python_code
stringlengths 0
679k
| repo_name
stringlengths 9
41
| file_path
stringlengths 6
149
|
|---|---|---|
# Copyright 2020 Google Research. 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.
# ==============================================================================
# Visualization library is mostly based on TensorFlow object detection API:
# https://github.com/tensorflow/models/tree/master/research/object_detection
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/visualize/__init__.py |
# Copyright 2020 Google Research. 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_keypoint_weights: groundtruth weight factor for keypoints.
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.
context_features: a flattened list of contextual features.
context_feature_length: the fixed length of each feature in
context_features, used for reshaping.
valid_context_size: the valid context size, used in filtering the padded
context features.
"""
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_keypoint_weights = 'groundtruth_keypoint_weights'
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'
context_features = 'context_features'
context_feature_length = 'context_feature_length'
valid_context_size = 'valid_context_size'
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.
detection_keypoint_scores: contains detection keypoint scores.
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'
detection_keypoint_scores = 'detection_keypoint_scores'
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'
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/visualize/standard_fields.py |
# Copyright 2020 Google Research. 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 set of functions that are used for visualization.
These functions often receive an image, perform some visualization on the image.
The functions do not return a value, instead they modify the image itself.
"""
import abc
import collections
import matplotlib
matplotlib.use('Agg') # Set headless-friendly backend.
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import numpy as np
import PIL.Image as Image
import PIL.ImageColor as ImageColor
import PIL.ImageDraw as ImageDraw
import PIL.ImageFont as ImageFont
import six
from six.moves import range
from six.moves import zip
import tensorflow.compat.v1 as tf
from visualize import shape_utils
from visualize import standard_fields as fields
_TITLE_LEFT_MARGIN = 10
_TITLE_TOP_MARGIN = 10
STANDARD_COLORS = [
'AliceBlue', 'Chartreuse', 'Aqua', 'Aquamarine', 'Azure', 'Beige', 'Bisque',
'BlanchedAlmond', 'BlueViolet', 'BurlyWood', 'CadetBlue', 'AntiqueWhite',
'Chocolate', 'Coral', 'CornflowerBlue', 'Cornsilk', 'Crimson', 'Cyan',
'DarkCyan', 'DarkGoldenRod', 'DarkGrey', 'DarkKhaki', 'DarkOrange',
'DarkOrchid', 'DarkSalmon', 'DarkSeaGreen', 'DarkTurquoise', 'DarkViolet',
'DeepPink', 'DeepSkyBlue', 'DodgerBlue', 'FireBrick', 'FloralWhite',
'ForestGreen', 'Fuchsia', 'Gainsboro', 'GhostWhite', 'Gold', 'GoldenRod',
'Salmon', 'Tan', 'HoneyDew', 'HotPink', 'IndianRed', 'Ivory', 'Khaki',
'Lavender', 'LavenderBlush', 'LawnGreen', 'LemonChiffon', 'LightBlue',
'LightCoral', 'LightCyan', 'LightGoldenRodYellow', 'LightGray', 'LightGrey',
'LightGreen', 'LightPink', 'LightSalmon', 'LightSeaGreen', 'LightSkyBlue',
'LightSlateGray', 'LightSlateGrey', 'LightSteelBlue', 'LightYellow', 'Lime',
'LimeGreen', 'Linen', 'Magenta', 'MediumAquaMarine', 'MediumOrchid',
'MediumPurple', 'MediumSeaGreen', 'MediumSlateBlue', 'MediumSpringGreen',
'MediumTurquoise', 'MediumVioletRed', 'MintCream', 'MistyRose', 'Moccasin',
'NavajoWhite', 'OldLace', 'Olive', 'OliveDrab', 'Orange', 'OrangeRed',
'Orchid', 'PaleGoldenRod', 'PaleGreen', 'PaleTurquoise', 'PaleVioletRed',
'PapayaWhip', 'PeachPuff', 'Peru', 'Pink', 'Plum', 'PowderBlue', 'Purple',
'Red', 'RosyBrown', 'RoyalBlue', 'SaddleBrown', 'Green', 'SandyBrown',
'SeaGreen', 'SeaShell', 'Sienna', 'Silver', 'SkyBlue', 'SlateBlue',
'SlateGray', 'SlateGrey', 'Snow', 'SpringGreen', 'SteelBlue', 'GreenYellow',
'Teal', 'Thistle', 'Tomato', 'Turquoise', 'Violet', 'Wheat', 'White',
'WhiteSmoke', 'Yellow', 'YellowGreen'
]
def _get_multiplier_for_color_randomness():
"""Returns a multiplier to get semi-random colors from successive indices.
This function computes a prime number, p, in the range [2, 17] that:
- is closest to len(STANDARD_COLORS) / 10
- does not divide len(STANDARD_COLORS)
If no prime numbers in that range satisfy the constraints, p is returned as 1.
Once p is established, it can be used as a multiplier to select
non-consecutive colors from STANDARD_COLORS:
colors = [(p * i) % len(STANDARD_COLORS) for i in range(20)]
"""
num_colors = len(STANDARD_COLORS)
prime_candidates = [5, 7, 11, 13, 17]
# Remove all prime candidates that divide the number of colors.
prime_candidates = [p for p in prime_candidates if num_colors % p]
if not prime_candidates:
return 1
# Return the closest prime number to num_colors / 10.
abs_distance = [np.abs(num_colors / 10. - p) for p in prime_candidates]
num_candidates = len(abs_distance)
inds = [i for _, i in sorted(zip(abs_distance, range(num_candidates)))]
return prime_candidates[inds[0]]
def save_image_array_as_png(image, output_path):
"""Saves an image (represented as a numpy array) to PNG.
Args:
image: a numpy array with shape [height, width, 3].
output_path: path to which image should be written.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
with tf.gfile.Open(output_path, 'w') as fid:
image_pil.save(fid, 'PNG')
def encode_image_array_as_png_str(image):
"""Encodes a numpy array into a PNG string.
Args:
image: a numpy array with shape [height, width, 3].
Returns:
PNG encoded image string.
"""
image_pil = Image.fromarray(np.uint8(image))
output = six.BytesIO()
image_pil.save(output, format='PNG')
png_string = output.getvalue()
output.close()
return png_string
def draw_bounding_box_on_image_array(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image (numpy array).
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Args:
image: a numpy array with shape [height, width, 3].
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box (each to be shown on its
own line).
use_normalized_coordinates: If True (default), treat coordinates ymin, xmin,
ymax, xmax as relative to the image. Otherwise treat coordinates as
absolute.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_bounding_box_on_image(image_pil, ymin, xmin, ymax, xmax, color,
thickness, display_str_list,
use_normalized_coordinates)
np.copyto(image, np.array(image_pil))
def draw_bounding_box_on_image(image,
ymin,
xmin,
ymax,
xmax,
color='red',
thickness=4,
display_str_list=(),
use_normalized_coordinates=True):
"""Adds a bounding box to an image.
Bounding box coordinates can be specified in either absolute (pixel) or
normalized coordinates by setting the use_normalized_coordinates argument.
Each string in display_str_list is displayed on a separate line above the
bounding box in black text on a rectangle filled with the input 'color'.
If the top of the bounding box extends to the edge of the image, the strings
are displayed below the bounding box.
Args:
image: a PIL.Image object.
ymin: ymin of bounding box.
xmin: xmin of bounding box.
ymax: ymax of bounding box.
xmax: xmax of bounding box.
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list: list of strings to display in box (each to be shown on its
own line).
use_normalized_coordinates: If True (default), treat coordinates ymin, xmin,
ymax, xmax as relative to the image. Otherwise treat coordinates as
absolute.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
if use_normalized_coordinates:
(left, right, top, bottom) = (xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
else:
(left, right, top, bottom) = (xmin, xmax, ymin, ymax)
if thickness > 0:
draw.line([(left, top), (left, bottom), (right, bottom), (right, top),
(left, top)],
width=thickness,
fill=color)
try:
font = ImageFont.truetype('arial.ttf', 24)
except IOError:
font = ImageFont.load_default()
# If the total height of the display strings added to the top of the bounding
# box exceeds the top of the image, stack the strings below the bounding box
# instead of above.
display_str_heights = [font.getsize(ds)[1] for ds in display_str_list]
# Each display_str has a top and bottom margin of 0.05x.
total_display_str_height = (1 + 2 * 0.05) * sum(display_str_heights)
if top > total_display_str_height:
text_bottom = top
else:
text_bottom = bottom + total_display_str_height
# Reverse list and print from bottom to top.
for display_str in display_str_list[::-1]:
text_width, text_height = font.getsize(display_str)
margin = np.ceil(0.05 * text_height)
draw.rectangle([(left, text_bottom - text_height - 2 * margin),
(left + text_width, text_bottom)],
fill=color)
draw.text((left + margin, text_bottom - text_height - margin),
display_str,
fill='black',
font=font)
text_bottom -= text_height - 2 * margin
def draw_bounding_boxes_on_image_array(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image (numpy array).
Args:
image: a numpy array object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax). The
coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings. a list of strings for each
bounding box. The reason to pass a list of strings for a bounding box is
that it might contain multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
image_pil = Image.fromarray(image)
draw_bounding_boxes_on_image(image_pil, boxes, color, thickness,
display_str_list_list)
np.copyto(image, np.array(image_pil))
def draw_bounding_boxes_on_image(image,
boxes,
color='red',
thickness=4,
display_str_list_list=()):
"""Draws bounding boxes on image.
Args:
image: a PIL.Image object.
boxes: a 2 dimensional numpy array of [N, 4]: (ymin, xmin, ymax, xmax). The
coordinates are in normalized format between [0, 1].
color: color to draw bounding box. Default is red.
thickness: line thickness. Default value is 4.
display_str_list_list: list of list of strings. a list of strings for each
bounding box. The reason to pass a list of strings for a bounding box is
that it might contain multiple labels.
Raises:
ValueError: if boxes is not a [N, 4] array
"""
boxes_shape = boxes.shape
if not boxes_shape:
return
if len(boxes_shape) != 2 or boxes_shape[1] != 4:
raise ValueError('Input must be of size [N, 4]')
for i in range(boxes_shape[0]):
display_str_list = ()
if display_str_list_list:
display_str_list = display_str_list_list[i]
draw_bounding_box_on_image(image, boxes[i, 0], boxes[i, 1], boxes[i, 2],
boxes[i, 3], color, thickness, display_str_list)
def create_visualization_fn(category_index,
include_masks=False,
include_keypoints=False,
include_track_ids=False,
**kwargs):
"""Constructs a visualization function that can be wrapped in a py_func.
py_funcs only accept positional arguments. This function returns a suitable
function with the correct positional argument mapping. The positional
arguments in order are:
0: image
1: boxes
2: classes
3: scores
[4-6]: masks (optional)
[4-6]: keypoints (optional)
[4-6]: track_ids (optional)
-- Example 1 --
vis_only_masks_fn = create_visualization_fn(category_index,
include_masks=True, include_keypoints=False, include_track_ids=False,
**kwargs)
image = tf.py_func(vis_only_masks_fn,
inp=[image, boxes, classes, scores, masks],
Tout=tf.uint8)
-- Example 2 --
vis_masks_and_track_ids_fn = create_visualization_fn(category_index,
include_masks=True, include_keypoints=False, include_track_ids=True,
**kwargs)
image = tf.py_func(vis_masks_and_track_ids_fn,
inp=[image, boxes, classes, scores, masks, track_ids],
Tout=tf.uint8)
Args:
category_index: a dict that maps integer ids to category dicts. e.g.
{1: {1: 'dog'}, 2: {2: 'cat'}, ...}
include_masks: Whether masks should be expected as a positional argument in
the returned function.
include_keypoints: Whether keypoints should be expected as a positional
argument in the returned function.
include_track_ids: Whether track ids should be expected as a positional
argument in the returned function.
**kwargs: Additional kwargs that will be passed to
visualize_boxes_and_labels_on_image_array.
Returns:
Returns a function that only takes tensors as positional arguments.
"""
def visualization_py_func_fn(*args):
"""Visualization function that can be wrapped in a tf.py_func.
Args:
*args: First 4 positional arguments must be: image - uint8 numpy array
with shape (img_height, img_width, 3). boxes - a numpy array of shape
[N, 4]. classes - a numpy array of shape [N]. scores - a numpy array of
shape [N] or None. -- Optional positional arguments -- instance_masks -
a numpy array of shape [N, image_height, image_width]. keypoints - a
numpy array of shape [N, num_keypoints, 2]. track_ids - a numpy array of
shape [N] with unique track ids.
Returns:
uint8 numpy array with shape (img_height, img_width, 3) with overlaid
boxes.
"""
image = args[0]
boxes = args[1]
classes = args[2]
scores = args[3]
masks = keypoints = track_ids = None
pos_arg_ptr = 4 # Positional argument for first optional tensor (masks).
if include_masks:
masks = args[pos_arg_ptr]
pos_arg_ptr += 1
if include_keypoints:
keypoints = args[pos_arg_ptr]
pos_arg_ptr += 1
if include_track_ids:
track_ids = args[pos_arg_ptr]
return visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index=category_index,
instance_masks=masks,
keypoints=keypoints,
track_ids=track_ids,
**kwargs)
return visualization_py_func_fn
def _resize_original_image(image, image_shape):
image = tf.expand_dims(image, 0)
image = tf.image.resize_images(
image,
image_shape,
method=tf.image.ResizeMethod.NEAREST_NEIGHBOR,
align_corners=True)
return tf.cast(tf.squeeze(image, 0), tf.uint8)
def draw_bounding_boxes_on_image_tensors(images,
boxes,
classes,
scores,
category_index,
original_image_spatial_shape=None,
true_image_shape=None,
instance_masks=None,
keypoints=None,
keypoint_edges=None,
track_ids=None,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True):
"""Draws bounding boxes, masks, and keypoints on batch of image tensors.
Args:
images: A 4D uint8 image tensor of shape [N, H, W, C]. If C > 3, additional
channels will be ignored. If C = 1, then we convert the images to RGB
images.
boxes: [N, max_detections, 4] float32 tensor of detection boxes.
classes: [N, max_detections] int tensor of detection classes. Note that
classes are 1-indexed.
scores: [N, max_detections] float32 tensor of detection scores.
category_index: a dict that maps integer ids to category dicts. e.g.
{1: {1: 'dog'}, 2: {2: 'cat'}, ...}
original_image_spatial_shape: [N, 2] tensor containing the spatial size of
the original image.
true_image_shape: [N, 3] tensor containing the spatial size of unpadded
original_image.
instance_masks: A 4D uint8 tensor of shape [N, max_detection, H, W] with
instance masks.
keypoints: A 4D float32 tensor of shape [N, max_detection, num_keypoints, 2]
with keypoints.
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
track_ids: [N, max_detections] int32 tensor of unique tracks ids (i.e.
instance ids for each object). If provided, the color-coding of boxes is
dictated by these ids, and not classes.
max_boxes_to_draw: Maximum number of boxes to draw on an image. Default 20.
min_score_thresh: Minimum score threshold for visualization. Default 0.2.
use_normalized_coordinates: Whether to assume boxes and kepoints are in
normalized coordinates (as opposed to absolute coordiantes). Default is
True.
Returns:
4D image tensor of type uint8, with boxes drawn on top.
"""
# Additional channels are being ignored.
if images.shape[3] > 3:
images = images[:, :, :, 0:3]
elif images.shape[3] == 1:
images = tf.image.grayscale_to_rgb(images)
visualization_keyword_args = {
'use_normalized_coordinates': use_normalized_coordinates,
'max_boxes_to_draw': max_boxes_to_draw,
'min_score_thresh': min_score_thresh,
'agnostic_mode': False,
'line_thickness': 4,
'keypoint_edges': keypoint_edges
}
if true_image_shape is None:
true_shapes = tf.constant(-1, shape=[images.shape.as_list()[0], 3])
else:
true_shapes = true_image_shape
if original_image_spatial_shape is None:
original_shapes = tf.constant(-1, shape=[images.shape.as_list()[0], 2])
else:
original_shapes = original_image_spatial_shape
visualize_boxes_fn = create_visualization_fn(
category_index,
include_masks=instance_masks is not None,
include_keypoints=keypoints is not None,
include_track_ids=track_ids is not None,
**visualization_keyword_args)
elems = [true_shapes, original_shapes, images, boxes, classes, scores]
if instance_masks is not None:
elems.append(instance_masks)
if keypoints is not None:
elems.append(keypoints)
if track_ids is not None:
elems.append(track_ids)
def draw_boxes(image_and_detections):
"""Draws boxes on image."""
true_shape = image_and_detections[0]
original_shape = image_and_detections[1]
if true_image_shape is not None:
image = shape_utils.pad_or_clip_nd(image_and_detections[2],
[true_shape[0], true_shape[1], 3])
if original_image_spatial_shape is not None:
image_and_detections[2] = _resize_original_image(image, original_shape)
image_with_boxes = tf.py_func(visualize_boxes_fn, image_and_detections[2:],
tf.uint8)
return image_with_boxes
images = tf.map_fn(draw_boxes, elems, dtype=tf.uint8, back_prop=False)
return images
def draw_side_by_side_evaluation_image(eval_dict,
category_index,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True,
keypoint_edges=None):
"""Creates a side-by-side image with detections and groundtruth.
Bounding boxes (and instance masks, if available) are visualized on both
subimages.
Args:
eval_dict: The evaluation dictionary returned by
eval_util.result_dict_for_batched_example() or
eval_util.result_dict_for_single_example().
category_index: A category index (dictionary) produced from a labelmap.
max_boxes_to_draw: The maximum number of boxes to draw for detections.
min_score_thresh: The minimum score threshold for showing detections.
use_normalized_coordinates: Whether to assume boxes and keypoints are in
normalized coordinates (as opposed to absolute coordinates). Default is
True.
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
Returns:
A list of [1, H, 2 * W, C] uint8 tensor. The subimage on the left
corresponds to detections, while the subimage on the right corresponds to
groundtruth.
"""
detection_fields = fields.DetectionResultFields()
input_data_fields = fields.InputDataFields()
images_with_detections_list = []
# Add the batch dimension if the eval_dict is for single example.
if len(eval_dict[detection_fields.detection_classes].shape) == 1:
for key in eval_dict:
if key != input_data_fields.original_image and key != input_data_fields.image_additional_channels:
eval_dict[key] = tf.expand_dims(eval_dict[key], 0)
for indx in range(eval_dict[input_data_fields.original_image].shape[0]):
instance_masks = None
if detection_fields.detection_masks in eval_dict:
instance_masks = tf.cast(
tf.expand_dims(
eval_dict[detection_fields.detection_masks][indx], axis=0),
tf.uint8)
keypoints = None
if detection_fields.detection_keypoints in eval_dict:
keypoints = tf.expand_dims(
eval_dict[detection_fields.detection_keypoints][indx], axis=0)
groundtruth_instance_masks = None
if input_data_fields.groundtruth_instance_masks in eval_dict:
groundtruth_instance_masks = tf.cast(
tf.expand_dims(
eval_dict[input_data_fields.groundtruth_instance_masks][indx],
axis=0), tf.uint8)
images_with_detections = draw_bounding_boxes_on_image_tensors(
tf.expand_dims(
eval_dict[input_data_fields.original_image][indx], axis=0),
tf.expand_dims(
eval_dict[detection_fields.detection_boxes][indx], axis=0),
tf.expand_dims(
eval_dict[detection_fields.detection_classes][indx], axis=0),
tf.expand_dims(
eval_dict[detection_fields.detection_scores][indx], axis=0),
category_index,
original_image_spatial_shape=tf.expand_dims(
eval_dict[input_data_fields.original_image_spatial_shape][indx],
axis=0),
true_image_shape=tf.expand_dims(
eval_dict[input_data_fields.true_image_shape][indx], axis=0),
instance_masks=instance_masks,
keypoints=keypoints,
keypoint_edges=keypoint_edges,
max_boxes_to_draw=max_boxes_to_draw,
min_score_thresh=min_score_thresh,
use_normalized_coordinates=use_normalized_coordinates)
images_with_groundtruth = draw_bounding_boxes_on_image_tensors(
tf.expand_dims(
eval_dict[input_data_fields.original_image][indx], axis=0),
tf.expand_dims(
eval_dict[input_data_fields.groundtruth_boxes][indx], axis=0),
tf.expand_dims(
eval_dict[input_data_fields.groundtruth_classes][indx], axis=0),
tf.expand_dims(
tf.ones_like(
eval_dict[input_data_fields.groundtruth_classes][indx],
dtype=tf.float32),
axis=0),
category_index,
original_image_spatial_shape=tf.expand_dims(
eval_dict[input_data_fields.original_image_spatial_shape][indx],
axis=0),
true_image_shape=tf.expand_dims(
eval_dict[input_data_fields.true_image_shape][indx], axis=0),
instance_masks=groundtruth_instance_masks,
keypoints=None,
keypoint_edges=None,
max_boxes_to_draw=None,
min_score_thresh=0.0,
use_normalized_coordinates=use_normalized_coordinates)
images_to_visualize = tf.concat(
[images_with_detections, images_with_groundtruth], axis=2)
if input_data_fields.image_additional_channels in eval_dict:
images_with_additional_channels_groundtruth = (
draw_bounding_boxes_on_image_tensors(
tf.expand_dims(
eval_dict[input_data_fields.image_additional_channels][indx],
axis=0),
tf.expand_dims(
eval_dict[input_data_fields.groundtruth_boxes][indx], axis=0),
tf.expand_dims(
eval_dict[input_data_fields.groundtruth_classes][indx],
axis=0),
tf.expand_dims(
tf.ones_like(
eval_dict[input_data_fields.groundtruth_classes][indx],
dtype=tf.float32),
axis=0),
category_index,
original_image_spatial_shape=tf.expand_dims(
eval_dict[input_data_fields.original_image_spatial_shape]
[indx],
axis=0),
true_image_shape=tf.expand_dims(
eval_dict[input_data_fields.true_image_shape][indx], axis=0),
instance_masks=groundtruth_instance_masks,
keypoints=None,
keypoint_edges=None,
max_boxes_to_draw=None,
min_score_thresh=0.0,
use_normalized_coordinates=use_normalized_coordinates))
images_to_visualize = tf.concat(
[images_to_visualize, images_with_additional_channels_groundtruth],
axis=2)
images_with_detections_list.append(images_to_visualize)
return images_with_detections_list
def draw_keypoints_on_image_array(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True,
keypoint_edges=None,
keypoint_edge_color='green',
keypoint_edge_width=2):
"""Draws keypoints on an image (numpy array).
Args:
image: a numpy array with shape [height, width, 3].
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
keypoint_edge_color: color to draw the keypoint edges with. Default is red.
keypoint_edge_width: width of the edges drawn between keypoints. Default
value is 2.
"""
image_pil = Image.fromarray(np.uint8(image)).convert('RGB')
draw_keypoints_on_image(image_pil, keypoints, color, radius,
use_normalized_coordinates, keypoint_edges,
keypoint_edge_color, keypoint_edge_width)
np.copyto(image, np.array(image_pil))
def draw_keypoints_on_image(image,
keypoints,
color='red',
radius=2,
use_normalized_coordinates=True,
keypoint_edges=None,
keypoint_edge_color='green',
keypoint_edge_width=2):
"""Draws keypoints on an image.
Args:
image: a PIL.Image object.
keypoints: a numpy array with shape [num_keypoints, 2].
color: color to draw the keypoints with. Default is red.
radius: keypoint radius. Default value is 2.
use_normalized_coordinates: if True (default), treat keypoint values as
relative to the image. Otherwise treat them as absolute.
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
keypoint_edge_color: color to draw the keypoint edges with. Default is red.
keypoint_edge_width: width of the edges drawn between keypoints. Default
value is 2.
"""
draw = ImageDraw.Draw(image)
im_width, im_height = image.size
keypoints_x = [k[1] for k in keypoints]
keypoints_y = [k[0] for k in keypoints]
if use_normalized_coordinates:
keypoints_x = tuple([im_width * x for x in keypoints_x])
keypoints_y = tuple([im_height * y for y in keypoints_y])
for keypoint_x, keypoint_y in zip(keypoints_x, keypoints_y):
draw.ellipse([(keypoint_x - radius, keypoint_y - radius),
(keypoint_x + radius, keypoint_y + radius)],
outline=color,
fill=color)
if keypoint_edges is not None:
for keypoint_start, keypoint_end in keypoint_edges:
if (keypoint_start < 0 or keypoint_start >= len(keypoints) or
keypoint_end < 0 or keypoint_end >= len(keypoints)):
continue
edge_coordinates = [
keypoints_x[keypoint_start], keypoints_y[keypoint_start],
keypoints_x[keypoint_end], keypoints_y[keypoint_end]
]
draw.line(
edge_coordinates, fill=keypoint_edge_color, width=keypoint_edge_width)
def draw_mask_on_image_array(image, mask, color='red', alpha=0.4):
"""Draws mask on an image.
Args:
image: uint8 numpy array with shape (img_height, img_height, 3)
mask: a uint8 numpy array of shape (img_height, img_height) with values
between either 0 or 1.
color: color to draw the keypoints with. Default is red.
alpha: transparency value between 0 and 1. (default: 0.4)
Raises:
ValueError: On incorrect data type for image or masks.
"""
if image.dtype != np.uint8:
raise ValueError('`image` not of type np.uint8')
if mask.dtype != np.uint8:
raise ValueError('`mask` not of type np.uint8')
if np.any(np.logical_and(mask != 1, mask != 0)):
raise ValueError('`mask` elements should be in [0, 1]')
if image.shape[:2] != mask.shape:
raise ValueError('The image has spatial dimensions %s but the mask has '
'dimensions %s' % (image.shape[:2], mask.shape))
rgb = ImageColor.getrgb(color)
pil_image = Image.fromarray(image)
solid_color = np.expand_dims(
np.ones_like(mask), axis=2) * np.reshape(list(rgb), [1, 1, 3])
pil_solid_color = Image.fromarray(np.uint8(solid_color)).convert('RGBA')
pil_mask = Image.fromarray(np.uint8(255.0 * alpha * mask)).convert('L')
pil_image = Image.composite(pil_solid_color, pil_image, pil_mask)
np.copyto(image, np.array(pil_image.convert('RGB')))
def visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
category_index,
instance_masks=None,
instance_boundaries=None,
keypoints=None,
keypoint_edges=None,
track_ids=None,
use_normalized_coordinates=False,
max_boxes_to_draw=20,
min_score_thresh=.5,
agnostic_mode=False,
line_thickness=4,
groundtruth_box_visualization_color='black',
skip_boxes=False,
skip_scores=False,
skip_labels=False,
skip_track_ids=False):
"""Overlay labeled boxes on an image with formatted scores and label names.
This function groups boxes that correspond to the same location
and creates a display string for each detection and overlays these
on the image. Note that this function modifies the image in place, and returns
that same image.
Args:
image: uint8 numpy array with shape (img_height, img_width, 3)
boxes: a numpy array of shape [N, 4]
classes: a numpy array of shape [N]. Note that class indices are 1-based,
and match the keys in the label map.
scores: a numpy array of shape [N] or None. If scores=None, then this
function assumes that the boxes to be plotted are groundtruth boxes and
plot all boxes as black with no classes or scores.
category_index: a dict containing category dictionaries (each holding
category index `id` and category name `name`) keyed by category indices.
instance_masks: a numpy array of shape [N, image_height, image_width] with
values ranging between 0 and 1, can be None.
instance_boundaries: a numpy array of shape [N, image_height, image_width]
with values ranging between 0 and 1, can be None.
keypoints: a numpy array of shape [N, num_keypoints, 2], can be None
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
track_ids: a numpy array of shape [N] with unique track ids. If provided,
color-coding of boxes will be determined by these ids, and not the class
indices.
use_normalized_coordinates: whether boxes is to be interpreted as normalized
coordinates or not.
max_boxes_to_draw: maximum number of boxes to visualize. If None, draw all
boxes.
min_score_thresh: minimum score threshold for a box to be visualized
agnostic_mode: boolean (default: False) controlling whether to evaluate in
class-agnostic mode or not. This mode will display scores but ignore
classes.
line_thickness: integer (default: 4) controlling line width of the boxes.
groundtruth_box_visualization_color: box color for visualizing groundtruth
boxes
skip_boxes: whether to skip the drawing of bounding boxes.
skip_scores: whether to skip score when drawing a single detection
skip_labels: whether to skip label when drawing a single detection
skip_track_ids: whether to skip track id when drawing a single detection
Returns:
uint8 numpy array with shape (img_height, img_width, 3) with overlaid boxes.
"""
# Create a display string (and color) for every box location, group any boxes
# that correspond to the same location.
box_to_display_str_map = collections.defaultdict(list)
box_to_color_map = collections.defaultdict(str)
box_to_instance_masks_map = {}
box_to_instance_boundaries_map = {}
box_to_keypoints_map = collections.defaultdict(list)
box_to_track_ids_map = {}
if not max_boxes_to_draw:
max_boxes_to_draw = boxes.shape[0]
for i in range(boxes.shape[0]):
if max_boxes_to_draw == len(box_to_color_map):
break
if scores is None or scores[i] > min_score_thresh:
box = tuple(boxes[i].tolist())
if instance_masks is not None:
box_to_instance_masks_map[box] = instance_masks[i]
if instance_boundaries is not None:
box_to_instance_boundaries_map[box] = instance_boundaries[i]
if keypoints is not None:
box_to_keypoints_map[box].extend(keypoints[i])
if track_ids is not None:
box_to_track_ids_map[box] = track_ids[i]
if scores is None:
box_to_color_map[box] = groundtruth_box_visualization_color
else:
display_str = ''
if not skip_labels:
if not agnostic_mode:
if classes[i] in six.viewkeys(category_index):
class_name = category_index[classes[i]]['name']
else:
class_name = 'N/A'
display_str = str(class_name)
if not skip_scores:
if not display_str:
display_str = '{}%'.format(int(100 * scores[i]))
else:
display_str = '{}: {}%'.format(display_str, int(100 * scores[i]))
if not skip_track_ids and track_ids is not None:
if not display_str:
display_str = 'ID {}'.format(track_ids[i])
else:
display_str = '{}: ID {}'.format(display_str, track_ids[i])
box_to_display_str_map[box].append(display_str)
if agnostic_mode:
box_to_color_map[box] = 'DarkOrange'
elif track_ids is not None:
prime_multipler = _get_multiplier_for_color_randomness()
box_to_color_map[box] = STANDARD_COLORS[(prime_multipler *
track_ids[i]) %
len(STANDARD_COLORS)]
else:
box_to_color_map[box] = STANDARD_COLORS[classes[i] %
len(STANDARD_COLORS)]
# Draw all boxes onto image.
for box, color in box_to_color_map.items():
ymin, xmin, ymax, xmax = box
if instance_masks is not None:
draw_mask_on_image_array(
image, box_to_instance_masks_map[box], color=color)
if instance_boundaries is not None:
draw_mask_on_image_array(
image, box_to_instance_boundaries_map[box], color='red', alpha=1.0)
draw_bounding_box_on_image_array(
image,
ymin,
xmin,
ymax,
xmax,
color=color,
thickness=0 if skip_boxes else line_thickness,
display_str_list=box_to_display_str_map[box],
use_normalized_coordinates=use_normalized_coordinates)
if keypoints is not None:
draw_keypoints_on_image_array(
image,
box_to_keypoints_map[box],
color=color,
radius=line_thickness / 2,
use_normalized_coordinates=use_normalized_coordinates,
keypoint_edges=keypoint_edges,
keypoint_edge_color=color,
keypoint_edge_width=line_thickness // 2)
return image
def add_cdf_image_summary(values, name):
"""Adds a tf.summary.image for a CDF plot of the values.
Normalizes `values` such that they sum to 1, plots the cumulative distribution
function and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
name: name for the image summary.
"""
def cdf_plot(values):
"""Numpy function to plot CDF."""
normalized_values = values / np.sum(values)
sorted_values = np.sort(normalized_values)
cumulative_values = np.cumsum(sorted_values)
fraction_of_examples = (
np.arange(cumulative_values.size, dtype=np.float32) /
cumulative_values.size)
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
ax.plot(fraction_of_examples, cumulative_values)
ax.set_ylabel('cumulative normalized values')
ax.set_xlabel('fraction of examples')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.frombuffer(
fig.canvas.tostring_rgb(),
dtype='uint8').reshape(1, int(height), int(width), 3)
return image
cdf_plot = tf.py_func(cdf_plot, [values], tf.uint8)
tf.summary.image(name, cdf_plot)
def add_hist_image_summary(values, bins, name):
"""Adds a tf.summary.image for a histogram plot of the values.
Plots the histogram of values and creates a tf image summary.
Args:
values: a 1-D float32 tensor containing the values.
bins: bin edges which will be directly passed to np.histogram.
name: name for the image summary.
"""
def hist_plot(values, bins):
"""Numpy function to plot hist."""
fig = plt.figure(frameon=False)
ax = fig.add_subplot('111')
y, x = np.histogram(values, bins=bins)
ax.plot(x[:-1], y)
ax.set_ylabel('count')
ax.set_xlabel('value')
fig.canvas.draw()
width, height = fig.get_size_inches() * fig.get_dpi()
image = np.frombuffer(
fig.canvas.tostring_rgb(),
dtype='uint8').reshape(1, int(height), int(width), 3)
return image
hist_plot = tf.py_func(hist_plot, [values, bins], tf.uint8)
tf.summary.image(name, hist_plot)
class EvalMetricOpsVisualization(six.with_metaclass(abc.ABCMeta, object)):
"""Abstract base class responsible for visualizations during evaluation.
Currently, summary images are not run during evaluation. One way to produce
evaluation images in Tensorboard is to provide tf.summary.image strings as
`value_ops` in tf.estimator.EstimatorSpec's `eval_metric_ops`. This class is
responsible for accruing images (with overlaid detections and groundtruth)
and returning a dictionary that can be passed to `eval_metric_ops`.
"""
def __init__(self,
category_index,
max_examples_to_draw=5,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True,
summary_name_prefix='evaluation_image',
keypoint_edges=None):
"""Creates an EvalMetricOpsVisualization.
Args:
category_index: A category index (dictionary) produced from a labelmap.
max_examples_to_draw: The maximum number of example summaries to produce.
max_boxes_to_draw: The maximum number of boxes to draw for detections.
min_score_thresh: The minimum score threshold for showing detections.
use_normalized_coordinates: Whether to assume boxes and keypoints are in
normalized coordinates (as opposed to absolute coordinates). Default is
True.
summary_name_prefix: A string prefix for each image summary.
keypoint_edges: A list of tuples with keypoint indices that specify which
keypoints should be connected by an edge, e.g. [(0, 1), (2, 4)] draws
edges from keypoint 0 to 1 and from keypoint 2 to 4.
"""
self._category_index = category_index
self._max_examples_to_draw = max_examples_to_draw
self._max_boxes_to_draw = max_boxes_to_draw
self._min_score_thresh = min_score_thresh
self._use_normalized_coordinates = use_normalized_coordinates
self._summary_name_prefix = summary_name_prefix
self._keypoint_edges = keypoint_edges
self._images = []
def clear(self):
self._images = []
def add_images(self, images):
"""Store a list of images, each with shape [1, H, W, C]."""
if len(self._images) >= self._max_examples_to_draw:
return
# Store images and clip list if necessary.
self._images.extend(images)
if len(self._images) > self._max_examples_to_draw:
self._images[self._max_examples_to_draw:] = []
def get_estimator_eval_metric_ops(self, eval_dict):
# pyformat: disable
"""Returns metric ops for use in tf.estimator.EstimatorSpec.
Args:
eval_dict: A dictionary that holds an image, groundtruth, and detections
for a batched example. Note that, we use only the first example for
visualization. See eval_util.result_dict_for_batched_example() for a
convenient method for constructing such a dictionary. The dictionary
contains
fields.InputDataFields.original_image: [batch_size, H, W, 3] image.
fields.InputDataFields.original_image_spatial_shape: [batch_size, 2]
tensor containing the size of the original image.
fields.InputDataFields.true_image_shape: [batch_size, 3]
tensor containing the spatial size of the upadded original image.
fields.InputDataFields.groundtruth_boxes - [batch_size, num_boxes, 4]
float32 tensor with groundtruth boxes in range [0.0, 1.0].
fields.InputDataFields.groundtruth_classes - [batch_size, num_boxes]
int64 tensor with 1-indexed groundtruth classes.
fields.InputDataFields.groundtruth_instance_masks - (optional)
[batch_size, num_boxes, H, W] int64 tensor with instance masks.
fields.DetectionResultFields.detection_boxes - [batch_size,
max_num_boxes, 4] float32 tensor with detection boxes in range [0.0,
1.0].
fields.DetectionResultFields.detection_classes - [batch_size,
max_num_boxes] int64 tensor with 1-indexed detection classes.
fields.DetectionResultFields.detection_scores - [batch_size,
max_num_boxes] float32 tensor with detection scores.
fields.DetectionResultFields.detection_masks - (optional) [batch_size,
max_num_boxes, H, W] float32 tensor of binarized masks.
fields.DetectionResultFields.detection_keypoints - (optional)
[batch_size, max_num_boxes, num_keypoints, 2] float32 tensor with
keypoints.
Returns:
A dictionary of image summary names to tuple of (value_op, update_op). The
`update_op` is the same for all items in the dictionary, and is
responsible for saving a single side-by-side image with detections and
groundtruth. Each `value_op` holds the tf.summary.image string for a given
image.
"""
# pyformat: enable
if self._max_examples_to_draw == 0:
return {}
images = self.images_from_evaluation_dict(eval_dict)
def get_images():
"""Returns a list of images, padded to self._max_images_to_draw."""
images = self._images
while len(images) < self._max_examples_to_draw:
images.append(np.array(0, dtype=np.uint8))
self.clear()
return images
def image_summary_or_default_string(summary_name, image):
"""Returns image summaries for non-padded elements."""
return tf.cond(
tf.equal(tf.size(tf.shape(image)), 4), # pyformat: disable
lambda: tf.summary.image(summary_name, image),
lambda: tf.constant(''))
if tf.executing_eagerly():
update_op = self.add_images([[images[0]]]) # pylint: disable=assignment-from-none
image_tensors = get_images()
else:
update_op = tf.py_func(self.add_images, [[images[0]]], [])
image_tensors = tf.py_func(get_images, [],
[tf.uint8] * self._max_examples_to_draw)
eval_metric_ops = {}
for i, image in enumerate(image_tensors):
summary_name = self._summary_name_prefix + '/' + str(i)
value_op = image_summary_or_default_string(summary_name, image)
eval_metric_ops[summary_name] = (value_op, update_op)
return eval_metric_ops
@abc.abstractmethod
def images_from_evaluation_dict(self, eval_dict):
"""Converts evaluation dictionary into a list of image tensors.
To be overridden by implementations.
Args:
eval_dict: A dictionary with all the necessary information for producing
visualizations.
Returns:
A list of [1, H, W, C] uint8 tensors.
"""
raise NotImplementedError
class VisualizeSingleFrameDetections(EvalMetricOpsVisualization):
"""Class responsible for single-frame object detection visualizations."""
def __init__(self,
category_index,
max_examples_to_draw=5,
max_boxes_to_draw=20,
min_score_thresh=0.2,
use_normalized_coordinates=True,
summary_name_prefix='Detections_Left_Groundtruth_Right',
keypoint_edges=None):
super(VisualizeSingleFrameDetections, self).__init__(
category_index=category_index,
max_examples_to_draw=max_examples_to_draw,
max_boxes_to_draw=max_boxes_to_draw,
min_score_thresh=min_score_thresh,
use_normalized_coordinates=use_normalized_coordinates,
summary_name_prefix=summary_name_prefix,
keypoint_edges=keypoint_edges)
def images_from_evaluation_dict(self, eval_dict):
return draw_side_by_side_evaluation_image(eval_dict, self._category_index,
self._max_boxes_to_draw,
self._min_score_thresh,
self._use_normalized_coordinates,
self._keypoint_edges)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/visualize/vis_utils.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Helper functions to access TensorShape values.
The rank 4 tensor_shape must be of the form [batch_size, height, width, depth].
"""
def get_dim_as_int(dim):
"""Utility to get v1 or v2 TensorShape dim as an int.
Args:
dim: The TensorShape dimension to get as an int
Returns:
None or an int.
"""
try:
return dim.value
except AttributeError:
return dim
def get_batch_size(tensor_shape):
"""Returns batch size from the tensor shape.
Args:
tensor_shape: A rank 4 TensorShape.
Returns:
An integer representing the batch size of the tensor.
"""
tensor_shape.assert_has_rank(rank=4)
return get_dim_as_int(tensor_shape[0])
def get_height(tensor_shape):
"""Returns height from the tensor shape.
Args:
tensor_shape: A rank 4 TensorShape.
Returns:
An integer representing the height of the tensor.
"""
tensor_shape.assert_has_rank(rank=4)
return get_dim_as_int(tensor_shape[1])
def get_width(tensor_shape):
"""Returns width from the tensor shape.
Args:
tensor_shape: A rank 4 TensorShape.
Returns:
An integer representing the width of the tensor.
"""
tensor_shape.assert_has_rank(rank=4)
return get_dim_as_int(tensor_shape[2])
def get_depth(tensor_shape):
"""Returns depth from the tensor shape.
Args:
tensor_shape: A rank 4 TensorShape.
Returns:
An integer representing the depth of the tensor.
"""
tensor_shape.assert_has_rank(rank=4)
return get_dim_as_int(tensor_shape[3])
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/visualize/static_shape.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Optimizer related utils."""
from absl import logging
import tensorflow as tf
from tensorflow_addons.optimizers import MovingAverage
from model import learning_rate
@tf.keras.utils.register_keras_serializable(package='Custom')
class HvdMovingAverage(MovingAverage):
def swap_weights(self):
"""Swap the average and moving weights.
The original function in the parent class assumes a cross replica
context, which fails for single GPU training. It also failed in the case of
multi-GPU training with Horovod.
"""
self._swap_weights()
def _create_slots(self, var_list):
"""[summary]
The original function in the parent class, in addition to calling
_create_slots() of the base optimizer, reassigns trainable tensors to
self._average_weights and self._model_weights, which has the effect of
removing non-trainable tensors (e.g., moving means and variances) from EMA.
By overriding it, we simply keep the part that calls _create_slots of the base
optimizer. To make up for the removed part of the code, we call shadow_copy, which
assigns both trainable and non-trainable tensors to self._average_weights and
self._model_weights.
Args:
var_list ([type]): [description]
"""
self._optimizer._create_slots(var_list=var_list)
def apply_gradients(self, grads_and_vars, name=None, experimental_aggregate_gradients=True):
self._optimizer._iterations = self.iterations
result = super().apply_gradients(grads_and_vars, name)
# update EMA weights after the weights are updated
self.update_average(self._optimizer.iterations)
return result
def _resource_apply_dense(self, grad, var):
"""[summary]
We must override this function, eliminating the part that performs
EMA updates for trainable variables. The reasons is that we use our custom
self.update_average(), called in apply_gradients, which performs EMA updates
for both trainable and non-trainable variables. If we don't override this
function, in each iteration, EMA of trainable variables get updated twice
(once here and once in apply_gradient) while EMA of non-trainable variables get
updated only once in apply_gradients.
"""
return self._optimizer._resource_apply_dense(grad, var)
def _resource_apply_sparse(self, grad, var, indices):
"""[summary]
We must override this function, eliminating the part that performs
EMA updates for trainable variables. The reasons is that we use our custom
self.update_average(), called in apply_gradients, which performs EMA updates
for both trainable and non-trainable variables. If we don't override this
function, in each iteration, EMA of trainable variables get updated twice
(once here and once in apply_gradient) while EMA of non-trainable variables get
updated only once in apply_gradients.
"""
return self._optimizer._resource_apply_sparse(grad, var, indices)
def _resource_apply_sparse_duplicate_indices(self, grad, var, indices):
"""[summary]
We must override this function, eliminating the part that performs
EMA updates for trainable variables. The reasons is that we use our custom
self.update_average(), called in apply_gradients, which performs EMA updates
for both trainable and non-trainable variables. If we don't override this
function, in each iteration, EMA of trainable variables get updated twice
(once here and once in apply_gradient) while EMA of non-trainable variables get
updated only once in apply_gradients.
"""
return self._optimizer._resource_apply_sparse_duplicate_indices(
grad, var, indices)
@tf.function
def update_average(self, step: tf.Tensor):
step = tf.cast(step, tf.float32)
average_decay = self._get_hyper("average_decay", tf.dtypes.float32)
if step < self._start_step:
decay = tf.constant(0., tf.float32)
elif self._dynamic_decay:
decay = step - self._start_step
decay = tf.minimum(average_decay, (1. + decay) / (10. + decay))
else:
decay = average_decay
def _apply_moving(v_moving, v_normal):
diff = v_moving - v_normal
v_moving.assign_sub(tf.cast(1. - decay, v_moving.dtype) * diff)
return v_moving
def _update(strategy, v_moving_and_v_normal):
for v_moving, v_normal in v_moving_and_v_normal:
strategy.extended.update(v_moving, _apply_moving, args=(v_normal,))
ctx = tf.distribute.get_replica_context()
return ctx.merge_call(_update, args=(zip(self._average_weights,
self._model_weights),))
@classmethod
def from_config(cls, config, custom_objects=None):
optimizer = tf.keras.optimizers.deserialize(
config.pop('optimizer'),
custom_objects=custom_objects,
)
return cls(optimizer, **config)
def get_optimizer(params):
"""Get optimizer."""
lr = learning_rate.learning_rate_schedule(params)
if params['optimizer'].lower() == 'sgd':
logging.info('Use SGD optimizer')
optimizer = tf.keras.optimizers.SGD(
lr, momentum=params['momentum'])
else:
raise ValueError('optimizer should be sgd')
moving_average_decay = params['moving_average_decay']
if moving_average_decay is not None and moving_average_decay > 0.0:
optimizer = HvdMovingAverage(optimizer, average_decay=moving_average_decay, dynamic_decay=True)
if params['mixed_precision']:
optimizer = tf.keras.mixed_precision.LossScaleOptimizer(
optimizer, initial_scale=params['loss_scale'])
return optimizer | DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/optimizer_builder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Common utils."""
from typing import Text, Union
import tensorflow as tf
import horovod.tensorflow.keras as hvd
from utils.horovod_utils import get_world_size
from model import activation_builder
class BatchNormalization(tf.keras.layers.BatchNormalization):
"""Fixed default name of BatchNormalization to match TpuBatchNormalization."""
def __init__(self, **kwargs):
if not kwargs.get('name', None):
kwargs['name'] = 'tpu_batch_normalization'
super().__init__(**kwargs)
def batch_norm_class(is_training=True):
if is_training:
# TODO(fsx950223): use SyncBatchNorm after TF bug is fixed (incorrect nccl
# all_reduce). See https://github.com/tensorflow/tensorflow/issues/41980
return BatchNormalization
else:
return BatchNormalization
def batch_normalization(inputs, training=False, **kwargs):
"""A wrapper for TpuBatchNormalization."""
bn_layer = batch_norm_class(training)(**kwargs)
return bn_layer(inputs, training=training)
def batch_norm_act(inputs,
is_training_bn: bool,
act_type: Union[Text, None],
init_zero: bool = False,
data_format: Text = 'channels_last',
momentum: float = 0.99,
epsilon: float = 1e-3,
name: Text = None):
"""Performs a batch normalization followed by a non-linear activation.
Args:
inputs: `Tensor` of shape `[batch, channels, ...]`.
is_training_bn: `bool` for whether the model is training.
act_type: non-linear relu function type. If None, omits the relu operation.
init_zero: `bool` if True, initializes scale parameter of batch
normalization with 0 instead of 1 (default).
data_format: `str` either "channels_first" for `[batch, channels, height,
width]` or "channels_last for `[batch, height, width, channels]`.
momentum: `float`, momentume of batch norm.
epsilon: `float`, small value for numerical stability.
name: the name of the batch normalization layer
Returns:
A normalized `Tensor` with the same `data_format`.
"""
if init_zero:
gamma_initializer = tf.zeros_initializer()
else:
gamma_initializer = tf.ones_initializer()
if data_format == 'channels_first':
axis = 1
else:
axis = 3
inputs = batch_normalization(
inputs=inputs,
axis=axis,
momentum=momentum,
epsilon=epsilon,
center=True,
scale=True,
training=is_training_bn,
gamma_initializer=gamma_initializer,
name=name)
if act_type:
inputs = activation_builder.activation_fn(inputs, act_type)
return inputs
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/normalization_builder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""IoU utils for box regression with iou losses.
Distance-IoU Loss: Faster and Better Learning for Bounding Box Regression.
https://arxiv.org/pdf/1911.08287.pdf
"""
import math
from typing import Union, Text
import numpy as np
import tensorflow as tf
FloatType = Union[tf.Tensor, float, np.float32, np.float64]
def _get_v(b1_height: FloatType, b1_width: FloatType, b2_height: FloatType,
b2_width: FloatType) -> tf.Tensor:
"""Get the consistency measurement of aspect ratio for ciou."""
@tf.custom_gradient
def _get_grad_v(height, width):
"""backpropogate gradient."""
arctan = tf.atan(tf.math.divide_no_nan(b1_width, b1_height)) - tf.atan(
tf.math.divide_no_nan(width, height))
v = 4 * ((arctan / math.pi)**2)
def _grad_v(dv):
"""Grad for eager mode."""
gdw = dv * 8 * arctan * height / (math.pi**2)
gdh = -dv * 8 * arctan * width / (math.pi**2)
return [gdh, gdw]
def _grad_v_graph(dv, variables):
"""Grad for graph mode."""
gdw = dv * 8 * arctan * height / (math.pi**2)
gdh = -dv * 8 * arctan * width / (math.pi**2)
return [gdh, gdw], tf.gradients(v, variables, grad_ys=dv)
if tf.compat.v1.executing_eagerly_outside_functions():
return v, _grad_v
return v, _grad_v_graph
return _get_grad_v(b2_height, b2_width)
def _iou_per_anchor(pred_boxes: FloatType,
target_boxes: FloatType,
iou_type: Text = 'iou') -> tf.Tensor:
"""Computing the IoU for a single anchor.
Args:
pred_boxes: predicted boxes, with coordinate [y_min, x_min, y_max, x_max].
target_boxes: target boxes, with coordinate [y_min, x_min, y_max, x_max].
iou_type: one of ['iou', 'ciou', 'diou', 'giou'].
Returns:
IoU loss float `Tensor`.
"""
# t_ denotes target boxes and p_ denotes predicted boxes.
t_ymin, t_xmin, t_ymax, t_xmax = target_boxes
p_ymin, p_xmin, p_ymax, p_xmax = pred_boxes
zero = tf.convert_to_tensor(0.0, t_ymin.dtype)
p_width = tf.maximum(zero, p_xmax - p_xmin)
p_height = tf.maximum(zero, p_ymax - p_ymin)
t_width = tf.maximum(zero, t_xmax - t_xmin)
t_height = tf.maximum(zero, t_ymax - t_ymin)
p_area = p_width * p_height
t_area = t_width * t_height
intersect_ymin = tf.maximum(p_ymin, t_ymin)
intersect_xmin = tf.maximum(p_xmin, t_xmin)
intersect_ymax = tf.minimum(p_ymax, t_ymax)
intersect_xmax = tf.minimum(p_xmax, t_xmax)
intersect_width = tf.maximum(zero, intersect_xmax - intersect_xmin)
intersect_height = tf.maximum(zero, intersect_ymax - intersect_ymin)
intersect_area = intersect_width * intersect_height
union_area = p_area + t_area - intersect_area
iou_v = tf.math.divide_no_nan(intersect_area, union_area)
if iou_type == 'iou':
return iou_v # iou is the simplest form.
enclose_ymin = tf.minimum(p_ymin, t_ymin)
enclose_xmin = tf.minimum(p_xmin, t_xmin)
enclose_ymax = tf.maximum(p_ymax, t_ymax)
enclose_xmax = tf.maximum(p_xmax, t_xmax)
assert iou_type in ('giou', 'diou', 'ciou')
if iou_type == 'giou': # giou is the generalized iou.
enclose_width = tf.maximum(zero, enclose_xmax - enclose_xmin)
enclose_height = tf.maximum(zero, enclose_ymax - enclose_ymin)
enclose_area = enclose_width * enclose_height
giou_v = iou_v - tf.math.divide_no_nan(
(enclose_area - union_area), enclose_area)
return giou_v
assert iou_type in ('diou', 'ciou')
p_center = tf.stack([(p_ymin + p_ymax) / 2, (p_xmin + p_xmax) / 2], axis=-1)
t_center = tf.stack([(t_ymin + t_ymax) / 2, (t_xmin + t_xmax) / 2], axis=-1)
euclidean = tf.linalg.norm(t_center - p_center, axis=-1)
diag_length = tf.linalg.norm(
tf.stack([enclose_ymax - enclose_ymin, enclose_xmax - enclose_xmin],
axis=-1),
axis=-1)
diou_v = iou_v - tf.math.divide_no_nan(euclidean**2, diag_length**2)
if iou_type == 'diou': # diou is the distance iou.
return diou_v
assert iou_type == 'ciou'
v = _get_v(p_height, p_width, t_height, t_width)
alpha = tf.math.divide_no_nan(v, ((1 - iou_v) + v))
return diou_v - alpha * v # the last one is ciou.
def iou_loss(pred_boxes: FloatType,
target_boxes: FloatType,
iou_type: Text = 'iou') -> tf.Tensor:
"""A unified interface for computing various IoU losses.
Let B and B_gt denotes the pred_box and B_gt is the target box (ground truth):
IoU = |B & B_gt| / |B | B_gt|
GIoU = IoU - |C - B U B_gt| / C, where C is the smallest box covering B and
B_gt.
DIoU = IoU - E(B, B_gt)^2 / c^2, E is the Euclidean distance of the center
points of B and B_gt, and c is the diagonal length of the smallest box
covering the two boxes
CIoU = IoU - DIoU - a * v, where a is a positive trade-off parameter, and
v measures the consistency of aspect ratio:
v = (arctan(w_gt / h_gt) - arctan(w / h)) * 4 / pi^2
where (w_gt, h_gt) and (w, h) are the width and height of the target and
predicted box respectively.
The returned loss is computed as 1 - one of {IoU, GIoU, DIoU, CIoU}.
Args:
pred_boxes: predicted boxes, with coordinate [y_min, x_min, y_max, x_max]*.
It can be multiple anchors, with each anchor box has four coordinates.
target_boxes: target boxes, with coordinate [y_min, x_min, y_max, x_max]*.
It can be multiple anchors, with each anchor box has four coordinates.
iou_type: one of ['iou', 'ciou', 'diou', 'giou'].
Returns:
IoU loss float `Tensor`.
"""
if iou_type not in ('iou', 'ciou', 'diou', 'giou'):
raise ValueError(
'Unknown loss_type {}, not iou/ciou/diou/giou'.format(iou_type))
pred_boxes = tf.convert_to_tensor(pred_boxes, tf.float32)
target_boxes = tf.cast(target_boxes, pred_boxes.dtype)
# t_ denotes target boxes and p_ denotes predicted boxes: (y, x, y_max, x_max)
pred_boxes_list = tf.unstack(pred_boxes, None, axis=-1)
target_boxes_list = tf.unstack(target_boxes, None, axis=-1)
assert len(pred_boxes_list) == len(target_boxes_list)
assert len(pred_boxes_list) % 4 == 0
iou_loss_list = []
for i in range(0, len(pred_boxes_list), 4):
pred_boxes = pred_boxes_list[i:i + 4]
target_boxes = target_boxes_list[i:i + 4]
# Compute mask.
t_ymin, t_xmin, t_ymax, t_xmax = target_boxes
mask = tf.math.logical_and(t_ymax > t_ymin, t_xmax > t_xmin)
mask = tf.cast(mask, t_ymin.dtype)
# Loss should be mask * (1 - iou) = mask - masked_iou.
pred_boxes = [b * mask for b in pred_boxes]
target_boxes = [b * mask for b in target_boxes]
iou_loss_list.append(
mask *
(1 - tf.squeeze(_iou_per_anchor(pred_boxes, target_boxes, iou_type))))
if len(iou_loss_list) == 1:
return iou_loss_list[0]
return tf.reduce_sum(tf.stack(iou_loss_list), 0)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/iou_utils.py |
# Copyright 2020 Google Research. 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 few predefined label id mapping."""
import tensorflow as tf
import yaml
coco = {
# 0: 'background',
1: 'person',
2: 'bicycle',
3: 'car',
4: 'motorcycle',
5: 'airplane',
6: 'bus',
7: 'train',
8: 'truck',
9: 'boat',
10: 'traffic light',
11: 'fire hydrant',
13: 'stop sign',
14: 'parking meter',
15: 'bench',
16: 'bird',
17: 'cat',
18: 'dog',
19: 'horse',
20: 'sheep',
21: 'cow',
22: 'elephant',
23: 'bear',
24: 'zebra',
25: 'giraffe',
27: 'backpack',
28: 'umbrella',
31: 'handbag',
32: 'tie',
33: 'suitcase',
34: 'frisbee',
35: 'skis',
36: 'snowboard',
37: 'sports ball',
38: 'kite',
39: 'baseball bat',
40: 'baseball glove',
41: 'skateboard',
42: 'surfboard',
43: 'tennis racket',
44: 'bottle',
46: 'wine glass',
47: 'cup',
48: 'fork',
49: 'knife',
50: 'spoon',
51: 'bowl',
52: 'banana',
53: 'apple',
54: 'sandwich',
55: 'orange',
56: 'broccoli',
57: 'carrot',
58: 'hot dog',
59: 'pizza',
60: 'donut',
61: 'cake',
62: 'chair',
63: 'couch',
64: 'potted plant',
65: 'bed',
67: 'dining table',
70: 'toilet',
72: 'tv',
73: 'laptop',
74: 'mouse',
75: 'remote',
76: 'keyboard',
77: 'cell phone',
78: 'microwave',
79: 'oven',
80: 'toaster',
81: 'sink',
82: 'refrigerator',
84: 'book',
85: 'clock',
86: 'vase',
87: 'scissors',
88: 'teddy bear',
89: 'hair drier',
90: 'toothbrush',
}
voc = {
# 0: 'background',
1: 'aeroplane',
2: 'bicycle',
3: 'bird',
4: 'boat',
5: 'bottle',
6: 'bus',
7: 'car',
8: 'cat',
9: 'chair',
10: 'cow',
11: 'diningtable',
12: 'dog',
13: 'horse',
14: 'motorbike',
15: 'person',
16: 'pottedplant',
17: 'sheep',
18: 'sofa',
19: 'train',
20: 'tvmonitor',
}
waymo = {
# 0: 'background',
1: 'vehicle',
2: 'pedestrian',
3: 'cyclist',
}
def get_label_map(mapping):
"""Get label id map based on the name, filename, or dict."""
# case 1: if it is None or dict, just return it.
if not mapping or isinstance(mapping, dict):
return mapping
# case 2: if it is a yaml file, load it to a dict and return the dict.
assert isinstance(mapping, str), 'mapping must be dict or str.'
if mapping.endswith('.yaml'):
with tf.io.gfile.GFile(mapping) as f:
return yaml.load(f, Loader=yaml.FullLoader)
# case 3: it is a name of a predefined dataset.
return {'coco': coco, 'voc': voc, 'waymo': waymo}[mapping]
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/label_util.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""BiFPN/QuFPN and other FPN configs.
BiFPN is presented in the EfficientDet paper.
QuFPN is proposed in https://github.com/google/automl/pull/580
"""
import itertools
from utils import hparams_config
def bifpn_config(min_level, max_level, weight_method):
"""A dynamic bifpn config that can adapt to different min/max levels."""
p = hparams_config.Config()
p.weight_method = weight_method or 'fastattn'
# Node id starts from the input features and monotonically increase whenever
# a new node is added. Here is an example for level P3 - P7:
# P7 (4) P7" (12)
# P6 (3) P6' (5) P6" (11)
# P5 (2) P5' (6) P5" (10)
# P4 (1) P4' (7) P4" (9)
# P3 (0) P3" (8)
# So output would be like:
# [
# {'feat_level': 6, 'inputs_offsets': [3, 4]}, # for P6'
# {'feat_level': 5, 'inputs_offsets': [2, 5]}, # for P5'
# {'feat_level': 4, 'inputs_offsets': [1, 6]}, # for P4'
# {'feat_level': 3, 'inputs_offsets': [0, 7]}, # for P3"
# {'feat_level': 4, 'inputs_offsets': [1, 7, 8]}, # for P4"
# {'feat_level': 5, 'inputs_offsets': [2, 6, 9]}, # for P5"
# {'feat_level': 6, 'inputs_offsets': [3, 5, 10]}, # for P6"
# {'feat_level': 7, 'inputs_offsets': [4, 11]}, # for P7"
# ]
num_levels = max_level - min_level + 1
node_ids = {min_level + i: [i] for i in range(num_levels)}
level_last_id = lambda level: node_ids[level][-1]
level_all_ids = lambda level: node_ids[level]
id_cnt = itertools.count(num_levels)
p.nodes = []
for i in range(max_level - 1, min_level - 1, -1):
# top-down path.
p.nodes.append({
'feat_level': i,
'inputs_offsets': [level_last_id(i),
level_last_id(i + 1)]
})
node_ids[i].append(next(id_cnt))
for i in range(min_level + 1, max_level + 1):
# bottom-up path.
p.nodes.append({
'feat_level': i,
'inputs_offsets': level_all_ids(i) + [level_last_id(i - 1)]
})
node_ids[i].append(next(id_cnt))
return p
def qufpn_config(min_level, max_level, weight_method=None):
"""A dynamic quad fpn config that can adapt to different min/max levels."""
# It extends the idea of BiFPN, and has four paths:
# (up_down -> bottom_up) + (bottom_up -> up_down).
# See test for an example for level 2 and 7.
p = hparams_config.Config()
p.weight_method = weight_method or 'fastattn'
p.quad_method = 'fastattn'
num_levels = max_level - min_level + 1
node_ids = {min_level + i: [i] for i in range(num_levels)}
level_last_id = lambda level: node_ids[level][-1]
level_all_ids = lambda level: node_ids[level]
level_first_id = lambda level: node_ids[level][0]
id_cnt = itertools.count(num_levels)
p.nodes = []
for i in range(max_level - 1, min_level - 1, -1):
# top-down path 1.
p.nodes.append({
'feat_level': i,
'inputs_offsets': [level_last_id(i),
level_last_id(i + 1)],
'weight_method': p.weight_method
})
node_ids[i].append(next(id_cnt))
node_ids[max_level].append(node_ids[max_level][-1])
for i in range(min_level + 1, max_level):
# bottom-up path 2.
p.nodes.append({
'feat_level': i,
'inputs_offsets': level_all_ids(i) + [level_last_id(i - 1)],
'weight_method': p.weight_method
})
node_ids[i].append(next(id_cnt))
i = max_level
p.nodes.append({
'feat_level': i,
'inputs_offsets': [level_first_id(i)] + [level_last_id(i - 1)],
'weight_method': p.weight_method
})
node_ids[i].append(next(id_cnt))
node_ids[min_level].append(node_ids[min_level][-1])
for i in range(min_level + 1, max_level + 1, 1):
# bottom-up path 3.
p.nodes.append({
'feat_level': i,
'inputs_offsets': [
level_first_id(i),
level_last_id(i - 1) if i != min_level + 1 else level_first_id(i -
1)
],
'weight_method': p.weight_method
})
node_ids[i].append(next(id_cnt))
node_ids[min_level].append(node_ids[min_level][-1])
for i in range(max_level - 1, min_level, -1):
# top-down path 4.
p.nodes.append({
'feat_level':
i,
'inputs_offsets': [node_ids[i][0]] + [node_ids[i][-1]] +
[level_last_id(i + 1)],
'weight_method':
p.weight_method
})
node_ids[i].append(next(id_cnt))
i = min_level
p.nodes.append({
'feat_level': i,
'inputs_offsets': [node_ids[i][0]] + [level_last_id(i + 1)],
'weight_method': p.weight_method
})
node_ids[i].append(next(id_cnt))
node_ids[max_level].append(node_ids[max_level][-1])
for i in range(max_level, min_level - 1, -1):
# quad-add path.
p.nodes.append({
'feat_level': i,
'inputs_offsets': [node_ids[i][2], node_ids[i][4]],
'weight_method': p.quad_method
})
node_ids[i].append(next(id_cnt))
return p
def get_fpn_config(fpn_name, min_level, max_level, weight_method):
"""Get fpn related configuration."""
if not fpn_name:
fpn_name = 'bifpn'
name_to_config = {
'bifpn': bifpn_config(min_level, max_level, weight_method),
'qufpn': qufpn_config(min_level, max_level, weight_method),
# legacy only: to be deprecated.
'bifpn_dyn': bifpn_config(min_level, max_level, weight_method),
}
return name_to_config[fpn_name]
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/fpn_configs.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Anchor definition."""
import numpy as np
# The minimum score to consider a logit for identifying detections.
MIN_CLASS_SCORE = -5.0
# The score for a dummy detection
_DUMMY_DETECTION_SCORE = -1e5
# The maximum number of (anchor,class) pairs to keep for non-max suppression.
MAX_DETECTION_POINTS = 5000
def diou_nms(dets, iou_thresh=None):
"""DIOU non-maximum suppression.
diou = iou - square of euclidian distance of box centers
/ square of diagonal of smallest enclosing bounding box
Reference: https://arxiv.org/pdf/1911.08287.pdf
Args:
dets: detection with shape (num, 5) and format [x1, y1, x2, y2, score].
iou_thresh: IOU threshold,
Returns:
numpy.array: Retained boxes.
"""
iou_thresh = iou_thresh or 0.5
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
center_x = (x1 + x2) / 2
center_y = (y1 + y2) / 2
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
intersection = w * h
iou = intersection / (areas[i] + areas[order[1:]] - intersection)
smallest_enclosing_box_x1 = np.minimum(x1[i], x1[order[1:]])
smallest_enclosing_box_x2 = np.maximum(x2[i], x2[order[1:]])
smallest_enclosing_box_y1 = np.minimum(y1[i], y1[order[1:]])
smallest_enclosing_box_y2 = np.maximum(y2[i], y2[order[1:]])
square_of_the_diagonal = (
(smallest_enclosing_box_x2 - smallest_enclosing_box_x1)**2 +
(smallest_enclosing_box_y2 - smallest_enclosing_box_y1)**2)
square_of_center_distance = ((center_x[i] - center_x[order[1:]])**2 +
(center_y[i] - center_y[order[1:]])**2)
# Add 1e-10 for numerical stability.
diou = iou - square_of_center_distance / (square_of_the_diagonal + 1e-10)
inds = np.where(diou <= iou_thresh)[0]
order = order[inds + 1]
return dets[keep]
def hard_nms(dets, iou_thresh=None):
"""The basic hard non-maximum suppression.
Args:
dets: detection with shape (num, 5) and format [x1, y1, x2, y2, score].
iou_thresh: IOU threshold,
Returns:
numpy.array: Retained boxes.
"""
iou_thresh = iou_thresh or 0.5
x1 = dets[:, 0]
y1 = dets[:, 1]
x2 = dets[:, 2]
y2 = dets[:, 3]
scores = dets[:, 4]
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
order = scores.argsort()[::-1]
keep = []
while order.size > 0:
i = order[0]
keep.append(i)
xx1 = np.maximum(x1[i], x1[order[1:]])
yy1 = np.maximum(y1[i], y1[order[1:]])
xx2 = np.minimum(x2[i], x2[order[1:]])
yy2 = np.minimum(y2[i], y2[order[1:]])
w = np.maximum(0.0, xx2 - xx1 + 1)
h = np.maximum(0.0, yy2 - yy1 + 1)
intersection = w * h
overlap = intersection / (areas[i] + areas[order[1:]] - intersection)
inds = np.where(overlap <= iou_thresh)[0]
order = order[inds + 1]
return dets[keep]
def soft_nms(dets, nms_configs):
"""Soft non-maximum suppression.
[1] Soft-NMS -- Improving Object Detection With One Line of Code.
https://arxiv.org/abs/1704.04503
Args:
dets: detection with shape (num, 5) and format [x1, y1, x2, y2, score].
nms_configs: a dict config that may contain the following members
* method: one of {`linear`, `gaussian`, 'hard'}. Use `gaussian` if None.
* iou_thresh (float): IOU threshold, only for `linear`, `hard`.
* sigma: Gaussian parameter, only for method 'gaussian'.
* score_thresh (float): Box score threshold for final boxes.
Returns:
numpy.array: Retained boxes.
"""
method = nms_configs['method']
# Default sigma and iou_thresh are from the original soft-nms paper.
sigma = nms_configs['sigma'] or 0.5
iou_thresh = nms_configs['iou_thresh'] or 0.3
score_thresh = nms_configs['score_thresh'] or 0.001
x1 = np.float32(dets[:, 0])
y1 = np.float32(dets[:, 1])
x2 = np.float32(dets[:, 2])
y2 = np.float32(dets[:, 3])
areas = (x2 - x1 + 1) * (y2 - y1 + 1)
# expand dets with areas, and the second dimension is
# x1, y1, x2, y2, score, area
dets = np.concatenate((dets, areas[:, None]), axis=1)
retained_box = []
while dets.size > 0:
max_idx = np.argmax(dets[:, 4], axis=0)
dets[[0, max_idx], :] = dets[[max_idx, 0], :]
retained_box.append(dets[0, :-1])
xx1 = np.maximum(dets[0, 0], dets[1:, 0])
yy1 = np.maximum(dets[0, 1], dets[1:, 1])
xx2 = np.minimum(dets[0, 2], dets[1:, 2])
yy2 = np.minimum(dets[0, 3], dets[1:, 3])
w = np.maximum(xx2 - xx1 + 1, 0.0)
h = np.maximum(yy2 - yy1 + 1, 0.0)
inter = w * h
iou = inter / (dets[0, 5] + dets[1:, 5] - inter)
if method == 'linear':
weight = np.ones_like(iou)
weight[iou > iou_thresh] -= iou[iou > iou_thresh]
elif method == 'gaussian':
weight = np.exp(-(iou * iou) / sigma)
else: # traditional nms
weight = np.ones_like(iou)
weight[iou > iou_thresh] = 0
dets[1:, 4] *= weight
retained_idx = np.where(dets[1:, 4] >= score_thresh)[0]
dets = dets[retained_idx + 1, :]
return np.vstack(retained_box)
def nms(dets, nms_configs):
"""Non-maximum suppression.
Args:
dets: detection with shape (num, 5) and format [x1, y1, x2, y2, score].
nms_configs: a dict config that may contain parameters.
Returns:
numpy.array: Retained boxes.
"""
nms_configs = nms_configs or {}
method = nms_configs['method']
if method == 'hard' or not method:
return hard_nms(dets, nms_configs['iou_thresh'])
if method == 'diou':
return diou_nms(dets, nms_configs['iou_thresh'])
if method in ('linear', 'gaussian'):
return soft_nms(dets, nms_configs)
raise ValueError('Unknown NMS method: {}'.format(method))
def per_class_nms(boxes, scores, classes, image_id, image_scale, num_classes,
max_boxes_to_draw, nms_configs):
"""Perform per class nms."""
boxes = boxes[:, [1, 0, 3, 2]]
detections = []
for c in range(num_classes):
indices = np.where(classes == c)[0]
if indices.shape[0] == 0:
continue
boxes_cls = boxes[indices, :]
scores_cls = scores[indices]
# Select top-scoring boxes in each class and apply non-maximum suppression
# (nms) for boxes in the same class. The selected boxes from each class are
# then concatenated for the final detection outputs.
all_detections_cls = np.column_stack((boxes_cls, scores_cls))
top_detections_cls = nms(all_detections_cls, nms_configs)
top_detections_cls = np.column_stack(
(np.repeat(image_id, len(top_detections_cls)),
top_detections_cls,
np.repeat(c + 1, len(top_detections_cls)))
)
detections.append(top_detections_cls)
def _generate_dummy_detections(number):
detections_dummy = np.zeros((number, 7), dtype=np.float32)
detections_dummy[:, 0] = image_id[0]
detections_dummy[:, 5] = _DUMMY_DETECTION_SCORE
return detections_dummy
if detections:
detections = np.vstack(detections)
# take final 100 detections
indices = np.argsort(-detections[:, -2])
detections = np.array(
detections[indices[0:max_boxes_to_draw]], dtype=np.float32)
# Add dummy detections to fill up to 100 detections
n = max(max_boxes_to_draw - len(detections), 0)
detections_dummy = _generate_dummy_detections(n)
detections = np.vstack([detections, detections_dummy])
else:
detections = _generate_dummy_detections(max_boxes_to_draw)
detections[:, 1:5] *= image_scale
return detections | DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/nms_np.py |
# Copyright 2020 Google Research. 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.
# =============================================================================
"""Postprocessing for anchor-based detection."""
import functools
from typing import List, Tuple
from absl import logging
import tensorflow as tf
from model import nms_np
from utils import model_utils
from model import anchors
T = tf.Tensor # a shortcut for typing check.
CLASS_OFFSET = 1
def to_list(inputs):
if isinstance(inputs, dict):
return [inputs[k] for k in sorted(inputs.keys())]
if isinstance(inputs, list):
return inputs
raise ValueError('Unrecognized inputs : {}'.format(inputs))
def batch_map_fn(map_fn, inputs, *args):
"""Apply map_fn at batch dimension."""
if isinstance(inputs[0], (list, tuple)):
batch_size = len(inputs[0])
else:
batch_size = inputs[0].shape.as_list()[0]
if not batch_size:
# handle dynamic batch size: tf.vectorized_map is faster than tf.map_fn.
return tf.vectorized_map(map_fn, inputs, *args)
outputs = []
for i in range(batch_size):
outputs.append(map_fn([x[i] for x in inputs]))
return [tf.stack(y) for y in zip(*outputs)]
def clip_boxes(boxes: T, image_size: int) -> T:
"""Clip boxes to fit the image size."""
image_size = model_utils.parse_image_size(image_size) * 2
return tf.clip_by_value(boxes, [0], image_size)
def merge_class_box_level_outputs(params, cls_outputs: List[T],
box_outputs: List[T]) -> Tuple[T, T]:
"""Concatenates class and box of all levels into one tensor."""
cls_outputs_all, box_outputs_all = [], []
batch_size = tf.shape(cls_outputs[0])[0]
for level in range(0, params['max_level'] - params['min_level'] + 1):
if params['data_format'] == 'channels_first':
cls_outputs[level] = tf.transpose(cls_outputs[level], [0, 2, 3, 1])
box_outputs[level] = tf.transpose(box_outputs[level], [0, 2, 3, 1])
cls_outputs_all.append(
tf.reshape(cls_outputs[level], [batch_size, -1, params['num_classes']]))
box_outputs_all.append(tf.reshape(box_outputs[level], [batch_size, -1, 4]))
return tf.concat(cls_outputs_all, 1), tf.concat(box_outputs_all, 1)
def topk_class_boxes(params, cls_outputs: T,
box_outputs: T) -> Tuple[T, T, T, T]:
"""Pick the topk class and box outputs."""
batch_size = tf.shape(cls_outputs)[0]
num_classes = params['num_classes']
max_nms_inputs = params['nms_configs'].get('max_nms_inputs', 0)
if max_nms_inputs > 0:
# Prune anchors and detections to only keep max_nms_inputs.
# Due to some issues, top_k is currently slow in graph model.
logging.info('use max_nms_inputs for pre-nms topk.')
cls_outputs_reshape = tf.reshape(cls_outputs, [batch_size, -1])
_, cls_topk_indices = tf.math.top_k(
cls_outputs_reshape, k=max_nms_inputs, sorted=False)
indices = cls_topk_indices // num_classes
classes = cls_topk_indices % num_classes
cls_indices = tf.stack([indices, classes], axis=2)
cls_outputs_topk = tf.gather_nd(cls_outputs, cls_indices, batch_dims=1)
box_outputs_topk = tf.gather_nd(
box_outputs, tf.expand_dims(indices, 2), batch_dims=1)
else:
logging.info('use max_reduce for pre-nms topk.')
# Keep all anchors, but for each anchor, just keep the max probablity for
# each class.
cls_outputs_idx = tf.math.argmax(cls_outputs, axis=-1, output_type=tf.int32)
num_anchors = tf.shape(cls_outputs)[1]
classes = cls_outputs_idx
indices = tf.tile(
tf.expand_dims(tf.range(num_anchors), axis=0), [batch_size, 1])
cls_outputs_topk = tf.reduce_max(cls_outputs, -1)
box_outputs_topk = box_outputs
return cls_outputs_topk, box_outputs_topk, classes, indices
def pre_nms(params, cls_outputs, box_outputs, topk=True):
"""Detection post processing before nms.
It takes the multi-level class and box predictions from network, merge them
into unified tensors, and compute boxes, scores, and classes.
Args:
params: a dict of parameters.
cls_outputs: a list of tensors for classes, each tensor denotes a level of
logits with shape [N, H, W, num_class * num_anchors].
box_outputs: a list of tensors for boxes, each tensor ddenotes a level of
boxes with shape [N, H, W, 4 * num_anchors].
topk: if True, select topk before nms (mainly to speed up nms).
Returns:
A tuple of (boxes, scores, classes).
"""
# get boxes by apply bounding box regression to anchors.
eval_anchors = anchors.Anchors(params['min_level'], params['max_level'],
params['num_scales'], params['aspect_ratios'],
params['anchor_scale'], params['image_size'])
cls_outputs, box_outputs = merge_class_box_level_outputs(
params, cls_outputs, box_outputs)
if topk:
# select topK purely based on scores before NMS, in order to speed up nms.
cls_outputs, box_outputs, classes, indices = topk_class_boxes(
params, cls_outputs, box_outputs)
anchor_boxes = tf.gather(eval_anchors.boxes, indices)
else:
anchor_boxes = eval_anchors.boxes
classes = None
boxes = anchors.decode_box_outputs(box_outputs, anchor_boxes)
# convert logits to scores.
scores = tf.math.sigmoid(cls_outputs)
return boxes, scores, classes
def nms(params, boxes: T, scores: T, classes: T,
padded: bool) -> Tuple[T, T, T, T]:
"""Non-maximum suppression.
Args:
params: a dict of parameters.
boxes: a tensor with shape [N, 4], where N is the number of boxes. Box
format is [y_min, x_min, y_max, x_max].
scores: a tensor with shape [N].
classes: a tensor with shape [N].
padded: a bool vallue indicating whether the results are padded.
Returns:
A tuple (boxes, scores, classes, valid_lens), where valid_lens is a scalar
denoting the valid length of boxes/scores/classes outputs.
"""
nms_configs = params['nms_configs']
method = nms_configs['method']
max_output_size = nms_configs['max_output_size']
if method == 'hard' or not method:
# hard nms.
sigma = 0.0
iou_thresh = nms_configs['iou_thresh'] or 0.5
score_thresh = nms_configs['score_thresh'] or float('-inf')
elif method == 'gaussian':
sigma = nms_configs['sigma'] or 0.5
iou_thresh = 1.0
score_thresh = nms_configs['score_thresh'] or 0.001
else:
raise ValueError('Inference has invalid nms method {}'.format(method))
# TF API's sigma is twice as the paper's value, so here we divide it by 2:
# https://github.com/tensorflow/tensorflow/issues/40253.
nms_top_idx, nms_scores, nms_valid_lens = tf.raw_ops.NonMaxSuppressionV5(
boxes=boxes,
scores=scores,
max_output_size=max_output_size,
iou_threshold=iou_thresh,
score_threshold=score_thresh,
soft_nms_sigma=(sigma / 2),
pad_to_max_output_size=padded)
nms_boxes = tf.gather(boxes, nms_top_idx)
nms_classes = tf.cast(
tf.gather(classes, nms_top_idx) + CLASS_OFFSET, tf.float32)
return nms_boxes, nms_scores, nms_classes, nms_valid_lens
def postprocess_combined(params, cls_outputs, box_outputs, image_scales=None):
"""Post processing with combined NMS.
Leverage the tf combined NMS. It is fast on TensorRT, but slow on CPU/GPU.
Args:
params: a dict of parameters.
cls_outputs: a list of tensors for classes, each tensor denotes a level of
logits with shape [N, H, W, num_class * num_anchors].
box_outputs: a list of tensors for boxes, each tensor ddenotes a level of
boxes with shape [N, H, W, 4 * num_anchors]. Each box format is [y_min,
x_min, y_max, x_man].
image_scales: scaling factor or the final image and bounding boxes.
Returns:
A tuple of batch level (boxes, scores, classess, valid_len) after nms.
"""
cls_outputs = to_list(cls_outputs)
box_outputs = to_list(box_outputs)
# Don't filter any outputs because combine_nms need the raw information.
boxes, scores, _ = pre_nms(params, cls_outputs, box_outputs, topk=False)
max_output_size = params['nms_configs']['max_output_size']
score_thresh = params['nms_configs']['score_thresh'] or float('-inf')
nms_boxes, nms_scores, nms_classes, nms_valid_len = (
tf.image.combined_non_max_suppression(
tf.expand_dims(boxes, axis=2),
scores,
max_output_size,
max_output_size,
score_threshold=score_thresh,
clip_boxes=False))
nms_classes += CLASS_OFFSET
nms_boxes = clip_boxes(nms_boxes, params['image_size'])
if image_scales is not None:
scales = tf.expand_dims(tf.expand_dims(image_scales, -1), -1)
nms_boxes = nms_boxes * tf.cast(scales, nms_boxes.dtype)
return nms_boxes, nms_scores, nms_classes, nms_valid_len
def postprocess_global(params, cls_outputs, box_outputs, image_scales=None):
"""Post processing with global NMS.
A fast but less accurate version of NMS. The idea is to treat the scores for
different classes in a unified way, and perform NMS globally for all classes.
Args:
params: a dict of parameters.
cls_outputs: a list of tensors for classes, each tensor denotes a level of
logits with shape [N, H, W, num_class * num_anchors].
box_outputs: a list of tensors for boxes, each tensor ddenotes a level of
boxes with shape [N, H, W, 4 * num_anchors]. Each box format is [y_min,
x_min, y_max, x_man].
image_scales: scaling factor or the final image and bounding boxes.
Returns:
A tuple of batch level (boxes, scores, classess, valid_len) after nms.
"""
cls_outputs = to_list(cls_outputs)
box_outputs = to_list(box_outputs)
boxes, scores, classes = pre_nms(params, cls_outputs, box_outputs)
def single_batch_fn(element):
return nms(params, element[0], element[1], element[2], True)
nms_boxes, nms_scores, nms_classes, nms_valid_len = batch_map_fn(
single_batch_fn, [boxes, scores, classes])
nms_boxes = clip_boxes(nms_boxes, params['image_size'])
if image_scales is not None:
scales = tf.expand_dims(tf.expand_dims(image_scales, -1), -1)
nms_boxes = nms_boxes * tf.cast(scales, nms_boxes.dtype)
return nms_boxes, nms_scores, nms_classes, nms_valid_len
def per_class_nms(params, boxes, scores, classes, image_scales=None):
"""Per-class nms, a utility for postprocess_per_class.
Args:
params: a dict of parameters.
boxes: A tensor with shape [N, K, 4], where N is batch_size, K is num_boxes.
Box format is [y_min, x_min, y_max, x_max].
scores: A tensor with shape [N, K].
classes: A tensor with shape [N, K].
image_scales: scaling factor or the final image and bounding boxes.
Returns:
A tuple of batch level (boxes, scores, classess, valid_len) after nms.
"""
def single_batch_fn(element):
"""A mapping function for a single batch."""
boxes_i, scores_i, classes_i = element[0], element[1], element[2]
nms_boxes_cls, nms_scores_cls, nms_classes_cls = [], [], []
nms_valid_len_cls = []
for cid in range(params['num_classes']):
indices = tf.where(tf.equal(classes_i, cid))
if indices.shape[0] == 0:
continue
classes_cls = tf.gather_nd(classes_i, indices)
boxes_cls = tf.gather_nd(boxes_i, indices)
scores_cls = tf.gather_nd(scores_i, indices)
nms_boxes, nms_scores, nms_classes, nms_valid_len = nms(
params, boxes_cls, scores_cls, classes_cls, False)
nms_boxes_cls.append(nms_boxes)
nms_scores_cls.append(nms_scores)
nms_classes_cls.append(nms_classes)
nms_valid_len_cls.append(nms_valid_len)
# Pad zeros and select topk.
max_output_size = params['nms_configs'].get('max_output_size', 100)
nms_boxes_cls = tf.pad(
tf.concat(nms_boxes_cls, 0), [[0, max_output_size], [0, 0]])
nms_scores_cls = tf.pad(
tf.concat(nms_scores_cls, 0), [[0, max_output_size]])
nms_classes_cls = tf.pad(
tf.concat(nms_classes_cls, 0), [[0, max_output_size]])
nms_valid_len_cls = tf.stack(nms_valid_len_cls)
_, indices = tf.math.top_k(nms_scores_cls, k=max_output_size, sorted=True)
return tuple((
tf.gather(nms_boxes_cls, indices),
tf.gather(nms_scores_cls, indices),
tf.gather(nms_classes_cls, indices),
tf.minimum(max_output_size, tf.reduce_sum(nms_valid_len_cls))))
# end of single_batch_fn
nms_boxes, nms_scores, nms_classes, nms_valid_len = batch_map_fn(
single_batch_fn, [boxes, scores, classes])
if image_scales is not None:
scales = tf.expand_dims(tf.expand_dims(image_scales, -1), -1)
nms_boxes = nms_boxes * tf.cast(scales, nms_boxes.dtype)
return nms_boxes, nms_scores, nms_classes, nms_valid_len
def postprocess_per_class(params, cls_outputs, box_outputs, image_scales=None):
"""Post processing with per class NMS.
An accurate but relatively slow version of NMS. The idea is to perform NMS for
each class, and then combine them.
Args:
params: a dict of parameters.
cls_outputs: a list of tensors for classes, each tensor denotes a level of
logits with shape [N, H, W, num_class * num_anchors].
box_outputs: a list of tensors for boxes, each tensor ddenotes a level of
boxes with shape [N, H, W, 4 * num_anchors]. Each box format is [y_min,
x_min, y_max, x_man].
image_scales: scaling factor or the final image and bounding boxes.
Returns:
A tuple of batch level (boxes, scores, classess, valid_len) after nms.
"""
cls_outputs = to_list(cls_outputs)
box_outputs = to_list(box_outputs)
boxes, scores, classes = pre_nms(params, cls_outputs, box_outputs)
return per_class_nms(params, boxes, scores, classes, image_scales)
def generate_detections(params,
cls_outputs,
box_outputs,
image_scales,
image_ids,
flip=False):
"""A legacy interface for generating [id, x, y, w, h, score, class]."""
_, width = model_utils.parse_image_size(params['image_size'])
original_image_widths = tf.expand_dims(image_scales, -1) * width
if params['nms_configs'].get('pyfunc', True):
# numpy based soft-nms gives better accuracy than the tensorflow builtin
# the reason why is unknown
detections_bs = []
boxes, scores, classes = pre_nms(params, cls_outputs, box_outputs)
for index in range(boxes.shape[0]):
nms_configs = params['nms_configs']
detections = tf.numpy_function(
functools.partial(nms_np.per_class_nms, nms_configs=nms_configs), [
boxes[index],
scores[index],
classes[index],
tf.slice(image_ids, [index], [1]),
tf.slice(image_scales, [index], [1]),
params['num_classes'],
nms_configs['max_output_size'],
], tf.float32)
if flip:
detections = tf.stack([
detections[:, 0],
# the mirrored location of the left edge is the image width
# minus the position of the right edge
original_image_widths[index] - detections[:, 3],
detections[:, 2],
# the mirrored location of the right edge is the image width
# minus the position of the left edge
original_image_widths[index] - detections[:, 1],
detections[:, 4],
detections[:, 5],
detections[:, 6],
], axis=-1)
detections_bs.append(detections)
return tf.stack(detections_bs, axis=0, name='detnections')
nms_boxes_bs, nms_scores_bs, nms_classes_bs, _ = postprocess_per_class(
params, cls_outputs, box_outputs, image_scales)
image_ids_bs = tf.cast(tf.expand_dims(image_ids, -1), nms_scores_bs.dtype)
if flip:
detections_bs = [
image_ids_bs * tf.ones_like(nms_scores_bs),
# the mirrored location of the left edge is the image width
# minus the position of the right edge
original_image_widths - nms_boxes_bs[:, :, 3],
nms_boxes_bs[:, :, 0],
# the mirrored location of the right edge is the image width
# minus the position of the left edge
original_image_widths - nms_boxes_bs[:, :, 1],
nms_boxes_bs[:, :, 2],
nms_scores_bs,
nms_classes_bs,
]
else:
detections_bs = [
image_ids_bs * tf.ones_like(nms_scores_bs),
nms_boxes_bs[:, :, 1],
nms_boxes_bs[:, :, 0],
nms_boxes_bs[:, :, 3],
nms_boxes_bs[:, :, 2],
nms_scores_bs,
nms_classes_bs,
]
return tf.stack(detections_bs, axis=-1, name='detnections')
def transform_detections(detections):
"""A transforms detections in [id, x1, y1, x2, y2, score, class] form to [id, x, y, w, h, score, class]."""
return tf.stack([
detections[:, :, 0],
detections[:, :, 1],
detections[:, :, 2],
detections[:, :, 3] - detections[:, :, 1],
detections[:, :, 4] - detections[:, :, 2],
detections[:, :, 5],
detections[:, :, 6],
],
axis=-1)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/postprocess.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Learning rate related utils."""
import math
from absl import logging
from typing import Any, Mapping
import tensorflow as tf
def update_learning_rate_schedule_parameters(params):
"""Updates params that are related to the learning rate schedule."""
steps_per_epoch = params['steps_per_epoch']
params['lr_warmup_step'] = int(params['lr_warmup_epoch'] * steps_per_epoch)
params['total_steps'] = int(params['num_epochs'] * steps_per_epoch)
@tf.keras.utils.register_keras_serializable(package='Custom')
class CosineLrSchedule(tf.keras.optimizers.schedules.LearningRateSchedule):
"""Cosine learning rate schedule."""
def __init__(self, base_lr: float, lr_warmup_init: float,
lr_warmup_step: int, total_steps: int):
"""Build a CosineLrSchedule.
Args:
base_lr: `float`, The initial learning rate.
lr_warmup_init: `float`, The warm up learning rate.
lr_warmup_step: `int`, The warm up step.
total_steps: `int`, Total train steps.
"""
super(CosineLrSchedule, self).__init__()
logging.info('LR schedule method: cosine')
self.base_lr = base_lr
self.lr_warmup_init = lr_warmup_init
self.lr_warmup_step = lr_warmup_step
self.decay_steps = tf.cast(total_steps - lr_warmup_step, tf.float32)
def __call__(self, step):
linear_warmup = (
self.lr_warmup_init +
(tf.cast(step, dtype=tf.float32) / self.lr_warmup_step *
(self.base_lr - self.lr_warmup_init)))
cosine_lr = 0.5 * self.base_lr * (
1 + tf.cos(math.pi * (tf.cast(step, tf.float32) - self.lr_warmup_step) / self.decay_steps))
return tf.where(step < self.lr_warmup_step, linear_warmup, cosine_lr)
def get_config(self) -> Mapping[str, Any]:
return {
"base_lr": self.base_lr,
"lr_warmup_init": self.lr_warmup_init,
"lr_warmup_step": self.lr_warmup_step,
}
def learning_rate_schedule(params):
"""Learning rate schedule based on global step."""
update_learning_rate_schedule_parameters(params)
lr_decay_method = params['lr_decay_method']
if lr_decay_method == 'cosine':
return CosineLrSchedule(params['learning_rate'],
params['lr_warmup_init'], params['lr_warmup_step'],
params['total_steps'])
raise ValueError('unknown lr_decay_method: {}'.format(lr_decay_method))
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/learning_rate.py |
DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/__init__.py |
|
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Callback related utils."""
from concurrent import futures
import os
from mpi4py import MPI
import time
import numpy as np
import tensorflow as tf
import horovod.tensorflow.keras.callbacks as hvd_callbacks
from tensorflow_addons.optimizers import MovingAverage
from typeguard import typechecked
from typing import Any, List, MutableMapping, Text
from model import inference, optimizer_builder
from utils import model_utils
from model import efficientdet_keras, coco_metric, label_util, postprocess
from utils.horovod_utils import get_world_size, is_main_process
class DisplayCallback(tf.keras.callbacks.Callback):
"""Display inference result callback."""
def __init__(self, sample_image, output_dir, update_freq=1):
super().__init__()
image_file = tf.io.read_file(sample_image)
self.sample_image = tf.expand_dims(
tf.image.decode_jpeg(image_file, channels=3), axis=0)
self.executor = futures.ThreadPoolExecutor(max_workers=1)
self.update_freq = update_freq
self.output_dir = output_dir
def set_model(self, model: tf.keras.Model):
self.train_model = model
with tf.device('/cpu:0'):
self.model = efficientdet_keras.EfficientDetModel(config=model.config)
height, width = model_utils.parse_image_size(model.config.image_size)
self.model.build((1, height, width, 3))
self.file_writer = tf.summary.create_file_writer(self.output_dir)
self.min_score_thresh = self.model.config.nms_configs['score_thresh'] or 0.4
self.max_boxes_to_draw = (
self.model.config.nms_configs['max_output_size'] or 100)
def on_epoch_end(self, epoch, logs=None):
if epoch % self.update_freq == 0:
self.executor.submit(self.draw_inference, epoch)
@tf.function
def inference(self):
return self.model(self.sample_image, training=False)
def draw_inference(self, epoch):
self.model.set_weights(self.train_model.get_weights())
boxes, scores, classes, valid_len = self.inference()
length = valid_len[0]
image = inference.visualize_image(
self.sample_image[0],
boxes[0].numpy()[:length],
classes[0].numpy().astype(np.int)[:length],
scores[0].numpy()[:length],
label_map=self.model.config.label_map,
min_score_thresh=self.min_score_thresh,
max_boxes_to_draw=self.max_boxes_to_draw)
with self.file_writer.as_default():
tf.summary.image('Test image', tf.expand_dims(image, axis=0), step=epoch)
class BatchTimestamp(object):
"""A structure to store batch time stamp."""
def __init__(self, batch_index, timestamp):
self.batch_index = batch_index
self.timestamp = timestamp
def __repr__(self):
return "'BatchTimestamp<batch_index: {}, timestamp: {}>'".format(
self.batch_index, self.timestamp)
class TimeHistory(tf.keras.callbacks.Callback):
"""Callback for Keras models."""
def __init__(self, batch_size, logger, log_steps=1, logdir=None):
"""Callback for logging performance.
Args:
batch_size: Total batch size.
log_steps: Interval of steps between logging of batch level stats.
logdir: Optional directory to write TensorBoard summaries.
"""
# TODO(wcromar): remove this parameter and rely on `logs` parameter of
# on_train_batch_end()
self.batch_size = batch_size
super(TimeHistory, self).__init__()
self.log_steps = log_steps
self.last_log_step = 0
self.steps_before_epoch = 0
self.steps_in_epoch = 0
self.start_time = None
self.logger = logger
self.step_per_epoch = 0
if logdir:
self.summary_writer = tf.summary.create_file_writer(logdir)
else:
self.summary_writer = None
# Logs start of step 1 then end of each step based on log_steps interval.
self.timestamp_log = []
# Records the time each epoch takes to run from start to finish of epoch.
self.epoch_runtime_log = []
self.latency = []
self.throughput = []
@property
def global_steps(self):
"""The current 1-indexed global step."""
return self.steps_before_epoch + self.steps_in_epoch
@property
def average_steps_per_second(self):
"""The average training steps per second across all epochs."""
return (self.global_steps - self.step_per_epoch) / sum(self.epoch_runtime_log[1:])
@property
def average_examples_per_second(self):
"""The average number of training examples per second across all epochs."""
# return self.average_steps_per_second * self.batch_size
ind = int(0.1*len(self.throughput))
return sum(self.throughput[ind:])/(len(self.throughput[ind:]))
@property
def average_time_per_iteration(self):
"""The average time per iteration in seconds across all epochs."""
ind = int(0.1*len(self.latency))
return sum(self.latency[ind:])/(len(self.latency[ind:]))
def on_train_end(self, logs=None):
self.train_finish_time = time.time()
if self.summary_writer:
self.summary_writer.flush()
def on_epoch_begin(self, epoch, logs=None):
self.epoch_start = time.time()
def on_batch_begin(self, batch, logs=None):
if not self.start_time:
self.start_time = time.time()
# Record the timestamp of the first global step
if not self.timestamp_log:
self.timestamp_log.append(BatchTimestamp(self.global_steps,
self.start_time))
def on_batch_end(self, batch, logs=None):
"""Records elapse time of the batch and calculates examples per second."""
self.steps_in_epoch = batch + 1
steps_since_last_log = self.global_steps - self.last_log_step
if steps_since_last_log >= self.log_steps:
now = time.time()
elapsed_time = now - self.start_time
steps_per_second = steps_since_last_log / elapsed_time
examples_per_second = steps_per_second * self.batch_size
self.timestamp_log.append(BatchTimestamp(self.global_steps, now))
elapsed_time_str='{:.2f} seconds'.format(elapsed_time)
self.logger.log(step='PARAMETER', data={'Latency': elapsed_time_str, 'fps': examples_per_second, 'steps': (self.last_log_step, self.global_steps)})
self.logger.flush()
if self.summary_writer:
with self.summary_writer.as_default():
tf.summary.scalar('global_step/sec', steps_per_second,
self.global_steps)
tf.summary.scalar('examples/sec', examples_per_second,
self.global_steps)
self.last_log_step = self.global_steps
self.start_time = None
self.latency.append(elapsed_time)
self.throughput.append(examples_per_second)
def on_epoch_end(self, epoch, logs=None):
if epoch == 0:
self.step_per_epoch = self.steps_in_epoch
epoch_run_time = time.time() - self.epoch_start
self.epoch_runtime_log.append(epoch_run_time)
self.steps_before_epoch += self.steps_in_epoch
self.steps_in_epoch = 0
class LRTensorBoard(tf.keras.callbacks.Callback):
def __init__(self, log_dir, **kwargs):
super().__init__(**kwargs)
self.summary_writer = tf.summary.create_file_writer(log_dir)
self.steps_before_epoch = 0
self.steps_in_epoch = 0
@property
def global_steps(self):
"""The current 1-indexed global step."""
return self.steps_before_epoch + self.steps_in_epoch
def on_batch_end(self, batch, logs=None):
self.steps_in_epoch = batch + 1
lr = self.model.optimizer.lr(self.global_steps)
with self.summary_writer.as_default():
summary = tf.summary.scalar('learning_rate', lr, self.global_steps)
def on_epoch_end(self, epoch, logs=None):
self.steps_before_epoch += self.steps_in_epoch
self.steps_in_epoch = 0
def on_train_end(self, logs=None):
self.summary_writer.flush()
class LoggingCallback(tf.keras.callbacks.Callback):
def on_train_batch_end(self, batch, logs=None):
print("Iter: {}".format(batch))
for var in self.model.variables:
# if 'dense' in var.name:
# continue
print("Var: {} {}".format(var.name, var.value))
try:
slot = self.model.optimizer.get_slot(var, "average")
print("Avg: {}".format(slot))
except KeyError as e:
print("{} does not have ema average slot".format(var.name))
def fetch_optimizer(model,opt_type) -> tf.keras.optimizers.Optimizer:
"""Get the base optimizer used by the current model."""
# this is the case where our target optimizer is not wrapped by any other optimizer(s)
if isinstance(model.optimizer,opt_type):
return model.optimizer
# Dive into nested optimizer object until we reach the target opt
opt = model.optimizer
while hasattr(opt, '_optimizer'):
opt = opt._optimizer
if isinstance(opt,opt_type):
return opt
raise TypeError(f'Failed to find {opt_type} in the nested optimizer object')
class MovingAverageCallback(tf.keras.callbacks.Callback):
"""A Callback to be used with a `MovingAverage` optimizer.
Applies moving average weights to the model during validation time to test
and predict on the averaged weights rather than the current model weights.
Once training is complete, the model weights will be overwritten with the
averaged weights (by default).
Attributes:
overwrite_weights_on_train_end: Whether to overwrite the current model
weights with the averaged weights from the moving average optimizer.
**kwargs: Any additional callback arguments.
"""
def __init__(self,
overwrite_weights_on_train_end: bool = False,
**kwargs):
super(MovingAverageCallback, self).__init__(**kwargs)
self.overwrite_weights_on_train_end = overwrite_weights_on_train_end
self.ema_opt = None
def set_model(self, model: tf.keras.Model):
super(MovingAverageCallback, self).set_model(model)
self.ema_opt = fetch_optimizer(model, MovingAverage)
self.ema_opt.shadow_copy(self.model.weights)
def on_test_begin(self, logs: MutableMapping[Text, Any] = None):
self.ema_opt.swap_weights()
def on_test_end(self, logs: MutableMapping[Text, Any] = None):
self.ema_opt.swap_weights()
def on_train_end(self, logs: MutableMapping[Text, Any] = None):
if self.overwrite_weights_on_train_end:
self.ema_opt.assign_average_vars(self.model.variables)
class AverageModelCheckpoint(tf.keras.callbacks.ModelCheckpoint):
"""Saves and, optionally, assigns the averaged weights.
Taken from tfa.callbacks.AverageModelCheckpoint [original class].
NOTE1: The original class has a type check decorator, which prevents passing non-string save_freq (fix: removed)
NOTE2: The original class may not properly handle layered (nested) optimizer objects (fix: use fetch_optimizer)
Attributes:
update_weights: If True, assign the moving average weights
to the model, and save them. If False, keep the old
non-averaged weights, but the saved model uses the
average weights.
See `tf.keras.callbacks.ModelCheckpoint` for the other args.
"""
def __init__(
self,
update_weights: bool,
filepath: str,
monitor: str = 'val_loss',
verbose: int = 0,
save_best_only: bool = False,
save_weights_only: bool = False,
mode: str = 'auto',
save_freq: str = 'epoch',
**kwargs):
super().__init__(
filepath,
monitor,
verbose,
save_best_only,
save_weights_only,
mode,
save_freq,
**kwargs)
self.update_weights = update_weights
self.ema_opt = None
def set_model(self, model):
self.ema_opt = fetch_optimizer(model, MovingAverage)
return super().set_model(model)
def _save_model(self, epoch, batch, logs):
assert isinstance(self.ema_opt, MovingAverage)
if self.update_weights:
self.ema_opt.assign_average_vars(self.model.variables)
return super()._save_model(epoch, batch, logs)
else:
# Note: `model.get_weights()` gives us the weights (non-ref)
# whereas `model.variables` returns references to the variables.
non_avg_weights = self.model.get_weights()
self.ema_opt.assign_average_vars(self.model.variables)
# result is currently None, since `super._save_model` doesn't
# return anything, but this may change in the future.
result = super()._save_model(epoch, batch, logs)
self.model.set_weights(non_avg_weights)
return result
class StopEarlyCallback(tf.keras.callbacks.Callback):
def __init__(self, num_epochs, stop_75, **kwargs):
super(StopEarlyCallback, self).__init__(**kwargs)
self.num_epochs = num_epochs
self.stop_75 = stop_75
def on_epoch_end(self, epoch, logs=None):
if ((epoch + 1) > (0.75 * self.num_epochs) and self.stop_75) or ((epoch + 1) == 300):
self.model.stop_training = True
class COCOEvalCallback(tf.keras.callbacks.Callback):
def __init__(self, eval_dataset, eval_freq, start_eval_epoch, eval_params, logger, **kwargs):
super(COCOEvalCallback, self).__init__(**kwargs)
self.dataset = eval_dataset
self.eval_freq = eval_freq
self.start_eval_epoch = start_eval_epoch
self.eval_params = eval_params
self.ema_opt = None
self.logger = logger
label_map = label_util.get_label_map(eval_params['label_map'])
self.evaluator = coco_metric.EvaluationMetric(
filename=eval_params['val_json_file'], label_map=label_map)
self.pbar = tf.keras.utils.Progbar(eval_params['num_samples'])
def set_model(self, model):
self.ema_opt = fetch_optimizer(model, MovingAverage)
return super().set_model(model)
@tf.function
def eval_model_fn(self, images, labels):
cls_outputs, box_outputs = self.model(images, training=False)
detections = postprocess.generate_detections(self.eval_params, cls_outputs, box_outputs,
labels['image_scales'],
labels['source_ids'])
tf.numpy_function(self.evaluator.update_state,
[labels['groundtruth_data'],
postprocess.transform_detections(detections)], [])
def evaluate(self, epoch):
if self.eval_params['moving_average_decay'] > 0:
self.ema_opt.swap_weights() # get ema weights
self.evaluator.reset_states()
# evaluate all images.
for i, (images, labels) in enumerate(self.dataset):
self.eval_model_fn(images, labels)
if is_main_process():
self.pbar.update(i)
# gather detections from all ranks
self.evaluator.gather()
# compute the final eval results.
if is_main_process():
metrics = self.evaluator.result()
metric_dict = {}
for i, name in enumerate(self.evaluator.metric_names):
metric_dict[name] = metrics[i]
# csv format
csv_metrics = ['AP','AP50','AP75','APs','APm','APl']
csv_format = ",".join([str(epoch+1)] + [str(round(metric_dict[key] * 100, 2)) for key in csv_metrics])
print(metric_dict, "csv format:", csv_format)
self.logger.log(step=(), data={'epoch': epoch+1,
'validation_accuracy_mAP': round(metric_dict['AP'] * 100, 2)})
if self.eval_params['moving_average_decay'] > 0:
self.ema_opt.swap_weights() # get base weights
MPI.COMM_WORLD.Barrier()
def on_epoch_end(self, epoch, logs=None):
if (epoch + 1) >= self.start_eval_epoch and (epoch + 1) % self.eval_freq == 0:
self.evaluate(epoch)
def get_callbacks(
params, training_mode, eval_params, eval_dataset, logger,
time_history=True, log_steps=1, lr_tb=True, benchmark=False
):
"""Get callbacks for given params."""
callbacks = []
if is_main_process():
if benchmark == False:
tb_callback = tf.keras.callbacks.TensorBoard(
log_dir=params['model_dir'], profile_batch=0, histogram_freq = 1)
callbacks.append(tb_callback)
if params['moving_average_decay']:
emackpt_callback = AverageModelCheckpoint(
filepath=os.path.join(params['model_dir'], 'ema_weights', 'emackpt-{epoch:02d}'),
update_weights=False,
amp=params['mixed_precision'],
verbose=1,
save_freq='epoch',
save_weights_only=True,
period=params['checkpoint_period'])
callbacks.append(emackpt_callback)
ckpt_callback = tf.keras.callbacks.ModelCheckpoint(
os.path.join(params['model_dir'], 'ckpt'),
verbose=1,
save_freq='epoch',
save_weights_only=True,
period=params['checkpoint_period'])
callbacks.append(ckpt_callback)
if time_history:
time_callback = TimeHistory(params['batch_size'] * get_world_size(),
logger=logger,
logdir=params['model_dir'],
log_steps=log_steps)
callbacks.append(time_callback)
# log LR in tensorboard
if lr_tb == True and benchmark == False:
callbacks.append(LRTensorBoard(log_dir=params['model_dir']))
hvd_callback = hvd_callbacks.BroadcastGlobalVariablesCallback(0)
callbacks.append(hvd_callback)
# for large batch sizes training schedule of 350/400 epochs gives better mAP
# but the best mAP is generally reached after 75% of the training schedule.
# So we can stop training at that point or continue to train until 300 epochs
stop_75 = False if 'eval' in training_mode or '300' in training_mode else True
early_stopping = StopEarlyCallback(params['num_epochs'], stop_75=stop_75)
callbacks.append(early_stopping)
if 'eval' in training_mode:
cocoeval = COCOEvalCallback(eval_dataset,
eval_freq=params['checkpoint_period'],
start_eval_epoch=200,
eval_params=eval_params,
logger=logger)
callbacks.append(cocoeval)
if params['moving_average_decay']:
callbacks.append(MovingAverageCallback())
if params.get('sample_image', None):
display_callback = DisplayCallback(
params.get('sample_image', None),
os.path.join(params['model_dir'], 'train'))
callbacks.append(display_callback)
return callbacks
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/callback_builder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Keras implementation of efficientdet."""
import functools
from absl import logging
import numpy as np
import tensorflow as tf
from efficientnet import efficientnet_model
from model import dataloader
from model import normalization_builder
from model import activation_builder
from model import fpn_configs
from model import postprocess
from utils import hparams_config
from utils import model_utils
from utils import util_keras
# pylint: disable=arguments-differ # fo keras layers.
class FNode(tf.keras.layers.Layer):
"""A Keras Layer implementing BiFPN Node."""
def __init__(self,
feat_level,
inputs_offsets,
fpn_num_filters,
apply_bn_for_resampling,
is_training_bn,
conv_after_downsample,
conv_bn_act_pattern,
separable_conv,
act_type,
weight_method,
data_format,
name='fnode'):
super().__init__(name=name)
self.feat_level = feat_level
self.inputs_offsets = inputs_offsets
self.fpn_num_filters = fpn_num_filters
self.apply_bn_for_resampling = apply_bn_for_resampling
self.separable_conv = separable_conv
self.act_type = act_type
self.is_training_bn = is_training_bn
self.conv_after_downsample = conv_after_downsample
self.data_format = data_format
self.weight_method = weight_method
self.conv_bn_act_pattern = conv_bn_act_pattern
self.resample_layers = []
self.vars = []
def fuse_features(self, nodes):
"""Fuse features from different resolutions and return a weighted sum.
Args:
nodes: a list of tensorflow features at different levels
Returns:
A tensor denoting the fused feature.
"""
dtype = nodes[0].dtype
if self.weight_method == 'attn':
edge_weights = []
for var in self.vars:
var = tf.cast(var, dtype=dtype)
edge_weights.append(var)
normalized_weights = tf.nn.softmax(tf.stack(edge_weights))
nodes = tf.stack(nodes, axis=-1)
new_node = tf.reduce_sum(nodes * normalized_weights, -1)
elif self.weight_method == 'fastattn':
edge_weights = []
for var in self.vars:
var = tf.cast(var, dtype=dtype)
edge_weights.append(var)
weights_sum = tf.add_n(edge_weights)
nodes = [
nodes[i] * edge_weights[i] / (weights_sum + 0.0001)
for i in range(len(nodes))
]
new_node = tf.add_n(nodes)
elif self.weight_method == 'channel_attn':
edge_weights = []
for var in self.vars:
var = tf.cast(var, dtype=dtype)
edge_weights.append(var)
normalized_weights = tf.nn.softmax(tf.stack(edge_weights, -1), axis=-1)
nodes = tf.stack(nodes, axis=-1)
new_node = tf.reduce_sum(nodes * normalized_weights, -1)
elif self.weight_method == 'channel_fastattn':
edge_weights = []
for var in self.vars:
var = tf.cast(var, dtype=dtype)
edge_weights.append(var)
weights_sum = tf.add_n(edge_weights)
nodes = [
nodes[i] * edge_weights[i] / (weights_sum + 0.0001)
for i in range(len(nodes))
]
new_node = tf.add_n(nodes)
elif self.weight_method == 'sum':
new_node = sum(nodes) # tf.add_n is not supported by tflite gpu.
else:
raise ValueError('unknown weight_method %s' % self.weight_method)
return new_node
def _add_wsm(self, initializer):
for i, _ in enumerate(self.inputs_offsets):
name = 'WSM' + ('' if i == 0 else '_' + str(i))
self.vars.append(self.add_weight(initializer=initializer, name=name))
def build(self, feats_shape):
for i, input_offset in enumerate(self.inputs_offsets):
name = 'resample_{}_{}_{}'.format(i, input_offset, len(feats_shape))
self.resample_layers.append(
ResampleFeatureMap(
self.feat_level,
self.fpn_num_filters,
self.apply_bn_for_resampling,
self.is_training_bn,
self.conv_after_downsample,
data_format=self.data_format,
name=name))
if self.weight_method == 'attn':
self._add_wsm('ones')
elif self.weight_method == 'fastattn':
self._add_wsm('ones')
elif self.weight_method == 'channel_attn':
num_filters = int(self.fpn_num_filters)
self._add_wsm(lambda: tf.ones([num_filters]))
elif self.weight_method == 'channel_fastattn':
num_filters = int(self.fpn_num_filters)
self._add_wsm(lambda: tf.ones([num_filters]))
self.op_after_combine = OpAfterCombine(
self.is_training_bn,
self.conv_bn_act_pattern,
self.separable_conv,
self.fpn_num_filters,
self.act_type,
self.data_format,
name='op_after_combine{}'.format(len(feats_shape)))
self.built = True
super().build(feats_shape)
def call(self, feats, training):
nodes = []
for i, input_offset in enumerate(self.inputs_offsets):
input_node = feats[input_offset]
input_node = self.resample_layers[i](input_node, training, feats)
nodes.append(input_node)
new_node = self.fuse_features(nodes)
new_node = self.op_after_combine(new_node)
return feats + [new_node]
class OpAfterCombine(tf.keras.layers.Layer):
"""Operation after combining input features during feature fusiong."""
def __init__(self,
is_training_bn,
conv_bn_act_pattern,
separable_conv,
fpn_num_filters,
act_type,
data_format,
name='op_after_combine'):
super().__init__(name=name)
self.conv_bn_act_pattern = conv_bn_act_pattern
self.separable_conv = separable_conv
self.fpn_num_filters = fpn_num_filters
self.act_type = act_type
self.data_format = data_format
self.is_training_bn = is_training_bn
if self.separable_conv:
conv2d_layer = functools.partial(
tf.keras.layers.SeparableConv2D, depth_multiplier=1)
else:
conv2d_layer = tf.keras.layers.Conv2D
self.conv_op = conv2d_layer(
filters=fpn_num_filters,
kernel_size=(3, 3),
padding='same',
use_bias=not self.conv_bn_act_pattern,
data_format=self.data_format,
name='conv')
self.bn = util_keras.build_batch_norm(
is_training_bn=self.is_training_bn,
data_format=self.data_format,
name='bn')
def call(self, new_node, training):
if not self.conv_bn_act_pattern:
new_node = activation_builder.activation_fn(new_node, self.act_type)
new_node = self.conv_op(new_node)
new_node = self.bn(new_node, training=training)
if self.conv_bn_act_pattern:
new_node = activation_builder.activation_fn(new_node, self.act_type)
return new_node
class ResampleFeatureMap(tf.keras.layers.Layer):
"""Resample feature map for downsampling or upsampling."""
def __init__(self,
feat_level,
target_num_channels,
apply_bn=False,
is_training_bn=None,
conv_after_downsample=False,
data_format=None,
pooling_type=None,
upsampling_type=None,
name='resample_p0'):
super().__init__(name=name)
self.apply_bn = apply_bn
self.is_training_bn = is_training_bn
self.data_format = data_format
self.target_num_channels = target_num_channels
self.feat_level = feat_level
self.conv_after_downsample = conv_after_downsample
self.pooling_type = pooling_type or 'max'
self.upsampling_type = upsampling_type or 'nearest'
self.conv2d = tf.keras.layers.Conv2D(
self.target_num_channels, (1, 1),
padding='same',
data_format=self.data_format,
name='conv2d')
self.bn = util_keras.build_batch_norm(
is_training_bn=self.is_training_bn,
data_format=self.data_format,
name='bn')
def _pool2d(self, inputs, height, width, target_height, target_width):
"""Pool the inputs to target height and width."""
height_stride_size = int((height - 1) // target_height + 1)
width_stride_size = int((width - 1) // target_width + 1)
if self.pooling_type == 'max':
return tf.keras.layers.MaxPooling2D(
pool_size=[height_stride_size + 1, width_stride_size + 1],
strides=[height_stride_size, width_stride_size],
padding='SAME',
data_format=self.data_format)(inputs)
elif self.pooling_type == 'avg':
return tf.keras.layers.AveragePooling2D(
pool_size=[height_stride_size + 1, width_stride_size + 1],
strides=[height_stride_size, width_stride_size],
padding='SAME',
data_format=self.data_format)(inputs)
else:
raise ValueError('Unsupported pooling type {}.'.format(self.pooling_type))
def _upsample2d(self, inputs, target_height, target_width):
return tf.cast(
tf.image.resize(
tf.cast(inputs, tf.float32), [target_height, target_width],
method=self.upsampling_type), inputs.dtype)
def _maybe_apply_1x1(self, feat, training, num_channels):
"""Apply 1x1 conv to change layer width if necessary."""
if num_channels != self.target_num_channels:
feat = self.conv2d(feat)
if self.apply_bn:
feat = self.bn(feat, training=training)
return feat
def call(self, feat, training, all_feats):
hwc_idx = (2, 3, 1) if self.data_format == 'channels_first' else (1, 2, 3)
height, width, num_channels = [feat.shape.as_list()[i] for i in hwc_idx]
if all_feats:
target_feat_shape = all_feats[self.feat_level].shape.as_list()
target_height, target_width, _ = [target_feat_shape[i] for i in hwc_idx]
else:
# Default to downsampling if all_feats is empty.
target_height, target_width = (height + 1) // 2, (width + 1) // 2
# If conv_after_downsample is True, when downsampling, apply 1x1 after
# downsampling for efficiency.
if height > target_height and width > target_width:
if not self.conv_after_downsample:
feat = self._maybe_apply_1x1(feat, training, num_channels)
feat = self._pool2d(feat, height, width, target_height, target_width)
if self.conv_after_downsample:
feat = self._maybe_apply_1x1(feat, training, num_channels)
elif height <= target_height and width <= target_width:
feat = self._maybe_apply_1x1(feat, training, num_channels)
if height < target_height or width < target_width:
feat = self._upsample2d(feat, target_height, target_width)
else:
raise ValueError(
'Incompatible Resampling : feat shape {}x{} target_shape: {}x{}'
.format(height, width, target_height, target_width))
return feat
class ClassNet(tf.keras.layers.Layer):
"""Object class prediction network."""
def __init__(self,
num_classes=90,
num_anchors=9,
num_filters=32,
min_level=3,
max_level=7,
is_training_bn=False,
act_type='swish',
repeats=4,
separable_conv=True,
survival_prob=None,
data_format='channels_last',
name='class_net',
**kwargs):
"""Initialize the ClassNet.
Args:
num_classes: number of classes.
num_anchors: number of anchors.
num_filters: number of filters for "intermediate" layers.
min_level: minimum level for features.
max_level: maximum level for features.
is_training_bn: True if we train the BatchNorm.
act_type: String of the activation used.
repeats: number of intermediate layers.
separable_conv: True to use separable_conv instead of conv2D.
survival_prob: if a value is set then drop connect will be used.
data_format: string of 'channel_first' or 'channels_last'.
name: the name of this layerl.
**kwargs: other parameters.
"""
super().__init__(name=name, **kwargs)
self.num_classes = num_classes
self.num_anchors = num_anchors
self.num_filters = num_filters
self.min_level = min_level
self.max_level = max_level
self.repeats = repeats
self.separable_conv = separable_conv
self.is_training_bn = is_training_bn
self.survival_prob = survival_prob
self.act_type = act_type
self.data_format = data_format
self.conv_ops = []
self.bns = []
if separable_conv:
conv2d_layer = functools.partial(
tf.keras.layers.SeparableConv2D,
depth_multiplier=1,
data_format=data_format,
pointwise_initializer=tf.initializers.VarianceScaling(),
depthwise_initializer=tf.initializers.VarianceScaling())
else:
conv2d_layer = functools.partial(
tf.keras.layers.Conv2D,
data_format=data_format,
kernel_initializer=tf.random_normal_initializer(stddev=0.01))
for i in range(self.repeats):
# If using SeparableConv2D
self.conv_ops.append(
conv2d_layer(
self.num_filters,
kernel_size=3,
bias_initializer=tf.zeros_initializer(),
activation=None,
padding='same',
name='class-%d' % i))
bn_per_level = []
for level in range(self.min_level, self.max_level + 1):
bn_per_level.append(
util_keras.build_batch_norm(
is_training_bn=self.is_training_bn,
data_format=self.data_format,
name='class-%d-bn-%d' % (i, level),
))
self.bns.append(bn_per_level)
self.classes = conv2d_layer(
num_classes * num_anchors,
kernel_size=3,
bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01)),
padding='same',
name='class-predict')
def call(self, inputs, training, **kwargs):
"""Call ClassNet."""
class_outputs = []
for level_id in range(0, self.max_level - self.min_level + 1):
image = inputs[level_id]
for i in range(self.repeats):
original_image = image
image = self.conv_ops[i](image)
image = self.bns[i][level_id](image, training=training)
if self.act_type:
image = activation_builder.activation_fn(image, self.act_type)
if i > 0 and self.survival_prob:
image = model_utils.drop_connect(image, training, self.survival_prob)
image = image + original_image
class_outputs.append(self.classes(image))
return class_outputs
class BoxNet(tf.keras.layers.Layer):
"""Box regression network."""
def __init__(self,
num_anchors=9,
num_filters=32,
min_level=3,
max_level=7,
is_training_bn=False,
act_type='swish',
repeats=4,
separable_conv=True,
survival_prob=None,
data_format='channels_last',
name='box_net',
**kwargs):
"""Initialize BoxNet.
Args:
num_anchors: number of anchors used.
num_filters: number of filters for "intermediate" layers.
min_level: minimum level for features.
max_level: maximum level for features.
is_training_bn: True if we train the BatchNorm.
act_type: String of the activation used.
repeats: number of "intermediate" layers.
separable_conv: True to use separable_conv instead of conv2D.
survival_prob: if a value is set then drop connect will be used.
data_format: string of 'channel_first' or 'channels_last'.
name: Name of the layer.
**kwargs: other parameters.
"""
super().__init__(name=name, **kwargs)
self.num_anchors = num_anchors
self.num_filters = num_filters
self.min_level = min_level
self.max_level = max_level
self.repeats = repeats
self.separable_conv = separable_conv
self.is_training_bn = is_training_bn
self.survival_prob = survival_prob
self.act_type = act_type
self.data_format = data_format
self.conv_ops = []
self.bns = []
for i in range(self.repeats):
# If using SeparableConv2D
if self.separable_conv:
self.conv_ops.append(
tf.keras.layers.SeparableConv2D(
filters=self.num_filters,
depth_multiplier=1,
pointwise_initializer=tf.initializers.VarianceScaling(),
depthwise_initializer=tf.initializers.VarianceScaling(),
data_format=self.data_format,
kernel_size=3,
activation=None,
bias_initializer=tf.zeros_initializer(),
padding='same',
name='box-%d' % i))
# If using Conv2d
else:
self.conv_ops.append(
tf.keras.layers.Conv2D(
filters=self.num_filters,
kernel_initializer=tf.random_normal_initializer(stddev=0.01),
data_format=self.data_format,
kernel_size=3,
activation=None,
bias_initializer=tf.zeros_initializer(),
padding='same',
name='box-%d' % i))
bn_per_level = []
for level in range(self.min_level, self.max_level + 1):
bn_per_level.append(
util_keras.build_batch_norm(
is_training_bn=self.is_training_bn,
data_format=self.data_format,
name='box-%d-bn-%d' % (i, level)))
self.bns.append(bn_per_level)
if self.separable_conv:
self.boxes = tf.keras.layers.SeparableConv2D(
filters=4 * self.num_anchors,
depth_multiplier=1,
pointwise_initializer=tf.initializers.VarianceScaling(),
depthwise_initializer=tf.initializers.VarianceScaling(),
data_format=self.data_format,
kernel_size=3,
activation=None,
bias_initializer=tf.zeros_initializer(),
padding='same',
name='box-predict')
else:
self.boxes = tf.keras.layers.Conv2D(
filters=4 * self.num_anchors,
kernel_initializer=tf.random_normal_initializer(stddev=0.01),
data_format=self.data_format,
kernel_size=3,
activation=None,
bias_initializer=tf.zeros_initializer(),
padding='same',
name='box-predict')
def call(self, inputs, training):
"""Call boxnet."""
box_outputs = []
for level_id in range(0, self.max_level - self.min_level + 1):
image = inputs[level_id]
for i in range(self.repeats):
original_image = image
image = self.conv_ops[i](image)
image = self.bns[i][level_id](image, training=training)
if self.act_type:
image = activation_builder.activation_fn(image, self.act_type)
if i > 0 and self.survival_prob:
image = model_utils.drop_connect(image, training, self.survival_prob)
image = image + original_image
box_outputs.append(self.boxes(image))
return box_outputs
class SegmentationHead(tf.keras.layers.Layer):
"""Keras layer for semantic segmentation head."""
def __init__(self,
num_classes,
num_filters,
min_level,
max_level,
data_format,
is_training_bn,
act_type,
**kwargs):
"""Initialize SegmentationHead.
Args:
num_classes: number of classes.
num_filters: number of filters for "intermediate" layers.
min_level: minimum level for features.
max_level: maximum level for features.
data_format: string of 'channel_first' or 'channels_last'.
is_training_bn: True if we train the BatchNorm.
act_type: String of the activation used.
**kwargs: other parameters.
"""
super().__init__(**kwargs)
self.act_type = act_type
self.con2d_ts = []
self.con2d_t_bns = []
for _ in range(max_level - min_level):
self.con2d_ts.append(
tf.keras.layers.Conv2DTranspose(
num_filters,
3,
strides=2,
padding='same',
data_format=data_format,
use_bias=False))
self.con2d_t_bns.append(
util_keras.build_batch_norm(
is_training_bn=is_training_bn,
data_format=data_format,
name='bn'))
self.head_transpose = tf.keras.layers.Conv2DTranspose(
num_classes, 3, strides=2, padding='same')
def call(self, feats, training):
x = feats[-1]
skips = list(reversed(feats[:-1]))
for con2d_t, con2d_t_bn, skip in zip(self.con2d_ts, self.con2d_t_bns,
skips):
x = con2d_t(x)
x = con2d_t_bn(x, training)
x = activation_builder.activation_fn(x, self.act_type)
x = tf.concat([x, skip], axis=-1)
# This is the last layer of the model
return self.head_transpose(x) # 64x64 -> 128x128
class FPNCells(tf.keras.layers.Layer):
"""FPN cells."""
def __init__(self, config, name='fpn_cells'):
super().__init__(name=name)
self.config = config
if config.fpn_config:
self.fpn_config = config.fpn_config
else:
self.fpn_config = fpn_configs.get_fpn_config(config.fpn_name,
config.min_level,
config.max_level,
config.fpn_weight_method)
self.cells = [
FPNCell(self.config, name='cell_%d' % rep)
for rep in range(self.config.fpn_cell_repeats)
]
def call(self, feats, training):
for cell in self.cells:
cell_feats = cell(feats, training)
min_level = self.config.min_level
max_level = self.config.max_level
feats = []
for level in range(min_level, max_level + 1):
for i, fnode in enumerate(reversed(self.fpn_config.nodes)):
if fnode['feat_level'] == level:
feats.append(cell_feats[-1 - i])
break
return feats
class FPNCell(tf.keras.layers.Layer):
"""A single FPN cell."""
def __init__(self, config, name='fpn_cell'):
super().__init__(name=name)
self.config = config
if config.fpn_config:
self.fpn_config = config.fpn_config
else:
self.fpn_config = fpn_configs.get_fpn_config(config.fpn_name,
config.min_level,
config.max_level,
config.fpn_weight_method)
self.fnodes = []
for i, fnode_cfg in enumerate(self.fpn_config.nodes):
logging.info('fnode %d : %s', i, fnode_cfg)
fnode = FNode(
fnode_cfg['feat_level'] - self.config.min_level,
fnode_cfg['inputs_offsets'],
config.fpn_num_filters,
config.apply_bn_for_resampling,
config.is_training_bn,
config.conv_after_downsample,
config.conv_bn_act_pattern,
config.separable_conv,
config.act_type,
weight_method=self.fpn_config.weight_method,
data_format=config.data_format,
name='fnode%d' % i)
self.fnodes.append(fnode)
def call(self, feats, training):
for fnode in self.fnodes:
feats = fnode(feats, training)
return feats
class EfficientDetNet(tf.keras.Model):
"""EfficientDet keras network without pre/post-processing."""
def __init__(self, model_name=None, config=None, name=''):
"""Initialize model."""
super().__init__(name=name)
config = config or hparams_config.get_efficientdet_config(model_name)
self.config = config
# Backbone.
backbone_name = config.backbone_name
is_training_bn = config.is_training_bn
if 'efficientnet' in backbone_name:
override_params = {
'batch_norm':
normalization_builder.batch_norm_class(is_training_bn),
'relu_fn':
functools.partial(activation_builder.activation_fn, act_type=config.act_type),
'weight_decay': config.weight_decay,
'data_format': config.data_format,
'activation': config.act_type,
}
if 'b0' in backbone_name:
override_params['survival_prob'] = 0.0
override_params['data_format'] = config.data_format
self.backbone = efficientnet_model.EfficientNet().from_name(
model_name=backbone_name, features_only=True, model_weights_path=config.backbone_init,
weights_format='saved_model', overrides=override_params)
# Feature network.
self.resample_layers = [] # additional resampling layers.
for level in range(6, config.max_level + 1):
# Adds a coarser level by downsampling the last feature map.
self.resample_layers.append(
ResampleFeatureMap(
feat_level=(level - config.min_level),
target_num_channels=config.fpn_num_filters,
apply_bn=config.apply_bn_for_resampling,
is_training_bn=config.is_training_bn,
conv_after_downsample=config.conv_after_downsample,
data_format=config.data_format,
name='resample_p%d' % level,
))
self.fpn_cells = FPNCells(config)
# class/box output prediction network.
num_anchors = len(config.aspect_ratios) * config.num_scales
num_filters = config.fpn_num_filters
for head in config.heads:
if head == 'object_detection':
self.class_net = ClassNet(
num_classes=config.num_classes,
num_anchors=num_anchors,
num_filters=num_filters,
min_level=config.min_level,
max_level=config.max_level,
is_training_bn=config.is_training_bn,
act_type=config.act_type,
repeats=config.box_class_repeats,
separable_conv=config.separable_conv,
survival_prob=config.survival_prob,
data_format=config.data_format)
self.box_net = BoxNet(
num_anchors=num_anchors,
num_filters=num_filters,
min_level=config.min_level,
max_level=config.max_level,
is_training_bn=config.is_training_bn,
act_type=config.act_type,
repeats=config.box_class_repeats,
separable_conv=config.separable_conv,
survival_prob=config.survival_prob,
data_format=config.data_format)
if head == 'segmentation':
self.seg_head = SegmentationHead(
num_classes=config.seg_num_classes,
num_filters=num_filters,
min_level=config.min_level,
max_level=config.max_level,
is_training_bn=config.is_training_bn,
act_type=config.act_type,
data_format=config.data_format)
def _init_set_name(self, name, zero_based=True):
"""A hack to allow empty model name for legacy checkpoint compitability."""
if name == '': # pylint: disable=g-explicit-bool-comparison
self._name = name
else:
self._name = super().__init__(name, zero_based)
def call(self, inputs, training):
config = self.config
# call backbone network.
all_feats = self.backbone(inputs, training=training)
feats = all_feats[config.min_level:config.max_level + 1]
# Build additional input features that are not from backbone.
for resample_layer in self.resample_layers:
feats.append(resample_layer(feats[-1], training, None))
# call feature network.
fpn_feats = self.fpn_cells(feats, training)
# call class/box/seg output network.
outputs = []
if 'object_detection' in config.heads:
class_outputs = self.class_net(fpn_feats, training)
box_outputs = self.box_net(fpn_feats, training)
outputs.extend([class_outputs, box_outputs])
if 'segmentation' in config.heads:
seg_outputs = self.seg_head(fpn_feats, training)
outputs.append(seg_outputs)
return tuple(outputs)
class EfficientDetModel(EfficientDetNet):
"""EfficientDet full keras model with pre and post processing."""
def _preprocessing(self, raw_images, image_size, mode=None):
"""Preprocess images before feeding to the network."""
if not mode:
return raw_images, None
image_size = model_utils.parse_image_size(image_size)
if mode != 'infer':
# We only support inference for now.
raise ValueError('preprocessing must be infer or empty')
def map_fn(image):
input_processor = dataloader.DetectionInputProcessor(
image, image_size)
input_processor.normalize_image()
input_processor.set_scale_factors_to_output_size()
image = input_processor.resize_and_crop_image()
image_scale = input_processor.image_scale_to_original
return image, image_scale
if raw_images.shape.as_list()[0]: # fixed batch size.
batch_size = raw_images.shape.as_list()[0]
outputs = [map_fn(raw_images[i]) for i in range(batch_size)]
return [tf.stack(y) for y in zip(*outputs)]
# otherwise treat it as dynamic batch size.
return tf.vectorized_map(map_fn, raw_images)
def _postprocess(self, cls_outputs, box_outputs, scales, mode='global'):
"""Postprocess class and box predictions."""
if not mode:
return cls_outputs, box_outputs
# TODO(tanmingxing): remove this cast once FP16 works postprocessing.
cls_outputs = [tf.cast(i, tf.float32) for i in cls_outputs]
box_outputs = [tf.cast(i, tf.float32) for i in box_outputs]
if mode == 'global':
return postprocess.postprocess_global(self.config.as_dict(), cls_outputs,
box_outputs, scales)
if mode == 'per_class':
return postprocess.postprocess_per_class(self.config.as_dict(),
cls_outputs, box_outputs, scales)
raise ValueError('Unsupported postprocess mode {}'.format(mode))
def call(self, inputs, training=False, pre_mode='infer', post_mode='global'):
"""Call this model.
Args:
inputs: a tensor with common shape [batch, height, width, channels].
training: If true, it is training mode. Otherwise, eval mode.
pre_mode: preprocessing mode, must be {None, 'infer'}.
post_mode: postprrocessing mode, must be {None, 'global', 'per_class'}.
Returns:
the output tensor list.
"""
config = self.config
# preprocess.
inputs, scales = self._preprocessing(inputs, config.image_size, pre_mode)
# network.
outputs = super().call(inputs, training)
if 'object_detection' in config.heads and post_mode:
# postprocess for detection
det_outputs = self._postprocess(outputs[0], outputs[1], scales, post_mode)
outputs = det_outputs + outputs[2:]
return outputs
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/efficientdet_keras.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Anchor definition."""
import collections
import numpy as np
import tensorflow as tf
from utils import model_utils
from object_detection import argmax_matcher
from object_detection import box_list
from object_detection import faster_rcnn_box_coder
from object_detection import region_similarity_calculator
from object_detection import target_assigner
MAX_DETECTION_POINTS = 5000
def decode_box_outputs(pred_boxes, anchor_boxes):
"""Transforms relative regression coordinates to absolute positions.
Network predictions are normalized and relative to a given anchor; this
reverses the transformation and outputs absolute coordinates for the input
image.
Args:
pred_boxes: predicted box regression targets.
anchor_boxes: anchors on all feature levels.
Returns:
outputs: bounding boxes.
"""
anchor_boxes = tf.cast(anchor_boxes, pred_boxes.dtype)
ycenter_a = (anchor_boxes[..., 0] + anchor_boxes[..., 2]) / 2
xcenter_a = (anchor_boxes[..., 1] + anchor_boxes[..., 3]) / 2
ha = anchor_boxes[..., 2] - anchor_boxes[..., 0]
wa = anchor_boxes[..., 3] - anchor_boxes[..., 1]
ty, tx, th, tw = tf.unstack(pred_boxes, num=4, axis=-1)
w = tf.math.exp(tw) * wa
h = tf.math.exp(th) * ha
ycenter = ty * ha + ycenter_a
xcenter = tx * wa + xcenter_a
ymin = ycenter - h / 2.
xmin = xcenter - w / 2.
ymax = ycenter + h / 2.
xmax = xcenter + w / 2.
return tf.stack([ymin, xmin, ymax, xmax], axis=-1)
def _generate_anchor_configs(feat_sizes, min_level, max_level, num_scales,
aspect_ratios):
"""Generates mapping from output level to a list of anchor configurations.
A configuration is a tuple of (num_anchors, scale, aspect_ratio).
Args:
feat_sizes: list of dict of integer numbers of feature map sizes.
min_level: integer number of minimum level of the output feature pyramid.
max_level: integer number of maximum level of the output feature pyramid.
num_scales: integer number representing intermediate scales added
on each level. For instances, num_scales=2 adds two additional
anchor scales [2^0, 2^0.5] on each level.
aspect_ratios: list of tuples representing the aspect ratio anchors added
on each level. For instances, aspect_ratios =
[(1, 1), (1.4, 0.7), (0.7, 1.4)] adds three anchors on each level.
Returns:
anchor_configs: a dictionary with keys as the levels of anchors and
values as a list of anchor configuration.
"""
anchor_configs = {}
for level in range(min_level, max_level + 1):
anchor_configs[level] = []
for scale_octave in range(num_scales):
for aspect in aspect_ratios:
anchor_configs[level].append(
((feat_sizes[0]['height'] / float(feat_sizes[level]['height']),
feat_sizes[0]['width'] / float(feat_sizes[level]['width'])),
scale_octave / float(num_scales), aspect))
return anchor_configs
def _generate_anchor_boxes(image_size, anchor_scale, anchor_configs):
"""Generates multiscale anchor boxes.
Args:
image_size: tuple of integer numbers of input image size.
anchor_scale: float number representing the scale of size of the base
anchor to the feature stride 2^level.
anchor_configs: a dictionary with keys as the levels of anchors and
values as a list of anchor configuration.
Returns:
anchor_boxes: a numpy array with shape [N, 4], which stacks anchors on all
feature levels.
Raises:
ValueError: input size must be the multiple of largest feature stride.
"""
boxes_all = []
for _, configs in anchor_configs.items():
boxes_level = []
for config in configs:
stride, octave_scale, aspect = config
base_anchor_size_x = anchor_scale * stride[1] * 2**octave_scale
base_anchor_size_y = anchor_scale * stride[0] * 2**octave_scale
anchor_size_x_2 = base_anchor_size_x * aspect[0] / 2.0
anchor_size_y_2 = base_anchor_size_y * aspect[1] / 2.0
x = np.arange(stride[1] / 2, image_size[1], stride[1])
y = np.arange(stride[0] / 2, image_size[0], stride[0])
xv, yv = np.meshgrid(x, y)
xv = xv.reshape(-1)
yv = yv.reshape(-1)
boxes = np.vstack((yv - anchor_size_y_2, xv - anchor_size_x_2,
yv + anchor_size_y_2, xv + anchor_size_x_2))
boxes = np.swapaxes(boxes, 0, 1)
boxes_level.append(np.expand_dims(boxes, axis=1))
# concat anchors on the same level to the reshape NxAx4
boxes_level = np.concatenate(boxes_level, axis=1)
boxes_all.append(boxes_level.reshape([-1, 4]))
anchor_boxes = np.vstack(boxes_all)
return anchor_boxes
class Anchors(object):
"""RetinaNet Anchors class."""
def __init__(self, min_level, max_level, num_scales, aspect_ratios,
anchor_scale, image_size):
"""Constructs multiscale RetinaNet anchors.
Args:
min_level: integer number of minimum level of the output feature pyramid.
max_level: integer number of maximum level of the output feature pyramid.
num_scales: integer number representing intermediate scales added
on each level. For instances, num_scales=2 adds two additional
anchor scales [2^0, 2^0.5] on each level.
aspect_ratios: list of tuples representing the aspect ratio anchors added
on each level. For instances, aspect_ratios =
[(1, 1), (1.4, 0.7), (0.7, 1.4)] adds three anchors on each level.
anchor_scale: float number representing the scale of size of the base
anchor to the feature stride 2^level.
image_size: integer number or tuple of integer number of input image size.
"""
self.min_level = min_level
self.max_level = max_level
self.num_scales = num_scales
self.aspect_ratios = aspect_ratios
self.anchor_scale = anchor_scale
self.image_size = model_utils.parse_image_size(image_size)
self.feat_sizes = model_utils.get_feat_sizes(image_size, max_level)
self.config = self._generate_configs()
self.boxes = self._generate_boxes()
def _generate_configs(self):
"""Generate configurations of anchor boxes."""
return _generate_anchor_configs(self.feat_sizes, self.min_level,
self.max_level, self.num_scales,
self.aspect_ratios)
def _generate_boxes(self):
"""Generates multiscale anchor boxes."""
boxes = _generate_anchor_boxes(self.image_size, self.anchor_scale,
self.config)
boxes = tf.convert_to_tensor(boxes, dtype=tf.float32)
return boxes
def get_anchors_per_location(self):
return self.num_scales * len(self.aspect_ratios)
class AnchorLabeler(object):
"""Labeler for multiscale anchor boxes."""
def __init__(self, anchors, num_classes, match_threshold=0.5):
"""Constructs anchor labeler to assign labels to anchors.
Args:
anchors: an instance of class Anchors.
num_classes: integer number representing number of classes in the dataset.
match_threshold: float number between 0 and 1 representing the threshold
to assign positive labels for anchors.
"""
similarity_calc = region_similarity_calculator.IouSimilarity()
matcher = argmax_matcher.ArgMaxMatcher(
match_threshold,
unmatched_threshold=match_threshold,
negatives_lower_than_unmatched=True,
force_match_for_each_row=True)
box_coder = faster_rcnn_box_coder.FasterRcnnBoxCoder()
self._target_assigner = target_assigner.TargetAssigner(
similarity_calc, matcher, box_coder)
self._anchors = anchors
self._match_threshold = match_threshold
self._num_classes = num_classes
def _unpack_labels(self, labels):
"""Unpacks an array of labels into multiscales labels."""
labels_unpacked = collections.OrderedDict()
anchors = self._anchors
count = 0
for level in range(anchors.min_level, anchors.max_level + 1):
feat_size = anchors.feat_sizes[level]
steps = feat_size['height'] * feat_size[
'width'] * anchors.get_anchors_per_location()
indices = tf.range(count, count + steps)
count += steps
labels_unpacked[level] = tf.reshape(
tf.gather(labels, indices),
[feat_size['height'], feat_size['width'], -1])
return labels_unpacked
def label_anchors(self, gt_boxes, gt_labels):
"""Labels anchors with ground truth inputs.
Args:
gt_boxes: A float tensor with shape [N, 4] representing groundtruth boxes.
For each row, it stores [y0, x0, y1, x1] for four corners of a box.
gt_labels: A integer tensor with shape [N, 1] representing groundtruth
classes.
Returns:
cls_targets_dict: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, num_anchors]. The height_l and width_l
represent the dimension of class logits at l-th level.
box_targets_dict: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, num_anchors * 4]. The height_l and
width_l represent the dimension of bounding box regression output at
l-th level.
num_positives: scalar tensor storing number of positives in an image.
"""
gt_box_list = box_list.BoxList(gt_boxes)
anchor_box_list = box_list.BoxList(self._anchors.boxes)
# cls_weights, box_weights are not used
cls_targets, _, box_targets, _, matches = self._target_assigner.assign(
anchor_box_list, gt_box_list, gt_labels)
# class labels start from 1 and the background class = -1
cls_targets -= 1
cls_targets = tf.cast(cls_targets, tf.int32)
# Unpack labels.
cls_targets_dict = self._unpack_labels(cls_targets)
box_targets_dict = self._unpack_labels(box_targets)
num_positives = tf.reduce_sum(
tf.cast(tf.not_equal(matches.match_results, -1), tf.float32))
return cls_targets_dict, box_targets_dict, num_positives
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/anchors.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
r"""Inference related utilities."""
import copy
import os
import time
from typing import Text, Dict, Any
from absl import logging
import numpy as np
import tensorflow as tf
import dllogger as DLLogger
from model import efficientdet_keras
from model import label_util
from utils import hparams_config
from utils import model_utils
from utils import util_keras
from visualize import vis_utils
def visualize_image(image,
boxes,
classes,
scores,
label_map=None,
min_score_thresh=0.01,
max_boxes_to_draw=1000,
line_thickness=2,
**kwargs):
"""Visualizes a given image.
Args:
image: a image with shape [H, W, C].
boxes: a box prediction with shape [N, 4] ordered [ymin, xmin, ymax, xmax].
classes: a class prediction with shape [N].
scores: A list of float value with shape [N].
label_map: a dictionary from class id to name.
min_score_thresh: minimal score for showing. If claass probability is below
this threshold, then the object will not show up.
max_boxes_to_draw: maximum bounding box to draw.
line_thickness: how thick is the bounding box line.
**kwargs: extra parameters.
Returns:
output_image: an output image with annotated boxes and classes.
"""
label_map = label_util.get_label_map(label_map or 'coco')
category_index = {k: {'id': k, 'name': label_map[k]} for k in label_map}
img = np.array(image)
vis_utils.visualize_boxes_and_labels_on_image_array(
img,
boxes,
classes,
scores,
category_index,
min_score_thresh=min_score_thresh,
max_boxes_to_draw=max_boxes_to_draw,
line_thickness=line_thickness,
**kwargs)
return img
class ExportModel(tf.Module):
def __init__(self, model):
super().__init__()
self.model = model
@tf.function
def __call__(self, imgs):
return self.model(imgs, training=False, post_mode='global')
class ServingDriver(object):
"""A driver for serving single or batch images.
This driver supports serving with image files or arrays, with configurable
batch size.
Example 1. Serving streaming image contents:
driver = inference.ServingDriver(
'efficientdet-d0', '/tmp/efficientdet-d0', batch_size=1)
driver.build()
for m in image_iterator():
predictions = driver.serve_files([m])
boxes, scores, classes, _ = tf.nest.map_structure(np.array, predictions)
driver.visualize(m, boxes[0], scores[0], classes[0])
# m is the new image with annotated boxes.
Example 2. Serving batch image contents:
imgs = []
for f in ['/tmp/1.jpg', '/tmp/2.jpg']:
imgs.append(np.array(Image.open(f)))
driver = inference.ServingDriver(
'efficientdet-d0', '/tmp/efficientdet-d0', batch_size=len(imgs))
driver.build()
predictions = driver.serve(imgs)
boxes, scores, classes, _ = tf.nest.map_structure(np.array, predictions)
for i in range(len(imgs)):
driver.visualize(imgs[i], boxes[i], scores[i], classes[i])
Example 3: another way is to use SavedModel:
# step1: export a model.
driver = inference.ServingDriver('efficientdet-d0', '/tmp/efficientdet-d0')
driver.build()
driver.export('/tmp/saved_model_path')
# step2: Serve a model.
driver.load(self.saved_model_dir)
raw_images = []
for f in tf.io.gfile.glob('/tmp/images/*.jpg'):
raw_images.append(np.array(PIL.Image.open(f)))
detections = driver.serve(raw_images)
boxes, scores, classes, _ = tf.nest.map_structure(np.array, detections)
for i in range(len(imgs)):
driver.visualize(imgs[i], boxes[i], scores[i], classes[i])
"""
def __init__(self,
model_name: Text,
ckpt_path: Text = None,
batch_size: int = 1,
min_score_thresh: float = None,
max_boxes_to_draw: float = None,
model_params: Dict[Text, Any] = None):
"""Initialize the inference driver.
Args:
model_name: target model name, such as efficientdet-d0.
ckpt_path: checkpoint path, such as /tmp/efficientdet-d0/.
batch_size: batch size for inference.
min_score_thresh: minimal score threshold for filtering predictions.
max_boxes_to_draw: the maximum number of boxes per image.
model_params: model parameters for overriding the config.
"""
super().__init__()
self.model_name = model_name
self.ckpt_path = ckpt_path
self.batch_size = batch_size
self.params = hparams_config.get_detection_config(model_name).as_dict()
if model_params:
self.params.update(model_params)
self.params.update(dict(is_training_bn=False))
self.label_map = self.params.get('label_map', None)
self.model = None
self.min_score_thresh = min_score_thresh
self.max_boxes_to_draw = max_boxes_to_draw
mixed_precision = self.params.get('mixed_precision', None)
precision = 'mixed_float16' if mixed_precision else 'float32'
policy = tf.keras.mixed_precision.experimental.Policy(precision)
tf.keras.mixed_precision.experimental.set_policy(policy)
def build(self, params_override=None):
"""Build model and restore checkpoints."""
params = copy.deepcopy(self.params)
if params_override:
params.update(params_override)
config = hparams_config.get_efficientdet_config(self.model_name)
config.override(params)
self.model = efficientdet_keras.EfficientDetModel(config=config)
image_size = model_utils.parse_image_size(params['image_size'])
self.model.build((self.batch_size, *image_size, 3))
util_keras.restore_ckpt(self.model, self.ckpt_path, 0,
params['moving_average_decay'])
def visualize(self, image, boxes, classes, scores, **kwargs):
"""Visualize prediction on image."""
return visualize_image(image, boxes, classes.astype(int), scores,
self.label_map, **kwargs)
def benchmark(self, image_arrays, bm_runs=10, trace_filename=None):
"""Benchmark inference latency/throughput.
Args:
image_arrays: a list of images in numpy array format.
bm_runs: Number of benchmark runs.
trace_filename: If None, specify the filename for saving trace.
"""
if not self.model:
self.build()
@tf.function
def test_func(image_arrays):
return self.model(image_arrays, training=False)
latency = []
for _ in range(10): # warmup 10 runs.
test_func(image_arrays)
start = time.perf_counter()
for _ in range(bm_runs):
batch_start = time.perf_counter()
test_func(image_arrays)
latency.append(time.perf_counter() - batch_start)
end = time.perf_counter()
inference_time = (end - start) / bm_runs
print('Per batch inference time: ', inference_time)
fps = self.batch_size / inference_time
print('FPS: ', fps)
latency_avg = sum(latency) / len(latency)
latency.sort()
def _latency_avg(n):
return sum(latency[:n]) / n
latency_90 = _latency_avg(int(len(latency)*0.9))
latency_95 = _latency_avg(int(len(latency)*0.95))
latency_99 = _latency_avg(int(len(latency)*0.99))
stats = {'inference_fps': fps, 'inference_latency_ms': float(inference_time * 1000),
'latency_avg' : latency_avg, 'latency_90': latency_90,
'latency_95' : latency_95, 'latency_99': latency_99,}
DLLogger.log(step=(), data=stats)
if trace_filename:
options = tf.profiler.experimental.ProfilerOptions()
tf.profiler.experimental.start(trace_filename, options)
test_func(image_arrays)
tf.profiler.experimental.stop()
def serve(self, image_arrays):
"""Serve a list of image arrays.
Args:
image_arrays: A list of image content with each image has shape [height,
width, 3] and uint8 type.
Returns:
A list of detections.
"""
if not self.model:
self.build()
return self.model(image_arrays, False)
def load(self, saved_model_dir_or_frozen_graph: Text):
"""Load the model using saved model or a frozen graph."""
# Load saved model if it is a folder.
if tf.saved_model.contains_saved_model(saved_model_dir_or_frozen_graph):
self.model = tf.saved_model.load(saved_model_dir_or_frozen_graph)
return
# Load a frozen graph.
def wrap_frozen_graph(graph_def, inputs, outputs):
# https://www.tensorflow.org/guide/migrate
imports_graph_def_fn = lambda: tf.import_graph_def(graph_def, name='')
wrapped_import = tf.compat.v1.wrap_function(imports_graph_def_fn, [])
import_graph = wrapped_import.graph
return wrapped_import.prune(
tf.nest.map_structure(import_graph.as_graph_element, inputs),
tf.nest.map_structure(import_graph.as_graph_element, outputs))
graph_def = tf.Graph().as_graph_def()
with tf.io.gfile.GFile(saved_model_dir_or_frozen_graph, 'rb') as f:
graph_def.ParseFromString(f.read())
self.model = wrap_frozen_graph(
graph_def,
inputs='images:0',
outputs=['Identity:0', 'Identity_1:0', 'Identity_2:0', 'Identity_3:0'])
def freeze(self, func):
"""Freeze the graph."""
# pylint: disable=g-import-not-at-top,disable=g-direct-tensorflow-import
from tensorflow.python.framework.convert_to_constants \
import convert_variables_to_constants_v2_as_graph
_, graphdef = convert_variables_to_constants_v2_as_graph(func)
return graphdef
def export(self,
output_dir: Text,
tflite_path: Text = None,
tensorrt: Text = None):
"""Export a saved model, frozen graph, and potential tflite/tensorrt model.
Args:
output_dir: the output folder for saved model.
tflite_path: the path for saved tflite file.
tensorrt: If not None, must be {'FP32', 'FP16', 'INT8'}.
"""
if not self.model:
self.build()
export_model = ExportModel(self.model)
tf.saved_model.save(
export_model,
output_dir,
signatures=export_model.__call__.get_concrete_function(
tf.TensorSpec(
shape=[None, None, None, 3], dtype=tf.uint8, name='images')))
logging.info('Model saved at %s', output_dir)
# also save freeze pb file.
graphdef = self.freeze(
export_model.__call__.get_concrete_function(
tf.TensorSpec(
shape=[None, None, None, 3], dtype=tf.uint8, name='images')))
proto_path = tf.io.write_graph(
graphdef, output_dir, self.model_name + '_frozen.pb', as_text=False)
logging.info('Frozen graph saved at %s', proto_path)
if tflite_path:
# Neither of the two approaches works so far.
converter = tf.lite.TFLiteConverter.from_keras_model(self.model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
# converter = tf.lite.TFLiteConverter.from_saved_model(output_dir)
# converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_model = converter.convert()
tf.io.gfile.GFile(tflite_path, 'wb').write(tflite_model)
logging.info('TFLite is saved at %s', tflite_path)
if tensorrt:
trt_path = os.path.join(output_dir, 'tensorrt_' + tensorrt.lower())
conversion_params = tf.experimental.tensorrt.ConversionParams(
max_workspace_size_bytes=(2 << 20),
maximum_cached_engines=1,
precision_mode=tensorrt.upper())
converter = tf.experimental.tensorrt.Converter(
output_dir, conversion_params=conversion_params)
converter.convert()
converter.save(trt_path)
logging.info('TensorRT model is saved at %s', trt_path)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/inference.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Data loader and processing."""
from absl import logging
import multiprocessing
import tensorflow as tf
import horovod.tensorflow as hvd
from utils import model_utils
from model import anchors
from object_detection import preprocessor
from object_detection import tf_example_decoder
from utils.horovod_utils import get_rank, get_world_size
from utils.util_keras import get_mixed_precision_policy
class InputProcessor:
"""Base class of Input processor."""
def __init__(self, image, output_size):
"""Initializes a new `InputProcessor`.
Args:
image: The input image before processing.
output_size: The output image size after calling resize_and_crop_image
function.
"""
self._image = image
if isinstance(output_size, int):
self._output_size = (output_size, output_size)
else:
self._output_size = output_size
# Parameters to control rescaling and shifting during preprocessing.
# Image scale defines scale from original image to scaled image.
self._image_scale = tf.constant(1.0)
# The integer height and width of scaled image.
self._scaled_height = tf.shape(image)[0]
self._scaled_width = tf.shape(image)[1]
# The x and y translation offset to crop scaled image to the output size.
self._crop_offset_y = tf.constant(0)
self._crop_offset_x = tf.constant(0)
def normalize_image(self, dtype=tf.float32):
"""Normalize the image to zero mean and unit variance."""
# The image normalization is identical to Cloud TPU ResNet.
self._image = tf.image.convert_image_dtype(self._image, dtype=dtype)
offset = tf.constant([0.485, 0.456, 0.406], dtype=dtype)
offset = tf.expand_dims(offset, axis=0)
offset = tf.expand_dims(offset, axis=0)
self._image -= offset
scale = tf.constant([0.229, 0.224, 0.225], dtype=dtype)
scale = tf.expand_dims(scale, axis=0)
scale = tf.expand_dims(scale, axis=0)
self._image /= scale
def get_image(self):
return self._image
def set_training_random_scale_factors(self,
scale_min,
scale_max,
target_size=None):
"""Set the parameters for multiscale training.
Notably, if train and eval use different sizes, then target_size should be
set as eval size to avoid the discrency between train and eval.
Args:
scale_min: minimal scale factor.
scale_max: maximum scale factor.
target_size: targeted size, usually same as eval. If None, use train size.
"""
if not target_size:
target_size = self._output_size
target_size = model_utils.parse_image_size(target_size)
logging.info('target_size = %s, output_size = %s', target_size,
self._output_size)
# Select a random scale factor.
random_scale_factor = tf.random.uniform([], scale_min, scale_max)
scaled_y = tf.cast(random_scale_factor * target_size[0], tf.int32)
scaled_x = tf.cast(random_scale_factor * target_size[1], tf.int32)
# Recompute the accurate scale_factor using rounded scaled image size.
height = tf.cast(tf.shape(self._image)[0], tf.float32)
width = tf.cast(tf.shape(self._image)[1], tf.float32)
image_scale_y = tf.cast(scaled_y, tf.float32) / height
image_scale_x = tf.cast(scaled_x, tf.float32) / width
image_scale = tf.minimum(image_scale_x, image_scale_y)
# Select non-zero random offset (x, y) if scaled image is larger than
# self._output_size.
scaled_height = tf.cast(height * image_scale, tf.int32)
scaled_width = tf.cast(width * image_scale, tf.int32)
offset_y = tf.cast(scaled_height - self._output_size[0], tf.float32)
offset_x = tf.cast(scaled_width - self._output_size[1], tf.float32)
offset_y = tf.maximum(0.0, offset_y) * tf.random.uniform([], 0, 1)
offset_x = tf.maximum(0.0, offset_x) * tf.random.uniform([], 0, 1)
offset_y = tf.cast(offset_y, tf.int32)
offset_x = tf.cast(offset_x, tf.int32)
self._image_scale = image_scale
self._scaled_height = scaled_height
self._scaled_width = scaled_width
self._crop_offset_x = offset_x
self._crop_offset_y = offset_y
def set_scale_factors_to_output_size(self):
"""Set the parameters to resize input image to self._output_size."""
# Compute the scale_factor using rounded scaled image size.
height = tf.cast(tf.shape(self._image)[0], tf.float32)
width = tf.cast(tf.shape(self._image)[1], tf.float32)
image_scale_y = tf.cast(self._output_size[0], tf.float32) / height
image_scale_x = tf.cast(self._output_size[1], tf.float32) / width
image_scale = tf.minimum(image_scale_x, image_scale_y)
scaled_height = tf.cast(height * image_scale, tf.int32)
scaled_width = tf.cast(width * image_scale, tf.int32)
self._image_scale = image_scale
self._scaled_height = scaled_height
self._scaled_width = scaled_width
def resize_and_crop_image(self, method=tf.image.ResizeMethod.BILINEAR):
"""Resize input image and crop it to the self._output dimension."""
dtype = self._image.dtype
scaled_image = tf.compat.v1.image.resize(
self._image, [self._scaled_height, self._scaled_width], method=method)
if scaled_image.dtype != dtype:
scaled_image = tf.image.convert_image_dtype(scaled_image, dtype=dtype)
scaled_image = scaled_image[self._crop_offset_y:self._crop_offset_y +
self._output_size[0],
self._crop_offset_x:self._crop_offset_x +
self._output_size[1], :]
self._image = tf.image.pad_to_bounding_box(scaled_image, 0, 0,
self._output_size[0],
self._output_size[1])
# self._image = tf.cast(output_image, dtype)
return self._image
class DetectionInputProcessor(InputProcessor):
"""Input processor for object detection."""
def __init__(self, image, output_size, boxes=None, classes=None):
InputProcessor.__init__(self, image, output_size)
self._boxes = boxes
self._classes = classes
def random_horizontal_flip(self):
"""Randomly flip input image and bounding boxes."""
self._image, self._boxes = preprocessor.random_horizontal_flip(
self._image, boxes=self._boxes)
def clip_boxes(self, boxes):
"""Clip boxes to fit in an image."""
ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1)
ymin = tf.clip_by_value(ymin, 0, self._output_size[0] - 1)
xmin = tf.clip_by_value(xmin, 0, self._output_size[1] - 1)
ymax = tf.clip_by_value(ymax, 0, self._output_size[0] - 1)
xmax = tf.clip_by_value(xmax, 0, self._output_size[1] - 1)
boxes = tf.stack([ymin, xmin, ymax, xmax], axis=1)
return boxes
def resize_and_crop_boxes(self):
"""Resize boxes and crop it to the self._output dimension."""
boxlist = preprocessor.box_list.BoxList(self._boxes)
# boxlist is in range of [0, 1], so here we pass the scale_height/width
# instead of just scale.
boxes = preprocessor.box_list_scale(boxlist, self._scaled_height,
self._scaled_width).get()
# Adjust box coordinates based on the offset.
box_offset = tf.stack([
self._crop_offset_y,
self._crop_offset_x,
self._crop_offset_y,
self._crop_offset_x,
])
boxes -= tf.cast(tf.reshape(box_offset, [1, 4]), tf.float32)
# Clip the boxes.
boxes = self.clip_boxes(boxes)
# Filter out ground truth boxes that are illegal.
indices = tf.where(
tf.not_equal((boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]),
0))
boxes = tf.gather_nd(boxes, indices)
classes = tf.gather_nd(self._classes, indices)
return boxes, classes
@property
def image_scale(self):
# Return image scale from original image to scaled image.
return self._image_scale
@property
def image_scale_to_original(self):
# Return image scale from scaled image to original image.
return 1.0 / self._image_scale
@property
def offset_x(self):
return self._crop_offset_x
@property
def offset_y(self):
return self._crop_offset_y
def pad_to_fixed_size(data, pad_value, output_shape):
"""Pad data to a fixed length at the first dimension.
Args:
data: Tensor to be padded to output_shape.
pad_value: A constant value assigned to the paddings.
output_shape: The output shape of a 2D tensor.
Returns:
The Padded tensor with output_shape [max_instances_per_image, dimension].
"""
max_instances_per_image = output_shape[0]
dimension = output_shape[1]
data = tf.reshape(data, [-1, dimension])
num_instances = tf.shape(data)[0]
msg = 'ERROR: please increase config.max_instances_per_image'
with tf.control_dependencies(
[tf.assert_less(num_instances, max_instances_per_image, message=msg)]):
pad_length = max_instances_per_image - num_instances
paddings = pad_value * tf.ones([pad_length, dimension])
padded_data = tf.concat([data, paddings], axis=0)
padded_data = tf.reshape(padded_data, output_shape)
return padded_data
class InputReader:
"""Input reader for dataset."""
def __init__(self,
file_pattern,
is_training,
use_fake_data=False,
max_instances_per_image=None,
enable_map_parallelization=True):
self._file_pattern = file_pattern
self._is_training = is_training
self._use_fake_data = use_fake_data
# COCO has 100 limit, but users may set different values for custom dataset.
self._max_instances_per_image = max_instances_per_image or 100
self._enable_map_parallelization = enable_map_parallelization
@tf.autograph.experimental.do_not_convert
def dataset_parser(self, value, example_decoder, anchor_labeler, params):
"""Parse data to a fixed dimension input image and learning targets.
Args:
value: a single serialized tf.Example string.
example_decoder: TF example decoder.
anchor_labeler: anchor box labeler.
params: a dict of extra parameters.
Returns:
image: Image tensor that is preprocessed to have normalized value and
fixed dimension [image_height, image_width, 3]
cls_targets_dict: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, num_anchors]. The height_l and width_l
represent the dimension of class logits at l-th level.
box_targets_dict: ordered dictionary with keys
[min_level, min_level+1, ..., max_level]. The values are tensor with
shape [height_l, width_l, num_anchors * 4]. The height_l and
width_l represent the dimension of bounding box regression output at
l-th level.
num_positives: Number of positive anchors in the image.
source_id: Source image id. Default value -1 if the source id is empty
in the groundtruth annotation.
image_scale: Scale of the processed image to the original image.
boxes: Groundtruth bounding box annotations. The box is represented in
[y1, x1, y2, x2] format. The tensor is padded with -1 to the fixed
dimension [self._max_instances_per_image, 4].
is_crowds: Groundtruth annotations to indicate if an annotation
represents a group of instances by value {0, 1}. The tensor is
padded with 0 to the fixed dimension [self._max_instances_per_image].
areas: Groundtruth areas annotations. The tensor is padded with -1
to the fixed dimension [self._max_instances_per_image].
classes: Groundtruth classes annotations. The tensor is padded with -1
to the fixed dimension [self._max_instances_per_image].
"""
with tf.name_scope('parser'):
data = example_decoder.decode(value)
source_id = data['source_id']
image = data['image']
boxes = data['groundtruth_boxes']
classes = data['groundtruth_classes']
classes = tf.reshape(tf.cast(classes, dtype=tf.float32), [-1, 1])
areas = data['groundtruth_area']
is_crowds = data['groundtruth_is_crowd']
image_masks = data.get('groundtruth_instance_masks', [])
classes = tf.reshape(tf.cast(classes, dtype=tf.float32), [-1, 1])
if self._is_training:
# Training time preprocessing.
if params['skip_crowd_during_training']:
indices = tf.where(tf.logical_not(data['groundtruth_is_crowd']))
classes = tf.gather_nd(classes, indices)
boxes = tf.gather_nd(boxes, indices)
input_processor = DetectionInputProcessor(image, params['image_size'],
boxes, classes)
input_processor.normalize_image(dtype=tf.float16 if \
params['mixed_precision'] else tf.float32)
if self._is_training:
if params['input_rand_hflip']:
input_processor.random_horizontal_flip()
input_processor.set_training_random_scale_factors(
params['jitter_min'], params['jitter_max'],
params.get('target_size', None))
else:
input_processor.set_scale_factors_to_output_size()
image = input_processor.resize_and_crop_image()
boxes, classes = input_processor.resize_and_crop_boxes()
# Assign anchors.
(cls_targets, box_targets,
num_positives) = anchor_labeler.label_anchors(boxes, classes)
source_id = tf.where(
tf.equal(source_id, tf.constant('')), '-1', source_id)
source_id = tf.strings.to_number(source_id)
# Pad groundtruth data for evaluation.
image_scale = input_processor.image_scale_to_original
boxes *= image_scale
is_crowds = tf.cast(is_crowds, dtype=tf.float32)
boxes = pad_to_fixed_size(boxes, -1, [self._max_instances_per_image, 4])
is_crowds = pad_to_fixed_size(is_crowds, 0,
[self._max_instances_per_image, 1])
areas = pad_to_fixed_size(areas, -1, [self._max_instances_per_image, 1])
classes = pad_to_fixed_size(classes, -1,
[self._max_instances_per_image, 1])
if params['mixed_precision']:
dtype = get_mixed_precision_policy().compute_dtype
if image.dtype != dtype:
image = tf.cast(image, dtype=dtype)
box_targets = tf.nest.map_structure(
lambda box_target: tf.cast(box_target, dtype=dtype), box_targets)
return (image, cls_targets, box_targets, num_positives, source_id,
image_scale, boxes, is_crowds, areas, classes, image_masks)
@tf.autograph.experimental.do_not_convert
def process_example(self, params, batch_size, images, cls_targets,
box_targets, num_positives, source_ids, image_scales,
boxes, is_crowds, areas, classes, image_masks):
"""Processes one batch of data."""
labels = {}
# Count num_positives in a batch.
num_positives_batch = tf.reduce_mean(num_positives)
labels['mean_num_positives'] = tf.reshape(
tf.tile(tf.expand_dims(num_positives_batch, 0), [
batch_size,
]), [batch_size, 1])
if params['data_format'] == 'channels_first':
images = tf.transpose(images, [0, 3, 1, 2])
for level in range(params['min_level'], params['max_level'] + 1):
labels['cls_targets_%d' % level] = cls_targets[level]
labels['box_targets_%d' % level] = box_targets[level]
if params['data_format'] == 'channels_first':
labels['cls_targets_%d' % level] = tf.transpose(
labels['cls_targets_%d' % level], [0, 3, 1, 2])
labels['box_targets_%d' % level] = tf.transpose(
labels['box_targets_%d' % level], [0, 3, 1, 2])
# Concatenate groundtruth annotations to a tensor.
groundtruth_data = tf.concat([boxes, is_crowds, areas, classes], axis=2)
labels['source_ids'] = source_ids
labels['groundtruth_data'] = groundtruth_data
labels['image_scales'] = image_scales
labels['image_masks'] = image_masks
return images, labels
@property
def dataset_options(self):
options = tf.data.Options()
options.experimental_deterministic = not self._is_training
options.experimental_optimization.map_parallelization = self._enable_map_parallelization
options.experimental_optimization.parallel_batch = True
options.threading.private_threadpool_size = max(2, (multiprocessing.cpu_count() // hvd.local_size()) - 2)
return options
def __call__(self, params, input_context=None, batch_size=None):
input_anchors = anchors.Anchors(params['min_level'], params['max_level'],
params['num_scales'],
params['aspect_ratios'],
params['anchor_scale'],
params['image_size'])
anchor_labeler = anchors.AnchorLabeler(input_anchors, params['num_classes'])
example_decoder = tf_example_decoder.TfExampleDecoder(
include_mask='segmentation' in params['heads'],
regenerate_source_id=params['regenerate_source_id']
)
batch_size = batch_size or params['batch_size']
dataset = tf.data.Dataset.list_files(self._file_pattern, shuffle=False)
if self._is_training:
dataset = dataset.shard(get_world_size(), get_rank())
dataset.shuffle(buffer_size=1024)
# Prefetch data from files.
def _prefetch_dataset(filename):
if params.get('dataset_type', None) == 'sstable':
pass
else:
dataset = tf.data.TFRecordDataset(filename).prefetch(1)
return dataset
dataset = dataset.interleave(
_prefetch_dataset, cycle_length=10, block_length=16,
num_parallel_calls=tf.data.experimental.AUTOTUNE)
dataset = dataset.with_options(self.dataset_options)
if self._is_training:
dataset = dataset.shuffle(params['shuffle_buffer'])
# Parse the fetched records to input tensors for model function.
# pylint: disable=g-long-lambda
if params.get('dataset_type', None) == 'sstable':
map_fn = lambda key, value: self.dataset_parser(value, example_decoder,
anchor_labeler, params)
else:
map_fn = lambda value: self.dataset_parser(value, example_decoder,
anchor_labeler, params)
# pylint: enable=g-long-lambda
dataset = dataset.map(
map_fn, num_parallel_calls=tf.data.experimental.AUTOTUNE)
# dataset = dataset.prefetch(batch_size)
dataset = dataset.batch(batch_size, drop_remainder=params['drop_remainder'])
dataset = dataset.map(
lambda *args: self.process_example(params, batch_size, *args))
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
if self._is_training:
dataset = dataset.repeat()
if self._use_fake_data:
# Turn this dataset into a semi-fake dataset which always loop at the
# first batch. This reduces variance in performance and is useful in
# testing.
dataset = dataset.take(1).cache().repeat()
return dataset
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/dataloader.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Common utils."""
from typing import Text
import tensorflow as tf
def srelu_fn(x):
"""Smooth relu: a smooth version of relu."""
with tf.name_scope('srelu'):
beta = tf.Variable(20.0, name='srelu_beta', dtype=tf.float32)**2
beta = tf.cast(beta**2, x.dtype)
safe_log = tf.math.log(tf.where(x > 0., beta * x + 1., tf.ones_like(x)))
return tf.where((x > 0.), x - (1. / beta) * safe_log, tf.zeros_like(x))
def activation_fn(features: tf.Tensor, act_type: Text):
"""Customized non-linear activation type."""
if act_type in ('silu', 'swish'):
return tf.nn.swish(features)
elif act_type == 'swish_native':
return features * tf.sigmoid(features)
elif act_type == 'hswish':
return features * tf.nn.relu6(features + 3) / 6
elif act_type == 'relu':
return tf.nn.relu(features)
elif act_type == 'relu6':
return tf.nn.relu6(features)
elif act_type == 'mish':
return features * tf.math.tanh(tf.math.softplus(features))
elif act_type == 'identity':
return tf.identity(features)
elif act_type == 'srelu':
return srelu_fn(features)
else:
raise ValueError('Unsupported act_type {}'.format(act_type)) | DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/activation_builder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""COCO-style evaluation metrics.
Implements the interface of COCO API and metric_fn in tf.TPUEstimator.
COCO API: github.com/cocodataset/cocoapi/
"""
import json
import os
from absl import logging
import numpy as np
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval
import tensorflow as tf
import horovod.tensorflow.keras as hvd
from model import label_util
class EvaluationMetric():
"""COCO evaluation metric class.
This class cannot inherit from tf.keras.metrics.Metric due to numpy.
"""
def __init__(self, filename=None, testdev_dir=None, label_map=None):
"""Constructs COCO evaluation class.
The class provides the interface to metrics_fn in TPUEstimator. The
_update_op() takes detections from each image and push them to
self.detections. The _evaluate() loads a JSON file in COCO annotation format
as the groundtruth and runs COCO evaluation.
Args:
filename: Ground truth JSON file name. If filename is None, use
groundtruth data passed from the dataloader for evaluation. filename is
ignored if testdev_dir is not None.
testdev_dir: folder name for testdev data. If None, run eval without
groundtruth, and filename will be ignored.
label_map: a dict from id to class name. Used for per-class AP.
"""
self.label_map = label_map
self.filename = filename
self.testdev_dir = testdev_dir
self.metric_names = ['AP', 'AP50', 'AP75', 'APs', 'APm', 'APl', 'ARmax1',
'ARmax10', 'ARmax100', 'ARs', 'ARm', 'ARl']
self.reset_states()
def reset_states(self):
"""Reset COCO API object."""
self.detections = []
self.dataset = {
'images': [],
'annotations': [],
'categories': []
}
self.image_id = 1
self.annotation_id = 1
self.category_ids = []
self.metric_values = None
def evaluate(self):
"""Evaluates with detections from all images with COCO API.
Returns:
coco_metric: float numpy array with shape [12] representing the
coco-style evaluation metrics.
"""
if self.filename:
coco_gt = COCO(self.filename)
else:
coco_gt = COCO()
coco_gt.dataset = self.dataset
coco_gt.createIndex()
if self.testdev_dir:
# Run on test-dev dataset.
box_result_list = []
for det in self.detections:
box_result_list.append({
'image_id': int(det[0]),
'category_id': int(det[6]),
'bbox': np.around(
det[1:5].astype(np.float64), decimals=2).tolist(),
'score': float(np.around(det[5], decimals=3)),
})
json.encoder.FLOAT_REPR = lambda o: format(o, '.3f')
# Must be in the formst of 'detections_test-dev2017_xxx_results'.
fname = 'detections_test-dev2017_test_results'
output_path = os.path.join(self.testdev_dir, fname + '.json')
logging.info('Writing output json file to: %s', output_path)
with tf.io.gfile.GFile(output_path, 'w') as fid:
json.dump(box_result_list, fid)
return np.array([-1.], dtype=np.float32)
else:
# Run on validation dataset.
detections = np.array(self.detections)
image_ids = list(set(detections[:, 0]))
coco_dt = coco_gt.loadRes(detections)
coco_eval = COCOeval(coco_gt, coco_dt, iouType='bbox')
coco_eval.params.imgIds = image_ids
coco_eval.evaluate()
coco_eval.accumulate()
coco_eval.summarize()
coco_metrics = coco_eval.stats
if self.label_map:
# Get per_class AP, see pycocotools/cocoeval.py:334
# TxRxKxAxM: iouThrs x recThrs x catIds x areaRng x maxDets
# Use areaRng_id=0 ('all') and maxDets_id=-1 (200) in default
precision = coco_eval.eval['precision'][:, :, :, 0, -1]
# Ideally, label_map should match the eval set, but it is possible that
# some classes has no data in the eval set.
ap_perclass = [0] * max(precision.shape[-1], len(self.label_map))
for c in range(precision.shape[-1]): # iterate over all classes
precision_c = precision[:, :, c]
# Only consider values if > -1.
precision_c = precision_c[precision_c > -1]
ap_c = np.mean(precision_c) if precision_c.size else -1.
ap_perclass[c] = ap_c
coco_metrics = np.concatenate((coco_metrics, ap_perclass))
# Return the concat normal and per-class AP.
return np.array(coco_metrics, dtype=np.float32)
def result(self):
"""Return the metric values (and compute it if needed)."""
if self.metric_values is None:
self.metric_values = self.evaluate()
return self.metric_values
def update_state(self, groundtruth_data, detections):
"""Update detection results and groundtruth data.
Append detection results to self.detections to aggregate results from
all validation set. The groundtruth_data is parsed and added into a
dictionary with the same format as COCO dataset, which can be used for
evaluation.
Args:
groundtruth_data: Groundtruth annotations in a tensor with each row
representing [y1, x1, y2, x2, is_crowd, area, class].
detections: Detection results in a tensor with each row representing
[image_id, x, y, width, height, score, class].
"""
for i, det in enumerate(detections):
# Filter out detections with predicted class label = -1.
indices = np.where(det[:, -1] > -1)[0]
det = det[indices]
if det.shape[0] == 0:
continue
# Append groundtruth annotations to create COCO dataset object.
# Add images.
image_id = det[0, 0]
if image_id == -1:
image_id = self.image_id
det[:, 0] = image_id
self.detections.extend(det)
if not self.filename and not self.testdev_dir:
# process groudtruth data only if filename is empty and no test_dev.
self.dataset['images'].append({
'id': int(image_id),
})
# Add annotations.
indices = np.where(groundtruth_data[i, :, -1] > -1)[0]
for data in groundtruth_data[i, indices]:
box = data[0:4]
is_crowd = data[4]
area = (box[3] - box[1]) * (box[2] - box[0])
category_id = data[6]
if category_id < 0:
break
self.dataset['annotations'].append({
'id': int(self.annotation_id),
'image_id': int(image_id),
'category_id': int(category_id),
'bbox': [box[1], box[0], box[3] - box[1], box[2] - box[0]],
'area': area,
'iscrowd': int(is_crowd)
})
self.annotation_id += 1
self.category_ids.append(category_id)
self.image_id += 1
if not self.filename:
self.category_ids = list(set(self.category_ids))
self.dataset['categories'] = [
{'id': int(category_id)} for category_id in self.category_ids
]
def gather(self):
self.detections = hvd.allgather(self.detections)
def estimator_metric_fn(self, detections, groundtruth_data):
"""Constructs the metric function for tf.TPUEstimator.
For each metric, we return the evaluation op and an update op; the update op
is shared across all metrics and simply appends the set of detections to the
`self.detections` list. The metric op is invoked after all examples have
been seen and computes the aggregate COCO metrics. Please find details API
in: https://www.tensorflow.org/api_docs/python/tf/contrib/learn/MetricSpec
Args:
detections: Detection results in a tensor with each row representing
[image_id, x, y, width, height, score, class]
groundtruth_data: Groundtruth annotations in a tensor with each row
representing [y1, x1, y2, x2, is_crowd, area, class].
Returns:
metrics_dict: A dictionary mapping from evaluation name to a tuple of
operations (`metric_op`, `update_op`). `update_op` appends the
detections for the metric to the `self.detections` list.
"""
with tf.name_scope('coco_metric'):
if self.testdev_dir:
update_op = tf.numpy_function(self.update_state,
[groundtruth_data, detections], [])
metrics = tf.numpy_function(self.result, [], tf.float32)
metrics_dict = {'AP': (metrics, update_op)}
return metrics_dict
else:
update_op = tf.numpy_function(self.update_state,
[groundtruth_data, detections], [])
metrics = tf.numpy_function(self.result, [], tf.float32)
metrics_dict = {}
for i, name in enumerate(self.metric_names):
metrics_dict[name] = (metrics[i], update_op)
if self.label_map:
# process per-class AP.
label_map = label_util.get_label_map(self.label_map)
for i, cid in enumerate(sorted(label_map.keys())):
name = 'AP_/%s' % label_map[cid]
metrics_dict[name] = (metrics[i + len(self.metric_names)],
update_op)
return metrics_dict
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/model/coco_metric.py |
# Copyright 2020 Google Research. 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.
"""
import tensorflow.compat.v1 as tf
from object_detection import box_list
from object_detection import shape_utils
KEYPOINTS_FIELD_NAME = 'keypoints'
class TargetAssigner(object):
"""Target assigner to compute classification and regression targets."""
def __init__(self, similarity_calc, matcher, box_coder,
negative_class_weight=1.0, unmatched_cls_target=None):
"""Construct Object Detection Target Assigner.
Args:
similarity_calc: a RegionSimilarityCalculator
matcher: Matcher used to match groundtruth to anchors.
box_coder: 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.].
unmatched_cls_target: 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.
Raises:
ValueError: if similarity_calc is not a RegionSimilarityCalculator or
if matcher is not a Matcher or if box_coder is not a BoxCoder
"""
self._similarity_calc = similarity_calc
self._matcher = matcher
self._box_coder = box_coder
self._negative_class_weight = negative_class_weight
if unmatched_cls_target is None:
self._unmatched_cls_target = tf.constant([0], tf.float32)
else:
self._unmatched_cls_target = unmatched_cls_target
@property
def box_coder(self):
return self._box_coder
def assign(self, anchors, groundtruth_boxes, groundtruth_labels=None,
groundtruth_weights=None, **params):
"""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).
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.
**params: Additional keyword arguments for specific implementations of
the Matcher.
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]
reg_targets: a float32 tensor with shape [num_anchors, box_code_dimension]
reg_weights: a float32 tensor with shape [num_anchors]
match: a matcher.Match object encoding the match between anchors and
groundtruth boxes, with rows corresponding to groundtruth boxes
and columns corresponding to anchors.
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 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(
self._unmatched_cls_target))
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)
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, **params)
reg_targets = self._create_regression_targets(anchors,
groundtruth_boxes,
match)
cls_targets = self._create_classification_targets(groundtruth_labels,
match)
reg_weights = self._create_regression_weights(match, groundtruth_weights)
cls_weights = self._create_classification_weights(match,
groundtruth_weights)
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
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(KEYPOINTS_FIELD_NAME):
groundtruth_keypoints = groundtruth_boxes.get_field(KEYPOINTS_FIELD_NAME)
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(KEYPOINTS_FIELD_NAME, 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, 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).
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=self._unmatched_cls_target,
ignored_value=self._unmatched_cls_target)
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
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/target_assigner.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Matcher interface and Match class.
This module defines the Matcher interface and the Match object. The job of the
matcher is to match row and column indices based on the similarity matrix and
other optional parameters. Each column is matched to at most one row. There
are three possibilities for the matching:
1) match: A column matches a row.
2) no_match: A column does not match any row.
3) ignore: A column that is neither 'match' nor no_match.
The ignore case is regularly encountered in object detection: when an anchor has
a relatively small overlap with a ground-truth box, one neither wants to
consider this box a positive example (match) nor a negative example (no match).
The Match class is used to store the match results and it provides simple apis
to query the results.
"""
import abc
import tensorflow.compat.v1 as tf
class Match(object):
"""Class to store results from the matcher.
This class is used to store the results from the matcher. It provides
convenient methods to query the matching results.
"""
def __init__(self, match_results):
"""Constructs a Match object.
Args:
match_results: Integer tensor of shape [N] with (1) match_results[i]>=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.
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
@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.shape(self.matched_column_indices())[0]
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.shape(self.unmatched_column_indices())[0]
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 column 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.shape(self.ignored_column_indices())[0]
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(
tf.gather(self._match_results, self.matched_column_indices()))
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 = tf.gather(input_tensor, gather_indices)
return gathered_tensor
class Matcher(object):
"""Abstract base class for matcher.
"""
__metaclass__ = abc.ABCMeta
def match(self, similarity_matrix, scope=None, **params):
"""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.
scope: Op scope name. Defaults to 'Match' if None.
**params: Additional keyword arguments for specific implementations of
the Matcher.
Returns:
A Match object with the results of matching.
"""
with tf.name_scope(scope, 'Match', [similarity_matrix, params]) as scope:
return Match(self._match(similarity_matrix, **params))
@abc.abstractmethod
def _match(self, similarity_matrix, **params):
"""Method to be overridden by implementations.
Args:
similarity_matrix: Float tensor of shape [N, M] with pairwise similarity
where higher value means more similar.
**params: Additional keyword arguments for specific implementations of
the Matcher.
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
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/matcher.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Faster RCNN box coder.
Faster RCNN box coder follows the coding schema described below:
ty = (y - ya) / ha
tx = (x - xa) / wa
th = log(h / ha)
tw = log(w / wa)
where x, y, w, h denote the box's center coordinates, width and height
respectively. Similarly, xa, ya, wa, ha denote the anchor's center
coordinates, width and height. tx, ty, tw and th denote the anchor-encoded
center, width and height respectively.
See http://arxiv.org/abs/1506.01497 for details.
"""
import tensorflow.compat.v1 as tf
from object_detection import box_coder
from object_detection import box_list
EPSILON = 1e-8
class FasterRcnnBoxCoder(box_coder.BoxCoder):
"""Faster RCNN box coder."""
def __init__(self, scale_factors=None):
"""Constructor for FasterRcnnBoxCoder.
Args:
scale_factors: List of 4 positive scalars to scale ty, tx, th and tw.
If set to None, does not perform scaling. For Faster RCNN,
the open-source implementation recommends using [10.0, 10.0, 5.0, 5.0].
"""
if scale_factors:
assert len(scale_factors) == 4
for scalar in scale_factors:
assert scalar > 0
self._scale_factors = scale_factors
@property
def code_size(self):
return 4
def _encode(self, boxes, anchors):
"""Encode a box collection with respect to anchor collection.
Args:
boxes: BoxList holding N boxes to be encoded.
anchors: BoxList of anchors.
Returns:
a tensor representing N anchor-encoded boxes of the format
[ty, tx, th, tw].
"""
# Convert anchors to the center coordinate representation.
ycenter_a, xcenter_a, ha, wa = anchors.get_center_coordinates_and_sizes()
ycenter, xcenter, h, w = boxes.get_center_coordinates_and_sizes()
# Avoid NaN in division and log below.
ha = tf.maximum(EPSILON, ha)
wa = tf.maximum(EPSILON, wa)
h = tf.maximum(EPSILON, h)
w = tf.maximum(EPSILON, w)
tx = (xcenter - xcenter_a) / wa
ty = (ycenter - ycenter_a) / ha
tw = tf.log(w / wa)
th = tf.log(h / ha)
# Scales location targets as used in paper for joint training.
if self._scale_factors:
ty *= self._scale_factors[0]
tx *= self._scale_factors[1]
th *= self._scale_factors[2]
tw *= self._scale_factors[3]
return tf.transpose(tf.stack([ty, tx, th, tw]))
def _decode(self, rel_codes, anchors):
"""Decode relative codes to boxes.
Args:
rel_codes: a tensor representing N anchor-encoded boxes.
anchors: BoxList of anchors.
Returns:
boxes: BoxList holding N bounding boxes.
"""
ycenter_a, xcenter_a, ha, wa = anchors.get_center_coordinates_and_sizes()
ty, tx, th, tw = tf.unstack(tf.transpose(rel_codes))
if self._scale_factors:
ty /= self._scale_factors[0]
tx /= self._scale_factors[1]
th /= self._scale_factors[2]
tw /= self._scale_factors[3]
w = tf.exp(tw) * wa
h = tf.exp(th) * ha
ycenter = ty * ha + ycenter_a
xcenter = tx * wa + xcenter_a
ymin = ycenter - h / 2.
xmin = xcenter - w / 2.
ymax = ycenter + h / 2.
xmax = xcenter + w / 2.
return box_list.BoxList(tf.transpose(tf.stack([ymin, xmin, ymax, xmax])))
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/faster_rcnn_box_coder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Utils used to manipulate tensor shapes."""
import tensorflow.compat.v1 as tf
def assert_shape_equal(shape_a, shape_b):
"""Asserts that shape_a and shape_b are equal.
If the shapes are static, raises a ValueError when the shapes
mismatch.
If the shapes are dynamic, raises a tf InvalidArgumentError when the shapes
mismatch.
Args:
shape_a: a list containing shape of the first tensor.
shape_b: a list containing shape of the second tensor.
Returns:
Either a tf.no_op() when shapes are all static and a tf.assert_equal() op
when the shapes are dynamic.
Raises:
ValueError: When shapes are both static and unequal.
"""
if (all(isinstance(dim, int) for dim in shape_a) and
all(isinstance(dim, int) for dim in shape_b)):
if shape_a != shape_b:
raise ValueError('Unequal shapes {}, {}'.format(shape_a, shape_b))
else: return tf.no_op()
else:
return tf.assert_equal(shape_a, shape_b)
def combined_static_and_dynamic_shape(tensor):
"""Returns a list containing static and dynamic values for the dimensions.
Returns a list of static and dynamic values for shape dimensions. This is
useful to preserve static shapes when available in reshape operation.
Args:
tensor: A tensor of any type.
Returns:
A list of size tensor.shape.ndims containing integers or a scalar tensor.
"""
static_tensor_shape = tensor.shape.as_list()
dynamic_tensor_shape = tf.shape(tensor)
combined_shape = []
for index, dim in enumerate(static_tensor_shape):
if dim is not None:
combined_shape.append(dim)
else:
combined_shape.append(dynamic_tensor_shape[index])
return combined_shape
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/shape_utils.py |
# Copyright 2020 Google Research. 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 abc import ABCMeta
from abc import abstractmethod
from abc import abstractproperty
import tensorflow.compat.v1 as tf
# Box coder types.
FASTER_RCNN = 'faster_rcnn'
KEYPOINT = 'keypoint'
MEAN_STDDEV = 'mean_stddev'
SQUARE = 'square'
class BoxCoder(object):
"""Abstract base class for box coder."""
__metaclass__ = ABCMeta
@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 overridden 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 overridden 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 encoded_boxes.get_shape()[1].value != 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.' %
(encoded_boxes.get_shape()[1].value,
anchors.num_boxes_static()))
decoded_boxes = tf.stack([
box_coder.decode(boxes, anchors).get()
for boxes in tf.unstack(encoded_boxes)
])
return decoded_boxes
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/box_coder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/__init__.py |
# Copyright 2020 Google Research. 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 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]
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.
"""
import tensorflow.compat.v1 as tf
from object_detection import box_list
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_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 keypoint_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 random_horizontal_flip(image,
boxes=None,
masks=None,
keypoints=None,
keypoint_flip_permutation=None,
seed=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
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
do_a_flip_random = tf.greater(tf.random_uniform([], seed=seed), 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_flip_horizontal(keypoints, 0.5, permutation),
lambda: keypoints)
result.append(keypoints)
return tuple(result)
def _compute_new_static_size(image, min_dimension, max_dimension):
"""Compute new static shape for resize_to_range method."""
image_shape = image.get_shape().as_list()
orig_height = image_shape[0]
orig_width = image_shape[1]
num_channels = image_shape[2]
orig_min_dim = min(orig_height, orig_width)
# Calculates the larger of the possible sizes
large_scale_factor = min_dimension / float(orig_min_dim)
# Scaling orig_(height|width) by large_scale_factor will make the smaller
# dimension equal to min_dimension, save for floating point rounding errors.
# For reasonably-sized images, taking the nearest integer will reliably
# eliminate this error.
large_height = int(round(orig_height * large_scale_factor))
large_width = int(round(orig_width * large_scale_factor))
large_size = [large_height, large_width]
if max_dimension:
# Calculates the smaller of the possible sizes, use that if the larger
# is too big.
orig_max_dim = max(orig_height, orig_width)
small_scale_factor = max_dimension / float(orig_max_dim)
# Scaling orig_(height|width) by small_scale_factor will make the larger
# dimension equal to max_dimension, save for floating point rounding
# errors. For reasonably-sized images, taking the nearest integer will
# reliably eliminate this error.
small_height = int(round(orig_height * small_scale_factor))
small_width = int(round(orig_width * small_scale_factor))
small_size = [small_height, small_width]
new_size = large_size
if max(large_size) > max_dimension:
new_size = small_size
else:
new_size = large_size
return tf.constant(new_size + [num_channels])
def _compute_new_dynamic_size(image, min_dimension, max_dimension):
"""Compute new dynamic shape for resize_to_range method."""
image_shape = tf.shape(image)
orig_height = tf.to_float(image_shape[0])
orig_width = tf.to_float(image_shape[1])
num_channels = image_shape[2]
orig_min_dim = tf.minimum(orig_height, orig_width)
# Calculates the larger of the possible sizes
min_dimension = tf.constant(min_dimension, dtype=tf.float32)
large_scale_factor = min_dimension / orig_min_dim
# Scaling orig_(height|width) by large_scale_factor will make the smaller
# dimension equal to min_dimension, save for floating point rounding errors.
# For reasonably-sized images, taking the nearest integer will reliably
# eliminate this error.
large_height = tf.to_int32(tf.round(orig_height * large_scale_factor))
large_width = tf.to_int32(tf.round(orig_width * large_scale_factor))
large_size = tf.stack([large_height, large_width])
if max_dimension:
# Calculates the smaller of the possible sizes, use that if the larger
# is too big.
orig_max_dim = tf.maximum(orig_height, orig_width)
max_dimension = tf.constant(max_dimension, dtype=tf.float32)
small_scale_factor = max_dimension / orig_max_dim
# Scaling orig_(height|width) by small_scale_factor will make the larger
# dimension equal to max_dimension, save for floating point rounding
# errors. For reasonably-sized images, taking the nearest integer will
# reliably eliminate this error.
small_height = tf.to_int32(tf.round(orig_height * small_scale_factor))
small_width = tf.to_int32(tf.round(orig_width * small_scale_factor))
small_size = tf.stack([small_height, small_width])
new_size = tf.cond(
tf.to_float(tf.reduce_max(large_size)) > max_dimension,
lambda: small_size, lambda: large_size)
else:
new_size = large_size
return tf.stack(tf.unstack(new_size) + [num_channels])
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):
"""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.
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')
with tf.name_scope('ResizeToRange', values=[image, min_dimension]):
if image.get_shape().is_fully_defined():
new_size = _compute_new_static_size(image, min_dimension, max_dimension)
else:
new_size = _compute_new_dynamic_size(image, min_dimension, max_dimension)
new_image = tf.image.resize_images(
image, new_size[:-1], method=method, align_corners=align_corners)
if pad_to_max_dimension:
new_image = tf.image.pad_to_bounding_box(
new_image, 0, 0, max_dimension, max_dimension)
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)
new_masks = tf.squeeze(new_masks, 3)
if pad_to_max_dimension:
new_masks = tf.image.pad_to_bounding_box(
new_masks, 0, 0, max_dimension, max_dimension)
result.append(new_masks)
result.append(new_size)
return result
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 box_list_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 keypoint_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 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_scale(boxlist, image_height, image_width).get()
result = [image, scaled_boxes]
if keypoints is not None:
scaled_keypoints = keypoint_scale(keypoints, image_height, image_width)
result.append(scaled_keypoints)
return tuple(result)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/preprocessor.py |
# Copyright 2020 Google Research. 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 inferable 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.compat.v1 as tf
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.')
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
inferable at graph construction time.
"""
return self.data['boxes'].get_shape().as_list()[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
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/box_list.py |
# Copyright 2020 Google Research. 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 abc import ABCMeta
from abc import abstractmethod
import tensorflow.compat.v1 as tf
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 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 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))
class RegionSimilarityCalculator(object):
"""Abstract base class for region similarity calculator."""
__metaclass__ = ABCMeta
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 iou(boxlist1, boxlist2)
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/region_similarity_calculator.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Tensorflow Example proto decoder for object detection.
A decoder to decode string tensors containing serialized tensorflow.Example
protos for object detection.
"""
import tensorflow.compat.v1 as tf
def _get_source_id_from_encoded_image(parsed_tensors):
return tf.strings.as_string(
tf.strings.to_hash_bucket_fast(parsed_tensors['image/encoded'],
2**63 - 1))
class TfExampleDecoder(object):
"""Tensorflow Example proto decoder."""
def __init__(self, include_mask=False, regenerate_source_id=False):
self._include_mask = include_mask
self._regenerate_source_id = regenerate_source_id
self._keys_to_features = {
'image/encoded': tf.FixedLenFeature((), tf.string),
'image/source_id': tf.FixedLenFeature((), tf.string, ''),
'image/height': tf.FixedLenFeature((), tf.int64, -1),
'image/width': tf.FixedLenFeature((), tf.int64, -1),
'image/object/bbox/xmin': tf.VarLenFeature(tf.float32),
'image/object/bbox/xmax': tf.VarLenFeature(tf.float32),
'image/object/bbox/ymin': tf.VarLenFeature(tf.float32),
'image/object/bbox/ymax': tf.VarLenFeature(tf.float32),
'image/object/class/label': tf.VarLenFeature(tf.int64),
'image/object/area': tf.VarLenFeature(tf.float32),
'image/object/is_crowd': tf.VarLenFeature(tf.int64),
}
if include_mask:
self._keys_to_features.update({
'image/object/mask':
tf.VarLenFeature(tf.string),
})
def _decode_image(self, parsed_tensors):
"""Decodes the image and set its static shape."""
image = tf.io.decode_image(parsed_tensors['image/encoded'], channels=3)
image.set_shape([None, None, 3])
return image
def _decode_boxes(self, parsed_tensors):
"""Concat box coordinates in the format of [ymin, xmin, ymax, xmax]."""
xmin = parsed_tensors['image/object/bbox/xmin']
xmax = parsed_tensors['image/object/bbox/xmax']
ymin = parsed_tensors['image/object/bbox/ymin']
ymax = parsed_tensors['image/object/bbox/ymax']
return tf.stack([ymin, xmin, ymax, xmax], axis=-1)
def _decode_masks(self, parsed_tensors):
"""Decode a set of PNG masks to the tf.float32 tensors."""
def _decode_png_mask(png_bytes):
mask = tf.squeeze(
tf.io.decode_png(png_bytes, channels=1, dtype=tf.uint8), axis=-1)
mask = tf.cast(mask, dtype=tf.float32)
mask.set_shape([None, None])
return mask
height = parsed_tensors['image/height']
width = parsed_tensors['image/width']
masks = parsed_tensors['image/object/mask']
return tf.cond(
tf.greater(tf.shape(masks)[0], 0),
lambda: tf.map_fn(_decode_png_mask, masks, dtype=tf.float32),
lambda: tf.zeros([0, height, width], dtype=tf.float32))
def _decode_areas(self, parsed_tensors):
xmin = parsed_tensors['image/object/bbox/xmin']
xmax = parsed_tensors['image/object/bbox/xmax']
ymin = parsed_tensors['image/object/bbox/ymin']
ymax = parsed_tensors['image/object/bbox/ymax']
return tf.cond(
tf.greater(tf.shape(parsed_tensors['image/object/area'])[0], 0),
lambda: parsed_tensors['image/object/area'],
lambda: (xmax - xmin) * (ymax - ymin))
def decode(self, serialized_example):
"""Decode the serialized example.
Args:
serialized_example: a single serialized tf.Example string.
Returns:
decoded_tensors: a dictionary of tensors with the following fields:
- image: a uint8 tensor of shape [None, None, 3].
- source_id: a string scalar tensor.
- height: an integer scalar tensor.
- width: an integer scalar tensor.
- groundtruth_classes: a int64 tensor of shape [None].
- groundtruth_is_crowd: a bool tensor of shape [None].
- groundtruth_area: a float32 tensor of shape [None].
- groundtruth_boxes: a float32 tensor of shape [None, 4].
- groundtruth_instance_masks: a float32 tensor of shape
[None, None, None].
- groundtruth_instance_masks_png: a string tensor of shape [None].
"""
parsed_tensors = tf.io.parse_single_example(
serialized_example, self._keys_to_features)
for k in parsed_tensors:
if isinstance(parsed_tensors[k], tf.SparseTensor):
if parsed_tensors[k].dtype == tf.string:
parsed_tensors[k] = tf.sparse_tensor_to_dense(
parsed_tensors[k], default_value='')
else:
parsed_tensors[k] = tf.sparse_tensor_to_dense(
parsed_tensors[k], default_value=0)
image = self._decode_image(parsed_tensors)
boxes = self._decode_boxes(parsed_tensors)
areas = self._decode_areas(parsed_tensors)
decode_image_shape = tf.logical_or(
tf.equal(parsed_tensors['image/height'], -1),
tf.equal(parsed_tensors['image/width'], -1))
image_shape = tf.cast(tf.shape(image), dtype=tf.int64)
parsed_tensors['image/height'] = tf.where(decode_image_shape,
image_shape[0],
parsed_tensors['image/height'])
parsed_tensors['image/width'] = tf.where(decode_image_shape, image_shape[1],
parsed_tensors['image/width'])
is_crowds = tf.cond(
tf.greater(tf.shape(parsed_tensors['image/object/is_crowd'])[0], 0),
lambda: tf.cast(parsed_tensors['image/object/is_crowd'], dtype=tf.bool),
lambda: tf.zeros_like(parsed_tensors['image/object/class/label'], dtype=tf.bool)) # pylint: disable=line-too-long
if self._regenerate_source_id:
source_id = _get_source_id_from_encoded_image(parsed_tensors)
else:
source_id = tf.cond(
tf.greater(tf.strings.length(parsed_tensors['image/source_id']),
0), lambda: parsed_tensors['image/source_id'],
lambda: _get_source_id_from_encoded_image(parsed_tensors))
if self._include_mask:
masks = self._decode_masks(parsed_tensors)
decoded_tensors = {
'image': image,
'source_id': source_id,
'height': parsed_tensors['image/height'],
'width': parsed_tensors['image/width'],
'groundtruth_classes': parsed_tensors['image/object/class/label'],
'groundtruth_is_crowd': is_crowds,
'groundtruth_area': areas,
'groundtruth_boxes': boxes,
}
if self._include_mask:
decoded_tensors.update({
'groundtruth_instance_masks': masks,
'groundtruth_instance_masks_png': parsed_tensors['image/object/mask'],
})
return decoded_tensors
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/tf_example_decoder.py |
# Copyright 2020 Google Research. 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.
# ==============================================================================
"""Argmax matcher implementation.
This class takes a similarity matrix and matches columns to rows based on the
maximum value per column. One can specify matched_thresholds and
to prevent columns from matching to rows (generally resulting in a negative
training example) and unmatched_theshold to ignore the match (generally
resulting in neither a positive or negative training example).
This matcher is used in Fast(er)-RCNN.
Note: matchers are used in TargetAssigners. There is a create_target_assigner
factory function for popular implementations.
"""
import tensorflow.compat.v1 as tf
from object_detection import matcher
from object_detection import shape_utils
class ArgMaxMatcher(matcher.Matcher):
"""Matcher based on highest value.
This class computes matches from a similarity matrix. Each column is matched
to a single row.
To support object detection target assignment this class enables setting both
matched_threshold (upper threshold) and unmatched_threshold (lower thresholds)
defining three categories of similarity which define whether examples are
positive, negative, or ignored:
(1) similarity >= matched_threshold: Highest similarity. Matched/Positive!
(2) matched_threshold > similarity >= unmatched_threshold: Medium similarity.
Depending on negatives_lower_than_unmatched, this is either
Unmatched/Negative OR Ignore.
(3) unmatched_threshold > similarity: Lowest similarity. Depending on flag
negatives_lower_than_unmatched, either Unmatched/Negative OR Ignore.
For ignored matches this class sets the values in the Match object to -2.
"""
def __init__(self,
matched_threshold,
unmatched_threshold=None,
negatives_lower_than_unmatched=True,
force_match_for_each_row=False):
"""Construct ArgMaxMatcher.
Args:
matched_threshold: Threshold for positive matches. Positive if
sim >= matched_threshold, where sim is the maximum value of the
similarity matrix for a given column. Set to None for no threshold.
unmatched_threshold: Threshold for negative matches. Negative if
sim < unmatched_threshold. Defaults to matched_threshold
when set to None.
negatives_lower_than_unmatched: Boolean which defaults to True. If True
then negative matches are the ones below the unmatched_threshold,
whereas ignored matches are in between the matched and unmatched
threshold. If False, then negative matches are in between the matched
and unmatched threshold, and everything lower than unmatched is ignored.
force_match_for_each_row: If True, ensures that each row is matched to
at least one column (which is not guaranteed otherwise if the
matched_threshold is high). Defaults to False. See
argmax_matcher_test.testMatcherForceMatch() for an example.
Raises:
ValueError: if unmatched_threshold is set but matched_threshold is not set
or if unmatched_threshold > matched_threshold.
"""
if (matched_threshold is None) and (unmatched_threshold is not None):
raise ValueError('Need to also define matched_threshold when'
'unmatched_threshold is defined')
self._matched_threshold = matched_threshold
if unmatched_threshold is None:
self._unmatched_threshold = matched_threshold
else:
if unmatched_threshold > matched_threshold:
raise ValueError('unmatched_threshold needs to be smaller or equal'
'to matched_threshold')
self._unmatched_threshold = unmatched_threshold
if not negatives_lower_than_unmatched:
if self._unmatched_threshold == self._matched_threshold:
raise ValueError('When negatives are in between matched and '
'unmatched thresholds, these cannot be of equal '
'value. matched: %s, unmatched: %s',
self._matched_threshold, self._unmatched_threshold)
self._force_match_for_each_row = force_match_for_each_row
self._negatives_lower_than_unmatched = negatives_lower_than_unmatched
def _match(self, similarity_matrix):
"""Tries to match each column of the similarity matrix to a row.
Args:
similarity_matrix: tensor of shape [N, M] representing any similarity
metric.
Returns:
Match object with corresponding matches for each of M columns.
"""
def _match_when_rows_are_empty():
"""Performs matching when the rows of similarity matrix are empty.
When the rows are empty, all detections are false positives. So we return
a tensor of -1's to indicate that the columns do not match to any rows.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
similarity_matrix_shape = shape_utils.combined_static_and_dynamic_shape(
similarity_matrix)
return -1 * tf.ones([similarity_matrix_shape[1]], dtype=tf.int32)
def _match_when_rows_are_non_empty():
"""Performs matching when the rows of similarity matrix are non empty.
Returns:
matches: int32 tensor indicating the row each column matches to.
"""
# Matches for each column
matches = tf.argmax(similarity_matrix, 0, output_type=tf.int32)
# Deal with matched and unmatched threshold
if self._matched_threshold is not None:
# Get logical indices of ignored and unmatched columns as tf.int64
matched_vals = tf.reduce_max(similarity_matrix, 0)
below_unmatched_threshold = tf.greater(self._unmatched_threshold,
matched_vals)
between_thresholds = tf.logical_and(
tf.greater_equal(matched_vals, self._unmatched_threshold),
tf.greater(self._matched_threshold, matched_vals))
if self._negatives_lower_than_unmatched:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-1)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-2)
else:
matches = self._set_values_using_indicator(matches,
below_unmatched_threshold,
-2)
matches = self._set_values_using_indicator(matches,
between_thresholds,
-1)
if self._force_match_for_each_row:
similarity_matrix_shape = shape_utils.combined_static_and_dynamic_shape(
similarity_matrix)
force_match_column_ids = tf.argmax(similarity_matrix, 1,
output_type=tf.int32)
force_match_column_indicators = tf.one_hot(
force_match_column_ids, depth=similarity_matrix_shape[1])
force_match_row_ids = tf.argmax(force_match_column_indicators, 0,
output_type=tf.int32)
force_match_column_mask = tf.cast(
tf.reduce_max(force_match_column_indicators, 0), tf.bool)
final_matches = tf.where(force_match_column_mask,
force_match_row_ids, matches)
return final_matches
else:
return matches
if similarity_matrix.shape.is_fully_defined():
if similarity_matrix.shape[0] == 0:
return _match_when_rows_are_empty()
else:
return _match_when_rows_are_non_empty()
else:
return tf.cond(
tf.greater(tf.shape(similarity_matrix)[0], 0),
_match_when_rows_are_non_empty, _match_when_rows_are_empty)
def _set_values_using_indicator(self, x, indicator, val):
"""Set the indicated fields of x to val.
Args:
x: tensor.
indicator: boolean with same shape as x.
val: scalar with value to set.
Returns:
modified tensor.
"""
indicator = tf.cast(indicator, x.dtype)
return x * (1 - indicator) + val * indicator
| DeepLearningExamples-master | TensorFlow2/Detection/Efficientdet/object_detection/argmax_matcher.py |
# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: MIT
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
# Used to plot the Co-ordinates
def gen_plot(df):
plt.figure(figsize=(11, 11))
plt.scatter(
df["xcord"][:1],
df["ycord"][:1],
label="Depot",
color="Green",
marker="o",
s=25,
)
plt.scatter(
df["xcord"][1::],
df["ycord"][1::],
label="Locations",
color="Red",
marker="o",
s=25,
)
plt.xlabel("x - axis")
# frequency label
plt.ylabel("y - axis")
# plot title
plt.title("Simplified Map")
# showing legend
plt.legend()
for i, label in enumerate(df.index.values):
plt.annotate(
label,
(df["xcord"][i], df["ycord"][i]),
fontproperties=fm.FontProperties(size=12),
)
return plt
# Used to plot arrows
def add_arrows(df, routes, plt, color="green"):
prev_cord = ()
for i, label in enumerate(routes["route"].to_numpy()):
if i > 0:
plt.annotate(
"",
xy=(df["xcord"][label], df["ycord"][label]),
xytext=prev_cord,
arrowprops=dict(
arrowstyle="simple, head_length=0.5, head_width=0.5, tail_width=0.15", # noqa
connectionstyle="arc3",
color=color,
mutation_scale=20,
ec="black",
),
label="vehicle-1",
)
prev_cord = df["xcord"][label], df["ycord"][label]
return plt
# Prints vehicle routes
def show_vehicle_routes(routes, locations):
vehicles = routes.truck_id.unique().to_numpy()
for id in vehicles:
print("For vehicle -", id, "route is: \n")
route = routes[routes.truck_id == id]
path = ""
route_ids = route.route.to_numpy()
for index, route_id in enumerate(route_ids):
path += locations[route_id]
type(route_ids)
if index != (len(route_ids) - 1):
path += "->"
print(path + "\n\n")
def map_vehicle_routes(df, route, colors):
plt = gen_plot(df)
veh_ids = route.truck_id.unique().to_numpy()
idx = 0
vid_map = {}
for v_id in veh_ids:
vid_map[v_id] = idx
idx = idx + 1
for v_id in veh_ids:
plt = add_arrows(
df, route[route.truck_id == v_id], plt, color=colors[vid_map[v_id]]
)
return plt
| cuOpt-Resources-branch-22.12 | notebooks/routing/python/notebook_utils/notebook_helpers.py |
# SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: MIT
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import pandas as pd
# Used to plot the Co-ordinates
def gen_plot(df):
plt.figure(figsize=(11, 11))
plt.scatter(
df["xcord"][:1],
df["ycord"][:1],
label="Depot",
color="Green",
marker="o",
s=100,
)
plt.scatter(
df["xcord"][1::],
df["ycord"][1::],
label="Locations",
color="Red",
marker="o",
s=100,
)
plt.xlabel("x - axis")
# frequency label
plt.ylabel("y - axis")
# plot title
plt.title("Simplified Map")
# showing legend
plt.legend()
for i, label in enumerate(df.index.values):
plt.annotate(
label,
(df["xcord"][i], df["ycord"][i]),
fontproperties=fm.FontProperties(size=16),
)
return plt
# Used to plot arrows
def add_arrows(df, route, plt, color="green"):
prev_cord = ()
for i, label in enumerate(route):
if i > 0:
plt.annotate(
"",
xy=(df["xcord"][label], df["ycord"][label]),
xytext=prev_cord,
arrowprops=dict(
arrowstyle="simple, head_length=0.5, head_width=0.5, tail_width=0.15", # noqa
connectionstyle="arc3",
color=color,
mutation_scale=20,
ec="black",
),
label="vehicle-1",
)
prev_cord = df["xcord"][label], df["ycord"][label]
return plt
# Convert the solver response from the server to a cuDF dataframe
# for waypoint graph problems
def get_solution_df(resp):
solution = resp["vehicle_data"]
df = {}
df["route"] = []
df["truck_id"] = []
df["location"] = []
types = []
for vid, route in solution.items():
df["location"] = df["location"] + route["route"]
df["truck_id"] = df["truck_id"] + [vid] * len(route["route"])
if "type" in list(route.keys()):
types = types + route["type"]
if len(types) != 0:
df["types"] = types
df["route"] = df["location"]
return pd.DataFrame(df)
# Prints vehicle routes
def show_vehicle_routes(resp, locations):
solution = resp["vehicle_data"]
for id in list(solution.keys()):
route = solution[id]["route"]
print("For vehicle -", id, "route is: \n")
path = ""
for index, route_id in enumerate(route):
path += locations[route_id]
if index != (len(route) - 1):
path += "->"
print(path + "\n\n")
# Map vehicle routes
def map_vehicle_routes(df, resp, colors):
solution = resp["vehicle_data"]
plt = gen_plot(df)
veh_ids = list(solution.keys())
idx = 0
vid_map = {}
for v_id in veh_ids:
vid_map[v_id] = idx
idx = idx + 1
for v_id in veh_ids:
plt = add_arrows(
df, solution[v_id]["route"], plt, color=colors[vid_map[v_id]]
)
return plt
def create_from_file(file_path, is_pdp=False):
node_list = []
with open(file_path, "rt") as f:
count = 1
for line in f:
if is_pdp and count == 1:
vehicle_num, vehicle_capacity, speed = line.split()
elif not is_pdp and count == 5:
vehicle_num, vehicle_capacity = line.split()
elif is_pdp:
node_list.append(line.split())
elif count >= 10:
node_list.append(line.split())
count += 1
# if count == 36:
# break
vehicle_num = int(vehicle_num)
vehicle_capacity = int(vehicle_capacity)
df = pd.DataFrame(
columns=[
"vertex",
"xcord",
"ycord",
"demand",
"earliest_time",
"latest_time",
"service_time",
"pickup_index",
"delivery_index",
]
)
for item in node_list:
row = {
"vertex": int(item[0]),
"xcord": float(item[1]),
"ycord": float(item[2]),
"demand": int(item[3]),
"earliest_time": int(item[4]),
"latest_time": int(item[5]),
"service_time": int(item[6]),
}
if is_pdp:
row["pickup_index"] = int(item[7])
row["delivery_index"] = int(item[8])
df = pd.concat([df, pd.DataFrame(row, index=[0])], ignore_index=True)
return df, vehicle_capacity, vehicle_num
def print_data(data, completed_tasks):
print("Completed tasks :", completed_tasks)
print("Pending tasks :", data["task_locations"])
print("Pickup indices :", data["pickup_indices"])
print("Delivery indices :", data["delivery_indices"])
print("Task Earliest :", data["task_earliest_time"])
print("Task Latest :", data["task_latest_time"])
print("Task Service :", data["task_service_time"])
print("Vehicle locations :", data["vehicle_locations"])
print("Vehicle earliest :", data["vehicle_earliest"])
print("Order vehicle match :", data["order_vehicle_match"])
def print_vehicle_data(response):
for veh_id, veh_data in response["vehicle_data"].items():
print("\nVehicle Id :", veh_id)
print("Route :", veh_data["route"])
print("Type :", veh_data["task_type"])
print("Task Id :", veh_data["task_id"])
print("Arrival Stamp :", veh_data["arrival_stamp"])
print("--------------------------------------------------------")
| cuOpt-Resources-branch-22.12 | notebooks/routing/service/notebook_utils/notebook_helpers.py |
#!/usr/bin/env python3
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: MIT
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
# Converts OpenRM binhex-encoded images to Nouveau-compatible binary blobs
# See nouveau_firmware_layout.ods for documentation on the file format
import sys
import os
import argparse
import shutil
import re
import gzip
import struct
class MyException(Exception):
pass
def round_up_to_base(x, base = 10):
return x + (base - x) % base
def getbytes(filename, array):
"""Extract the bytes for the given array in the given file.
:param filename: the file to parse
:param array: the name of the array to parse
:returns: byte array
This function scans the file for the array and returns a bytearray of
its contents, uncompressing the data if it is tagged as compressed.
This function assumes that each array is immediately preceded with a comment
section that specifies whether the array is compressed and how many bytes of
data there should be. Example:
#if defined(BINDATA_INCLUDE_DATA)
//
// FUNCTION: ksec2GetBinArchiveSecurescrubUcode_AD10X("header_prod")
// FILE NAME: kernel/inc/securescrub/bin/ad10x/g_securescrubuc_sec2_ad10x_boot_from_hs_prod.h
// FILE TYPE: TEXT
// VAR NAME: securescrub_ucode_header_ad10x_boot_from_hs
// COMPRESSION: YES
// COMPLEX_STRUCT: NO
// DATA SIZE (bytes): 36
// COMPRESSED SIZE (bytes): 27
//
static BINDATA_CONST NvU8 ksec2BinArchiveSecurescrubUcode_AD10X_header_prod_data[] =
{
0x63, 0x60, 0x00, 0x02, 0x46, 0x20, 0x96, 0x02, 0x62, 0x66, 0x08, 0x13, 0x4c, 0x48, 0x42, 0x69,
0x20, 0x00, 0x00, 0x30, 0x39, 0x0a, 0xfc, 0x24, 0x00, 0x00, 0x00,
};
#endif // defined(BINDATA_INCLUDE_DATA)
"""
with open(filename) as f:
for line in f:
if "COMPRESSION: NO" in line:
compressed = False
if "COMPRESSION: YES" in line:
compressed = True
m = re.search("DATA SIZE \(bytes\): (\d+)", line)
if m:
data_size = int(m.group(1))
m = re.search("COMPRESSED SIZE \(bytes\): (\d+)", line)
if m:
compressed_size = int(m.group(1))
if "static BINDATA_CONST NvU8 " + array in line:
break
else:
raise MyException(f"array {array} not found in {filename}")
output = b''
for line in f:
if "};" in line:
break
bytes = [int(b, 16) for b in re.findall('0x[0-9a-f][0-9a-f]', line)]
if len(bytes) > 0:
output += struct.pack(f"{len(bytes)}B", *bytes)
if len(output) == 0:
raise MyException(f"no data found for {array}")
if compressed:
if len(output) != compressed_size:
raise MyException(f"compressed array {array} in {filename} should be {compressed_size} bytes but is actually {len(output)}.")
gzipheader = struct.pack("<4BL2B", 0x1f, 0x8b, 8, 0, 0, 0, 3)
output = gzip.decompress(gzipheader + output)
if len(output) != data_size:
raise MyException(f"array {array} in {filename} decompressed to {len(output)} bytes but should have been {data_size} bytes.")
return output
else:
if len(output) != data_size:
raise MyException(f"array {array} in {filename} should be {compressed_size} bytes but is actually {len(output)}.")
return output
# GSP bootloader
def bootloader(gpu, type):
global outputpath
global version
GPU=gpu.upper()
filename = f"src/nvidia/generated/g_bindata_kgspGetBinArchiveGspRmBoot_{GPU}.c"
print(f"Creating nvidia/{gpu}/gsp/bootloader-{version}.bin")
os.makedirs(f"{outputpath}/nvidia/{gpu}/gsp/", exist_ok = True)
with open(f"{outputpath}/nvidia/{gpu}/gsp/bootloader-{version}.bin", "wb") as f:
# Extract the actual bootloader firmware
array = f"kgspBinArchiveGspRmBoot_{GPU}_ucode_image{type}data"
firmware = getbytes(filename, array)
firmware_size = len(firmware)
# Extract the descriptor (RM_RISCV_UCODE_DESC)
array = f"kgspBinArchiveGspRmBoot_{GPU}_ucode_desc{type}data"
descriptor = getbytes(filename, array)
descriptor_size = len(descriptor)
# First, add the nvfw_bin_hdr header
total_size = round_up_to_base(24 + firmware_size + descriptor_size, 256)
firmware_offset = 24 + descriptor_size
f.write(struct.pack("<6L", 0x10de, 1, total_size, 24, firmware_offset, firmware_size))
# Second, add the descriptor
f.write(descriptor)
# Finally, the actual bootloader image
f.write(firmware)
# GSP Booter load and unload
def booter(gpu, load, sigsize):
global outputpath
global version
GPU = gpu.upper()
LOAD = load.capitalize()
filename = f"src/nvidia/generated/g_bindata_kgspGetBinArchiveBooter{LOAD}Ucode_{GPU}.c"
print(f"Creating nvidia/{gpu}/gsp/booter_{load}-{version}.bin")
os.makedirs(f"{outputpath}/nvidia/{gpu}/gsp/", exist_ok = True)
with open(f"{outputpath}/nvidia/{gpu}/gsp/booter_{load}-{version}.bin", "wb") as f:
# Extract the actual scrubber firmware
array = f"kgspBinArchiveBooter{LOAD}Ucode_{GPU}_image_prod_data"
firmware = getbytes(filename, array)
firmware_size = len(firmware)
# Extract the signatures
array = f"kgspBinArchiveBooter{LOAD}Ucode_{GPU}_sig_prod_data"
signatures = getbytes(filename, array)
signatures_size = len(signatures)
if signatures_size % sigsize:
raise MyException(f"signature file size for {array} is uneven value of {sigsize}")
num_sigs = int(signatures_size / sigsize);
if num_sigs < 1:
raise MyException(f"invalid number of signatures {num_sigs}")
# First, add the nvfw_bin_hdr header
total_size = round_up_to_base(120 + signatures_size + firmware_size, 256)
firmware_offset = 120 + signatures_size
f.write(struct.pack("<6L", 0x10de, 1, total_size, 24, firmware_offset, firmware_size))
# Second, add the nvfw_hs_header_v2 header
patch_loc_offset = 60 + signatures_size
patch_sig_offset = patch_loc_offset + 4
meta_data_offset = patch_sig_offset + 4
num_sig_offset = meta_data_offset + 12
header_offset = num_sig_offset + 4
f.write(struct.pack("<9L", 60, signatures_size, patch_loc_offset,
patch_sig_offset, meta_data_offset, 12,
num_sig_offset, header_offset, 36))
# Third, the actual signatures
f.write(signatures)
# Extract the patch location
array = f"kgspBinArchiveBooter{LOAD}Ucode_{GPU}_patch_loc_data"
bytes = getbytes(filename, array)
patchloc = struct.unpack("<L", bytes)[0]
# Extract the patch meta variables
array = f"kgspBinArchiveBooter{LOAD}Ucode_{GPU}_patch_meta_data"
bytes = getbytes(filename, array)
fuse_ver, engine_id, ucode_id = struct.unpack("<LLL", bytes)
# Fourth, patch_loc[], patch_sig[], fuse_ver, engine_id, ucode_id, and num_sigs
f.write(struct.pack("<6L", patchloc, 0, fuse_ver, engine_id, ucode_id, num_sigs))
# Extract the descriptor (nvkm_gsp_booter_fw_hdr)
array = f"kgspBinArchiveBooter{LOAD}Ucode_{GPU}_header_prod_data"
descriptor = getbytes(filename, array)
# Fifth, the descriptor
f.write(descriptor)
# And finally, the actual scrubber image
f.write(firmware)
# GPU memory scrubber, needed for some GPUs and configurations
def scrubber(gpu, sigsize):
global outputpath
global version
# Unfortunately, RM breaks convention with the scrubber image and labels
# the files and arrays with AD10X instead of AD102.
GPUX = f"{gpu[:-1].upper()}X"
filename = f"src/nvidia/generated/g_bindata_ksec2GetBinArchiveSecurescrubUcode_{GPUX}.c"
print(f"Creating nvidia/{gpu}/gsp/scrubber-{version}.bin")
os.makedirs(f"{outputpath}/nvidia/{gpu}/gsp/", exist_ok = True)
with open(f"{outputpath}/nvidia/{gpu}/gsp/scrubber-{version}.bin", "wb") as f:
# Extract the actual scrubber firmware
array = f"ksec2BinArchiveSecurescrubUcode_{GPUX}_image_prod_data[]"
firmware = getbytes(filename, array)
firmware_size = len(firmware)
# Extract the signatures
array = f"ksec2BinArchiveSecurescrubUcode_{GPUX}_sig_prod_data"
signatures = getbytes(filename, array)
signatures_size = len(signatures)
if signatures_size % sigsize:
raise MyException(f"signature file size for {array} is uneven value of {sigsize}")
num_sigs = int(signatures_size / sigsize);
if num_sigs < 1:
raise MyException(f"invalid number of signatures {num_sigs}")
# First, add the nvfw_bin_hdr header
total_size = round_up_to_base(120 + signatures_size + firmware_size, 256)
firmware_offset = 120 + signatures_size
f.write(struct.pack("<6L", 0x10de, 1, total_size, 24, firmware_offset, firmware_size))
# Second, add the nvfw_hs_header_v2 header
patch_loc_offset = 60 + signatures_size
patch_sig_offset = patch_loc_offset + 4
meta_data_offset = patch_sig_offset + 4
num_sig_offset = meta_data_offset + 12
header_offset = num_sig_offset + 4
f.write(struct.pack("<9L", 60, signatures_size, patch_loc_offset,
patch_sig_offset, meta_data_offset, 12,
num_sig_offset, header_offset, 36))
# Third, the actual signatures
f.write(signatures)
# Extract the patch location
array = f"ksec2BinArchiveSecurescrubUcode_{GPUX}_patch_loc_data"
bytes = getbytes(filename, array)
patchloc = struct.unpack("<L", bytes)[0]
# Extract the patch meta variables
array = f"ksec2BinArchiveSecurescrubUcode_{GPUX}_patch_meta_data"
bytes = getbytes(filename, array)
fuse_ver, engine_id, ucode_id = struct.unpack("<LLL", bytes)
# Fourth, patch_loc[], patch_sig[], fuse_ver, engine_id, ucode_id, and num_sigs
f.write(struct.pack("<6L", patchloc, 0, fuse_ver, engine_id, ucode_id, num_sigs))
# Extract the descriptor (nvkm_gsp_booter_fw_hdr)
array = f"ksec2BinArchiveSecurescrubUcode_{GPUX}_header_prod_data"
descriptor = getbytes(filename, array)
# Fifth, the descriptor
f.write(descriptor)
# And finally, the actual scrubber image
f.write(firmware)
def main():
global outputpath
global version
parser = argparse.ArgumentParser(
description = 'Extract firmware binaries from the OpenRM git repository'
' in a format expected by the Nouveau device driver.')
parser.add_argument('-i', '--input', default = os.getcwd(),
help = 'Path to source directory (where version.mk exists)')
parser.add_argument('-o', '--output', default = os.path.abspath(os.getcwd() + '/_out'),
help = 'Path to target directory (where files will be written)')
args = parser.parse_args()
os.chdir(args.input)
with open("version.mk") as f:
version = re.search(r'^NVIDIA_VERSION = ([^\s]+)', f.read(), re.MULTILINE).group(1)
print(f"Generating files for version {version}")
# Normal version strings are of the format xxx.yy.zz, which are all
# numbers. If it's a normal version string, convert it to a single number,
# as Nouveau currently expects. Otherwise, leave it alone.
if set(version) <= set('0123456789.'):
version = version.replace(".", "")
outputpath = args.output;
print(f"Writing files to {outputpath}")
os.makedirs(f"{outputpath}/nvidia", exist_ok = True)
booter("tu102", "load", 16)
booter("tu102", "unload", 16)
bootloader("tu102", "_")
booter("tu116", "load", 16)
booter("tu116", "unload", 16)
# TU11x uses the same bootloader as TU10x
booter("ga100", "load", 384)
booter("ga100", "unload", 384)
bootloader("ga100", "_")
booter("ga102", "load", 384)
booter("ga102", "unload", 384)
bootloader("ga102", "_prod_")
booter("ad102", "load", 384)
booter("ad102", "unload", 384)
bootloader("ad102", "_prod_")
# scrubber("ad102", 384) # Not currently used by Nouveau
if __name__ == "__main__":
main()
| open-gpu-kernel-modules-main | nouveau/extract-firmware-nouveau.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import math
import json
from torch.utils.checkpoint import checkpoint
import pdb
class SoftmaxAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.drop_attn = torch.nn.Dropout(p=config.attention_dropout)
self.head_dim = config.head_dim
def forward(self, Q, K, V, mask):
dot = torch.matmul(Q, torch.transpose(K, -2, -1))
dot = dot / math.sqrt(self.head_dim)
dot = dot - 1e6 * (1 - mask[:, None, None, :])
attn = nn.functional.softmax(dot, dim = -1)
attn = self.drop_attn(attn)
X = torch.matmul(attn, V)
return X
class NoneAttention(nn.Module):
def __init__(self, config):
super().__init__()
def forward(self, Q, K, V, mask):
return V
class Attention(nn.Module):
def __init__(self, config):
super().__init__()
self.grad_checkpointing = config.attention_grad_checkpointing
self.dim = config.transformer_dim
self.head_dim = config.head_dim
self.num_head = config.num_head
self.attn_type = config.attn_type
self.W_q = nn.Linear(self.dim, self.num_head * self.head_dim)
self.W_k = nn.Linear(self.dim, self.num_head * self.head_dim)
self.W_v = nn.Linear(self.dim, self.num_head * self.head_dim)
self.dconv_fc = None
if self.attn_type == "softmax":
self.attn = SoftmaxAttention(config)
elif self.attn_type == "none":
self.attn = NoneAttention(config)
elif self.attn_type.startswith("linformer"):
from attention_linformer import LinformerAttention
self.attn = LinformerAttention(config)
elif self.attn_type.startswith("reformer"):
from attention_reformer import LSHAttention
self.attn = LSHAttention(config, self.W_q, self.W_k, self.W_v)
elif self.attn_type.startswith("nystrom"):
from attention_nystrom import NystromAttention
self.attn = NystromAttention(config)
elif self.attn_type.startswith("performer"):
from attention_performer import PerformerAttention
self.attn = PerformerAttention(config)
elif self.attn_type.startswith("linear"):
from attention_linear import LinearAttention
self.attn = LinearAttention(config)
self.ff = nn.Linear(self.num_head * self.head_dim, self.dim)
def forward(self, X, mask):
if self.attn_type.startswith("longformer") or self.attn_type.startswith("reformer"):
with torch.cuda.amp.autocast(enabled = False):
attn_out = self.attn(X.float(), mask.float())
else:
Q = self.split_heads(self.W_q(X))
K = self.split_heads(self.W_k(X))
V = self.split_heads(self.W_v(X))
with torch.cuda.amp.autocast(enabled = False):
if self.grad_checkpointing:
attn_out = checkpoint(self.attn, Q.float(), K.float(), V.float(), mask.float())
else:
attn_out = self.attn(Q.float(), K.float(), V.float(), mask.float())
attn_out = self.combine_heads(attn_out)
out = self.ff(attn_out)
return out
def combine_heads(self, X):
X = X.transpose(1, 2)
X = X.reshape(X.size(0), X.size(1), self.num_head * self.head_dim)
return X
def split_heads(self, X):
X = X.reshape(X.size(0), X.size(1), self.num_head, self.head_dim)
X = X.transpose(1, 2)
return X
| transformer-ls-master | lra/attention.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import math
class NystromAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.head_dim = config.head_dim
self.num_head = config.num_head
self.num_landmarks = config.num_landmarks
self.seq_len = config.max_seq_len
if "inv_coeff_init_option" in config:
self.init_option = config.inv_coeff_init_option
else:
self.init_option = "original"
self.use_conv = hasattr(config, "conv_kernel_size" ) and getattr(config, "conv_kernel_size", '-1') > 0
if self.use_conv:
self.conv = nn.Conv2d(
in_channels=self.num_head, out_channels=self.num_head,
kernel_size=(config.conv_kernel_size, 1), padding=(config.conv_kernel_size // 2, 0),
bias=False,
groups=self.num_head)
def forward(self, Q, K, V, mask):
Q = Q * mask[:, None, :, None] / math.sqrt(math.sqrt(self.head_dim))
K = K * mask[:, None, :, None] / math.sqrt(math.sqrt(self.head_dim))
if self.num_landmarks == self.seq_len:
attn = torch.nn.functional.softmax(torch.matmul(Q, K.transpose(-1, -2)) - 1e9 * (1 - mask[:, None, None, :]), dim = -1)
X = torch.matmul(attn, V)
else:
Q_landmarks = Q.reshape(-1, self.num_head, self.num_landmarks, self.seq_len // self.num_landmarks, self.head_dim).mean(dim = -2)
K_landmarks = K.reshape(-1, self.num_head, self.num_landmarks, self.seq_len // self.num_landmarks, self.head_dim).mean(dim = -2)
kernel_1 = torch.nn.functional.softmax(torch.matmul(Q, K_landmarks.transpose(-1, -2)), dim = -1)
kernel_2 = torch.nn.functional.softmax(torch.matmul(Q_landmarks, K_landmarks.transpose(-1, -2)), dim = -1)
kernel_3 = torch.nn.functional.softmax(torch.matmul(Q_landmarks, K.transpose(-1, -2)) - 1e9 * (1 - mask[:, None, None, :]), dim = -1)
X = torch.matmul(torch.matmul(kernel_1, self.iterative_inv(kernel_2)), torch.matmul(kernel_3, V))
if self.use_conv:
X += self.conv(V * mask[:, None, :, None])
return X
def iterative_inv(self, mat, n_iter = 6):
I = torch.eye(mat.size(-1), device=mat.device)
K = mat
if self.init_option == "original":
V = 1 / torch.max(torch.sum(K, dim=-2)) * K.transpose(-1, -2)
else:
V = 1 / torch.max(torch.sum(K, dim=-2), dim=-1).values[:, :, None, None] * K.transpose(-1, -2)
for _ in range(n_iter):
KV = torch.matmul(K, V)
V = torch.matmul(0.25 * V, 13 * I - torch.matmul(KV, 15 * I - torch.matmul(KV, 7 * I - KV)))
return V
def extra_repr(self):
return f'num_landmarks={self.num_landmarks}, seq_len={self.seq_len}'
| transformer-ls-master | lra/attention_nystrom.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import math
from performer_pytorch import FastAttention
class PerformerAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.head_dim = config.head_dim
self.rp_dim = config.rp_dim
self.kernel_type = "relu" #config.kernel_type
if self.kernel_type == "relu":
self.attn_fn = FastAttention(dim_heads = self.head_dim, nb_features = self.rp_dim, causal = False, kernel_fn = nn.ReLU())
elif self.kernel_type == "exp":
self.attn_fn = FastAttention(dim_heads = self.head_dim, nb_features = self.rp_dim, causal = False, kernel_fn = torch.exp)
def forward(self, Q, K, V, mask):
return self.attn_fn(
Q / math.sqrt(math.sqrt(self.head_dim)),
K / math.sqrt(math.sqrt(self.head_dim)) * mask[:, None, :, None],
V * mask[:, None, :, None])
def extra_repr(self):
return f'rp_dim={self.rp_dim}, kernel_type={self.kernel_type}'
| transformer-ls-master | lra/attention_performer.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import numpy as np
import math
from torch.utils.checkpoint import checkpoint
from attention import Attention
from attention_transformer_ls import AttentionLS
import pdb
class Embeddings(nn.Module):
def __init__(self, config):
super().__init__()
assert config.embedding_dim == config.transformer_dim
self.dim = config.embedding_dim
self.word_embeddings = nn.Embedding(config.vocab_size, config.embedding_dim)
torch.nn.init.normal_(self.word_embeddings.weight, std=0.02)
self.position_embeddings = nn.Embedding(config.max_seq_len, config.embedding_dim)
torch.nn.init.normal_(self.position_embeddings.weight, std=0.02)
if config.debug:
self.word_embeddings.weight[-1].data[:] = 0
self.position_embeddings.weight[0].data[:] = 0
self.dropout = torch.nn.Dropout(p=config.dropout_prob)
def fixed_pos_emb(self, seq_len, device):
position = torch.arange(0, seq_len, device=device)[:, np.newaxis]
div_term = torch.exp(torch.arange(0, self.dim, 2, device=device) * -(math.log(10000.0) / self.dim))
pos_embed = torch.stack([torch.sin(position * div_term), torch.cos(position * div_term)], -1).reshape(seq_len, -1)
return pos_embed
def forward(self, input_ids):
batch_size, seq_len = input_ids.size()
X_token = self.word_embeddings(input_ids)
position_ids = torch.arange(seq_len, dtype=torch.long, device=input_ids.device)[None, :].repeat(batch_size, 1)
X_pos = self.position_embeddings(position_ids)
X = X_token + X_pos
X = self.dropout(X)
return X
class Transformer(nn.Module):
def __init__(self, config):
super().__init__()
self.norm1 = nn.LayerNorm(config.transformer_dim)
if config.attn_type == 'lsta':
self.mha = AttentionLS(config)
else:
self.mha = Attention(config)
self.dropout1 = torch.nn.Dropout(p=config.dropout_prob)
self.norm2 = nn.LayerNorm(config.transformer_dim)
self.debug = config.debug
self.mlpblock = nn.Sequential(
nn.Linear(config.transformer_dim, config.transformer_hidden_dim),
nn.GELU(),
torch.nn.Dropout(p=config.dropout_prob),
nn.Linear(config.transformer_hidden_dim, config.transformer_dim),
torch.nn.Dropout(p=config.dropout_prob)
)
def forward(self, X, mask, cls_embed=None):
if cls_embed is None:
X = self.dropout1(self.mha(self.norm1(X), mask)) + X
else:
if cls_embed.shape[0] == 1:
cls_embed = cls_embed.expand(X.shape[0], -1, -1)
X_prepend = torch.cat([cls_embed, X], dim=1)
if self.debug:
cls_embed = self.norm1(cls_embed)
X = self.dropout1(self.mha(self.norm1(X), mask, cls_embed)) + X_prepend
X = self.mlpblock(self.norm2(X)) + X
return X
class Model(nn.Module):
def __init__(self, config):
super().__init__()
self.num_layers = config.num_layers
self.tied_weights = config.tied_weights
self.cls_last_layer = config.cls_last_layer
self.embeddings = Embeddings(config)
if config.cls_token or self.cls_last_layer:
self.cls_embed = nn.Parameter(torch.zeros(1, 1, config.transformer_dim))
else:
self.cls_embed = None
if self.tied_weights:
self.transformer = Transformer(config)
else:
for idx in range(self.num_layers):
setattr(self, f"transformer_{idx}", Transformer(config))
self.norm = nn.LayerNorm(config.transformer_dim)
def forward(self, input_ids, mask=None):
X = self.embeddings(input_ids)
cls_embed = self.cls_embed if not self.cls_last_layer else None
if mask is None:
mask = torch.ones_like(input_ids)
if self.tied_weights:
for idx in range(self.num_layers):
if self.cls_last_layer and idx == self.num_layers - 1:
cls_embed = self.cls_embed
X = self.transformer(X, mask, cls_embed)
if cls_embed is not None:
# We always prepend the cls token into the first token
cls_embed = X[:, :1]
X = X[:, 1:]
else:
for idx in range(self.num_layers):
if self.cls_last_layer and idx == self.num_layers - 1:
cls_embed = self.cls_embed
X = getattr(self, f"transformer_{idx}")(X, mask, cls_embed)
if cls_embed is not None:
# We always prepend the cls token into the first token
cls_embed = X[:, :1]
X = X[:, 1:]
if cls_embed is not None:
cls_embed = self.norm(cls_embed)
return cls_embed
else:
X = self.norm(X) * mask[:, :, None]
return X
| transformer-ls-master | lra/model.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import math
from model import Model
def pooling(inp, mode):
# pdb.set_trace()
if mode.lower() == "cls":
pooled = inp[:, 0, :]
elif mode.lower() == "mean":
pooled = inp.mean(dim=1)
else:
raise Exception()
return pooled
def append_cls(inp, mask, vocab_size):
batch_size = inp.size(0)
cls_id = ((vocab_size - 1) * torch.ones(batch_size, dtype=inp.dtype, device=inp.device))#.long()
cls_mask = torch.ones(batch_size, dtype=mask.dtype, device=mask.device)
# inp = torch.cat([cls_id[:, None], inp[:, :-1]], dim=-1)
# mask = torch.cat([cls_mask[:, None], mask[:, :-1]], dim=-1)
inp = torch.cat([cls_id[:, None], inp], dim=-1)
mask = torch.cat([cls_mask[:, None], mask], dim=-1)
return inp, mask
class SCHead(nn.Module):
def __init__(self, config):
super().__init__()
self.config = config
self.pooling_mode = config.pooling_mode
if config.cls_last_layer:
self.pooling_mode = 'CLS'
self.mlpblock = nn.Sequential(
nn.Linear(config.transformer_dim, config.transformer_hidden_dim),
nn.ReLU(),
nn.Linear(config.transformer_hidden_dim, config.num_classes)
)
def forward(self, inp):
if self.config.cls_token:
seq_score = self.mlpblock(inp[:, 0, :])
else:
seq_score = self.mlpblock(pooling(inp, self.pooling_mode))
return seq_score
class ModelForSC(nn.Module):
def __init__(self, config):
super().__init__()
self.enable_amp = config.mixed_precision
self.pooling_mode = config.pooling_mode # something specific for Nystromformer?
assert not (config.pooling_mode.lower() == 'cls' and config.cls_last_layer )
self.cls_last_layer = config.cls_last_layer
self.vocab_size = config.vocab_size
self.model = Model(config)
self.seq_classifer = SCHead(config)
def forward(self, input_ids_0, mask_0, label):
with torch.cuda.amp.autocast(enabled=self.enable_amp):
if self.pooling_mode == "CLS" and not self.cls_last_layer:
input_ids_0, mask_0 = append_cls(input_ids_0, mask_0, self.vocab_size)
token_out = self.model(input_ids_0, mask_0)
seq_scores = self.seq_classifer(token_out)
seq_loss = torch.nn.CrossEntropyLoss(reduction="none")(seq_scores, label)
seq_accu = (seq_scores.argmax(dim=-1) == label).to(torch.float32)
outputs = {}
outputs["loss"] = seq_loss
outputs["accu"] = seq_accu
return outputs
class ModelForSCProbing(nn.Module):
def __init__(self, config):
super().__init__()
self.enable_amp = config.mixed_precision
self.pooling_mode = config.pooling_mode # something specific for Nystromformer?
assert not (config.pooling_mode.lower() == 'cls' and config.cls_last_layer )
self.cls_last_layer = config.cls_last_layer
self.vocab_size = config.vocab_size
self.model = Model(config)
self.seq_classifer = SCHead(config)
def forward(self, input_list):
input_ids_0, mask_0, label = input_list
with torch.cuda.amp.autocast(enabled=self.enable_amp):
if self.pooling_mode == "CLS" and not self.cls_last_layer:
input_ids_0, mask_0 = append_cls(input_ids_0, mask_0, self.vocab_size)
token_out = self.model(input_ids_0, mask_0)
seq_scores = self.seq_classifer(token_out)
seq_loss = torch.nn.CrossEntropyLoss(reduction="none")(seq_scores, label)
seq_accu = (seq_scores.argmax(dim=-1) == label).to(torch.float32)
outputs = {}
outputs["loss"] = seq_loss
outputs["accu"] = seq_accu
return outputs
class SCHeadDual(nn.Module):
def __init__(self, config):
super().__init__()
self.pooling_mode = config.pooling_mode
self.mlpblock = nn.Sequential(
nn.Linear(config.transformer_dim * 4, config.transformer_hidden_dim),
nn.ReLU(),
nn.Linear(config.transformer_hidden_dim, config.num_classes)
)
def forward(self, inp_0, inp_1):
X_0 = pooling(inp_0, self.pooling_mode)
X_1 = pooling(inp_1, self.pooling_mode)
seq_score = self.mlpblock(torch.cat([X_0, X_1, X_0 * X_1, X_0 - X_1], dim=-1))
return seq_score
class ModelForSCDual(nn.Module):
def __init__(self, config):
super().__init__()
self.enable_amp = config.mixed_precision
self.pooling_mode = config.pooling_mode
self.vocab_size = config.vocab_size
self.model = Model(config)
self.seq_classifer = SCHeadDual(config)
def forward(self, input_ids_0, input_ids_1, mask_0, mask_1, label):
with torch.cuda.amp.autocast(enabled=self.enable_amp):
if self.pooling_mode == "CLS":
input_ids_0, mask_0 = append_cls(input_ids_0, mask_0, self.vocab_size)
input_ids_1, mask_1 = append_cls(input_ids_1, mask_1, self.vocab_size)
token_out_0 = self.model(input_ids_0, mask_0)
token_out_1 = self.model(input_ids_1, mask_1)
seq_scores = self.seq_classifer(token_out_0, token_out_1)
seq_loss = torch.nn.CrossEntropyLoss(reduction="none")(seq_scores, label)
seq_accu = (seq_scores.argmax(dim=-1) == label).to(torch.float32)
outputs = {}
outputs["loss"] = seq_loss
outputs["accu"] = seq_accu
return outputs
class ModelForSCDualProbing(nn.Module):
def __init__(self, config):
super().__init__()
self.enable_amp = config.mixed_precision
self.pooling_mode = config.pooling_mode
self.vocab_size = config.vocab_size
self.model = Model(config)
self.seq_classifer = SCHeadDual(config)
def forward(self, input_list):
input_ids_0, input_ids_1, mask_0, mask_1, label = input_list
with torch.cuda.amp.autocast(enabled=self.enable_amp):
if self.pooling_mode == "CLS":
input_ids_0, mask_0 = append_cls(input_ids_0, mask_0, self.vocab_size)
input_ids_1, mask_1 = append_cls(input_ids_1, mask_1, self.vocab_size)
token_out_0 = self.model(input_ids_0, mask_0)
token_out_1 = self.model(input_ids_1, mask_1)
seq_scores = self.seq_classifer(token_out_0, token_out_1)
seq_loss = torch.nn.CrossEntropyLoss(reduction="none")(seq_scores, label)
seq_accu = (seq_scores.argmax(dim=-1) == label).to(torch.float32)
outputs = {}
outputs["loss"] = seq_loss
outputs["accu"] = seq_accu
return outputs
| transformer-ls-master | lra/model_wrapper.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
import math
from torch.utils.data.dataset import Dataset
import sys
import os
import random
import json
import pickle
import numpy as np
import pdb
class LRADataset(Dataset):
def __init__(self, file_path, endless):
self.endless = endless
with open(file_path, "rb") as f:
self.examples = pickle.load(f)
random.shuffle(self.examples)
self.curr_idx = 0
print(f"Loaded {file_path}... size={len(self.examples)}", flush = True)
def __len__(self):
if self.endless:
return 1000000000
else:
return len(self.examples)
def create_inst(self, inst):
output = {}
output["input_ids_0"] = torch.tensor(inst["input_ids_0"], dtype = torch.long)
output["mask_0"] = (output["input_ids_0"] != 0).float()
if "input_ids_1" in inst:
output["input_ids_1"] = torch.tensor(inst["input_ids_1"], dtype = torch.long)
output["mask_1"] = (output["input_ids_1"] != 0).float()
output["label"] = torch.tensor(inst["label"], dtype = torch.long)
return output
def __getitem__(self, i):
if not self.endless:
return self.create_inst(self.examples[i])
if self.curr_idx >= len(self.examples):
random.shuffle(self.examples)
self.curr_idx = 0
inst = self.examples[self.curr_idx]
self.curr_idx += 1
return self.create_inst(inst)
| transformer-ls-master | lra/dataset.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import torch
import torch.nn as nn
from transformers.models.reformer.modeling_reformer import LSHSelfAttention, ReformerConfig
class LSHAttention(LSHSelfAttention):
def __init__(self, config, query, key, value):
self.num_hash = config.num_hash
reformer_config = ReformerConfig()
reformer_config.attention_head_size = config.head_dim
reformer_config.num_attention_heads = config.num_head
reformer_config.attn_layers = ["lsh"]
reformer_config.num_hashes = config.num_hash
reformer_config.is_decoder = False
reformer_config.max_position_embeddings = config.max_seq_len
reformer_config.hidden_size = config.transformer_dim
super().__init__(reformer_config)
self.query_key.weight = query.weight
self.value.weight = value.weight
def forward(self, X, mask):
return super().forward(hidden_states = X, attention_mask = mask).hidden_states
def extra_repr(self):
return f'num_hash={self.num_hash}'
| transformer-ls-master | lra/attention_reformer.py |
"""
Adapted from https://github.com/mlpen/Nystromformer
"""
from fvcore.nn import FlopCountAnalysis
from model_wrapper import ModelForSC, ModelForSCDual, ModelForSCProbing, ModelForSCDualProbing
from dataset import LRADataset
import torch
import random
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
import torch
import torch.nn as nn
import time
import os
import json
import pickle
import numpy as np
import argparse
import math
import itertools
parser = argparse.ArgumentParser()
parser.add_argument("--model", type=str, help="model", dest="model", required=True)
parser.add_argument("--task", type=str, help="task", dest="task", required = False)
parser.add_argument("--skip_train", type = int, help = "skip_train", dest = "skip_train", default = 0)
parser.add_argument("--logging", action='store_true', default=False)
parser.add_argument("--expname", type=str, default="default")
# Model configs
parser.add_argument("--attention_grad_checkpointing", default=False, action="store_true")
parser.add_argument("--num_landmarks", default=128, type=int)
parser.add_argument("--window_size", default=129, type=int)
parser.add_argument("--conv_kernel_size", default=-1, type=int)
parser.add_argument("--learn_pos_emb", default=1, type=int,
help="Use 0 or 1 to represent false and true")
parser.add_argument("--tied_weights", default=False, action="store_true")
parser.add_argument("--embedding_dim", default=64, type=int)
parser.add_argument("--transformer_dim", default=64, type=int)
parser.add_argument("--transformer_hidden_dim", default=128, type=int)
parser.add_argument("--head_dim", default=32, type=int)
parser.add_argument("--num_head", default=2, type=int)
parser.add_argument("--num_layers", default=2, type=int)
parser.add_argument("--vocab_size", default=512, type=int)
parser.add_argument("--max_seq_len", default=4096, type=int)
parser.add_argument("--dropout_prob", default=0.1, type=float)
parser.add_argument("--attention_dropout", default=0.1, type=float)
parser.add_argument("--pooling_mode", default="MEAN", type=str)
parser.add_argument("--num_classes", default=2, type=int)
parser.add_argument("--cls_token", default=False, action='store_true')
# Training configs
parser.add_argument("--batch_size", default=32, type=int)
parser.add_argument("--learning_rate", default=1e-4, type=float)
parser.add_argument("--warmup", default=8000, type=int)
parser.add_argument("--lr_decay", default="linear", type=str)
parser.add_argument("--fixed_lr", default=False, action='store_true')
parser.add_argument("--weight_decay", default=0, type=float)
parser.add_argument("--adam_eps", default=1e-6, type=float)
parser.add_argument("--eval_frequency", default=500, type=int)
parser.add_argument("--num_train_steps", default=20000, type=int)
parser.add_argument("--num_eval_steps", default=781, type=int)
parser.add_argument("--fp32_attn", default=False, action='store_true')
parser.add_argument("--conv_zero_init", default=False, action='store_true')
# Dataset Configs
parser.add_argument("--n_train_samples", default=25000, type=int)
parser.add_argument("--n_dev_samples", default=25000, type=int)
parser.add_argument("--n_test_samples", default=25000, type=int)
parser.add_argument("--debug", default=False, action='store_true')
parser.add_argument("--cls_last_layer", default=False, action='store_true')
parser.add_argument("--seed", default=1234, type=int)
parser.add_argument("--linformer_k", default=256, type=int)
parser.add_argument("--rp_dim", default=256, type=int)
parser.add_argument("--num_hash", default=2, type=int)
parser.add_argument("--chk_path", default="LRA_chks", type=str)
parser.add_argument("--test_flops", default=False, action='store_true')
args = parser.parse_args()
random.seed(args.seed)
torch.manual_seed(args.seed)
# cudnn.deterministic = True
args.attn_type = args.model # remove attn_type in the future
args.mixed_precision = True # bool(args.mixed_precision)
task = args.task
checkpoint_dir = args.chk_path
print(args)
device_ids = list(range(torch.cuda.device_count()))
print(f"GPU list: {device_ids}")
if task == "retrieval":
if args.test_flops:
model = ModelForSCDualProbing(args)
else:
model = ModelForSCDual(args)
else:
if args.test_flops:
model = ModelForSCProbing(args)
else:
model = ModelForSC(args)
print(model)
print(f"parameter_size: {[weight.size() for weight in model.parameters()]}", flush=True)
print(f"num_parameter: {np.sum([np.prod(weight.size()) for weight in model.parameters()])}", flush=True)
model = model.cuda()
model = nn.DataParallel(model, device_ids = device_ids)
data_path = 'datasets'
ds_iter = {
"train":enumerate(DataLoader(LRADataset(f"{data_path}/{task}.train.pickle", True), batch_size=args.batch_size, drop_last=True)),
"dev":enumerate(DataLoader(LRADataset(f"{data_path}/{task}.dev.pickle", True), batch_size=args.batch_size, drop_last=True)),
"test":enumerate(DataLoader(LRADataset(f"{data_path}/{task}.test.pickle", False), batch_size=args.batch_size, drop_last=True)),
}
optimizer = torch.optim.AdamW(
model.parameters(),
lr=args.learning_rate,
betas=(0.9, 0.999), eps=args.adam_eps, weight_decay=args.weight_decay
)
lr_scheduler = torch.optim.lr_scheduler.OneCycleLR(
optimizer=optimizer,
max_lr=args.learning_rate,
pct_start=args.warmup / args.num_train_steps,
anneal_strategy=args.lr_decay,
total_steps=args.num_train_steps
)
amp_scaler = torch.cuda.amp.GradScaler() if args.mixed_precision else None
def step(component, step_idx):
t0 = time.time()
optimizer.zero_grad()
_, batch = next(ds_iter[component])
for key in batch:
batch[key] = batch[key].cuda()
if (args.model == 'nystrom' or args.model == 'reformer') and args.pooling_mode.lower() == 'cls':
for key in batch:
if 'input_ids' in key or 'mask' in key:
batch[key] = batch[key][:, :-1].contiguous()
if component == "train":
outputs = {}
partial_inputs_list = [{} for _ in range(accumu_steps)]
for key in batch:
for idx, inp in enumerate(torch.chunk(batch[key], accumu_steps, dim = 0)):
partial_inputs_list[idx][key] = inp
for partial_inputs in partial_inputs_list:
if args.test_flops:
if 'input_ids_1' in partial_inputs:
flops = FlopCountAnalysis(
model, [partial_inputs['input_ids_0'][:1], partial_inputs['input_ids_1'][:1],
partial_inputs['mask_0'][:1], partial_inputs['mask_1'][:1], partial_inputs['label'][:1]])
else:
flops = FlopCountAnalysis(
model, [partial_inputs['input_ids_0'][:1], partial_inputs['mask_0'][:1], partial_inputs['label'][:1]])
print(f"Flops of {args.model}: {flops.total()/1e9:.2f} G")
exit()
partial_outputs = model(**partial_inputs)
for key in partial_outputs:
partial_outputs[key] = partial_outputs[key].mean() / accumu_steps
if key not in outputs:
outputs[key] = partial_outputs[key]
else:
outputs[key] += partial_outputs[key]
amp_scaler.scale(partial_outputs["loss"]).backward()
amp_scaler.step(optimizer)
amp_scaler.update()
if (not args.fixed_lr) or step_idx < args.warmup:
lr_scheduler.step()
else:
with torch.no_grad():
outputs = {}
partial_inputs_list = [{} for _ in range(accumu_steps)]
for key in batch:
for idx, inp in enumerate(torch.chunk(batch[key], accumu_steps, dim = 0)):
partial_inputs_list[idx][key] = inp
for partial_inputs in partial_inputs_list:
partial_outputs = model(**partial_inputs)
for key in partial_outputs:
partial_outputs[key] = partial_outputs[key].mean() / accumu_steps
if key not in outputs:
outputs[key] = partial_outputs[key]
else:
outputs[key] += partial_outputs[key]
t1 = time.time()
batch_size = batch[list(batch.keys())[0]].size(0)
t_escape = t1 - t0
learning_rate = optimizer.param_groups[0]["lr"]
loss = outputs["loss"].data.item()
accu = outputs["accu"].data.item()
time_since_start = time.time() - init_t
print(f"step={step_idx}, tt={time_since_start:.1f}, t={t_escape:.3f}, bs={batch_size}, lr={learning_rate:.6f}, loss={loss:.4f}, accu={accu:.4f}\t\t\t\t", end = "\r", flush = True)
summary[component]["t"] += t_escape
summary[component]["loss"].append(loss)
summary[component]["accu"].append(accu)
def print_summary(summary, save_if_improved, train_step_idx, subset):
# subset: str, the subset to report the result
summary["loss"] = np.mean(summary["loss"])
summary["accu"] = np.mean(summary["accu"])
print()
if summary["accu"] > summary["best_accu"]:
summary["best_accu"] = summary["accu"]
if save_if_improved:
best_accu = summary["best_accu"]
torch.save({"model_state_dict":model.module.state_dict()}, log_f_path.replace(".log", ".model"))
print(f"best_accu={best_accu}. Saved best model")
summary_round = {"train_step_idx":train_step_idx}
for key in summary:
if type(summary[key]) is str:
summary_round[key+f"_{subset}"] = summary[key]
else:
summary_round[key+f"_{subset}"] = round(summary[key], 4)
print(summary_round, flush=True)
log_f.write(json.dumps(summary_round, sort_keys = True) + "\n")
log_f.flush()
summary["t"] = 0
summary["loss"] = []
summary["accu"] = []
init_t = time.time()
log_f_path = os.path.join(checkpoint_dir, f"{args.expname}_output.log")
log_f = open(log_f_path, "a+")
summary = {
component:{"t":0, "loss":[], "accu":[], "best_accu":0, "component":component}
for component in ["train", "dev", "test"]
}
# accumu_steps = max(training_config["batch_size"] // len(device_ids) // gpu_memory_config[attn_type], 1)
accumu_steps = max(args.batch_size // len(device_ids) // 32, 1)
print(f"accumu_steps={accumu_steps}")
if args.skip_train == 0:
try:
model.train()
for train_step_idx in range(args.num_train_steps):
outputs = step("train", train_step_idx)
if (train_step_idx + 1) % args.eval_frequency == 0:
print_summary(summary["train"], False, train_step_idx, 'train')
model.eval()
for dev_step_idx in range(args.num_eval_steps):
outputs = step("dev", dev_step_idx)
print_summary(summary["dev"], True, train_step_idx, 'dev')
model.train()
except KeyboardInterrupt as e:
print(e)
checkpoint = torch.load(log_f_path.replace(".log", ".model"), map_location="cpu")
model.module.load_state_dict(checkpoint["model_state_dict"])
model.eval()
try:
for test_step_idx in itertools.count():
outputs = step("test", test_step_idx)
except StopIteration:
print_summary(summary["test"], False, train_step_idx, 'test')
| transformer-ls-master | lra/run_tasks.py |
# Copyright (c) 2021 NVIDIA CORPORATION. Licensed under the MIT license.
# Written by Chen Zhu during an internship at NVIDIA, [email protected]
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class AttentionLS(nn.Module):
"""The long-short term attention for bidirectional language modelling
"""
def __init__(self, config):
super().__init__()
assert not (config.pooling_mode.lower() == 'cls' and config.cls_token)
self.cls_from_seq = config.pooling_mode.lower() == 'cls'
self.num_head = config.num_head
self.head_dim = config.head_dim
self.num_landmarks = config.num_landmarks
self.seq_len = config.max_seq_len
self.dim = config.transformer_dim
self.drop_attn = torch.nn.Dropout(p=config.attention_dropout)
self.window_size = config.window_size
self.W_q = nn.Linear(self.dim, self.num_head * self.head_dim)
self.W_k = nn.Linear(self.dim, self.num_head * self.head_dim)
self.W_v = nn.Linear(self.dim, self.num_head * self.head_dim)
self.W_o = nn.Linear(self.dim, self.num_head * self.head_dim)
self.fp32 = config.fp32_attn
self.dual_ln_s = nn.LayerNorm(self.num_head * self.head_dim)
self.dual_ln_l = nn.LayerNorm(self.num_head * self.head_dim)
self.dconv_fc = nn.Linear(self.dim, self.num_head * self.num_landmarks)
self.use_conv = getattr(config, "conv_kernel_size", -1) > 0
if self.use_conv:
self.conv = nn.Conv1d(
in_channels=self.num_head, out_channels=self.num_head,
kernel_size=(config.conv_kernel_size, 1), padding=(config.conv_kernel_size // 2, 0),
bias=False,
groups=self.num_head)
nn.init.zeros_(self.conv.weight)
def get_tiles(self, x, transpose=False):
# x: bsz x n_heads x seqlen x d_head
bsz, n_heads, seqlen, d_h = x.shape
out_shape = (bsz, n_heads, seqlen//self.window_size-1, 2 * self.window_size, d_h)
in_strides = x.stride()
out_strides = (in_strides[0], in_strides[1], in_strides[2]*self.window_size, in_strides[2], 1)
x_main = x.as_strided(size=out_shape, stride=out_strides)
x_last = x[:, :, None, -2*self.window_size:, :]
x = torch.cat([x_main, x_last], dim=2)
if transpose:
return x.transpose(-1, -2)
else:
# bsz x n_heads x seqlen//wlen x 2*wlen x d_h
return x
def get_tiled_mask(self, mask):
bsz, seqlen = mask.shape
out_shape = (bsz, seqlen//self.window_size-1, 2*self.window_size)
in_stride = mask.stride()
out_stride = (in_stride[0], in_stride[1]*self.window_size, in_stride[1])
mask_main = mask.as_strided(size=out_shape, stride=out_stride)[:, None, :, :]
mask_last = mask[:, None, None, -2*self.window_size:]
return torch.cat([mask_main, mask_last], dim=2)[:, :, :, None, :]
def sliding_chunks_matmul_qk(self, Q, K, padding_mask):
# Q, K: bsz x num_heads x seqlen x d_head
# padding_mask: bsz x seqlen
bsz, num_heads, seqlen, d_h = Q.shape
mask_tiles = self.get_tiled_mask(padding_mask)
K_tiles = self.get_tiles(K, transpose=True)
Q_tiles = Q.view(bsz, num_heads, seqlen//self.window_size, self.window_size, d_h)
# bsz x num_heads x seqlen//winsize x winsize x 2winsize
qk_scores = Q_tiles.matmul(K_tiles)
qk_scores.masked_fill_(mask_tiles, float('-inf'))
return qk_scores.view(bsz, num_heads, seqlen, 2*self.window_size)
def get_tiles_v2(self, x, transpose=False):
if self.window_size <= 0:
return x
bsz, n_heads, seqlen, d_h = x.shape
n_groups = seqlen // self.window_size
ext_len = max(self.window_size//2, 1)
x = F.pad(x, (0, 0, ext_len, ext_len), value=0)
strides = x.stride()
if transpose:
out_shape = (bsz, n_heads, n_groups, d_h, 2 * ext_len + self.window_size)
out_stride = (strides[0], strides[1], self.window_size * strides[2], strides[3], strides[2])
else:
out_shape = (bsz, n_heads, n_groups, 2 * ext_len + self.window_size, d_h)
out_stride = (strides[0], strides[1], self.window_size * strides[2], strides[2], strides[3])
return torch.as_strided(x, size=out_shape, stride=out_stride)
def get_tiled_mask_v2(self, mask):
# only mask along the key dimension
bsz, seqlen = mask.shape
ext_len = max(self.window_size//2, 1)
mask = F.pad(mask, (ext_len, ext_len), value=True)
out_shape = (bsz, seqlen//self.window_size, 2*ext_len + self.window_size)
in_stride = mask.stride()
out_stride = (in_stride[0], in_stride[1]*self.window_size, in_stride[1])
return mask.as_strided(size=out_shape, stride=out_stride)[:, None, :, None, :]
def sliding_chunks_matmul_qk_v2(self, Q, K, padding_mask):
bsz, num_heads, seqlen, d_h = Q.shape
if self.window_size > 0:
# Q, K: bsz x num_heads x seqlen x d_head
# padding_mask: bsz x seqlen
mask_tiles = self.get_tiled_mask_v2(padding_mask)
K_tiles = self.get_tiles_v2(K, transpose=True)
Q_tiles = Q.view(bsz, num_heads, seqlen//self.window_size, self.window_size, d_h)
# bsz x num_heads x seqlen//winsize x winsize x 2winsize
qk_scores = Q_tiles.matmul(K_tiles)
qk_scores = qk_scores.masked_fill(mask_tiles, float('-inf'))
return qk_scores.view(bsz, num_heads, seqlen, -1)
else:
qk_scores = torch.sum(Q*K, dim=-1, keepdim=True)
return qk_scores
def forward(self, X, mask, cls_embed=None):
assert not (self.num_landmarks <= 0 and cls_embed is None and self.window_size <= 0)
if self.cls_from_seq:
cls_embed = X[:,:1].contiguous()
X = X[:,1:].contiguous()
mask = mask[:,1:].contiguous()
bsz, seqlen, d_model = X.shape
# bsz x n_head x length x head_dim
Q = self.split_heads(self.W_q(X)).mul(1./math.sqrt(self.head_dim))
K = self.split_heads(self.dual_ln_l(self.W_k(X)))
V = self.split_heads(self.dual_ln_l(self.W_v(X)))
if self.fp32:
Q, K, V = Q.float(), K.float(), V.float()
# bsz x length x num_head*num_lms
padding_mask = ~mask.bool()
K_compress = V_compress = None
if self.num_landmarks > 0:
head_scores = self.dconv_fc(X).masked_fill(padding_mask[:, :, None], float('-inf'))
head_scores = F.softmax(head_scores, dim=1, dtype=torch.float32) #.to(X)
if not self.fp32:
head_scores = head_scores.to(X)
# bsz x num_head x num_lms x length
head_scores = head_scores.view(bsz, seqlen, self.num_head, self.num_landmarks).permute(0, 2, 3, 1)
K_compress = head_scores.matmul(K)
V_compress = head_scores.matmul(V)
if cls_embed is not None:
Q_cls = self.split_heads(self.W_q(cls_embed)).mul(1. / math.sqrt(self.head_dim))
K_cls = self.split_heads(self.W_k(cls_embed))
V_cls = self.split_heads(self.W_v(cls_embed))
if self.num_landmarks > 0:
K_compress = torch.cat([K_cls, K_compress], dim=2)
V_compress = torch.cat([V_cls, V_compress], dim=2)
else:
K_compress = K_cls
V_compress = V_cls
if self.dual_ln_s is not None and K_compress is not None:
K_compress = self.dual_ln_s(K_compress.transpose(1, 2).contiguous().view(bsz, -1, d_model))
K_compress = self.split_heads(K_compress)
V_compress = self.dual_ln_s(V_compress.transpose(1, 2).contiguous().view(bsz, -1, d_model))
V_compress = self.split_heads(V_compress)
if self.num_landmarks > 0 or (cls_embed is not None):
# bsz x num_head x length x num_lms
attn_compress = Q.matmul(K_compress.transpose(-1, -2))
else:
attn_compress = None
if self.window_size > 0 or self.num_landmarks == 0:
# First, compute the compressed part, or the attentions on the landmarks
# First use window attention to attend to the diagonals
# V: bsize, self.seq_len, self.num_head, self.head_dim
# win_attn_weights = self.sliding_chunks_matmul_qk(Q, K, padding_mask)
win_attn_weights = self.sliding_chunks_matmul_qk_v2(Q, K, padding_mask)
else:
win_attn_weights = None
if attn_compress is None:
all_attn_ = win_attn_weights
elif win_attn_weights is None:
all_attn_ = attn_compress
else:
all_attn_ = torch.cat([attn_compress, win_attn_weights], dim=-1)
all_attn = all_attn_.float().softmax(dim=-1).to(win_attn_weights)
# If one of the rows are all -inf, then it will be NaN!
all_attn = all_attn.masked_fill(padding_mask[:,None,:,None], 0)
if not self.fp32:
all_attn = all_attn.to(X)
all_attn = self.drop_attn(all_attn)
C = 0
if attn_compress is not None:
C += all_attn[:,:,:,:K_compress.shape[2]].matmul(V_compress)
if win_attn_weights is not None:
win_attn_probs = all_attn[:,:,:,-win_attn_weights.shape[-1]:]
if self.window_size > 0:
win_attn_probs = win_attn_probs.view(bsz, self.num_head, seqlen // self.window_size, self.window_size,-1)
V_tiles = self.get_tiles_v2(V, transpose=False)
C += win_attn_probs.matmul(V_tiles).view(bsz, self.num_head, seqlen, self.head_dim)
else:
C += win_attn_probs * V
if cls_embed is not None:
if self.fp32:
Q_cls, K_cls, V_cls = Q_cls.float(), K_cls.float(), V_cls.float()
# bsz x n_heads x 1 x (1+seqlen)
cls_scores = torch.cat([Q_cls.matmul(K_cls.transpose(-1, -2)),
Q_cls.matmul(C.transpose(-1, -2)).masked_fill(padding_mask[:,None,None,:], float('-inf'))],
dim=-1)
cls_probs = torch.softmax(cls_scores, dim=-1, dtype=torch.float32)#.to(X)
if not self.fp32:
cls_probs = cls_probs.to(X)
out_cls_embed = V_cls * cls_probs[:,:,:,:1] + cls_probs[:,:,:,1:].matmul(C)
if self.use_conv:
V = V.masked_fill(padding_mask[:, None, :, None], 0)
C = C + self.conv(V)
if cls_embed is not None:
C = torch.cat([out_cls_embed, C], dim=2)
if self.fp32:
# Finally convert it back, same as Nystromformer
C = C.to(X)
out = self.W_o(self.combine_heads(C))
return out
def extra_repr(self):
return f'num_landmarks={self.num_landmarks}, window_size={self.window_size}'
def combine_heads(self, X):
X = X.transpose(1, 2)
X = X.reshape(X.size(0), X.size(1), self.num_head * self.head_dim)
return X
def split_heads(self, X):
X = X.reshape(X.size(0), X.size(1), self.num_head, self.head_dim)
X = X.transpose(1, 2)
return X
| transformer-ls-master | lra/attention_transformer_ls.py |
"""
Adapted from https://github.com/mlpen/Nystromformer
Add dynamic convolution which is not included in Linformer.
"""
import torch
import torch.nn as nn
import math
import pdb
class LinformerAttention(nn.Module):
projection_matrix = None
def __init__(self, config):
super().__init__()
self.num_head = config.num_head
self.head_dim = config.head_dim
self.linformer_k = config.linformer_k
self.seq_len = config.max_seq_len
self.n_sparse = getattr(config, "n_sparse", 0)
self.dynamic_conv = getattr(config, "dynamic_conv", False)
if not self.dynamic_conv:
if LinformerAttention.projection_matrix is not None:
self.E = LinformerAttention.projection_matrix
else:
LinformerAttention.projection_matrix = nn.Parameter(torch.Tensor(self.num_head, self.linformer_k, self.seq_len))
torch.nn.init.normal_(LinformerAttention.projection_matrix, std = 0.02)
self.E = LinformerAttention.projection_matrix
self.use_conv = config.conv_kernel_size > 0
if self.use_conv:
self.conv = nn.Conv2d(
in_channels=self.num_head, out_channels=self.num_head,
kernel_size=(config.conv_kernel_size, 1), padding=(config.conv_kernel_size // 2, 0),
bias=False,
groups=self.num_head)
def forward(self, Q, K, V, mask, dconv_weight=None):
if self.dynamic_conv:
# V: bsize, self.num_head, self.seq_len, self.head_dim
# dconv_weight: bsize x num_head x k x seqlen
E = dconv_weight
else:
E = self.E
V_orig = V
if self.n_sparse > 0:
# sample the sparse tokens to attend to
sample_probs = mask / torch.sum(mask, dim=1, keepdim=True)
sample_probs = sample_probs.unsqueeze(1).expand(-1, self.num_head, -1).reshape(-1, self.seq_len)
sample_idxes = torch.multinomial(sample_probs, self.n_sparse, replacement=False).reshape(
-1, self.num_head, self.n_sparse)
sparse_mask = torch.zeros((Q.shape[0], self.num_head, self.seq_len), dtype=torch.bool).to(Q.device)
# sparse_mask: bsize x self.num_head x seqlen
sparse_mask.scatter_(2, sample_idxes, True)
K_samples = K.masked_select(sparse_mask.unsqueeze(-1)).reshape(
-1, self.num_head, self.n_sparse, self.head_dim)
V_samples = V.masked_select(sparse_mask.unsqueeze(-1)).reshape(
-1, self.num_head, self.n_sparse, self.head_dim)
K = torch.cat([E.matmul(K * mask[:, None, :, None]), K_samples], dim=-2)
V = torch.cat([E.matmul(V * mask[:, None, :, None]), V_samples], dim=-2)
else:
K = torch.matmul(E, K * mask[:, None, :, None])
V = torch.matmul(E, V * mask[:, None, :, None])
dot = torch.matmul(Q, torch.transpose(K, -2, -1))
dot = dot / math.sqrt(self.head_dim)
attn = nn.functional.softmax(dot, dim = -1)
X = torch.matmul(attn, V)
if self.use_conv:
X += self.conv(V_orig * mask[:, None, :, None])
return X
def extra_repr(self):
return f'linformer_k={self.linformer_k}'
| transformer-ls-master | lra/attention_linformer.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import sys
sys.path.append("./long-range-arena/lra_benchmarks/listops/")
import input_pipeline
import numpy as np
import pickle
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_datasets(
n_devices = 1, task_name = "basic", data_dir = "./lra_release/listops-1000/",
batch_size = 1, max_length = 2000)
mapping = {"train":train_ds, "dev": eval_ds, "test":test_ds}
for component in mapping:
ds_list = []
for idx, inst in enumerate(iter(mapping[component])):
ds_list.append({
"input_ids_0":np.concatenate([inst["inputs"].numpy()[0], np.zeros(48, dtype = np.int32)]),
"label":inst["targets"].numpy()[0]
})
if idx % 100 == 0:
print(f"{idx}\t\t", end = "\r")
with open(f"listops.{component}.pickle", "wb") as f:
pickle.dump(ds_list, f)
| transformer-ls-master | lra/datasets/listops.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import sys
sys.path.append("./long-range-arena/lra_benchmarks/text_classification/")
import input_pipeline
import numpy as np
import pickle
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_tc_datasets(
n_devices = 1, task_name = "imdb_reviews", data_dir = None,
batch_size = 1, fixed_vocab = None, max_length = 4000)
mapping = {"train":train_ds, "dev": eval_ds, "test":test_ds}
for component in mapping:
ds_list = []
for idx, inst in enumerate(iter(mapping[component])):
ds_list.append({
"input_ids_0":np.concatenate([inst["inputs"].numpy()[0], np.zeros(96, dtype = np.int32)]),
"label":inst["targets"].numpy()[0]
})
if idx % 100 == 0:
print(f"{idx}\t\t", end = "\r")
with open(f"text.{component}.pickle", "wb") as f:
pickle.dump(ds_list, f)
| transformer-ls-master | lra/datasets/text.py |
"""
This file is from https://github.com/mlpen/Nystromformer
"""
import sys
sys.path.append("./long-range-arena/lra_benchmarks/matching/")
import input_pipeline
import numpy as np
import pickle
datapath = './datasets'
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_matching_datasets(
n_devices = 1, task_name = None, data_dir = f"{datapath}/lra_release/lra_release/tsv_data/",
batch_size = 1, fixed_vocab = None, max_length = 4096, tokenizer = "char",
vocab_file_path = None)
mapping = {"train":train_ds, "dev": eval_ds, "test":test_ds}
for component in mapping:
ds_list = []
for idx, inst in enumerate(iter(mapping[component])):
ds_list.append({
"input_ids_0":np.concatenate([inst["inputs1"].numpy()[0]]),
"input_ids_1":np.concatenate([inst["inputs2"].numpy()[0]]),
"label":inst["targets"].numpy()[0]
})
if idx % 100 == 0:
print(f"{idx}\t\t", end = "\r")
with open(f"retrieval.{component}.pickle", "wb") as f:
pickle.dump(ds_list, f)
| transformer-ls-master | lra/datasets/retrieval.py |
transformer-ls-master | lra/datasets/long-range-arena/__init__.py |
|
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Build vocab and cache it so we don't have to keep running."""
import collections
from absl import app
from absl import flags
from absl import logging
import tensorflow.compat.v1 as tf
import tensorflow_datasets as tfds
flags.DEFINE_string('vocab_file_path', '/tmp/lra_data/aan',
'Path for vocab file output.')
FLAGS = flags.FLAGS
DATASET_PATHS = '/tmp/dataset'
def whitespace_tokenize(text):
"""Splits an input into tokens by whitespace."""
return text.strip().split()
def build_vocab(datasets,
special_tokens=(b'<pad>', b'<unk>', b'<s>', b'</s>'),
min_freq=10,
text_keys=None):
"""Returns a vocabulary of tokens with optional minimum frequency."""
# Count the tokens in the datasets.
logging.info('Building Vocab...')
counter = collections.Counter()
num_processed = 0
for dataset in datasets:
for example in tfds.as_numpy(dataset):
# logging.info(example)
for k in text_keys[:1]:
# logging.info(example[k])
counter.update(whitespace_tokenize(example[k][:100]))
num_processed += 1
if num_processed % 100 == 0:
logging.info('Processed %d', num_processed)
# Add special tokens to the start of vocab.
vocab = collections.OrderedDict()
for token in special_tokens:
vocab[token] = len(vocab)
# Add all other tokens to the vocab if their frequency is >= min_freq.
for token in sorted(list(counter.keys())):
if counter[token] >= min_freq:
vocab[token] = len(vocab)
logging.info('Number of unfiltered tokens: %d', len(counter))
logging.info('Vocabulary size: %d', len(vocab))
return vocab
def get_tsv_dataset(file_path, batch_size):
"""Preprocess dataset."""
tf.logging.info(file_path)
# sel_cols = ['label', 'id1', 'id2']
col_defaults = [tf.string, tf.string, tf.string, tf.string, tf.string]
col_names = ['label', 'id1', 'id2', 'text1', 'text2']
ds = tf.data.experimental.make_csv_dataset([file_path],
batch_size,
column_names=col_names,
column_defaults=col_defaults,
use_quote_delim=False,
field_delim='\t',
shuffle=False,
header=False,
num_epochs=1)
ds = ds.unbatch()
return ds
def get_dataset(batch_size):
"""Get dataset from matching datasets converts into src/tgt pairs."""
train_fps = DATASET_PATHS + '.train.tsv'
train = get_tsv_dataset(train_fps, batch_size)
def adapt_example(example):
return {
'Source1': example['text1'],
'Source2': example['text2'],
'Target': example['label']
}
train = train.map(adapt_example)
train = train.prefetch(tf.data.experimental.AUTOTUNE)
return train
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
train = get_dataset(1)
logging.info('Building/loading subword tokenizer')
encoder = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
(en['Source1'].numpy() for en in train), target_vocab_size=2**13)
encoder.save_to_file(FLAGS.vocab_file_path)
logging.info('Saved')
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/matching/build_vocab.py |
# Copyright 2020 Google LLC
# 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
# https://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.\
"""Input pipeline for the imdb dataset."""
import os
from absl import logging
import tensorflow.compat.v1 as tf
import tensorflow_datasets as tfds
AUTOTUNE = tf.data.experimental.AUTOTUNE
DATASET_PATHS = '/tmp/dataset'
SHUFFLE_BUFFER_SIZE = 2048
def get_tsv_dataset(file_path, batch_size):
"""Preprocess dataset."""
tf.logging.info(file_path)
# sel_cols = ['label', 'id1', 'id2']
col_defaults = [tf.float32, tf.string, tf.string, tf.string, tf.string]
col_names = ['label', 'id1', 'id2', 'text1', 'text2']
ds = tf.data.experimental.make_csv_dataset([file_path],
batch_size,
column_names=col_names,
column_defaults=col_defaults,
use_quote_delim=False,
field_delim='\t',
header=False,
shuffle=True,
shuffle_buffer_size=10000,
num_epochs=1)
ds = ds.unbatch()
return ds
def get_dataset(batch_size, data_path):
"""Get dataset from matching datasets converts into src/tgt pairs."""
train_fps = data_path + '.train.tsv'
valid_fps = data_path + '.eval.tsv'
test_fps = data_path + '.test.tsv'
train = get_tsv_dataset(train_fps, batch_size)
valid = get_tsv_dataset(valid_fps, batch_size)
test = get_tsv_dataset(test_fps, batch_size)
# Print an example.
logging.info('Data sample: %s', next(iter(tfds.as_numpy(test.skip(4)))))
def adapt_example(example):
return {
'Source1': example['text1'],
'Source2': example['text2'],
'Target': example['label']
}
train = train.map(adapt_example)
valid = valid.map(adapt_example)
test = test.map(adapt_example)
return train, valid, test
def get_matching_datasets(n_devices,
task_name,
data_dir=None,
batch_size=256,
fixed_vocab=None,
max_length=512,
tokenizer='subword',
vocab_file_path=None):
"""Get text matching classification datasets."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
del task_name # not used but may be used in the future.
if data_dir is None:
data_path = DATASET_PATHS
else:
data_path = os.path.join(data_dir, 'new_aan_pairs')
train_dataset, val_dataset, test_dataset = get_dataset(batch_size, data_path)
tf.logging.info('Finished getting dataset.')
if tokenizer == 'char':
logging.info('Using char-level/byte dataset..')
encoder = tfds.deprecated.text.ByteTextEncoder()
elif tokenizer == 'subword':
logging.info('Building/loading subword tokenizer')
if vocab_file_path is None:
raise ValueError('tokenizer=subword requires vocab_file_path')
if tf.io.gfile.exists(vocab_file_path + '.subwords'):
logging.info('Found vocab..already exists. loading..')
encoder = tfds.deprecated.text.SubwordTextEncoder.load_from_file(
vocab_file_path)
logging.info('Loaded encoder')
else:
encoder = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(
(en['Source1'].numpy() for en in train_dataset),
target_vocab_size=2**13)
encoder.save_to_file(vocab_file_path)
logging.info('Saved!')
else:
if fixed_vocab is None:
tf.logging.info('Building vocab')
# build vocab
vocab_set = set()
tokenizer = tfds.deprecated.text.Tokenizer()
i = 0
for example in tfds.as_numpy(train_dataset):
# examples = data['Source1']
examples = tokenizer.tokenize(example['Source1'])
# examples = np.reshape(examples, (-1)).tolist()
vocab_set.update(examples)
if i % 1000 == 0:
tf.logging.info('Processed {}'.format(i))
i += 1
tf.logging.info(len(vocab_set))
vocab_set = list(set(vocab_set))
tf.logging.info('Finished processing vocab size={}'.format(
len(vocab_set)))
else:
vocab_set = list(set(fixed_vocab))
vocab_set = ['<pad>'] + vocab_set
encoder = tfds.deprecated.text.TokenTextEncoder(vocab_set)
def tf_encode(x):
result = tf.py_function(
lambda s: tf.constant(encoder.encode(s.numpy()[:10000])), [
x,
], tf.int32)
result.set_shape([None])
return result
def tokenize(d):
return {
'inputs1': tf_encode(d['Source1'])[:max_length],
'inputs2': tf_encode(d['Source2'])[:max_length],
'targets': tf.cast(d['Target'], tf.int32)
}
train_dataset = train_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
max_shape = {'inputs1': [max_length], 'inputs2': [max_length], 'targets': []}
train_dataset = train_dataset.padded_batch(
batch_size, padded_shapes=max_shape, drop_remainder=True)
val_dataset = val_dataset.padded_batch(
batch_size, padded_shapes=max_shape, drop_remainder=True)
test_dataset = test_dataset.padded_batch(
batch_size, padded_shapes=max_shape, drop_remainder=True)
train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
val_dataset = val_dataset.prefetch(tf.data.experimental.AUTOTUNE)
test_dataset = test_dataset.prefetch(tf.data.experimental.AUTOTUNE)
return train_dataset, val_dataset, test_dataset, encoder
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/matching/input_pipeline.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Main script for document matching in dual encoder style with AAN dataset."""
import functools
import itertools
import json
import os
import time
from absl import app
from absl import flags
from absl import logging
from flax import jax_utils
from flax import nn
from flax import optim
from flax.metrics import tensorboard
from flax.training import checkpoints
from flax.training import common_utils
import jax
from jax import random
import jax.nn
import jax.numpy as jnp
from lra_benchmarks.matching import input_pipeline
from lra_benchmarks.models.transformer import transformer
from lra_benchmarks.utils import train_utils
from ml_collections import config_flags
import tensorflow.compat.v2 as tf
FLAGS = flags.FLAGS
config_flags.DEFINE_config_file(
'config', None, 'Training configuration.', lock_config=True)
flags.DEFINE_string(
'model_dir', default=None, help='Directory to store model data.')
flags.DEFINE_string(
'task_name', default='aan', help='Directory to store model data.')
flags.DEFINE_string(
'data_dir', default=None, help='Directory containing datasets.')
flags.DEFINE_string(
'vocab_file_path',
default='/tmp/lra_data/aan',
help='Path for vocab file. Output of `build_vocab`.')
flags.DEFINE_bool(
'test_only', default=False, help='Run the evaluation on the test data.')
def create_model(key, flax_module, input1_shape, input2_shape, model_kwargs):
"""Creates and initializes the model."""
@functools.partial(jax.jit, backend='cpu')
def _create_model(key):
module = flax_module.partial(**model_kwargs)
with nn.stochastic(key):
_, initial_params = module.init_by_shape(key,
[(input1_shape, jnp.float32),
(input2_shape, jnp.float32)])
model = nn.Model(module, initial_params)
return model
return _create_model(key)
def create_optimizer(model, learning_rate, weight_decay):
optimizer_def = optim.Adam(
learning_rate, beta1=0.9, beta2=0.98, eps=1e-9, weight_decay=weight_decay)
optimizer = optimizer_def.create(model)
return optimizer
def compute_metrics(logits, labels, weights):
"""Compute summary metrics."""
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, labels, num_classes=2, weights=None)
acc, _ = train_utils.compute_weighted_accuracy(logits, labels, weights)
metrics = {
'loss': loss,
'accuracy': acc,
'denominator': weight_sum,
}
metrics = jax.lax.psum(metrics, 'batch')
return metrics
def train_step(optimizer, batch, learning_rate_fn, dropout_rng=None):
"""Perform a single training step."""
train_keys = ['inputs1', 'inputs2', 'targets']
(inputs1, inputs2, targets) = [batch.get(k, None) for k in train_keys]
# We handle PRNG splitting inside the top pmap, rather
# than handling it outside in the training loop - doing the
# latter can add some stalls to the devices.
dropout_rng, new_dropout_rng = random.split(dropout_rng)
def loss_fn(model):
"""Loss function used for training."""
with nn.stochastic(dropout_rng):
logits = model(inputs1, inputs2, train=True)
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, targets, num_classes=2, weights=None)
mean_loss = loss / weight_sum
return mean_loss, logits
step = optimizer.state.step
lr = learning_rate_fn(step)
grad_fn = jax.value_and_grad(loss_fn, has_aux=True)
(_, logits), grad = grad_fn(optimizer.target)
grad = jax.lax.pmean(grad, 'batch')
new_optimizer = optimizer.apply_gradient(grad, learning_rate=lr)
metrics = compute_metrics(logits, targets, None)
metrics['learning_rate'] = lr
return new_optimizer, metrics, new_dropout_rng
def eval_step(model, batch):
eval_keys = ['inputs1', 'inputs2', 'targets']
(inputs1, inputs2, targets) = [batch.get(k, None) for k in eval_keys]
logits = model(inputs1, inputs2, train=False)
return compute_metrics(logits, targets, None)
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
tf.enable_v2_behavior()
config = FLAGS.config
logging.info('===========Config Dict============')
logging.info(config)
batch_size = config.batch_size
learning_rate = config.learning_rate
num_train_steps = config.num_train_steps
num_eval_steps = config.num_eval_steps
eval_freq = config.eval_frequency
random_seed = config.random_seed
model_type = config.model_type
max_length = config.max_length
if jax.host_id() == 0:
summary_writer = tensorboard.SummaryWriter(
os.path.join(FLAGS.model_dir, 'summary'))
if batch_size % jax.device_count() > 0:
raise ValueError('Batch size must be divisible by the number of devices')
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_matching_datasets(
n_devices=jax.local_device_count(),
task_name=FLAGS.task_name,
data_dir=FLAGS.data_dir,
batch_size=batch_size,
fixed_vocab=None,
max_length=max_length,
tokenizer=config.tokenizer,
vocab_file_path=FLAGS.vocab_file_path)
vocab_size = encoder.vocab_size
logging.info('Vocab Size: %d', vocab_size)
train_ds = train_ds.repeat()
train_iter = iter(train_ds)
input_shape = (batch_size, max_length)
model_kwargs = {
'vocab_size': vocab_size,
'emb_dim': config.emb_dim,
'num_heads': config.num_heads,
'num_layers': config.num_layers,
'qkv_dim': config.qkv_dim,
'mlp_dim': config.mlp_dim,
'max_len': max_length,
'classifier': True,
'num_classes': 2,
'classifier_pool': config.pooling_mode
}
rng = random.PRNGKey(random_seed)
rng = jax.random.fold_in(rng, jax.host_id())
rng, init_rng = random.split(rng)
# We init the first set of dropout PRNG keys, but update it afterwards inside
# the main pmap'd training update for performance.
dropout_rngs = random.split(rng, jax.local_device_count())
if model_type == 'transformer':
model = create_model(init_rng, transformer.TransformerDualEncoder,
input_shape, input_shape, model_kwargs)
else:
raise ValueError('Model type not supported.')
optimizer = create_optimizer(
model, learning_rate, weight_decay=FLAGS.config.weight_decay)
del model # Don't keep a copy of the initial model.
start_step = 0
if config.restore_checkpoints or FLAGS.test_only:
# Restore unreplicated optimizer + model state from last checkpoint.
optimizer = checkpoints.restore_checkpoint(FLAGS.model_dir, optimizer)
# Grab last step.
start_step = int(optimizer.state.step)
# Replicate optimizer.
optimizer = jax_utils.replicate(optimizer)
learning_rate_fn = train_utils.create_learning_rate_scheduler(
factors=config.factors,
base_learning_rate=learning_rate,
warmup_steps=config.warmup)
p_train_step = jax.pmap(
functools.partial(train_step, learning_rate_fn=learning_rate_fn),
axis_name='batch')
p_eval_step = jax.pmap(eval_step, axis_name='batch')
# p_pred_step = jax.pmap(predict_step, axis_name='batch')
def run_eval(eval_ds, num_eval_steps=-1):
eval_metrics = []
eval_iter = iter(eval_ds)
if num_eval_steps == -1:
num_iter = itertools.count()
else:
num_iter = range(num_eval_steps)
for _, eval_batch in zip(num_iter, eval_iter):
# pylint: disable=protected-access
eval_batch = common_utils.shard(
jax.tree_map(lambda x: x._numpy(), eval_batch))
# pylint: enable=protected-access
metrics = p_eval_step(optimizer.target, eval_batch)
eval_metrics.append(metrics)
eval_metrics = common_utils.get_metrics(eval_metrics)
eval_metrics_sums = jax.tree_map(jnp.sum, eval_metrics)
eval_denominator = eval_metrics_sums.pop('denominator')
eval_summary = jax.tree_map(
lambda x: x / eval_denominator, # pylint: disable=cell-var-from-loop
eval_metrics_sums)
# Calculate (clipped) perplexity after averaging log-perplexities:
eval_summary['perplexity'] = jnp.clip(
jnp.exp(eval_summary['loss']), a_max=1.0e4)
return eval_summary
if FLAGS.test_only:
with tf.io.gfile.GFile(os.path.join(FLAGS.model_dir, 'results.json'),
'w') as f:
test_summary = run_eval(test_ds)
json.dump(jax.tree_map(lambda x: x.tolist(), test_summary), f)
return
metrics_all = []
tick = time.time()
logging.info('Starting training')
logging.info('====================')
for step, batch in zip(range(start_step, num_train_steps), train_iter):
batch = common_utils.shard(jax.tree_map(lambda x: x._numpy(), batch)) # pylint: disable=protected-access
# logging.info(batch)
optimizer, metrics, dropout_rngs = p_train_step(
optimizer, batch, dropout_rng=dropout_rngs)
metrics_all.append(metrics)
logging.info('train in step: %d', step)
# Save a Checkpoint
if ((step % config.checkpoint_freq == 0 and step > 0) or
step == num_train_steps - 1):
if jax.host_id() == 0 and config.save_checkpoints:
# Save unreplicated optimizer + model state.
checkpoints.save_checkpoint(FLAGS.model_dir,
jax_utils.unreplicate(optimizer), step)
# Periodic metric handling.
if step % eval_freq == 0 and step > 0:
metrics_all = common_utils.get_metrics(metrics_all)
lr = metrics_all.pop('learning_rate').mean()
metrics_sums = jax.tree_map(jnp.sum, metrics_all)
denominator = metrics_sums.pop('denominator')
summary = jax.tree_map(lambda x: x / denominator, metrics_sums) # pylint: disable=cell-var-from-loop
summary['learning_rate'] = lr
# Calculate (clipped) perplexity after averaging log-perplexities:
summary['perplexity'] = jnp.clip(jnp.exp(summary['loss']), a_max=1.0e4)
logging.info('train in step: %d, loss: %.4f, acc: %.4f', step,
summary['loss'], summary['accuracy'])
if jax.host_id() == 0:
tock = time.time()
steps_per_sec = eval_freq / (tock - tick)
tick = tock
summary_writer.scalar('steps per second', steps_per_sec, step)
for key, val in summary.items():
summary_writer.scalar(f'train_{key}', val, step)
summary_writer.flush()
# Reset metric accumulation for next evaluation cycle.
metrics_all = []
# Eval Metrics
eval_summary = run_eval(eval_ds, num_eval_steps)
logging.info('eval in step: %d, loss: %.4f, acc: %.4f', step,
eval_summary['loss'], eval_summary['accuracy'])
if jax.host_id() == 0:
for key, val in eval_summary.items():
summary_writer.scalar(f'eval_{key}', val, step)
summary_writer.flush()
# Test eval
# Eval Metrics
logging.info('Testing...')
test_summary = run_eval(test_ds, num_eval_steps)
logging.info('test in step: %d, loss: %.4f, acc: %.4f', step,
test_summary['loss'], test_summary['accuracy'])
if jax.host_id() == 0:
for key, val in test_summary.items():
summary_writer.scalar(f'test_{key}', val, step)
summary_writer.flush()
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/matching/train.py |
# Copyright 2020 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 32
config.eval_frequency = 100
config.num_train_steps = 5000
config.num_eval_steps = -1
config.learning_rate = 0.05
config.weight_decay = 1e-1
config.max_target_length = 200 # ignored
config.max_eval_target_length = 200 # ignored
config.sampling_temperature = 0.6
config.sampling_top_k = 20
config.max_predict_token_length = 50
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = 10000
config.random_seed = 0
config.prompt = ""
config.factors = "constant * linear_warmup * rsqrt_decay"
config.warmup = 8000
config.max_length = 4000
config.pooling_mode = "CLS"
config.tokenizer = "char"
config.emb_dim = 128
config.num_heads = 4
config.num_layers = 4
config.qkv_dim = 128
config.mlp_dim = 512
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/matching/configs/base_match_config.py |
# Copyright 2020 Google LLC
# 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
# https://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.\
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.matching.configs import base_match_config
def get_config():
"""Get the default hyperparameter configuration."""
config = base_match_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/matching/configs/transformer_base.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""This contains utility functions for model training and evaluation."""
import functools
from flax import nn
from flax import optim
from flax.training import common_utils
import jax
import jax.numpy as jnp
import numpy as onp
def create_learning_rate_scheduler(
factors='constant * linear_warmup * rsqrt_decay',
base_learning_rate=0.5,
warmup_steps=1000,
decay_factor=0.5,
steps_per_decay=20000,
steps_per_cycle=100000):
"""Creates learning rate schedule.
Interprets factors in the factors string which can consist of:
* constant: interpreted as the constant value,
* linear_warmup: interpreted as linear warmup until warmup_steps,
* rsqrt_decay: divide by square root of max(step, warmup_steps)
* rsqrt_normalized_decay: divide by square root of max(step/warmup_steps, 1)
* decay_every: Every k steps decay the learning rate by decay_factor.
* cosine_decay: Cyclic cosine decay, uses steps_per_cycle parameter.
Args:
factors: string, factors separated by '*' that defines the schedule.
base_learning_rate: float, the starting constant for the lr schedule.
warmup_steps: int, how many steps to warm up for in the warmup schedule.
decay_factor: float, the amount to decay the learning rate by.
steps_per_decay: int, how often to decay the learning rate.
steps_per_cycle: int, steps per cycle when using cosine decay.
Returns:
a function learning_rate(step): float -> {'learning_rate': float}, the
step-dependent lr.
"""
factors = [n.strip() for n in factors.split('*')]
def step_fn(step):
"""Step to learning rate function."""
ret = 1.0
for name in factors:
if name == 'constant':
ret *= base_learning_rate
elif name == 'linear_warmup':
ret *= jnp.minimum(1.0, step / warmup_steps)
elif name == 'rsqrt_decay':
ret /= jnp.sqrt(jnp.maximum(step, warmup_steps))
elif name == 'rsqrt_normalized_decay':
ret *= jnp.sqrt(warmup_steps)
ret /= jnp.sqrt(jnp.maximum(step, warmup_steps))
elif name == 'decay_every':
ret *= (decay_factor**(step // steps_per_decay))
elif name == 'cosine_decay':
progress = jnp.maximum(0.0,
(step - warmup_steps) / float(steps_per_cycle))
ret *= jnp.maximum(0.0,
0.5 * (1.0 + jnp.cos(jnp.pi * (progress % 1.0))))
else:
raise ValueError('Unknown factor %s.' % name)
return jnp.asarray(ret, dtype=jnp.float32)
return step_fn
def create_model(key, flax_module, input_shape, target_shape, model_kwargs):
"""Creates and initializes the model."""
@functools.partial(jax.jit, backend='cpu')
def _create_model(key):
model_def = flax_module.partial(**model_kwargs)
with nn.attention.Cache().mutate() as cache_def:
_, initial_params = model_def.init_by_shape(
key, [(input_shape, jnp.float32), (target_shape, jnp.float32)],
cache=cache_def)
model = nn.Model(model_def, initial_params)
return model, cache_def
return _create_model(key)
def create_optimizer(model, learning_rate, weight_decay):
optimizer_def = optim.Adam(
learning_rate, beta1=0.9, beta2=0.98, eps=1e-9, weight_decay=weight_decay)
optimizer = optimizer_def.create(model)
return optimizer
def compute_weighted_cross_entropy(logits, targets, num_classes, weights=None):
"""Compute weighted cross entropy and entropy for log probs and targets.
Args:
logits: [batch, num_classes] float array.
targets: categorical targets [batch, length] int array.
num_classes: int, num classes of problem.
weights: None or array of shape [batch x length]
Returns:
Tuple of scalar loss and batch normalizing factor.
"""
onehot_targets = common_utils.onehot(targets, num_classes)
loss = -jnp.sum(onehot_targets * nn.log_softmax(logits), axis=-1)
normalizing_factor = onehot_targets.sum()
if weights is not None:
loss = loss * weights
normalizing_factor = weights.sum()
return loss.sum(), normalizing_factor
def compute_weighted_accuracy(logits, targets, weights=None):
"""Compute weighted accuracy for log probs and targets.
Args:
logits: [batch, num_classes] float array.
targets: categorical targets [batch] int array.
weights: None or array of shape [batch]
Returns:
Tuple of scalar accuracy and batch normalizing factor.
"""
if logits.ndim != targets.ndim + 1:
raise ValueError('Incorrect shapes. Got shape %s logits and %s targets' %
(str(logits.shape), str(targets.shape)))
loss = jnp.equal(jnp.argmax(logits, axis=-1), targets)
normalizing_factor = onp.prod(logits.shape[:-1])
if weights is not None:
loss = loss * weights
normalizing_factor = weights.sum()
return loss.sum(), normalizing_factor
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/utils/train_utils.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""This script contains utility functions for data preprocessing and output post-processing."""
from collections import defaultdict ## pylint: disable=g-importing-member
import tempfile
import time
from absl import logging
import jax
import nltk
import tensorflow.compat.v2 as tf
import tensorflow_datasets as tfds
import tensorflow_text as tftxt
from sentencepiece import SentencePieceTrainer
PAD_TOKEN = {"index": 0, "token": "<pad>"}
UNK_TOKEN = {"index": 1, "token": "<unk>"}
EOS_TOKEN = {"index": 2, "token": "<eos>"}
BOS_TOKEN = {"index": 3, "token": "<bos>"}
nltk.download("punkt")
def filter_non_ascii(s):
"""Filter non-ascii characters from a string."""
if isinstance(s, bytes):
s = s.decode("utf-8")
return s.encode("ascii", errors="ignore").decode("utf-8")
def nltk_tokenize(s: str):
"""Tokenize a string to a sequence of tokens with nltk tokenizer.
Args:
s: str: input string.
Returns:
A tokenized string.
"""
return nltk.word_tokenize(s)
def add_bos_token(s: str):
return BOS_TOKEN["token"] + " " + s
def add_eos_token(s: str):
return s + " " + EOS_TOKEN["token"]
def build_vocab(train_dataset, fields, vocab_size=None, min_freq=0):
"""Build word vocab from the train dataset.
Assume the dataset has been preprocessed , tokenized, lowercased properly.
Args:
train_dataset: tf.Dataset: the training dataset.
fields: List[str]: the data fields for building the vocab.
vocab_size: None or int.
min_freq: int: minimum token frequency to be kept in the vocab.
Returns:
A vocab dictionary.
"""
vocab = {
PAD_TOKEN["token"]: PAD_TOKEN["index"],
UNK_TOKEN["token"]: UNK_TOKEN["index"],
BOS_TOKEN["token"]: BOS_TOKEN["index"],
EOS_TOKEN["token"]: EOS_TOKEN["index"]
}
word_freqs = defaultdict(int)
for example in train_dataset:
for field in fields:
s = example[field].numpy().decode("utf-8")
for token in s.split():
word_freqs[token] += 1
# filter vocab by min_freq and vocab size.
sorted_word_freqs = sorted(
word_freqs.items(), key=lambda item: item[1], reverse=True)
if vocab_size:
sorted_word_freqs = sorted_word_freqs[:vocab_size]
for (token, freq) in sorted_word_freqs:
if freq >= min_freq:
if token not in vocab:
vocab[token] = len(vocab)
logging.info("Vocab size: before filtering (%d), after(%d)", len(word_freqs),
len(vocab))
# logging.info("Top 10 frequent tokens: ", sorted_word_freqs[:10])
# logging.info("Bottom 10 frequent tokens: ", sorted_word_freqs[-10:])
return vocab
# -----------------------------------------------------------------------------
# Train and Load SentencePiece Tokenizer.
# -----------------------------------------------------------------------------
def dump_chars_to_textfile(dataset,
maxchars=1e9,
data_keys=("inputs", "targets")):
"""Write part of a TFDS sentence dataset to lines in a text file.
Args:
dataset: tf.dataset containing string-data.
maxchars: int: approximate number of characters to save from dataset.
data_keys: Tuple[str]: what keys in dataset to dump from.
Returns:
name of temp file with dataset bytes, exact number of characters dumped.
"""
char_count = 0
processed_examples = 0
ds_iter = dataset.as_numpy_iterator()
with tempfile.NamedTemporaryFile(
delete=False, prefix="/tmp/ds_chars") as outfp:
while char_count < maxchars:
example = next(ds_iter, None)
processed_examples += 1
if example is None:
break
for k in data_keys:
line = example[k] + b"\n"
char_count += len(line)
outfp.write(line)
logging.info("%d examples processed for training sentencepiece tokenizer.",
processed_examples)
return outfp.name, char_count
def train_sentencepiece(dataset,
vocab_size,
maxchars=1e9,
character_coverage=1.0,
model_path="model",
model_type="unigram",
data_keys=("inputs", "targets")):
"""Train SentencePiece tokenizer from subset of tf dataset.
Args:
dataset: tf.dataset
vocab_size: int: size of vocab tokens to train.
maxchars: int: number of characters to use for sentencepiece training.
character_coverage: amount of characters covered by the model, good defaults
are 0.9995 for languages with rich character set like Japanese or Chinese
and 1.0 for other languages with small character set.
model_path: str: path of model file to save vocab model to.
model_type: str: type of sentencepiece vocab to train.
data_keys: Tuple[str]: keys of dataset to use for training.
Returns:
path to the trained sentencepiece vocabulary model.
"""
fname, _ = dump_chars_to_textfile(
dataset, maxchars=maxchars, data_keys=data_keys)
with tempfile.NamedTemporaryFile(
delete=False, prefix="/tmp/sp_tmp") as model_fp:
pass # we just want a prefix'd tmp-filename
argstr = " ".join([
f"--input={fname}", f"--vocab_size={vocab_size}",
f"--character_coverage={character_coverage}",
f"--model_prefix={model_fp.name}", f"--model_type={model_type}"
])
SentencePieceTrainer.Train(argstr)
if jax.host_id() == 0:
# Use an intermediate filename that is renamed to the target name to address
# create and fill delays.
copy_rename_path = model_path + ".rntmp"
tf.io.gfile.copy(model_fp.name + ".model", copy_rename_path, overwrite=True)
tf.io.gfile.rename(copy_rename_path, model_path, overwrite=True)
tf.io.gfile.copy(
model_fp.name + ".vocab", copy_rename_path + ".vocab", overwrite=True)
tf.io.gfile.rename(
copy_rename_path + ".vocab", model_path + ".vocab", overwrite=True)
logging.info("copied %s to %s", model_fp.name + ".model", model_path)
else:
while not tf.io.gfile.exists(model_path):
time.sleep(1)
time.sleep(1)
return model_path
def load_sentencepiece_tokenizer(model_path,
add_bos=True,
add_eos=True,
reverse=False):
"""Load a tf-text SentencePiece tokenizer from given model filepath."""
with tf.io.gfile.GFile(model_path, "rb") as model_fp:
sp_model = model_fp.read()
sp_tokenizer = tftxt.SentencepieceTokenizer(
model=sp_model, add_bos=add_bos, add_eos=add_eos, reverse=reverse)
return sp_tokenizer
def load_tfds_dataset(data_dir, dataset_name, split, shuffle=True):
"""Return train and evaluation datasets, feature info and supervised keys.
Args:
data_dir: directory where the data is located.
dataset_name: a string, the name of the TFDS dataset.
split: string: the split of the dataset, e.g., {train, validation, test}
shuffle: Boolean determining whether or not to shuffle the train files at
startup. Set to False if you want data determinism.
Returns:
a 3-tuple consisting of:
* the train tf.Dataset
* information about features: a python dictionary with feature names
as keys and an object as value that provides .shape and .n_classes.
* supervised_keys: information what's the input and what's the target,
ie., a pair of lists with input and target feature names.
"""
dataset_builder = tfds.builder(dataset_name, data_dir=data_dir)
info = dataset_builder.info
splits = dataset_builder.info.splits
if split not in splits:
raise ValueError(
f"{split} not exists in the dataset {data_dir}/{dataset_name}/{splits}."
)
dataset = tfds.load(
name=dataset_name, split=split, data_dir=data_dir, shuffle_files=shuffle)
keys = None
if info.supervised_keys:
keys = info.supervised_keys
return dataset, info.features, keys
def bin_and_batch(
dataset,
length_fn, # the length function of an input sample
training,
n_devices,
target_batch_size=256,
target_bucket_length=32,
buckets=None,
max_eval_length=None,
drop_remainder=False):
"""Batching function, can specify batch size directly or per-device.
Args:
dataset: tf dataset containing individual sequences.
length_fn: a function to determine the sample length.
training: bool: is this a train or eval dataset.
n_devices: number of devices this dataset will be run on.
target_batch_size: int: the target batch size for binned batches.
target_bucket_length: int: the target sequence length for binned batches.
buckets: (List[int], List[int]): manually specified length buckets and batch
sizes for bins.
max_eval_length: int: for eval set allow a extra long-sequence bin.
drop_remainder: bool: if true drop last batch if not divisible by batch
sizes. (e.g. not divisible by n_devices).
Returns:
Dynamically binned batches of sequence that roughly keep the total
number of tokens (target_batch_size * target_bucket_length) the same, while
insuring batch sizes are divisible by n_devices for distributed training.
"""
# Create heuristic buckets is none are specified.
if buckets is None:
logging.info("Heuristically bucketing based on shapes of examples.")
bucket_boundaries = [
target_bucket_length // 4, target_bucket_length // 2,
target_bucket_length, target_bucket_length * 2,
target_bucket_length * 4, target_bucket_length * 8,
target_bucket_length * 16
]
bucket_batch_sizes = [
target_batch_size * 4, target_batch_size * 2, target_batch_size,
target_batch_size // 2, target_batch_size // 4, target_batch_size // 8,
target_batch_size // 16
]
# allow for different evaluation max-length bucket and batchsize
if not training:
max_eval_length = max_eval_length or target_bucket_length * 32
bucket_boundaries[-1] = max_eval_length
bucket_batch_sizes[-1] = (
target_batch_size // (max_eval_length // target_bucket_length))
# We will pad to boundaries which pads to bucket_boundary-1: add 1 here.
bucket_boundaries = [b + 1 for b in bucket_boundaries]
# Make batch sizes divisible by n_devices.
bucket_batch_sizes = [
max(b // n_devices, 1) * n_devices for b in bucket_batch_sizes
]
buckets = (bucket_boundaries, bucket_batch_sizes)
logging.info("Bucketing with buckets %s.", str(buckets))
boundaries, batch_sizes = buckets
# bucket_by_sequence_length expects a final dummy 1 batch_size
batch_sizes.append(1)
dataset = dataset.apply(
tf.data.experimental.bucket_by_sequence_length(
length_fn,
boundaries,
batch_sizes,
pad_to_bucket_boundary=True,
drop_remainder=drop_remainder))
return dataset
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/utils/data_utils.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Mapping tasks to data loaders."""
import functools
from lra_benchmarks.image import input_pipeline
TASK_DATA_DICT = {
'cifar10':
input_pipeline.get_cifar10_datasets,
'pathfinder32_easy':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=32,
split='easy'),
'pathfinder32_inter':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=32,
split='intermediate'),
'pathfinder32_hard':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=32,
split='hard'),
'pathfinder64_easy':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=64,
split='easy'),
'pathfinder64_inter':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=64,
split='intermediate'),
'pathfinder64_hard':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=64,
split='hard'),
'pathfinder128_easy':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=128,
split='easy'),
'pathfinder128_inter':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=128,
split='intermediate'),
'pathfinder128_hard':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=128,
split='hard'),
'pathfinder256_easy':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=256,
split='easy'),
'pathfinder256_inter':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=256,
split='intermediate'),
'pathfinder256_hard':
functools.partial(
input_pipeline.get_pathfinder_base_datasets,
resolution=256,
split='hard'),
}
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/task_registry.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Functions to get dataset pipeline for the image cls tasks."""
from lra_benchmarks.data import pathfinder
import tensorflow.compat.v1 as tf
import tensorflow_datasets as tfds
AUTOTUNE = tf.data.experimental.AUTOTUNE
def get_mnist_datasets(n_devices, batch_size=256, normalize=False):
"""Get MNIST dataset splits."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
train_dataset = tfds.load('mnist', split='train[:90%]')
val_dataset = tfds.load('mnist', split='train[90%:]')
test_dataset = tfds.load('mnist', split='test')
def decode(x):
decoded = {
'inputs': tf.cast(x['image'], dtype=tf.int32),
'targets': x['label']
}
if normalize:
decoded['inputs'] = decoded['inputs'] / 255
return decoded
train_dataset = train_dataset.map(decode, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(decode, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(decode, num_parallel_calls=AUTOTUNE)
train_dataset = train_dataset.repeat()
train_dataset = train_dataset.batch(batch_size, drop_remainder=True)
val_dataset = val_dataset.batch(batch_size, drop_remainder=True)
test_dataset = test_dataset.batch(batch_size, drop_remainder=True)
train_dataset = train_dataset.shuffle(
buffer_size=256, reshuffle_each_iteration=True)
return train_dataset, val_dataset, test_dataset, 10, 256, (batch_size, 28, 28,
1)
def get_cifar10_datasets(n_devices, batch_size=256, normalize=False):
"""Get CIFAR-10 dataset splits."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
train_dataset = tfds.load('cifar10', split='train[:90%]')
val_dataset = tfds.load('cifar10', split='train[90%:]')
test_dataset = tfds.load('cifar10', split='test')
def decode(x):
decoded = {
'inputs':
tf.cast(tf.image.rgb_to_grayscale(x['image']), dtype=tf.int32),
'targets':
x['label']
}
if normalize:
decoded['inputs'] = decoded['inputs'] / 255
return decoded
train_dataset = train_dataset.map(decode, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(decode, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(decode, num_parallel_calls=AUTOTUNE)
# train_dataset = train_dataset.repeat()
# train_dataset = train_dataset.batch(batch_size, drop_remainder=True)
# val_dataset = val_dataset.batch(batch_size, drop_remainder=True)
# test_dataset = test_dataset.batch(batch_size, drop_remainder=True)
train_dataset = train_dataset.batch(batch_size, drop_remainder=False)
val_dataset = val_dataset.batch(batch_size, drop_remainder=False)
test_dataset = test_dataset.batch(batch_size, drop_remainder=False)
# train_dataset = train_dataset.shuffle(
# buffer_size=256, reshuffle_each_iteration=True)
return train_dataset, val_dataset, test_dataset, 10, 256, (batch_size, 32, 32,
1)
def get_pathfinder_orig_datasets(n_devices, batch_size=256, normalize=False):
"""Get Pathfinder dataset splits."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
builder = pathfinder.Pathfinder(data_dir=_PATHFINER_TFDS_PATH)
def get_split(split):
ds_p = builder.as_dataset(split=f'positive{split}')
ds_n = builder.as_dataset(split=f'negetive{split}')
ds = tf.data.experimental.sample_from_datasets([ds_p, ds_n],
weights=None,
seed=None)
return ds
train_dataset = get_split('[:80%]')
val_dataset = get_split('[80%:90%]')
test_dataset = get_split('[90%:]')
def decode(x):
decoded = {
'inputs':
tf.cast(tf.image.rgb_to_grayscale(x['image']), dtype=tf.int32),
'targets':
x['label']
}
if normalize:
decoded['inputs'] = decoded['inputs'] / 255
return decoded
train_dataset = train_dataset.map(decode, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(decode, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(decode, num_parallel_calls=AUTOTUNE)
train_dataset = train_dataset.repeat()
train_dataset = train_dataset.batch(batch_size, drop_remainder=True)
val_dataset = val_dataset.batch(batch_size, drop_remainder=True)
test_dataset = test_dataset.batch(batch_size, drop_remainder=True)
train_dataset = train_dataset.shuffle(
buffer_size=256, reshuffle_each_iteration=True)
return train_dataset, val_dataset, test_dataset, 2, 256, (batch_size, 300,
300, 1)
def get_pathfinder_base_datasets(n_devices,
batch_size=256,
resolution=32,
normalize=False,
split='easy'):
"""Get Pathfinder dataset splits."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
if split not in ['easy', 'intermediate', 'hard']:
raise ValueError("split must be in ['easy', 'intermediate', 'hard'].")
if resolution == 32:
builder = pathfinder.Pathfinder32(data_dir=_PATHFINER_TFDS_PATH)
inputs_shape = (batch_size, 32, 32, 1)
elif resolution == 64:
builder = pathfinder.Pathfinder64(data_dir=_PATHFINER_TFDS_PATH)
inputs_shape = (batch_size, 64, 64, 1)
elif resolution == 128:
builder = pathfinder.Pathfinder128(data_dir=_PATHFINER_TFDS_PATH)
inputs_shape = (batch_size, 128, 128, 1)
elif resolution == 256:
builder = pathfinder.Pathfinder256(data_dir=_PATHFINER_TFDS_PATH)
inputs_shape = (batch_size, 256, 256, 1)
else:
raise ValueError('Resolution must be in [32, 64, 128, 256].')
def get_split(split):
ds = builder.as_dataset(
split=split, decoders={'image': tfds.decode.SkipDecoding()})
# Filter out examples with empty images:
ds = ds.filter(lambda x: tf.strings.length((x['image'])) > 0)
return ds
train_dataset = get_split(f'{split}[:80%]')
val_dataset = get_split(f'{split}[80%:90%]')
test_dataset = get_split(f'{split}[90%:]')
def decode(x):
decoded = {
'inputs': tf.cast(tf.image.decode_png(x['image']), dtype=tf.int32),
'targets': x['label']
}
if normalize:
decoded['inputs'] = decoded['inputs'] / 255
return decoded
train_dataset = train_dataset.map(decode, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(decode, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(decode, num_parallel_calls=AUTOTUNE)
train_dataset = train_dataset.repeat()
train_dataset = train_dataset.batch(batch_size, drop_remainder=True)
val_dataset = val_dataset.batch(batch_size, drop_remainder=True)
test_dataset = test_dataset.batch(batch_size, drop_remainder=True)
train_dataset = train_dataset.shuffle(
buffer_size=256 * 8, reshuffle_each_iteration=True)
return train_dataset, val_dataset, test_dataset, 2, 256, inputs_shape
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/input_pipeline.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Main training script for the image classification task."""
import functools
import itertools
import json
import os
import time
from absl import app
from absl import flags
from absl import logging
from flax import jax_utils
from flax import nn
from flax import optim
from flax.metrics import tensorboard
from flax.training import checkpoints
from flax.training import common_utils
import jax
from jax import random
import jax.nn
import jax.numpy as jnp
from lra_benchmarks.image import task_registry
from lra_benchmarks.models.transformer import transformer
from lra_benchmarks.utils import train_utils
from ml_collections import config_flags
import tensorflow.compat.v2 as tf
FLAGS = flags.FLAGS
config_flags.DEFINE_config_file(
'config', None, 'Training configuration.', lock_config=True)
flags.DEFINE_string(
'model_dir', default=None, help='Directory to store model data.')
flags.DEFINE_string('task_name', default='mnist', help='Name of the task')
flags.DEFINE_bool(
'eval_only', default=False, help='Run the evaluation on the test data.')
def create_model(key, flax_module, input_shape, model_kwargs):
"""Creates and initializes the model."""
@functools.partial(jax.jit, backend='cpu')
def _create_model(key):
module = flax_module.partial(**model_kwargs)
with nn.stateful() as init_state:
with nn.stochastic(key):
_, initial_params = module.init_by_shape(key,
[(input_shape, jnp.float32)])
model = nn.Model(module, initial_params)
return model, init_state
return _create_model(key)
def create_optimizer(model, learning_rate, weight_decay):
optimizer_def = optim.Adam(
learning_rate, beta1=0.9, beta2=0.98, eps=1e-9, weight_decay=weight_decay)
optimizer = optimizer_def.create(model)
return optimizer
def compute_metrics(logits, labels, num_classes, weights):
"""Compute summary metrics."""
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, labels, num_classes, weights=weights)
acc, _ = train_utils.compute_weighted_accuracy(logits, labels, weights)
metrics = {
'loss': loss,
'accuracy': acc,
'denominator': weight_sum,
}
metrics = jax.lax.psum(metrics, 'batch')
return metrics
def get_model(init_rng, input_shape, model_type, model_kwargs):
"""Create and initialize the model.
Args:
init_rng: float; Jax PRNG key.
input_shape: tuple; Tuple indicating input shape.
model_type: str; Type of Transformer model to create.
model_kwargs: keyword argument to the model.
Returns:
Initialized model.
"""
if model_type == 'transformer':
return create_model(init_rng, transformer.TransformerEncoder, input_shape,
model_kwargs)
else:
raise ValueError('Model type not supported')
def train_step(optimizer,
state,
batch,
learning_rate_fn,
num_classes,
flatten_input=True,
grad_clip_norm=None,
dropout_rng=None):
"""Perform a single training step."""
train_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in train_keys]
if flatten_input:
inputs = inputs.reshape(inputs.shape[0], -1)
# We handle PRNG splitting inside the top pmap, rather
# than handling it outside in the training loop - doing the
# latter can add some stalls to the devices.
dropout_rng, new_dropout_rng = random.split(dropout_rng)
def loss_fn(model):
"""Loss function used for training."""
with nn.stateful(state) as new_state:
with nn.stochastic(dropout_rng):
logits = model(inputs, train=True)
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, targets, num_classes=num_classes, weights=None)
mean_loss = loss / weight_sum
return mean_loss, (new_state, logits)
step = optimizer.state.step
lr = learning_rate_fn(step)
grad_fn = jax.value_and_grad(loss_fn, has_aux=True)
(_, (new_state, logits)), grad = grad_fn(optimizer.target)
grad = jax.lax.pmean(grad, 'batch')
if grad_clip_norm:
# Optionally resize the global gradient to a maximum norm.
gradients, _ = jax.tree_flatten(grad)
g_l2 = jnp.sqrt(sum([jnp.vdot(p, p) for p in gradients]))
g_factor = jnp.minimum(1.0, grad_clip_norm / g_l2)
grad = jax.tree_map(lambda p: g_factor * p, grad)
new_optimizer = optimizer.apply_gradient(grad, learning_rate=lr)
metrics = compute_metrics(logits, targets, num_classes, weights=None)
metrics['learning_rate'] = lr
return new_optimizer, new_state, metrics, new_dropout_rng
def eval_step(model, state, batch, num_classes, flatten_input=True):
eval_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in eval_keys]
if flatten_input:
inputs = inputs.reshape(inputs.shape[0], -1)
if jax.tree_leaves(state):
state = jax.lax.pmean(state, 'batch')
with nn.stateful(state, mutable=False):
logits = model(inputs, train=False)
return compute_metrics(logits, targets, num_classes, weights=None)
def test(optimizer, state, p_eval_step, step, test_ds, summary_writer,
model_dir):
"""Test the flax module in optimizer on test_ds.
Args:
optimizer: flax optimizer (contains flax module).
state: model state, e.g. batch statistics.
p_eval_step: fn; Pmapped evaluation step function.
step: int; Number of training steps passed so far.
test_ds: tf.dataset; Test dataset.
summary_writer: tensorflow summary writer.
model_dir: model directory.
"""
# Test Metrics
test_metrics = []
test_iter = iter(test_ds)
for _, test_batch in zip(itertools.repeat(1), test_iter):
# pylint: disable=protected-access
test_batch = common_utils.shard(
jax.tree_map(lambda x: x._numpy(), test_batch))
# pylint: enable=protected-access
metrics = p_eval_step(optimizer.target, state, test_batch)
test_metrics.append(metrics)
test_metrics = common_utils.get_metrics(test_metrics)
test_metrics_sums = jax.tree_map(jnp.sum, test_metrics)
test_denominator = test_metrics_sums.pop('denominator')
test_summary = jax.tree_map(
lambda x: x / test_denominator, # pylint: disable=cell-var-from-loop
test_metrics_sums)
logging.info('test in step: %d, loss: %.4f, acc: %.4f', step,
test_summary['loss'], test_summary['accuracy'])
if jax.host_id() == 0:
for key, val in test_summary.items():
summary_writer.scalar(f'test_{key}', val, step)
summary_writer.flush()
with tf.io.gfile.GFile(os.path.join(model_dir, 'results.json'), 'w') as f:
json.dump(jax.tree_map(lambda x: x.tolist(), test_summary), f)
def train_loop(config, dropout_rngs, eval_ds, eval_freq, num_eval_steps,
num_train_steps, optimizer, state, p_eval_step, p_train_step,
start_step, train_iter, summary_writer):
"""Training loop.
Args:
config: experiment config.
dropout_rngs: float array; Jax PRNG key.
eval_ds: tf.dataset; Evaluation dataset.
eval_freq: int; Evaluation frequency;
num_eval_steps: int; Number of evaluation steps.
num_train_steps: int; Number of training steps.
optimizer: flax optimizer.
state: model state, e.g. batch statistics.
p_eval_step: fn; Pmapped evaluation step function.
p_train_step: fn; Pmapped train step function.
start_step: int; global training step.
train_iter: iter(tf.dataset); Training data iterator.
summary_writer: tensorflow summary writer.
Returns:
optimizer, global training step
"""
metrics_all = []
tick = time.time()
logging.info('Starting training')
logging.info('====================')
step = 0
for step, batch in zip(range(start_step, num_train_steps), train_iter):
batch = common_utils.shard(jax.tree_map(lambda x: x._numpy(), batch)) # pylint: disable=protected-access
optimizer, state, metrics, dropout_rngs = p_train_step(
optimizer, state, batch, dropout_rng=dropout_rngs)
metrics_all.append(metrics)
# Save a Checkpoint
if ((step % config.checkpoint_freq == 0 and step > 0) or
step == num_train_steps - 1):
if jax.host_id() == 0 and config.save_checkpoints:
# Save unreplicated optimizer + model state.
checkpoints.save_checkpoint(
FLAGS.model_dir,
(jax_utils.unreplicate(optimizer), jax_utils.unreplicate(state)),
step)
# Periodic metric handling.
if step % eval_freq == 0 and step > 0:
metrics_all = common_utils.get_metrics(metrics_all)
lr = metrics_all.pop('learning_rate').mean()
metrics_sums = jax.tree_map(jnp.sum, metrics_all)
denominator = metrics_sums.pop('denominator')
summary = jax.tree_map(lambda x: x / denominator, metrics_sums) # pylint: disable=cell-var-from-loop
summary['learning_rate'] = lr
# Calculate (clipped) perplexity after averaging log-perplexities:
logging.info('train in step: %d, loss: %.4f, acc: %.4f', step,
summary['loss'], summary['accuracy'])
if jax.host_id() == 0:
tock = time.time()
steps_per_sec = eval_freq / (tock - tick)
tick = tock
summary_writer.scalar('examples_per_second',
steps_per_sec * config.batch_size, step)
for key, val in summary.items():
summary_writer.scalar(f'train_{key}', val, step)
summary_writer.flush()
# Reset metric accumulation for next evaluation cycle.
metrics_all = []
# Eval Metrics
eval_metrics = []
eval_iter = iter(eval_ds)
if num_eval_steps == -1:
num_iter = itertools.repeat(1)
else:
num_iter = range(num_eval_steps)
for _, eval_batch in zip(num_iter, eval_iter):
# pylint: disable=protected-access
eval_batch = common_utils.shard(
jax.tree_map(lambda x: x._numpy(), eval_batch))
# pylint: enable=protected-access
metrics = p_eval_step(optimizer.target, state, eval_batch)
eval_metrics.append(metrics)
eval_metrics = common_utils.get_metrics(eval_metrics)
eval_metrics_sums = jax.tree_map(jnp.sum, eval_metrics)
eval_denominator = eval_metrics_sums.pop('denominator')
eval_summary = jax.tree_map(
lambda x: x / eval_denominator, # pylint: disable=cell-var-from-loop
eval_metrics_sums)
logging.info('eval in step: %d, loss: %.4f, acc: %.4f', step,
eval_summary['loss'], eval_summary['accuracy'])
if jax.host_id() == 0:
for key, val in eval_summary.items():
summary_writer.scalar(f'val_{key}', val, step)
summary_writer.flush()
return optimizer, state, step
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
tf.enable_v2_behavior()
config = FLAGS.config
logging.info('===========Config Dict============')
logging.info(config)
batch_size = config.batch_size
learning_rate = config.learning_rate
num_train_steps = config.num_train_steps
num_eval_steps = config.num_eval_steps
eval_freq = config.eval_frequency
random_seed = config.random_seed
model_type = config.model_type
if jax.host_id() == 0:
summary_writer = tensorboard.SummaryWriter(
os.path.join(FLAGS.model_dir, 'summary'))
else:
summary_writer = None
if batch_size % jax.device_count() > 0:
raise ValueError('Batch size must be divisible by the number of devices')
logging.info('Training on %s', FLAGS.task_name)
if model_type in ['wideresnet', 'resnet', 'simple_cnn']:
normalize = True
else: # transformer-based models
normalize = False
(train_ds, eval_ds, test_ds, num_classes, vocab_size,
input_shape) = task_registry.TASK_DATA_DICT[FLAGS.task_name](
n_devices=jax.local_device_count(),
batch_size=batch_size,
normalize=normalize)
train_iter = iter(train_ds)
model_kwargs = {}
flatten_input = True
if model_type in ['wideresnet', 'resnet', 'simple_cnn']:
model_kwargs.update({
'num_classes': num_classes,
})
flatten_input = False
else: # transformer models
# we will flatten the input
bs, h, w, c = input_shape
assert c == 1
input_shape = (bs, h * w * c)
model_kwargs.update({
'vocab_size': vocab_size,
'max_len': input_shape[1],
'classifier': True,
'num_classes': num_classes,
})
model_kwargs.update(config.model)
rng = random.PRNGKey(random_seed)
rng = jax.random.fold_in(rng, jax.host_id())
rng, init_rng = random.split(rng)
# We init the first set of dropout PRNG keys, but update it afterwards inside
# the main pmap'd training update for performance.
dropout_rngs = random.split(rng, jax.local_device_count())
model, state = get_model(init_rng, input_shape, model_type, model_kwargs)
optimizer = create_optimizer(model, learning_rate, config.weight_decay)
del model # Don't keep a copy of the initial model.
start_step = 0
if config.restore_checkpoints:
# Restore unreplicated optimizer + model state from last checkpoint.
optimizer, state = checkpoints.restore_checkpoint(FLAGS.model_dir,
(optimizer, state))
# Grab last step.
start_step = int(optimizer.state.step)
# Replicate optimizer and state
optimizer = jax_utils.replicate(optimizer)
state = jax_utils.replicate(state)
learning_rate_fn = train_utils.create_learning_rate_scheduler(
factors=config.factors,
base_learning_rate=learning_rate,
warmup_steps=config.warmup,
steps_per_cycle=config.get('steps_per_cycle', None),
)
p_train_step = jax.pmap(
functools.partial(
train_step,
learning_rate_fn=learning_rate_fn,
num_classes=num_classes,
grad_clip_norm=config.get('grad_clip_norm', None),
flatten_input=flatten_input),
axis_name='batch')
p_eval_step = jax.pmap(
functools.partial(
eval_step, num_classes=num_classes, flatten_input=flatten_input),
axis_name='batch',
)
optimizer, state, step = train_loop(config, dropout_rngs, eval_ds, eval_freq,
num_eval_steps, num_train_steps,
optimizer, state, p_eval_step,
p_train_step, start_step, train_iter,
summary_writer)
logging.info('Starting testing')
logging.info('====================')
test(optimizer, state, p_eval_step, step, test_ds, summary_writer,
FLAGS.model_dir)
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/train.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/__init__.py |
|
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder128/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.image.configs.pathfinder128 import base_pathfinder128_config
def get_config():
"""Get the hyperparameter configuration."""
config = base_pathfinder128_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder128/transformer_base.py |
# Copyright 2021 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
NUM_EPOCHS = 200
TRAIN_EXAMPLES = 160000
VALID_EXAMPLES = 20000
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 64
config.eval_frequency = TRAIN_EXAMPLES // config.batch_size
config.num_train_steps = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
config.num_eval_steps = VALID_EXAMPLES // config.batch_size
config.weight_decay = 0.
config.grad_clip_norm = 1.
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = (TRAIN_EXAMPLES //
config.batch_size) * NUM_EPOCHS // 2
config.random_seed = 0
config.learning_rate = .001
config.factors = 'constant * linear_warmup * cosine_decay'
config.warmup = (TRAIN_EXAMPLES // config.batch_size) * 1
config.steps_per_cycle = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
# model params
config.model = ml_collections.ConfigDict()
config.model.num_layers = 1
config.model.num_heads = 2
config.model.emb_dim = 32
config.model.dropout_rate = 0.1
config.model.qkv_dim = config.model.emb_dim // 2
config.model.mlp_dim = config.model.qkv_dim * 2
config.model.attention_dropout_rate = 0.1
config.model.classifier_pool = 'MEAN'
config.model.learn_pos_emb = True
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder128/base_pathfinder128_config.py |
"""Base Configuration."""
# Copyright 2021 Google LLC
# 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
# https://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.
import ml_collections
NUM_EPOCHS = 100
TRAIN_EXAMPLES = 160000
VALID_EXAMPLES = 20000
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 32
config.eval_frequency = TRAIN_EXAMPLES // config.batch_size
config.num_train_steps = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
config.num_eval_steps = VALID_EXAMPLES // config.batch_size
config.weight_decay = 0.
config.grad_clip_norm = None
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = (TRAIN_EXAMPLES //
config.batch_size) * NUM_EPOCHS // 2
config.random_seed = 0
config.learning_rate = .001
config.factors = 'constant * linear_warmup * cosine_decay'
config.warmup = (TRAIN_EXAMPLES // config.batch_size) * 1
config.steps_per_cycle = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
# model params
config.model = ml_collections.ConfigDict()
config.model.emb_dim = 32
config.model.num_heads = 4
config.model.num_layers = 2
config.model.qkv_dim = 32
config.model.mlp_dim = 32
config.model.dropout_rate = 0.1
config.model.attention_dropout_rate = 0.1
config.model.classifier_pool = 'CLS'
config.model.learn_pos_emb = True
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder256/base_pathfinder256_config.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder256/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.image.configs.pathfinder256 import base_pathfinder256_config
def get_config():
"""Get the hyperparameter configuration."""
config = base_pathfinder256_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder256/transformer_base.py |
# Copyright 2021 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
NUM_EPOCHS = 200
TRAIN_EXAMPLES = 160000
VALID_EXAMPLES = 20000
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 256
config.eval_frequency = TRAIN_EXAMPLES // config.batch_size
config.num_train_steps = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
config.num_eval_steps = VALID_EXAMPLES // config.batch_size
config.weight_decay = 0.
config.grad_clip_norm = None
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = (TRAIN_EXAMPLES //
config.batch_size) * NUM_EPOCHS // 2
config.random_seed = 0
config.learning_rate = .001
config.factors = 'constant * linear_warmup * cosine_decay'
config.warmup = (TRAIN_EXAMPLES // config.batch_size) * 1
config.steps_per_cycle = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
# model params
config.model = ml_collections.ConfigDict()
config.model.emb_dim = 32
config.model.num_heads = 4
config.model.num_layers = 2
config.model.qkv_dim = 32
config.model.mlp_dim = 32
config.model.dropout_rate = 0.1
config.model.attention_dropout_rate = 0.1
config.model.classifier_pool = 'CLS'
config.model.learn_pos_emb = True
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder64/base_pathfinder64_config.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder64/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.image.configs.pathfinder64 import base_pathfinder64_config
def get_config():
"""Get the hyperparameter configuration."""
config = base_pathfinder64_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder64/transformer_base.py |
# Copyright 2021 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
NUM_EPOCHS = 200
TRAIN_EXAMPLES = 160000
VALID_EXAMPLES = 20000
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 512
config.eval_frequency = TRAIN_EXAMPLES // config.batch_size
config.num_train_steps = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
config.num_eval_steps = VALID_EXAMPLES // config.batch_size
config.weight_decay = 0.
config.grad_clip_norm = None
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = (TRAIN_EXAMPLES //
config.batch_size) * NUM_EPOCHS // 2
config.random_seed = 0
config.learning_rate = .001
config.factors = 'constant * linear_warmup * cosine_decay'
config.warmup = (TRAIN_EXAMPLES // config.batch_size) * 1
config.steps_per_cycle = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
# model params
config.model = ml_collections.ConfigDict()
config.model.num_layers = 1
config.model.num_heads = 2
config.model.emb_dim = 32
config.model.dropout_rate = 0.1
config.model.qkv_dim = config.model.emb_dim // 2
config.model.mlp_dim = config.model.qkv_dim * 2
config.model.attention_dropout_rate = 0.1
config.model.classifier_pool = 'MEAN'
config.model.learn_pos_emb = False
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder32/base_pathfinder32_config.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder32/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.image.configs.pathfinder32 import base_pathfinder32_config
def get_config():
"""Get the hyperparameter configuration."""
config = base_pathfinder32_config.get_config()
config.model_type = "transformer"
config.model.num_layers = 1
config.model.num_heads = 4
config.model.emb_dim = 128
config.model.dropout_rate = 0.2
config.model.qkv_dim = config.model.emb_dim // 2
config.model.mlp_dim = config.model.qkv_dim * 2
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/pathfinder32/transformer_base.py |
# Copyright 2020 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
NUM_EPOCHS = 200
TRAIN_EXAMPLES = 45000
VALID_EXAMPLES = 10000
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 256
config.eval_frequency = TRAIN_EXAMPLES // config.batch_size
config.num_train_steps = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
config.num_eval_steps = VALID_EXAMPLES // config.batch_size
config.weight_decay = 0.
config.grad_clip_norm = None
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = (TRAIN_EXAMPLES //
config.batch_size) * NUM_EPOCHS // 2
config.random_seed = 0
config.learning_rate = .0005
config.factors = 'constant * linear_warmup * cosine_decay'
config.warmup = (TRAIN_EXAMPLES // config.batch_size) * 1
config.steps_per_cycle = (TRAIN_EXAMPLES // config.batch_size) * NUM_EPOCHS
# model params
config.model = ml_collections.ConfigDict()
config.model.emb_dim = 32
config.model.num_heads = 1
config.model.num_layers = 1
config.model.qkv_dim = 32
config.model.mlp_dim = 64
config.model.dropout_rate = 0.3
config.model.attention_dropout_rate = 0.2
config.model.classifier_pool = 'CLS'
config.model.learn_pos_emb = True
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/cifar10/base_cifar10_config.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/cifar10/__init__.py |
|
# Copyright 2020 Google LLC
# 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
# https://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.\
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.image.configs.cifar10 import base_cifar10_config
def get_config():
"""Get the hyperparameter configuration."""
config = base_cifar10_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/image/configs/cifar10/transformer_base.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Input pipeline for the imdb dataset."""
from absl import logging
import numpy as np
import tensorflow.compat.v1 as tf
import tensorflow_datasets as tfds
AUTOTUNE = tf.data.experimental.AUTOTUNE
def preprocess_dataset(file_path, batch_size):
"""Preprocess dataset."""
tf.logging.info(file_path)
sel_cols = ['Source', 'Target']
col_defaults = [tf.string, tf.int32]
ds = tf.data.experimental.make_csv_dataset([file_path],
batch_size,
column_defaults=col_defaults,
select_columns=sel_cols,
field_delim=',',
header=True,
shuffle=False,
num_epochs=1)
ds = ds.unbatch()
return ds
def get_imdb_dataset():
"""Get dataset from imdb tfds. converts into src/tgt pairs."""
data = tfds.load('imdb_reviews')
train_raw = data['train']
valid_raw = data['test']
test_raw = data['test']
# use test set for validation because IMDb doesn't have val set.
# Print an example.
logging.info('Data sample: %s', next(iter(tfds.as_numpy(train_raw.skip(4)))))
def adapt_example(example):
return {'Source': example['text'], 'Target': example['label']}
train = train_raw.map(adapt_example)
valid = valid_raw.map(adapt_example)
test = test_raw.map(adapt_example)
return train, valid, test
def get_yelp_dataset():
"""Get dataset from yelp tfds. converts into src/tgt pairs."""
data = tfds.load('yelp_polarity_reviews')
train_raw = data['train']
valid_raw = data['test']
test_raw = data['test']
# use test set for validation because yelp doesn't have val set.
# Print an example.
logging.info('Data sample: %s', next(iter(tfds.as_numpy(train_raw.skip(4)))))
def adapt_example(example):
return {'Source': example['text'], 'Target': example['label']}
train = train_raw.map(adapt_example)
valid = valid_raw.map(adapt_example)
test = test_raw.map(adapt_example)
return train, valid, test
def get_agnews_dataset():
"""Get dataset from agnews tfds. converts into src/tgt pairs."""
data = tfds.load('ag_news_subset')
train_raw = data['train']
valid_raw = data['test']
test_raw = data['test']
# use test set for validation because agnews doesn't have val set.
# Print an example.
logging.info('Data sample: %s', next(iter(tfds.as_numpy(train_raw.skip(4)))))
def adapt_example(example):
return {'Source': example['description'], 'Target': example['label']}
train = train_raw.map(adapt_example)
valid = valid_raw.map(adapt_example)
test = test_raw.map(adapt_example)
return train, valid, test
def get_tc_datasets(n_devices,
task_name,
data_dir=None,
batch_size=256,
fixed_vocab=None,
max_length=512,
tokenizer='char'):
"""Get text classification datasets."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
if task_name == 'imdb_reviews':
train_dataset, val_dataset, test_dataset = get_imdb_dataset()
elif task_name == 'yelp_reviews':
train_dataset, val_dataset, test_dataset = get_yelp_dataset()
elif task_name == 'agnews':
train_dataset, val_dataset, test_dataset = get_agnews_dataset()
else:
train_path = data_dir + task_name + '_train.tsv'
val_path = data_dir + task_name + '_val.tsv'
test_path = data_dir + task_name + '_test.tsv'
train_dataset = preprocess_dataset(train_path, batch_size)
val_dataset = preprocess_dataset(val_path, batch_size)
test_dataset = preprocess_dataset(test_path, batch_size)
tf.logging.info('Finished preprocessing')
tf.logging.info(val_dataset)
if tokenizer == 'char':
logging.info('Using char/byte level vocab')
encoder = tfds.deprecated.text.ByteTextEncoder()
else:
if fixed_vocab is None:
tf.logging.info('Building vocab')
# build vocab
vocab_set = set()
tokenizer = tfds.deprecated.text.Tokenizer()
for i, data in enumerate(train_dataset):
examples = data['Source']
examples = tokenizer.tokenize(examples.numpy())
examples = np.reshape(examples, (-1)).tolist()
vocab_set.update(examples)
if i % 1000 == 0:
tf.logging.info('Processed {}'.format(i))
tf.logging.info(len(vocab_set))
vocab_set = list(set(vocab_set))
tf.logging.info('Finished processing vocab size={}'.format(
len(vocab_set)))
else:
vocab_set = list(set(fixed_vocab))
encoder = tfds.deprecated.text.TokenTextEncoder(vocab_set)
def tf_encode(x):
result = tf.py_function(lambda s: tf.constant(encoder.encode(s.numpy())), [
x,
], tf.int32)
result.set_shape([None])
return result
def tokenize(d):
return {
'inputs': tf_encode(d['Source'])[:max_length],
'targets': d['Target']
}
train_dataset = train_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
max_shape = {'inputs': [max_length], 'targets': []}
# train_dataset = train_dataset.shuffle(
# buffer_size=256, reshuffle_each_iteration=True).padded_batch(
# batch_size, padded_shapes=max_shape)
# train_dataset = train_dataset.shuffle(
# buffer_size=256, reshuffle_each_iteration=True).padded_batch(
# batch_size, padded_shapes=max_shape)
train_dataset = train_dataset.padded_batch(batch_size, padded_shapes=max_shape)
val_dataset = val_dataset.padded_batch(batch_size, padded_shapes=max_shape)
test_dataset = test_dataset.padded_batch(batch_size, padded_shapes=max_shape)
return train_dataset, val_dataset, test_dataset, encoder
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/text_classification/input_pipeline.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Document Classification tasks."""
import functools
import itertools
import json
import os
import time
from absl import app
from absl import flags
from absl import logging
from flax import jax_utils
from flax import nn
from flax import optim
from flax.metrics import tensorboard
from flax.training import checkpoints
from flax.training import common_utils
import jax
from jax import random
import jax.nn
import jax.numpy as jnp
from lra_benchmarks.models.transformer import transformer
from lra_benchmarks.text_classification import input_pipeline
from lra_benchmarks.utils import train_utils
from ml_collections import config_flags
import tensorflow.compat.v2 as tf
FLAGS = flags.FLAGS
config_flags.DEFINE_config_file(
'config', None, 'Training configuration.', lock_config=True)
flags.DEFINE_string(
'model_dir', default=None, help='Directory to store model data.')
flags.DEFINE_string(
'task_name',
default='basic_two_ptrs',
help='Directory to store model data.')
flags.DEFINE_string(
'data_dir', default=None, help='Directory containing datasets.')
flags.DEFINE_bool(
'test_only', default=False, help='Run the evaluation on the test data.')
CLASS_MAP = {'imdb_reviews': 2}
def create_model(key, flax_module, input_shape, model_kwargs):
"""Creates and initializes the model."""
@functools.partial(jax.jit, backend='cpu')
def _create_model(key):
module = flax_module.partial(**model_kwargs)
with nn.stochastic(key):
_, initial_params = module.init_by_shape(key,
[(input_shape, jnp.float32)])
model = nn.Model(module, initial_params)
return model
return _create_model(key)
def create_optimizer(model, learning_rate, weight_decay):
optimizer_def = optim.Adam(
learning_rate, beta1=0.9, beta2=0.98, eps=1e-9, weight_decay=weight_decay)
optimizer = optimizer_def.create(model)
return optimizer
def compute_metrics(logits, labels, weights):
"""Compute summary metrics."""
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, labels, num_classes=CLASS_MAP[FLAGS.task_name], weights=None)
acc, _ = train_utils.compute_weighted_accuracy(logits, labels, weights)
metrics = {
'loss': loss,
'accuracy': acc,
'denominator': weight_sum,
}
metrics = jax.lax.psum(metrics, 'batch')
return metrics
def train_step(optimizer, batch, learning_rate_fn, dropout_rng=None):
"""Perform a single training step."""
train_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in train_keys]
# We handle PRNG splitting inside the top pmap, rather
# than handling it outside in the training loop - doing the
# latter can add some stalls to the devices.
dropout_rng, new_dropout_rng = random.split(dropout_rng)
def loss_fn(model):
"""Loss function used for training."""
with nn.stochastic(dropout_rng):
logits = model(inputs, train=True)
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, targets, num_classes=CLASS_MAP[FLAGS.task_name], weights=None)
mean_loss = loss / weight_sum
return mean_loss, logits
step = optimizer.state.step
lr = learning_rate_fn(step)
grad_fn = jax.value_and_grad(loss_fn, has_aux=True)
(_, logits), grad = grad_fn(optimizer.target)
grad = jax.lax.pmean(grad, 'batch')
new_optimizer = optimizer.apply_gradient(grad, learning_rate=lr)
metrics = compute_metrics(logits, targets, None)
metrics['learning_rate'] = lr
return new_optimizer, metrics, new_dropout_rng
def eval_step(model, batch):
eval_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in eval_keys]
logits = model(inputs, train=False)
logging.info(logits)
return compute_metrics(logits, targets, None)
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
tf.enable_v2_behavior()
config = FLAGS.config
logging.info('===========Config Dict============')
logging.info(config)
batch_size = config.batch_size
learning_rate = config.learning_rate
num_train_steps = config.num_train_steps
num_eval_steps = config.num_eval_steps
eval_freq = config.eval_frequency
random_seed = config.random_seed
model_type = config.model_type
max_length = config.max_length
if jax.host_id() == 0:
summary_writer = tensorboard.SummaryWriter(
os.path.join(FLAGS.model_dir, 'summary'))
if batch_size % jax.device_count() > 0:
raise ValueError('Batch size must be divisible by the number of devices')
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_tc_datasets(
n_devices=jax.local_device_count(),
task_name=FLAGS.task_name,
data_dir=FLAGS.data_dir,
batch_size=batch_size,
fixed_vocab=None,
max_length=max_length)
vocab_size = encoder.vocab_size
logging.info('Vocab Size: %d', vocab_size)
train_ds = train_ds.repeat()
train_iter = iter(train_ds)
input_shape = (batch_size, max_length)
model_kwargs = {
'vocab_size': vocab_size,
'emb_dim': config.emb_dim,
'num_heads': config.num_heads,
'num_layers': config.num_layers,
'qkv_dim': config.qkv_dim,
'mlp_dim': config.mlp_dim,
'max_len': max_length,
'classifier': True,
'num_classes': CLASS_MAP[FLAGS.task_name],
'classifier_pool': config.classifier_pool
}
rng = random.PRNGKey(random_seed)
rng = jax.random.fold_in(rng, jax.host_id())
rng, init_rng = random.split(rng)
# We init the first set of dropout PRNG keys, but update it afterwards inside
# the main pmap'd training update for performance.
dropout_rngs = random.split(rng, jax.local_device_count())
if model_type == 'transformer':
model = create_model(init_rng, transformer.TransformerEncoder, input_shape,
model_kwargs)
else:
raise ValueError('Model type not supported')
optimizer = create_optimizer(
model, learning_rate, weight_decay=FLAGS.config.weight_decay)
del model # Don't keep a copy of the initial model.
start_step = 0
if config.restore_checkpoints or FLAGS.test_only:
# Restore unreplicated optimizer + model state from last checkpoint.
optimizer = checkpoints.restore_checkpoint(FLAGS.model_dir, optimizer)
# Grab last step.
start_step = int(optimizer.state.step)
# Replicate optimizer.
optimizer = jax_utils.replicate(optimizer)
learning_rate_fn = train_utils.create_learning_rate_scheduler(
factors=config.factors,
base_learning_rate=learning_rate,
warmup_steps=config.warmup)
p_train_step = jax.pmap(
functools.partial(train_step, learning_rate_fn=learning_rate_fn),
axis_name='batch')
p_eval_step = jax.pmap(eval_step, axis_name='batch')
# p_pred_step = jax.pmap(predict_step, axis_name='batch')
def run_eval(eval_ds, num_eval_steps=-1):
eval_metrics = []
eval_iter = iter(eval_ds)
if num_eval_steps == -1:
num_iter = itertools.count()
else:
num_iter = range(num_eval_steps)
for _, eval_batch in zip(num_iter, eval_iter):
# pylint: disable=protected-access
eval_batch = common_utils.shard(
jax.tree_map(lambda x: x._numpy(), eval_batch))
# pylint: enable=protected-access
metrics = p_eval_step(optimizer.target, eval_batch)
eval_metrics.append(metrics)
eval_metrics = common_utils.get_metrics(eval_metrics)
eval_metrics_sums = jax.tree_map(jnp.sum, eval_metrics)
eval_denominator = eval_metrics_sums.pop('denominator')
eval_summary = jax.tree_map(
lambda x: x / eval_denominator, # pylint: disable=cell-var-from-loop
eval_metrics_sums)
# Calculate (clipped) perplexity after averaging log-perplexities:
eval_summary['perplexity'] = jnp.clip(
jnp.exp(eval_summary['loss']), a_max=1.0e4)
return eval_summary
if FLAGS.test_only:
with tf.io.gfile.GFile(os.path.join(FLAGS.model_dir, 'results.json'),
'w') as f:
test_summary = run_eval(test_ds)
json.dump(jax.tree_map(lambda x: x.tolist(), test_summary), f)
return
metrics_all = []
tick = time.time()
logging.info('Starting training')
logging.info('====================')
for step, batch in zip(range(start_step, num_train_steps), train_iter):
batch = common_utils.shard(jax.tree_map(lambda x: x._numpy(), batch)) # pylint: disable=protected-access
optimizer, metrics, dropout_rngs = p_train_step(
optimizer, batch, dropout_rng=dropout_rngs)
metrics_all.append(metrics)
logging.info('train in step: %d', step)
# Save a Checkpoint
if ((step % config.checkpoint_freq == 0 and step > 0) or
step == num_train_steps - 1):
if jax.host_id() == 0 and config.save_checkpoints:
# Save unreplicated optimizer + model state.
checkpoints.save_checkpoint(FLAGS.model_dir,
jax_utils.unreplicate(optimizer), step)
# Periodic metric handling.
if step % eval_freq == 0 and step > 0:
metrics_all = common_utils.get_metrics(metrics_all)
lr = metrics_all.pop('learning_rate').mean()
metrics_sums = jax.tree_map(jnp.sum, metrics_all)
denominator = metrics_sums.pop('denominator')
summary = jax.tree_map(lambda x: x / denominator, metrics_sums) # pylint: disable=cell-var-from-loop
summary['learning_rate'] = lr
# Calculate (clipped) perplexity after averaging log-perplexities:
summary['perplexity'] = jnp.clip(jnp.exp(summary['loss']), a_max=1.0e4)
logging.info('train in step: %d, loss: %.4f, acc: %.4f', step,
summary['loss'], summary['accuracy'])
if jax.host_id() == 0:
tock = time.time()
steps_per_sec = eval_freq / (tock - tick)
tick = tock
summary_writer.scalar('steps per second', steps_per_sec, step)
for key, val in summary.items():
summary_writer.scalar(f'train_{key}', val, step)
summary_writer.flush()
# Reset metric accumulation for next evaluation cycle.
metrics_all = []
# Eval Metrics
eval_summary = run_eval(eval_ds, num_eval_steps)
logging.info('eval in step: %d, loss: %.4f, acc: %.4f', step,
eval_summary['loss'], eval_summary['accuracy'])
if jax.host_id() == 0:
for key, val in eval_summary.items():
summary_writer.scalar(f'eval_{key}', val, step)
summary_writer.flush()
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/text_classification/train.py |
# Copyright 2020 Google LLC
# 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
# https://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.\
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.text_classification.configs import base_tc_config
def get_config():
"""Get the default hyperparameter configuration."""
config = base_tc_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/text_classification/configs/transformer_base.py |
# Copyright 2020 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 32
config.eval_frequency = 100
config.num_train_steps = 20000
config.num_eval_steps = -1
config.learning_rate = 0.05
config.weight_decay = 1e-1
config.max_target_length = 200
config.max_eval_target_length = 200
config.sampling_temperature = 0.6
config.sampling_top_k = 20
config.max_predict_token_length = 50
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = 10000
config.random_seed = 0
config.prompt = ""
config.factors = "constant * linear_warmup * rsqrt_decay"
config.warmup = 8000
config.classifier_pool = "CLS"
config.max_length = 1000
config.emb_dim = 256
config.num_heads = 4
config.num_layers = 4
config.qkv_dim = 256
config.mlp_dim = 1024
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/text_classification/configs/base_tc_config.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""TFDS builder for pathfinder challenge."""
import os
import tensorflow as tf
import tensorflow_datasets as tfds
class Pathfinder32(tfds.core.BeamBasedBuilder):
"""Pathfinder TFDS builder (where the resolution is 32).
The data for this dataset was generated using the script in
https://github.com/drewlinsley/pathfinder with the default parameters, while
followings being customized:
```
args.paddle_margin_list = [1]
args.window_size = [32, 32]
args.padding= 1
args.paddle_length = 2
args.marker_radius = 1.5
args.contour_length = 14
args.paddle_thickness = 0.5
args.antialias_scale = 2
args.seed_distance= 7
args.continuity = 1.0
args.distractor_length = args.contour_length // 3
args.num_distractor_snakes = 20 // args.distractor_length
args.snake_contrast_list = [2]
args.paddle_contrast_list = [0.75]
```
"""
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=('This is a builder for pathfinder challenge dataset'),
features=tfds.features.FeaturesDict({
'image': tfds.features.Image(),
'label': tfds.features.ClassLabel(num_classes=2)
}),
supervised_keys=('image', 'label'),
homepage='',
citation="""@inproceedings{
Kim*2020Disentangling,
title={Disentangling neural mechanisms for perceptual grouping},
author={Junkyung Kim* and Drew Linsley* and Kalpit Thakkar and Thomas Serre},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://openreview.net/forum?id=HJxrVA4FDS}
}""",
)
def _split_generators(self, dl_manager):
"""Downloads the data and defines the splits."""
return [
tfds.core.SplitGenerator(
name='easy', gen_kwargs={'file_pattern': 'curv_baseline'}),
tfds.core.SplitGenerator(
name='intermediate',
gen_kwargs={'file_pattern': 'curv_contour_length_9'}),
tfds.core.SplitGenerator(
name='hard', gen_kwargs={'file_pattern': 'curv_contour_length_14'})
]
def _build_pcollection(self, pipeline, file_pattern):
"""Generate examples as dicts."""
beam = tfds.core.lazy_imports.apache_beam
def _generate_examples(file_path):
"""Read the input data out of the source files."""
example_id = 0
meta_examples = tf.io.read_file(file_path).numpy().decode('utf-8').split(
'\n')[:-1]
print(meta_examples)
for m_example in meta_examples:
m_example = m_example.split(' ')
image_path = os.path.join(ORIGINAL_DATA_DIR_32, file_pattern,
m_example[0], m_example[1])
example_id += 1
yield '_'.join([m_example[0], m_example[1],
str(example_id)]), {
'image': image_path,
'label': int(m_example[3]),
}
meta_file_pathes = tf.io.gfile.glob(
os.path.join(ORIGINAL_DATA_DIR_32, file_pattern, 'metadata/*.npy'))
print(len(meta_file_pathes))
return (pipeline
| 'Create' >> beam.Create(meta_file_pathes)
| 'Generate' >> beam.ParDo(_generate_examples))
class Pathfinder64(tfds.core.BeamBasedBuilder):
"""Pathfinder TFDS builder (where the resolution is 64).
The data for this dataset was generated using the script in
https://github.com/drewlinsley/pathfinder with the default parameters, while
followings being customized:
```
args.padding = 1
args.antialias_scale = 4
args.paddle_margin_list = [1]
args.seed_distance = 12
args.window_size = [64,64]
args.marker_radius = 2.5
args.contour_length = 14
args.paddle_thickness = 1
args.antialias_scale = 2
args.continuity = 1.8 # from 1.8 to 0.8, with steps of 66%
args.distractor_length = args.contour_length / 3
args.num_distractor_snakes = 22 / args.distractor_length
args.snake_contrast_list = [0.8]
```
"""
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=('This is a builder for pathfinder challenge dataset'),
features=tfds.features.FeaturesDict({
'image': tfds.features.Image(),
'label': tfds.features.ClassLabel(num_classes=2)
}),
supervised_keys=('image', 'label'),
homepage='',
citation="""@inproceedings{
Kim*2020Disentangling,
title={Disentangling neural mechanisms for perceptual grouping},
author={Junkyung Kim* and Drew Linsley* and Kalpit Thakkar and Thomas Serre},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://openreview.net/forum?id=HJxrVA4FDS}
}""",
)
def _split_generators(self, dl_manager):
"""Downloads the data and defines the splits."""
return [
tfds.core.SplitGenerator(
name='easy', gen_kwargs={'file_pattern': 'curv_baseline'}),
tfds.core.SplitGenerator(
name='intermediate',
gen_kwargs={'file_pattern': 'curv_contour_length_9'}),
tfds.core.SplitGenerator(
name='hard', gen_kwargs={'file_pattern': 'curv_contour_length_14'})
]
def _build_pcollection(self, pipeline, file_pattern):
"""Generate examples as dicts."""
beam = tfds.core.lazy_imports.apache_beam
def _generate_examples(file_path):
"""Read the input data out of the source files."""
example_id = 0
meta_examples = tf.io.read_file(file_path).numpy().decode('utf-8').split(
'\n')[:-1]
print(meta_examples)
for m_example in meta_examples:
m_example = m_example.split(' ')
image_path = os.path.join(ORIGINAL_DATA_DIR_64, file_pattern,
m_example[0], m_example[1])
example_id += 1
yield '_'.join([m_example[0], m_example[1],
str(example_id)]), {
'image': image_path,
'label': int(m_example[3]),
}
meta_file_pathes = tf.io.gfile.glob(
os.path.join(ORIGINAL_DATA_DIR_64, file_pattern, 'metadata/*.npy'))
print(len(meta_file_pathes))
return (pipeline
| 'Create' >> beam.Create(meta_file_pathes)
| 'Generate' >> beam.ParDo(_generate_examples))
class Pathfinder128(tfds.core.BeamBasedBuilder):
"""Pathfinder TFDS builder (where the resolution is 128).
The data for this dataset was generated using the script in
https://github.com/drewlinsley/pathfinder with the default parameters, while
followings being customized:
```
args.padding = 1
args.antialias_scale = 4
args.paddle_margin_list = [2,3]
args.seed_distance = 20
args.window_size = [128,128]
args.marker_radius = 3
args.contour_length = 14
args.paddle_thickness = 1.5
args.antialias_scale = 2
args.continuity = 1.8 # from 1.8 to 0.8, with steps of 66%
args.distractor_length = args.contour_length / 3
args.num_distractor_snakes = 35 / args.distractor_length
args.snake_contrast_list = [0.9]
```
"""
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=('This is a builder for pathfinder challenge dataset'),
features=tfds.features.FeaturesDict({
'image': tfds.features.Image(),
'label': tfds.features.ClassLabel(num_classes=2)
}),
supervised_keys=('image', 'label'),
homepage='',
citation="""@inproceedings{
Kim*2020Disentangling,
title={Disentangling neural mechanisms for perceptual grouping},
author={Junkyung Kim* and Drew Linsley* and Kalpit Thakkar and Thomas Serre},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://openreview.net/forum?id=HJxrVA4FDS}
}""",
)
def _split_generators(self, dl_manager):
"""Downloads the data and defines the splits."""
return [
tfds.core.SplitGenerator(
name='easy', gen_kwargs={'file_pattern': 'curv_baseline'}),
tfds.core.SplitGenerator(
name='intermediate',
gen_kwargs={'file_pattern': 'curv_contour_length_9'}),
tfds.core.SplitGenerator(
name='hard', gen_kwargs={'file_pattern': 'curv_contour_length_14'})
]
def _build_pcollection(self, pipeline, file_pattern):
"""Generate examples as dicts."""
beam = tfds.core.lazy_imports.apache_beam
def _generate_examples(file_path):
"""Read the input data out of the source files."""
example_id = 0
meta_examples = tf.io.read_file(
file_path).numpy().decode('utf-8').split('\n')[:-1]
print(meta_examples)
for m_example in meta_examples:
m_example = m_example.split(' ')
image_path = os.path.join(ORIGINAL_DATA_DIR_128, file_pattern,
m_example[0], m_example[1])
example_id += 1
yield '_'.join([m_example[0], m_example[1], str(example_id)]), {
'image': image_path,
'label': int(m_example[3]),
}
meta_file_pathes = tf.io.gfile.glob(
os.path.join(ORIGINAL_DATA_DIR_128, file_pattern, 'metadata/*.npy'))
print(len(meta_file_pathes))
return (
pipeline
| 'Create' >> beam.Create(meta_file_pathes)
| 'Generate' >> beam.ParDo(_generate_examples)
)
class Pathfinder256(tfds.core.BeamBasedBuilder):
"""Pathfinder TFDS builder (where the resolution is 256).
The data for this dataset was generated using the script in
https://github.com/drewlinsley/pathfinder with the default parameters, while
followings being customized:
```
args.antialias_scale = 4
args.paddle_margin_list = [3]
args.window_size = [256,256]
args.marker_radius = 5
args.contour_length = 14
args.paddle_thickness = 2
args.antialias_scale = 2
args.continuity = 1.8
args.distractor_length = args.contour_length / 3
args.num_distractor_snakes = 30 / args.distractor_length
args.snake_contrast_list = [1.0]
```
"""
VERSION = tfds.core.Version('1.0.0')
def _info(self):
return tfds.core.DatasetInfo(
builder=self,
description=('This is a builder for pathfinder challenge dataset'),
features=tfds.features.FeaturesDict({
'image': tfds.features.Image(),
'label': tfds.features.ClassLabel(num_classes=2)
}),
supervised_keys=('image', 'label'),
homepage='',
citation="""@inproceedings{
Kim*2020Disentangling,
title={Disentangling neural mechanisms for perceptual grouping},
author={Junkyung Kim* and Drew Linsley* and Kalpit Thakkar and Thomas Serre},
booktitle={International Conference on Learning Representations},
year={2020},
url={https://openreview.net/forum?id=HJxrVA4FDS}
}""",
)
def _split_generators(self, dl_manager):
"""Downloads the data and defines the splits."""
return [
tfds.core.SplitGenerator(
name='easy', gen_kwargs={'file_pattern': 'curv_baseline'}),
tfds.core.SplitGenerator(
name='intermediate',
gen_kwargs={'file_pattern': 'curv_contour_length_9'}),
tfds.core.SplitGenerator(
name='hard', gen_kwargs={'file_pattern': 'curv_contour_length_14'})
]
def _build_pcollection(self, pipeline, file_pattern):
"""Generate examples as dicts."""
beam = tfds.core.lazy_imports.apache_beam
def _generate_examples(file_path):
"""Read the input data out of the source files."""
example_id = 0
meta_examples = tf.io.read_file(file_path).numpy().decode('utf-8').split(
'\n')[:-1]
print(meta_examples)
for m_example in meta_examples:
m_example = m_example.split(' ')
image_path = os.path.join(ORIGINAL_DATA_DIR_256, file_pattern,
m_example[0], m_example[1])
example_id += 1
yield '_'.join([m_example[0], m_example[1],
str(example_id)]), {
'image': image_path,
'label': int(m_example[3]),
}
meta_file_pathes = tf.io.gfile.glob(
os.path.join(ORIGINAL_DATA_DIR_256, file_pattern, 'metadata/*.npy'))
print(len(meta_file_pathes))
return (pipeline
| 'Create' >> beam.Create(meta_file_pathes)
| 'Generate' >> beam.ParDo(_generate_examples))
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/data/pathfinder.py |
transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/data/__init__.py |
|
# Copyright 2021 Google LLC
# 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
# https://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.
"""Generators for custom listops tasks."""
import csv
import random
from absl import app
from absl import flags
import numpy as np
import tensorflow.compat.v1 as tf
flags.DEFINE_string(
'task', default='basic',
help='Name of task to create.')
flags.DEFINE_integer(
'num_train_samples', default=96000,
help=('Number of train samples.'))
flags.DEFINE_integer(
'num_valid_samples', default=2000,
help=('Number of test samples.'))
flags.DEFINE_integer(
'num_test_samples', default=2000,
help=('Number of test samples.'))
flags.DEFINE_integer(
'max_depth', default=10,
help=('maximum tree depth of training sequences.'))
flags.DEFINE_integer(
'max_args', default=10,
help=('maximum number of arguments per operator in training sequences.'))
flags.DEFINE_integer(
'max_length', default=2000,
help=('maximum length per sequence in training sequences.'))
flags.DEFINE_integer(
'min_length', default=500,
help=('minimum length per sequence in training sequences.'))
flags.DEFINE_string(
'output_dir', default='output_dir',
help='Directory to output files.')
FLAGS = flags.FLAGS
MIN = '[MIN'
MAX = '[MAX'
MED = '[MED'
FIRST = '[FIRST'
LAST = '[LAST'
SUM_MOD = '[SM'
END = ']'
OPERATORS = [MIN, MAX, MED, SUM_MOD] # , FIRST, LAST]
VALUES = range(10)
VALUE_P = 0.25
def generate_tree(depth, max_depth, max_args):
"""Generate tree-like equations.
Args:
depth: current depth of the node, int.
max_depth: maximum depth of the tree, int.
max_args: maximum number of arguments per operator, int.
Returns:
The root node of a tree structure.
"""
if depth < max_depth:
r = random.random()
else:
r = 1
if r > VALUE_P:
value = random.choice(VALUES)
return value, 1
else:
length = 2
num_values = random.randint(2, max_args)
values = []
for _ in range(num_values):
sub_t, sub_l = generate_tree(depth + 1, max_depth, max_args)
values.append(sub_t)
length += sub_l
op = random.choice(OPERATORS)
t = (op, values[0])
for value in values[1:]:
t = (t, value)
t = (t, END)
return t, length
def to_string(t, parens=True):
if isinstance(t, str):
return t
elif isinstance(t, int):
return str(t)
else:
if parens:
return '( ' + to_string(t[0]) + ' ' + to_string(t[1]) + ' )'
def to_value(t):
"""Compute the output of equation t.
Args:
t: a tree structure that represents equation t, list.
Returns:
The result of equation t, int.
"""
if not isinstance(t, tuple):
return t
l = to_value(t[0])
r = to_value(t[1])
if l in OPERATORS: # Create an unsaturated function.
return (l, [r])
elif r == END: # l must be an unsaturated function.
if l[0] == MIN:
return min(l[1])
elif l[0] == MAX:
return max(l[1])
elif l[0] == FIRST:
return l[1][0]
elif l[0] == LAST:
return l[1][-1]
elif l[0] == MED:
return int(np.median(l[1]))
elif l[0] == SUM_MOD:
return np.sum(l[1]) % 10
elif isinstance(l, tuple):
# We've hit an unsaturated function and an argument.
return (l[0], l[1] + [r])
def write_to_file(data, fp):
"""Write to file output."""
tf.logging.info(type(data))
tf.logging.info('Writing {} samples to {}'.format(len(data), fp + '.tsv'))
with tf.io.gfile.GFile(fp + '.tsv', 'w+') as f:
writer = csv.writer(f, delimiter='\t')
writer.writerow(['Source', 'Target'])
writer.writerows(data)
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
tf.logging.info('Start dataset construction')
data = set()
num_samples = FLAGS.num_train_samples \
+ FLAGS.num_test_samples + FLAGS.num_valid_samples
while len(data) < num_samples:
tree, length = generate_tree(1, FLAGS.max_depth, FLAGS.max_args)
if length > FLAGS.min_length and length < FLAGS.max_length:
data.add(tree)
if len(data) % 1000 == 0:
tf.logging.info('Processed {}'.format(len(data)))
print('Processed {}'.format(len(data)))
train = []
for example in data:
train.append([to_string(example), to_value(example)])
tf.logging.info('Finished running dataset construction')
val = train[FLAGS.num_train_samples:]
test = val[FLAGS.num_valid_samples:]
val = val[:FLAGS.num_valid_samples]
train = train[:FLAGS.num_train_samples]
tf.logging.info('Dataset size: %d/%d/%d' % (len(train), len(val), len(test)))
write_to_file(train, FLAGS.output_dir + '/{}_train'.format(FLAGS.task))
write_to_file(val, FLAGS.output_dir + '/{}_val'.format(FLAGS.task))
write_to_file(test, FLAGS.output_dir + '/{}_test'.format(FLAGS.task))
tf.logging.info('Finished writing all to file')
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/data/listops.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Input pipeline for the listops dataset."""
import numpy as np
import tensorflow.compat.v1 as tf
import tensorflow_datasets as tfds
AUTOTUNE = tf.data.experimental.AUTOTUNE
def preprocess_dataset(file_path, batch_size):
"""Preprocess dataset."""
tf.logging.info(file_path)
sel_cols = ['Source', 'Target']
col_defaults = [tf.string, tf.int32]
ds = tf.data.experimental.make_csv_dataset([file_path],
batch_size,
column_defaults=col_defaults,
select_columns=sel_cols,
field_delim='\t',
header=True,
num_epochs=1)
ds = ds.unbatch()
return ds
def get_datasets(n_devices,
task_name,
data_dir=None,
batch_size=256,
max_length=512):
"""Get algorithmic datasets."""
if batch_size % n_devices:
raise ValueError("Batch size %d isn't divided evenly by n_devices %d" %
(batch_size, n_devices))
train_path = data_dir + task_name + '_train.tsv'
val_path = data_dir + task_name + '_val.tsv'
test_path = data_dir + task_name + '_test.tsv'
train_dataset = preprocess_dataset(train_path, batch_size)
val_dataset = preprocess_dataset(val_path, batch_size)
test_dataset = preprocess_dataset(test_path, batch_size)
tf.logging.info('Finished preprocessing')
tf.logging.info('Building vocab')
# build vocab
vocab_set = set()
tokenizer = tfds.deprecated.text.Tokenizer()
for i, data in enumerate(train_dataset):
examples = data['Source']
examples = tokenizer.tokenize(examples.numpy())
examples = np.reshape(examples, (-1)).tolist()
vocab_set.update(examples)
if i % 1000 == 0:
tf.logging.info('Processed {}'.format(i))
if i > 1000:
break
vocab_set = list(set(vocab_set))
tf.logging.info('Finished processing vocab size={}'.format(len(vocab_set)))
encoder = tfds.deprecated.text.TokenTextEncoder(vocab_set)
def tf_encode(x):
result = tf.py_function(lambda s: tf.constant(encoder.encode(s.numpy())), [
x,
], tf.int32)
result.set_shape([None])
return result
def tokenize(d):
return {
'inputs': tf_encode(d['Source'])[:max_length],
'targets': d['Target']
}
train_dataset = train_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
val_dataset = val_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
test_dataset = test_dataset.map(tokenize, num_parallel_calls=AUTOTUNE)
max_shape = {'inputs': [max_length], 'targets': []}
# train_dataset = train_dataset.shuffle(
# buffer_size=1024, reshuffle_each_iteration=True).padded_batch(
# batch_size, padded_shapes=max_shape)
train_dataset = train_dataset.padded_batch(batch_size, padded_shapes=max_shape)
val_dataset = val_dataset.padded_batch(batch_size, padded_shapes=max_shape)
test_dataset = test_dataset.padded_batch(batch_size, padded_shapes=max_shape)
train_dataset = train_dataset.prefetch(tf.data.experimental.AUTOTUNE)
val_dataset = val_dataset.prefetch(tf.data.experimental.AUTOTUNE)
test_dataset = test_dataset.prefetch(tf.data.experimental.AUTOTUNE)
return train_dataset, val_dataset, test_dataset, encoder
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/listops/input_pipeline.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Main training script for the listops task."""
import functools
import itertools
import json
import os
import time
from absl import app
from absl import flags
from absl import logging
from flax import jax_utils
from flax import nn
from flax import optim
from flax.metrics import tensorboard
from flax.training import checkpoints
from flax.training import common_utils
import jax
from jax import random
import jax.nn
import jax.numpy as jnp
from lra_benchmarks.listops import input_pipeline
from lra_benchmarks.models.transformer import transformer
from lra_benchmarks.utils import train_utils
from ml_collections import config_flags
import numpy as np
import tensorflow.compat.v2 as tf
FLAGS = flags.FLAGS
config_flags.DEFINE_config_file(
'config', None, 'Training configuration.', lock_config=True)
flags.DEFINE_string(
'model_dir', default=None, help='Directory to store model data.')
flags.DEFINE_string(
'task_name',
default='basic',
help='Name of the task used for load training/test data.')
flags.DEFINE_string(
'data_dir', default=None, help='Directory containing datasets.')
flags.DEFINE_bool(
'test_only', default=False, help='Run the evaluation on the test data.')
def create_model(key, flax_module, input_shape, model_kwargs):
"""Creates and initializes the model."""
@functools.partial(jax.jit, backend='cpu')
def _create_model(key):
module = flax_module.partial(**model_kwargs)
with nn.stochastic(key):
_, initial_params = module.init_by_shape(key,
[(input_shape, jnp.float32)])
model = nn.Model(module, initial_params)
return model
return _create_model(key)
def create_optimizer(model, learning_rate):
optimizer_def = optim.Adam(
learning_rate,
beta1=0.9,
beta2=0.98,
eps=1e-9,
weight_decay=FLAGS.config.weight_decay)
optimizer = optimizer_def.create(model)
return optimizer
def compute_metrics(logits, labels, weights):
"""Compute summary metrics."""
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, labels, num_classes=10, weights=weights)
acc, _ = train_utils.compute_weighted_accuracy(logits, labels, weights)
metrics = {
'loss': loss,
'accuracy': acc,
'denominator': weight_sum,
}
metrics = jax.lax.psum(metrics, 'batch')
return metrics
def train_step(optimizer, batch, learning_rate_fn, dropout_rng=None):
"""Perform a single training step."""
train_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in train_keys]
# We handle PRNG splitting inside the top pmap, rather
# than handling it outside in the training loop - doing the
# latter can add some stalls to the devices.
dropout_rng, new_dropout_rng = random.split(dropout_rng)
def loss_fn(model):
"""Loss function used for training."""
with nn.stochastic(dropout_rng):
logits = model(inputs, train=True)
loss, weight_sum = train_utils.compute_weighted_cross_entropy(
logits, targets, num_classes=10, weights=None)
mean_loss = loss / weight_sum
return mean_loss, logits
step = optimizer.state.step
lr = learning_rate_fn(step)
grad_fn = jax.value_and_grad(loss_fn, has_aux=True)
(_, logits), grad = grad_fn(optimizer.target)
grad = jax.lax.pmean(grad, 'batch')
new_optimizer = optimizer.apply_gradient(grad, learning_rate=lr)
metrics = compute_metrics(logits, targets, None)
metrics['learning_rate'] = lr
return new_optimizer, metrics, new_dropout_rng
def eval_step(model, batch):
eval_keys = ['inputs', 'targets']
(inputs, targets) = [batch.get(k, None) for k in eval_keys]
logits = model(inputs, train=False)
return compute_metrics(logits, targets, None)
def tohost(x):
"""Collect batches from all devices to host and flatten batch dimensions."""
n_device, n_batch, *remaining_dims = x.shape
return np.array(x).reshape((n_device * n_batch,) + tuple(remaining_dims))
def main(argv):
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
tf.enable_v2_behavior()
config = FLAGS.config
logging.info('===========Config Dict============')
logging.info(config)
batch_size = config.batch_size
learning_rate = config.learning_rate
num_train_steps = config.num_train_steps
num_eval_steps = config.num_eval_steps
eval_freq = config.eval_frequency
random_seed = config.random_seed
model_type = config.model_type
model_kwargs = (
config.model_kwargs.to_dict() if 'model_kwargs' in config else {})
if jax.host_id() == 0:
summary_writer = tensorboard.SummaryWriter(
os.path.join(FLAGS.model_dir, 'summary'))
if batch_size % jax.device_count() > 0:
raise ValueError('Batch size must be divisible by the number of devices')
train_ds, eval_ds, test_ds, encoder = input_pipeline.get_datasets(
n_devices=jax.local_device_count(),
task_name=FLAGS.task_name,
data_dir=FLAGS.data_dir,
batch_size=batch_size,
max_length=config.max_length)
vocab_size = encoder.vocab_size
train_ds = train_ds.repeat()
train_iter = iter(train_ds)
max_length = config.max_length
input_shape = (batch_size, max_length)
model_kwargs.update({
'vocab_size': vocab_size,
'emb_dim': config.emb_dim,
'num_heads': config.num_heads,
'num_layers': config.num_layers,
'qkv_dim': config.qkv_dim,
'mlp_dim': config.mlp_dim,
'max_len': config.max_length,
'classifier': True,
'num_classes': 10
})
rng = random.PRNGKey(random_seed)
rng = jax.random.fold_in(rng, jax.host_id())
rng, init_rng = random.split(rng)
# We init the first set of dropout PRNG keys, but update it afterwards inside
# the main pmap'd training update for performance.
dropout_rngs = random.split(rng, jax.local_device_count())
if model_type == 'transformer':
model = create_model(init_rng, transformer.TransformerEncoder, input_shape,
model_kwargs)
else:
raise ValueError('Model type not supported')
optimizer = create_optimizer(model, learning_rate)
del model # Don't keep a copy of the initial model.
start_step = 0
if config.restore_checkpoints or FLAGS.test_only:
# Restore unreplicated optimizer + model state from last checkpoint.
optimizer = checkpoints.restore_checkpoint(FLAGS.model_dir, optimizer)
# Grab last step.
start_step = int(optimizer.state.step)
# Replicate optimizer.
optimizer = jax_utils.replicate(optimizer)
learning_rate_fn = train_utils.create_learning_rate_scheduler(
base_learning_rate=learning_rate)
p_train_step = jax.pmap(
functools.partial(train_step, learning_rate_fn=learning_rate_fn),
axis_name='batch')
p_eval_step = jax.pmap(eval_step, axis_name='batch')
# p_pred_step = jax.pmap(predict_step, axis_name='batch')
def run_eval(eval_ds, num_eval_steps=-1):
eval_metrics = []
eval_iter = iter(eval_ds)
if num_eval_steps == -1:
num_iter = itertools.count()
else:
num_iter = range(num_eval_steps)
for _, eval_batch in zip(num_iter, eval_iter):
# pylint: disable=protected-access
eval_batch = common_utils.shard(
jax.tree_map(lambda x: x._numpy(), eval_batch))
# pylint: enable=protected-access
metrics = p_eval_step(optimizer.target, eval_batch)
eval_metrics.append(metrics)
eval_metrics = common_utils.get_metrics(eval_metrics)
eval_metrics_sums = jax.tree_map(jnp.sum, eval_metrics)
eval_denominator = eval_metrics_sums.pop('denominator')
eval_summary = jax.tree_map(
lambda x: x / eval_denominator, # pylint: disable=cell-var-from-loop
eval_metrics_sums)
# Calculate (clipped) perplexity after averaging log-perplexities:
eval_summary['perplexity'] = jnp.clip(
jnp.exp(eval_summary['loss']), a_max=1.0e4)
return eval_summary
if FLAGS.test_only:
with tf.io.gfile.GFile(os.path.join(FLAGS.model_dir, 'results.json'),
'w') as f:
test_summary = run_eval(test_ds)
json.dump(jax.tree_map(lambda x: x.tolist(), test_summary), f)
return
metrics_all = []
tick = time.time()
for step, batch in zip(range(start_step, num_train_steps), train_iter):
batch = common_utils.shard(jax.tree_map(lambda x: x._numpy(), batch)) # pylint: disable=protected-access
optimizer, metrics, dropout_rngs = p_train_step(
optimizer, batch, dropout_rng=dropout_rngs)
metrics_all.append(metrics)
logging.info('train in step: %d', step)
# Save a Checkpoint
if ((step % config.checkpoint_freq == 0 and step > 0) or
step == num_train_steps - 1):
if jax.host_id() == 0 and config.save_checkpoints:
# Save unreplicated optimizer + model state.
checkpoints.save_checkpoint(FLAGS.model_dir,
jax_utils.unreplicate(optimizer), step)
# Periodic metric handling.
if step % eval_freq == 0 and step > 0:
metrics_all = common_utils.get_metrics(metrics_all)
lr = metrics_all.pop('learning_rate').mean()
metrics_sums = jax.tree_map(jnp.sum, metrics_all)
denominator = metrics_sums.pop('denominator')
summary = jax.tree_map(lambda x: x / denominator, metrics_sums) # pylint: disable=cell-var-from-loop
summary['learning_rate'] = lr
# Calculate (clipped) perplexity after averaging log-perplexities:
summary['perplexity'] = jnp.clip(jnp.exp(summary['loss']), a_max=1.0e4)
logging.info('train in step: %d, loss: %.4f', step, summary['loss'])
if jax.host_id() == 0:
tock = time.time()
steps_per_sec = eval_freq / (tock - tick)
tick = tock
summary_writer.scalar('steps per second', steps_per_sec, step)
for key, val in summary.items():
summary_writer.scalar(f'train_{key}', val, step)
summary_writer.flush()
# Reset metric accumulation for next evaluation cycle.
metrics_all = []
# Eval Metrics
eval_summary = run_eval(eval_ds, num_eval_steps)
logging.info('eval in step: %d, loss: %.4f, acc: %.4f', step,
eval_summary['loss'], eval_summary['accuracy'])
if jax.host_id() == 0:
for key, val in eval_summary.items():
summary_writer.scalar(f'eval_{key}', val, step)
summary_writer.flush()
if __name__ == '__main__':
app.run(main)
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/listops/train.py |
# Copyright 2021 Google LLC
# 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
# https://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 Configuration."""
import ml_collections
def get_config():
"""Get the default hyperparameter configuration."""
config = ml_collections.ConfigDict()
config.batch_size = 32
config.eval_frequency = 20
config.num_train_steps = 5000
config.num_eval_steps = 20
config.learning_rate = 0.05
config.weight_decay = 1e-1
config.max_target_length = 200 # ignored
config.max_eval_target_length = 200 # ignored
config.sampling_temperature = 0.6
config.sampling_top_k = 20
config.max_predict_token_length = 50
config.save_checkpoints = True
config.restore_checkpoints = True
config.checkpoint_freq = 10000
config.random_seed = 0
config.prompt = ""
config.factors = "constant * linear_warmup * rsqrt_decay"
config.warmup = 1000
config.max_length = 2000
config.tied_weights = True
config.pooling_mode = "CLS"
# config.interaction = "NLI"
config.emb_dim = 512
config.num_heads = 8
config.num_layers = 6
config.qkv_dim = 512
config.mlp_dim = 2048
config.trial = 0 # dummy for repeated runs.
return config
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/listops/configs/base_listops_config.py |
# Copyright 2021 Google LLC
# 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
# https://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.
"""Configuration and hyperparameter sweeps."""
from lra_benchmarks.listops.configs import base_listops_config
def get_config():
"""Get the default hyperparameter configuration."""
config = base_listops_config.get_config()
config.model_type = "transformer"
return config
def get_hyper(hyper):
return hyper.product([])
| transformer-ls-master | lra/datasets/long-range-arena/lra_benchmarks/listops/configs/transformer_base.py |
from .model_wrapper import *
from .truncated_bptt_lm_task import *
from .loss import * | transformer-ls-master | autoregressive/model_lib/__init__.py |
# Copyright (c) Facebook, Inc. and its affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from fairseq.modules.layer_norm import LayerNorm
from fairseq.modules.gelu import gelu
from .layer import ChunkedLSAttention
class PositionalEmbedding(nn.Module):
def __init__(self, demb):
super().__init__()
self.demb = demb
inv_freq = 1 / (10000 ** (torch.arange(0.0, demb, 2.0) / demb))
self.register_buffer("inv_freq", inv_freq)
def forward(self, pos_seq, bsz=None):
sinusoid_inp = torch.ger(pos_seq, self.inv_freq)
pos_emb = torch.cat([sinusoid_inp.sin(), sinusoid_inp.cos()], dim=-1)
if bsz is not None:
return pos_emb[None, :, :].expand(bsz, -1, -1)
else:
return pos_emb[None, :, :]
class FeedForwardLayer(nn.Module):
def __init__(self, d_model, d_inner, dropout, use_gelu):
nn.Module.__init__(self)
self.fc1 = nn.Linear(d_model, d_inner)
self.fc2 = nn.Linear(d_inner, d_model)
nn.init.xavier_uniform_(self.fc1.weight)
nn.init.xavier_uniform_(self.fc2.weight)
self.dropout = nn.Dropout(dropout)
self.use_gelu = use_gelu
def forward(self, h):
if self.use_gelu:
h1 = gelu(self.fc1(h))
else:
h1 = F.relu(self.fc1(h))
h1 = self.dropout(h1)
h2 = self.fc2(h1)
h2 = self.dropout(h2)
return h2
class TransformerLSLayer(nn.Module):
def __init__(self, d_model, d_inner, n_head, chunk_size, chunk_rank, window_len,
dropout, grad_chk, use_bias, pre_ln, use_gelu, probing):
nn.Module.__init__(self)
self.pre_ln = pre_ln
self.attn = ChunkedLSAttention(
d_model=d_model, n_head=n_head,
chunk_size=chunk_size, chunk_rank=chunk_rank, window_len=window_len,
dropout=dropout, grad_chk=grad_chk, use_bias=use_bias, probing=probing)
self.norm1 = LayerNorm(d_model, export=probing)
self.ff = FeedForwardLayer(d_model=d_model, d_inner=d_inner, dropout=dropout, use_gelu=use_gelu)
self.norm2 = LayerNorm(d_model, export=probing)
def forward(self, h, h_cache, key_pe, pos_embed_window, attn_mask=None, chunk_attn_mask=None):
# h = B x M x H
# h_cache = B x L x H
if self.pre_ln:
h = self.norm1(h)
h_cache = self.norm1(h_cache)
attn_out = self.attn(h, h_cache, key_pe, pos_embed_window, chunk_attn_mask)
if self.pre_ln:
h = h + attn_out
else:
h = self.norm1(h + attn_out) # B x M x H
if self.ff is not None:
if self.pre_ln:
h = self.norm2(h)
ff_out = self.ff(h)
if self.pre_ln:
out = h + ff_out # B x M x H
else:
out = self.norm2(h + ff_out) # B x M x H
else:
out = h
return out
class TransformerLSModel(nn.Module):
def __init__(
self,
vocab_size,
d_model,
d_inner,
n_head,
n_layer,
mem_len,
emb_dropout,
chunk_rank,
chunk_size,
window_len,
dropout,
use_bias,
pre_ln,
use_gelu,
grad_chk,
clamp_len,
cpos_clamp_len=-1,
probing=False,
):
nn.Module.__init__(self)
# token embeddings
self.in_emb = nn.Embedding(vocab_size, d_model)
nn.init.normal_(self.in_emb.weight, mean=0, std=d_model ** -0.5)
self.pos_emb = PositionalEmbedding(d_model)
# nn.init.uniform_(self.in_emb.weight, -0.01, 0.01)
self.out_emb = nn.Linear(d_model, vocab_size)
self.out_emb.weight = self.in_emb.weight
self.window_len = window_len
# Some knobs copied from Transformer XL
self.init = 'normal'
self.init_range = 0.01
self.proj_init_std = 0.01
self.init_std = 0.02
self.cpos_clamp_len = cpos_clamp_len
self.d_model = d_model
if emb_dropout > 0:
self.emb_dropout = nn.Dropout(emb_dropout)
else:
self.emb_dropout = None
self.chunk_size = chunk_size
self.chunk_rank = chunk_rank
self.layers = nn.ModuleList()
self.layers.extend(
TransformerLSLayer(
d_model=d_model,
d_inner=d_inner,
n_head=n_head,
chunk_rank=chunk_rank,
chunk_size=chunk_size,
window_len=window_len,
dropout=dropout,
use_bias=use_bias,
pre_ln=pre_ln,
use_gelu=use_gelu,
grad_chk=grad_chk,
probing=probing,
)
for _ in range(n_layer)
)
self.mem_len = mem_len
self.clamp_len = clamp_len
self.apply(self._init_weights)
def forward(self, x, h_cache, target=None):
# x size = B x M
padded = False
if self.chunk_size > 0 and (x.shape[1] % self.chunk_size ):
# or x.shape[1] % self.window_len
# usually happens at the end
# ad-hoc solution for the chunking issue during evaluation
orig_seqlen = x.shape[1]
pad_multip = abs(self.chunk_size * self.window_len) // math.gcd(self.chunk_size, self.window_len)
n_pad = pad_multip - x.shape[1] % pad_multip
x = F.pad(x, (0, n_pad))
padded = True
block_size = x.size(1)
h = self.in_emb(x) #.mul_(self.d_model ** 0.5) # B x M x H
h.mul_(self.d_model ** 0.5)
mlen = h_cache[0].shape[1]
klen = h.shape[1] + mlen
dec_attn_mask = None
pos_seq = torch.arange(self.window_len - 1, -1, -1.0, device=h.device, dtype=h.dtype)
n_chunk_vecs = klen // self.chunk_size * self.chunk_rank
n_chunks = klen // self.chunk_size
n_mem_chunks = mlen // self.chunk_size
chunk_attn_mask = torch.triu(h.new_ones((x.shape[1]//self.chunk_size, n_chunks), dtype=torch.bool), diagonal=n_mem_chunks)[
None, None, :, None, :, None]
chunk_attn_mask = chunk_attn_mask.expand(-1, -1, -1, -1, -1, self.chunk_rank).contiguous().view(1, 1, -1, 1, n_chunks*self.chunk_rank)
pos_chunk_ids = torch.arange(n_chunk_vecs - 1, -1, -1.0, device=h.device, dtype=h.dtype)
if self.cpos_clamp_len > 0:
pos_chunk_ids.clamp_(max=self.cpos_clamp_len)
pos_chunks = self.pos_emb(pos_chunk_ids)
if self.clamp_len > 0:
pos_seq.clamp_(max=self.clamp_len)
pos_emb = self.pos_emb(pos_seq)
if self.emb_dropout is not None:
h = self.emb_dropout(h)
pos_emb = self.emb_dropout(pos_emb)
h_cache_next = []
for l, layer in enumerate(self.layers):
cache_size = self.mem_len
if cache_size > block_size:
h_cache_next_l = torch.cat(
[h_cache[l][:, -cache_size + block_size :, :], h], dim=1
).detach()
else:
h_cache_next_l = h[:, -cache_size:, :].detach()
h_cache_next.append(h_cache_next_l)
h = layer(h, h_cache[l], pos_chunks, pos_emb, dec_attn_mask, chunk_attn_mask) # B x M x H
if self.emb_dropout is not None:
h = self.emb_dropout(h)
out = F.log_softmax(self.out_emb(h).float(), dim=-1).type_as(h)
dummy_loss = None
if padded:
out = out[:, :orig_seqlen]
return out, h_cache_next, dummy_loss
def get_aux_loss(self):
loss = 0.0
for layer in self.layers:
loss += layer.attn.attn.adaptive_span.get_loss()
return self.aux_loss_scaler * loss
def get_current_max_span(self):
max_span = 0.0
for layer in self.layers:
max_span = max(
max_span, layer.attn.attn.adaptive_span.get_current_max_span()
)
return max_span
def get_current_avg_span(self):
avg_span = 0.0
for layer in self.layers:
avg_span += layer.attn.attn.adaptive_span.get_current_avg_span()
return avg_span / len(self.layers)
def _init_weight(self, weight):
if self.init == "uniform":
nn.init.uniform_(weight, -self.init_range, self.init_range)
elif self.init == "normal":
nn.init.normal_(weight, 0.0, self.init_std)
def _init_bias(self, bias):
nn.init.constant_(bias, 0.0)
def _init_weights(self, m):
"""Initialize the weights."""
classname = m.__class__.__name__
if classname.find("Linear") != -1:
if hasattr(m, "weight") and m.weight is not None:
self._init_weight(m.weight)
if hasattr(m, "bias") and m.bias is not None:
self._init_bias(m.bias)
elif classname.find("Embedding") != -1:
if hasattr(m, "weight"):
self._init_weight(m.weight)
elif classname.find("LayerNorm") != -1:
if hasattr(m, "weight"):
nn.init.normal_(m.weight, 1.0, self.init_std)
if hasattr(m, "bias") and m.bias is not None:
self._init_bias(m.bias)
else:
hit = False
if hasattr(m, "r_emb"):
self._init_weight(m.r_emb)
hit = True
if hasattr(m, "r_w_bias"):
self._init_weight(m.r_w_bias)
hit = True
if hasattr(m, "r_r_bias"):
self._init_weight(m.r_r_bias)
hit = True
if hasattr(m, "r_bias"):
self._init_bias(m.r_bias)
hit = True
if not hit:
print("Missing {}".format(classname))
| transformer-ls-master | autoregressive/model_lib/model.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
from dataclasses import dataclass
from typing import Dict, List, Optional
import torch
from fairseq.dataclass import FairseqDataclass
from fairseq.models import (
FairseqIncrementalDecoder,
FairseqLanguageModel,
register_model,
)
from .model import TransformerLSModel
logger = logging.getLogger(__name__)
@dataclass
class TransformerLSConfig(FairseqDataclass):
# defaults come from https://github.com/facebookresearch/adaptive-span/blob/master/experiments/enwik8_small.sh
vocab_size: int = 50
d_model: int = 256
n_head: int = 4
d_inner: int = 1024
n_layer: int = 8
dropout: float = 0.0
emb_dropout: float = 0.0
chunk_rank: int = 1
chunk_size: int = 32
mem_len: int = 4096
window_len: int = 256
grad_chk: bool = False
pre_ln: bool = False
use_gelu: bool = False
use_bias: bool = False
clamp_len: int = -1
cpos_clamp_len: int = -1
probing: bool = False
@register_model("transformer-ls", dataclass=TransformerLSConfig)
class TransformerLS(FairseqLanguageModel):
@classmethod
def build_model(cls, cfg: TransformerLSConfig, task):
return cls(TransformerLSDecoder(cfg, task))
def get_aux_loss(self):
return self.decoder.get_aux_loss()
def get_current_max_span(self):
return self.decoder.get_current_max_span()
def get_current_avg_span(self):
return self.decoder.get_current_avg_span()
class TransformerLSDecoder(FairseqIncrementalDecoder):
def __init__(self, cfg, task):
super().__init__(task.target_dictionary)
self.config = cfg
config = TransformerLSConfig(
vocab_size=len(task.target_dictionary),
d_model=cfg.d_model,
n_head=cfg.n_head,
d_inner=cfg.d_inner,
n_layer=cfg.n_layer,
dropout=cfg.dropout,
emb_dropout=cfg.emb_dropout,
mem_len=cfg.mem_len,
chunk_rank=cfg.chunk_rank,
chunk_size=cfg.chunk_size,
window_len=cfg.window_len,
grad_chk=cfg.grad_chk,
pre_ln=cfg.pre_ln,
use_gelu=cfg.use_gelu,
use_bias=cfg.use_bias,
clamp_len=cfg.clamp_len,
cpos_clamp_len=cfg.cpos_clamp_len,
probing=cfg.probing,
)
logger.info(config)
del config.__dict__['_name']
self.model = TransformerLSModel(**config.__dict__)
self.cache_size = cfg.mem_len
self._mems = None
def forward(
self,
src_tokens,
incremental_state: Optional[Dict[str, List[torch.Tensor]]] = None,
encoder_out=None,
):
bsz = src_tokens.size(0)
if incremental_state is not None: # used during inference
mems = self.get_incremental_state("mems")
src_tokens = src_tokens[:, -1:] # only keep the most recent token
else:
mems = self._mems
if mems is None:
# first time init
mems = self.init_hid_cache(bsz)
output = self.model(x=src_tokens, h_cache=mems,)
if incremental_state is not None:
self.set_incremental_state(incremental_state, "mems", output[1])
else:
self._mems = output[1]
return (output[0],)
def init_hid_cache(self, batch_sz):
hid = []
for layer in self.model.layers:
param = next(self.model.parameters())
h = torch.zeros(
batch_sz,
self.cache_size,
self.config.d_model,
dtype=param.dtype,
device=param.device,
)
hid.append(h)
return hid
def get_aux_loss(self):
return self.model.get_aux_loss()
def get_current_max_span(self):
return self.model.get_current_max_span()
def get_current_avg_span(self):
return self.model.get_current_avg_span()
def reorder_incremental_state(
self,
incremental_state: Dict[str, Dict[str, Optional[torch.Tensor]]],
new_order: torch.Tensor,
):
"""Reorder incremental state.
This will be called when the order of the input has changed from the
previous time step. A typical use case is beam search, where the input
order changes between time steps based on the selection of beams.
"""
raise NotImplementedError("This is required for generation/beam search")
# mems = self.get_incremental_state(incremental_state, "mems")
# if mems is not None:
# new_mems = [mems_i.index_select(1, new_order) for mems_i in mems]
# self.set_incremental_state(incremental_state, "mems", new_mems)
| transformer-ls-master | autoregressive/model_lib/model_wrapper.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import math
from dataclasses import dataclass
import torch.nn.functional as F
from fairseq import metrics, utils
from fairseq.criterions import register_criterion
from fairseq.criterions.cross_entropy import CrossEntropyCriterion
from fairseq.dataclass import FairseqDataclass
from omegaconf import II
import pdb
@dataclass
class AdaptiveSpanCriterionConfig(FairseqDataclass):
sentence_avg: bool = II("optimization.sentence_avg")
@register_criterion("char_level_lm_loss", dataclass=AdaptiveSpanCriterionConfig)
class AdaptiveSpanCriterion(CrossEntropyCriterion):
def __init__(self, task, sentence_avg):
super().__init__(task, sentence_avg)
def forward(self, model, sample, reduce=True):
"""Compute the loss for the given sample.
Returns a tuple with three elements:
1) the loss here is summed, different from the adaptive span code
2) the sample size, which is used as the denominator for the gradient
3) logging outputs to display while training
"""
net_output = model(**sample["net_input"])
loss = self.compute_loss(
model, net_output, sample, reduce=reduce
)
sample_size = (
sample["target"].size(0) if self.sentence_avg else sample["ntokens"]
)
loss /= sample_size
total_loss = loss
sample_size = 1
logging_output = {
"loss": loss.data,
"ntokens": sample["ntokens"],
"nsentences": sample["target"].size(0),
"sample_size": sample_size,
"total_loss": total_loss.data,
}
return total_loss, sample_size, logging_output
def compute_loss(self, model, net_output, sample, reduce=True):
loss, _ = super().compute_loss(model, net_output, sample, reduce)
return loss
@staticmethod
def reduce_metrics(logging_outputs) -> None:
"""Aggregate logging outputs from data parallel training."""
loss_sum = sum(log.get("loss", 0) for log in logging_outputs)
ntokens = sum(log.get("ntokens", 0) for log in logging_outputs)
sample_size = sum(log.get("sample_size", 0) for log in logging_outputs)
total_loss_sum = sum(log.get("total_loss", 0) for log in logging_outputs)
# we divide by log(2) to convert the loss from base e to base 2
metrics.log_scalar(
"loss", loss_sum / sample_size / math.log(2), sample_size, round=3
)
# total loss contains the L1 norm on adaptive-span
metrics.log_scalar(
"total_loss",
total_loss_sum / sample_size / math.log(2),
sample_size,
round=3,
)
if sample_size != ntokens:
metrics.log_scalar(
"nll_loss", loss_sum / ntokens / math.log(2), ntokens, round=3
)
metrics.log_derived(
"ppl", lambda meters: utils.get_perplexity(meters["nll_loss"].avg)
)
else:
metrics.log_derived(
"ppl", lambda meters: utils.get_perplexity(meters["loss"].avg)
)
@staticmethod
def logging_outputs_can_be_summed() -> bool:
"""
Whether the logging outputs returned by `forward` can be summed
across workers prior to calling `reduce_metrics`. Setting this
to True will improves distributed training speed.
"""
return True
| transformer-ls-master | autoregressive/model_lib/loss.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Forked from https://github.com/pytorch/fairseq/blob/master/examples/truncated_bptt/truncated_bptt_lm_task.py
"""
import logging
import os
from dataclasses import dataclass, field
from typing import List, Optional, Tuple
import torch
from fairseq import utils
from fairseq.data import (
Dictionary,
TokenBlockDataset,
data_utils,
iterators,
)
from fairseq.dataclass import FairseqDataclass
from fairseq.distributed import utils as dist_utils
from fairseq.tasks import FairseqTask, register_task
from omegaconf import II
logger = logging.getLogger(__name__)
@dataclass
class TruncatedBPTTLMConfig(FairseqDataclass):
data: str = field(default="???", metadata={"help": "path to data directory"})
tokens_per_sample: int = field(
default=1024,
metadata={"help": "max number of tokens per sequence"},
)
batch_size: int = II("dataset.batch_size")
# Some models use *max_target_positions* to know how many positional
# embeddings to learn. We use II(...) to make it default to
# *tokens_per_sample*, but in principle there could be more positional
# embeddings than tokens in a single batch. This may also be irrelevant for
# custom model implementations.
max_target_positions: int = II("task.tokens_per_sample")
# these will be populated automatically if not provided
data_parallel_rank: Optional[int] = None
data_parallel_size: Optional[int] = None
@register_task("truncated_bptt_lm", dataclass=TruncatedBPTTLMConfig)
class TruncatedBPTTLMTask(FairseqTask):
def __init__(self, cfg: TruncatedBPTTLMConfig):
super().__init__(cfg)
if cfg.data_parallel_rank is None or cfg.data_parallel_size is None:
if torch.distributed.is_initialized():
cfg.data_parallel_rank = dist_utils.get_data_parallel_rank()
cfg.data_parallel_size = dist_utils.get_data_parallel_world_size()
else:
cfg.data_parallel_rank = 0
cfg.data_parallel_size = 1
# load the dictionary
paths = utils.split_paths(cfg.data)
assert len(paths) > 0
self.dictionary = Dictionary.load(os.path.join(paths[0], "dict.txt"))
logger.info("dictionary: {} types".format(len(self.dictionary)))
def load_dataset(self, split, epoch=1, combine=False, **kwargs):
"""Load a given dataset split (e.g., train, valid, test)"""
# support sharded datasets
paths = utils.split_paths(self.cfg.data)
assert len(paths) > 0
data_path = paths[(epoch - 1) % len(paths)]
split_path = os.path.join(data_path, split)
# each element of *data* will be a tensorized line from the original
# text dataset, similar to ``open(split_path).readlines()``
data = data_utils.load_indexed_dataset(
split_path, self.dictionary, combine=combine
)
if data is None:
raise FileNotFoundError(
"Dataset not found: {} ({})".format(split, split_path)
)
# this is similar to ``data.view(-1).split(tokens_per_sample)``
data = TokenBlockDataset(
data,
data.sizes,
block_size=self.cfg.tokens_per_sample,
pad=None, # unused
eos=None, # unused
break_mode="none",
)
self.datasets[split] = TruncatedBPTTDataset(
data=data,
bsz_per_shard=self.cfg.batch_size,
shard_id=self.cfg.data_parallel_rank,
num_shards=self.cfg.data_parallel_size,
)
def dataset(self, split):
return self.datasets[split]
def get_batch_iterator(
self, dataset, num_workers=0, epoch=1, data_buffer_size=0, **kwargs
):
return iterators.EpochBatchIterator(
dataset=dataset,
collate_fn=self._collate_fn,
num_workers=num_workers,
epoch=epoch,
buffer_size=data_buffer_size,
# we don't use the batching functionality from EpochBatchIterator;
# instead every item in *dataset* is a whole batch
batch_sampler=[[i] for i in range(len(dataset))],
disable_shuffling=True,
)
def _collate_fn(self, items: List[List[torch.Tensor]]):
# we don't use fairseq's batching functionality, so we expect a single
# Tensor of type List[torch.Tensor]
assert len(items) == 1
# item will have shape B x T (the last batch may have length < T)
id, item = items[0]
item = data_utils.collate_tokens(item, pad_idx=self.source_dictionary.pad())
B, T = item.size()
# shift item one position over and append a padding token for the target
target = torch.nn.functional.pad(
item[:, 1:], (0, 1, 0, 0), value=self.target_dictionary.pad()
)
# fairseq expects batches to have the following structure
return {
"id": torch.tensor([id]*item.size(0)),
"net_input": {
"src_tokens": item,
},
"target": target,
"nsentences": item.size(0),
"ntokens": item.numel(),
}
def build_dataset_for_inference(
self, src_tokens: List[torch.Tensor], src_lengths: List[int], **kwargs
) -> torch.utils.data.Dataset:
eos = self.source_dictionary.eos()
dataset = TokenBlockDataset(
src_tokens,
src_lengths,
block_size=None, # ignored for "eos" break mode
pad=self.source_dictionary.pad(),
eos=eos,
break_mode="eos",
)
class Dataset(torch.utils.data.Dataset):
def __getitem__(self, i):
item = dataset[i]
if item[-1] == eos:
# remove eos to support generating with a prefix
item = item[:-1]
return (i, [item])
def __len__(self):
return len(dataset)
return Dataset()
def inference_step(
self, generator, models, sample, prefix_tokens=None, constraints=None
):
with torch.no_grad():
if constraints is not None:
raise NotImplementedError
# SequenceGenerator doesn't use *src_tokens* directly, we need to
# pass the *prefix_tokens* argument instead.
if prefix_tokens is None and sample["net_input"]["src_tokens"].nelement():
prefix_tokens = sample["net_input"]["src_tokens"]
# begin generation with the end-of-sentence token
bos_token = self.source_dictionary.eos()
return generator.generate(
models, sample, prefix_tokens=prefix_tokens, bos_token=bos_token
)
def eval_lm_dataloader(
self,
dataset,
max_tokens: Optional[int] = 36000,
batch_size: Optional[int] = None,
max_positions: Optional[int] = None,
num_shards: int = 1,
shard_id: int = 0,
num_workers: int = 1,
data_buffer_size: int = 10,
context_window: int = 0,
):
if context_window > 0:
raise NotImplementedError(
"Transformer-XL doesn't need --context-window, try "
"--model-overrides '{\"mem_len\":42}' instead "
)
return self.get_batch_iterator(
dataset=dataset,
max_tokens=max_tokens,
max_sentences=batch_size,
max_positions=max_positions,
ignore_invalid_inputs=True,
num_shards=num_shards,
shard_id=shard_id,
num_workers=num_workers,
data_buffer_size=data_buffer_size,
).next_epoch_itr(shuffle=False)
@property
def source_dictionary(self):
return self.dictionary
@property
def target_dictionary(self):
return self.dictionary
class TruncatedBPTTDataset(torch.utils.data.Dataset):
def __init__(
self,
data: List[torch.Tensor], # ordered list of items
bsz_per_shard, # number of items processed per GPUs per forward
shard_id, # current GPU ID
num_shards, # number of GPUs
):
super().__init__()
self.data = data
def batchify(data, bsz):
# Work out how cleanly we can divide the dataset into bsz parts.
nbatch = data.size(0) // bsz
# Trim off any extra elements that wouldn't cleanly fit (remainders).
data = data.narrow(0, 0, nbatch * bsz)
# Evenly divide the data across the bsz batches.
data = data.view(bsz, -1).contiguous()
return data
# total number of sequences processed by all GPUs in each forward pass
global_batch_size = bsz_per_shard * num_shards
"""
With a 16 item dataset, bsz_per_shard=2 and num_shards=3,
*indices* might look like:
indices = [[0, 1],
[2, 3],
[4, 5],
[6, 7],
[8, 9],
[10, 11]]
The size of the TruncatedBPTTDataset instance will be 2,
and shard 1 will see items:
[(0, [data[4], data[6]]),
(1, [data[5], data[7]])]
"""
indices = batchify(torch.arange(len(data)), global_batch_size)
assert indices.size(0) == global_batch_size
self.my_indices = indices[
shard_id * bsz_per_shard : (shard_id + 1) * bsz_per_shard
]
assert self.my_indices.size(0) == bsz_per_shard
def __len__(self):
return self.my_indices.size(1)
def __getitem__(self, i) -> Tuple[int, List[torch.Tensor]]:
return (i, [self.data[idx] for idx in self.my_indices[:, i]])
| transformer-ls-master | autoregressive/model_lib/truncated_bptt_lm_task.py |
# Copyright (c) 2021 NVIDIA CORPORATION. Licensed under the MIT license.
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.checkpoint as cp
from fairseq.modules.layer_norm import LayerNorm
import pdb
class ChunkedLSAttention(nn.Module):
def __init__(self, d_model, n_head, chunk_size, chunk_rank, window_len, dropout,
grad_chk=False, use_bias=False, dp_attn=0,
probing=False):
nn.Module.__init__(self)
self.dropout = nn.Dropout(dropout)
self.dp_attn = nn.Dropout(dp_attn)
assert d_model % n_head == 0
assert chunk_size > 0
self.n_head = n_head
self.head_dim = d_model // n_head
self.window_len = window_len
self.chunk_rank = chunk_rank
self.chunk_size = chunk_size
self.n_head = n_head
self.d_h = d_model // n_head
self.d_model = d_model
self.dconv_1 = nn.Linear(d_model, n_head * chunk_rank)
self.r_net = nn.Linear(d_model, d_model, bias=False)
self.r_net_chunk = nn.Linear(d_model, d_model)
self.d_head = d_model // self.n_head
# Positional bias as in Transformer-XL.
self.r_r_bias = nn.Parameter(torch.FloatTensor(1, self.n_head, 1, self.d_head))
self.r_w_bias = nn.Parameter(torch.FloatTensor(1, self.n_head, 1, 1, self.d_head))
self.grad_chk = grad_chk
self.proj_query = nn.Linear(d_model, d_model, bias=use_bias)
nn.init.xavier_normal_(self.proj_query.weight)
self.proj_out = nn.Linear(d_model, d_model, bias=use_bias)
nn.init.xavier_normal_(self.proj_out.weight)
self.proj_val = nn.Linear(d_model, d_model, bias=use_bias)
nn.init.xavier_normal_(self.proj_val.weight)
self.proj_key = nn.Linear(d_model, d_model, bias=use_bias)
nn.init.xavier_normal_(self.proj_key.weight)
self.dual_ln_dproj = LayerNorm(d_model, export=probing)
self.dual_ln_win = LayerNorm(d_model, export=probing)
nn.init.zeros_(self.r_r_bias)
nn.init.zeros_(self.r_w_bias)
if use_bias:
nn.init.zeros_(self.proj_query.bias)
nn.init.zeros_(self.proj_out.bias)
nn.init.zeros_(self.proj_val.bias)
nn.init.zeros_(self.proj_key.bias)
def head_reshape(self, x):
K = self.n_head
D = self.head_dim
x = x.view(x.size()[:-1] + (K, D)) # B x (M+L) x K x D
x = x.transpose(1, 2).contiguous() # B x K x (M+L) x D
return x
def compute_scores(self, h_vecs):
# h_vecs: B x L x H
bsz = h_vecs.shape[0]
n_chunks = h_vecs.shape[1] // self.chunk_size
h_scores = self.dconv_1(h_vecs).view(bsz, n_chunks, self.chunk_size, self.n_head, self.chunk_rank)
# bsz x num_heads x n_chunks x chunk_rank x chunk_size
h_scores = h_scores.permute(0, 3, 1, 4, 2)
h_scores = F.softmax(h_scores.float(), dim=-1).type_as(h_scores)
return h_scores
def compress_chunks(self, h_vecs, h_scores):
# Reshape hvecs to be compatible with the weights
# h_vecs: B x L x H
bsz = h_vecs.shape[0]
n_chunks = h_vecs.shape[1] // self.chunk_size
# bsz x n_heads x n_chunks x chunk_size x d_h
h_vecs = h_vecs.view(-1, n_chunks, self.chunk_size, self.n_head, self.d_h).permute(0, 3, 1, 2, 4)
# bsz x n_heads x n_chunks x chunk_rank x d_h
h_vecs = h_scores.matmul(h_vecs).view(bsz, self.n_head, n_chunks * self.chunk_rank, self.d_h)
return h_vecs
def get_tiles(self, x, n_queries, transpose=False):
# input: bsz x win_bp_len x d
bsz, win_bp_len, d = x.shape
in_strides = x.stride()
out_strides = (in_strides[0], self.window_len*in_strides[1], in_strides[1], d//self.n_head, 1)
out_shape = (bsz, n_queries//self.window_len, 2*self.window_len, self.n_head, d//self.n_head)
x = x.as_strided(size=out_shape, stride=out_strides)
if transpose:
# shape: bsz x n_heads x n_queries//wlen x d//n_heads x 2*wlen
return x.permute(0, 3, 1, 4, 2)
else:
# shape: bsz x n_heads x n_queries//wlen x 2*wlen x d//n_heads
return x.permute(0, 3, 1, 2, 4)
def put_tiles(self, x):
# input: bsz x n_heads x bp_len x self.window_len
bsz, n_heads, bp_len, window_len = x.shape
if bp_len > window_len:
x = x.view(bsz, n_heads, bp_len//window_len, window_len, window_len)
out_size = (bsz, n_heads, bp_len//window_len, window_len, 2*window_len)
x = F.pad(x, (1, window_len))
else:
x = x.view(bsz, n_heads, 1, bp_len, window_len)
out_size = (bsz, n_heads, 1, bp_len, window_len + bp_len)
x = F.pad(x, (1, bp_len))
stride = x.stride()
out_stride = (stride[0], stride[1], stride[2], stride[3]-1, stride[4])
return x.as_strided(size=out_size, stride=out_stride)
def compute_pv(self, attn, val):
# attn: bsz x n_head x seqlen//wlen x wlen x 2*wlen
# val: bsz x n_head x seqlen//wlen x 2*wlen x d_h
bsz, n_head, chunks, wlen, _ = attn.shape
out = attn.matmul(val)
return out.view(bsz, n_head, int(chunks*wlen), -1)
def get_diagonals(self, attn):
# attn: bsz x n_heads x bp_len//self.window_len x self.window_len x 2*self.window_len
# takes the upper diagonal with length self.window_len from attn, ignoring the diagonal
bsz, n_heads, n_tiles, n_query, _ = attn.shape
out_size = (bsz, n_heads, n_tiles, n_query, self.window_len)
in_stride = attn.stride()
out_stride = (in_stride[0], in_stride[1], in_stride[2], in_stride[3]+1, 1)
return attn.as_strided(size=out_size, stride=out_stride, storage_offset=1).contiguous().view(
bsz, n_heads, -1, self.window_len)
def _rel_shift_chunked(self, x, chunk_size, chunk_rank):
# x: bsz x n_head x n_query x (n_chunks * chunk_rank)
# out: same size but shifted to the left, relative position encoding
bsz, n_head, n_query, n_c_vecs = x.shape
n_q_chunks = n_query // chunk_size
x = x.view(bsz, n_head, n_q_chunks, chunk_size, n_c_vecs).transpose(2, 3).contiguous()
x = F.pad(x, [0, chunk_rank])
p_stride = x.stride()
out_shape = list(x.shape)
out_shape[-1] -= chunk_rank
out_strides = (p_stride[0], p_stride[1], p_stride[2], p_stride[3]-chunk_rank, p_stride[4])
x = x.as_strided(size=out_shape, stride=out_strides, storage_offset=n_q_chunks*chunk_rank)
return x.transpose(2, 3).contiguous().view(bsz, n_head, n_query, n_c_vecs)
def attn(self, query, key_window, val_window, key_compressed, value_compressed,
pos_embed_chunks, pos_embed_window, chunk_attn_mask=None):
# query size = bsz x n_heads x M x H
# key, value sizes = bsz x (seq_len + cache_len) x (n_heads * H)
# key_compressed: bsz x n_heads x (M+L)//chunk_size*chunk_rank x H
bsz, n_heads, seq_len, d_h = query.shape
assert (self.window_len > 0 or self.chunk_size > 1)
query = query / math.sqrt(self.d_model // self.n_head)
# get the keys, values for the local window attention
if seq_len > self.window_len:
query_tile = query.view(bsz, n_heads, seq_len // self.window_len, self.window_len, d_h)
key_window = self.get_tiles(key_window, seq_len, transpose=True)
val_window = self.get_tiles(val_window, seq_len,
transpose=False) # bsz x n_heads x n_queries//wlen x 2*wlen x d//n_heads
else:
query_tile = query.view(bsz, n_heads, 1, seq_len, d_h)
key_window = key_window.view(bsz, -1, self.n_head, d_h).permute(0, 2, 3, 1)[:, :, None, :, :]
val_window = val_window.view(bsz, -1, self.n_head, d_h).permute(0, 2, 1, 3)[:, :, None, :, :]
# bsz x n_heads x bp_len//self.window_len x self.window_len x 2*self.window_len
attn_window = (query_tile+self.r_w_bias).matmul(key_window)
attn_window = self.get_diagonals(attn_window)
pos_trans = self.r_net(pos_embed_window).view(1, self.window_len, self.n_head, self.d_head).permute(0, 2, 3, 1)
attn_window_pos = (query+self.r_r_bias).matmul(pos_trans)
attn_window = attn_window + attn_window_pos
# Compute the long-range attention.
n_chunks = key_compressed.shape[2]
# compute attention from context
# bsz x n_heads x seq_len x (n_chunks*chunk_rank)
attn_cont = torch.matmul(query, key_compressed.transpose(-1, -2))
pos_chunks = self.r_net_chunk(pos_embed_chunks).view(1, n_chunks, self.n_head, self.d_head).permute(0, 2, 3, 1)
attn_pos = torch.matmul(query, pos_chunks) # B x H x M x L_pos
attn_pos = self._rel_shift_chunked(attn_pos, self.chunk_size, self.chunk_rank)
attn_compress = attn_cont + attn_pos
if chunk_attn_mask is not None:
attn_compress = attn_compress.view(
bsz, n_heads, seq_len//self.chunk_size, self.chunk_size, -1)
attn_compress = attn_compress.masked_fill(chunk_attn_mask, float('-inf'))
attn_compress = attn_compress.view(bsz, n_heads, seq_len, -1)
# Get the softmax score of both short-term and long-range attentions.
full_attn = torch.cat([attn_compress, attn_window], dim=3)
full_attn = F.softmax(full_attn.float(), dim=-1).type_as(full_attn)
full_attn = self.dp_attn(full_attn)
attn_compress = full_attn[:, :, :, :attn_compress.shape[3]]
attn_window = full_attn[:, :, :, attn_compress.shape[3]:]
attn_window = self.put_tiles(attn_window)
out = torch.matmul(attn_compress, value_compressed) \
+ self.compute_pv(attn_window, val_window)
return out
def forward(self, h, h_cache, key_pe, pos_embed_window, chunked_attn_mask=None):
if self.grad_chk:
out = cp.checkpoint(self.forward_, *[
h, h_cache, key_pe, pos_embed_window, chunked_attn_mask
])
else:
out = self.forward_(h, h_cache, key_pe, pos_embed_window, chunked_attn_mask)
return out
def forward_(self, h, h_cache, key_pe, pos_embed_window, chunked_attn_mask=None):
# h = bsz x seq_len x H
# h_cache = bsz x cache_len x H
bsz = h.size(0)
seqlen = h.size(1)
query = self.proj_query(h)
query = self.head_reshape(query)
# sequence length and cache length should be divisible by the chunk size
assert seqlen % self.chunk_size == 0 and h_cache.shape[1] % self.chunk_size == 0
cache_scores = self.compute_scores(h_cache)
h_cache_compressed = self.compress_chunks(h_cache, cache_scores)
# The projection for the cache can be compressed using dynamic projection
h_cache_merge = h_cache_compressed.view(
bsz, self.n_head, -1, self.d_h).transpose(1, 2).contiguous().view(
bsz, -1, self.d_model)
# Apply projections to the compressed sequence.
val_cache = self.proj_val(h_cache_merge)
key_cache = self.proj_key(h_cache_merge)
# DualLN (dproj)
key_cache = self.dual_ln_dproj(key_cache)
val_cache = self.dual_ln_dproj(val_cache)
val_cache = self.head_reshape(val_cache)
key_cache = self.head_reshape(key_cache)
# Apply window attention
val_window_bp = self.proj_val(h)
key_window_bp = self.proj_key(h)
# better using multipliers of 8
h_cache_win = h_cache[:, -self.window_len:]
key_cache_win = self.proj_key(h_cache_win)
val_cache_win = self.proj_val(h_cache_win)
key_window = torch.cat([key_cache_win, key_window_bp], dim=1)
val_window = torch.cat([val_cache_win, val_window_bp], dim=1)
# DualLN (window)
key_window = self.dual_ln_win(key_window)
val_window = self.dual_ln_win(val_window)
bp_scores = self.compute_scores(h)
# Compress the projeced keys and values.
val_bp_compressed = self.compress_chunks(val_window_bp, bp_scores)
key_bp_compressed = self.compress_chunks(key_window_bp, bp_scores)
# DualLN (dproj)
val_bp_compressed = self.dual_ln_dproj(
val_bp_compressed.transpose(1, 2).contiguous().view(bsz, -1, self.d_model))
key_bp_compressed = self.dual_ln_dproj(
key_bp_compressed.transpose(1, 2).contiguous().view(bsz, -1, self.d_model))
val_bp_compressed = self.head_reshape(val_bp_compressed)
key_bp_compressed = self.head_reshape(key_bp_compressed)
val_compressed = torch.cat([val_cache, val_bp_compressed], dim=2)
key_compressed = torch.cat([key_cache, key_bp_compressed], dim=2)
out = self.attn(query, key_window, val_window, key_compressed, val_compressed, key_pe, pos_embed_window, chunked_attn_mask) # B_K x M x D
out = out.transpose(1, 2).contiguous() # B x M x K x D
out = out.view(bsz, seqlen, -1) # B x M x K_D
out = self.proj_out(out)
out = self.dropout(out)
return out
| transformer-ls-master | autoregressive/model_lib/layer.py |
#!/usr/bin/env python
# coding=utf-8
"""Copied rom https://github.com/kimiyoung/transformer-xl/blob/master/prep_text8.py"""
import os
import sys
import zipfile
from io import open
if os.path.exists('train.txt'):
print('Tokenized text8 already exists - skipping processing')
sys.exit()
data = zipfile.ZipFile('text8.zip').extractall()
data = open('text8', 'r', encoding='utf-8').read()
print('Length of text8: {}'.format(len(data)))
num_test_chars = 5000000
train_data = data[: -2 * num_test_chars]
valid_data = data[-2 * num_test_chars: -num_test_chars]
test_data = data[-num_test_chars:]
for fn, part in [('train.txt', train_data), ('valid.txt', valid_data), ('test.txt', test_data)]:
print('{} will have {} bytes'.format(fn, len(part)))
print('- Tokenizing...')
# Change space ' ' to underscore '_'
part_str = ' '.join(['_' if c == ' ' else c for c in part.strip()])
print('- Writing...')
f = open(fn, 'w').write(part_str)
f = open(fn + '.raw', 'w', encoding='utf-8').write(part) | transformer-ls-master | autoregressive/data_prepro/prep_text8.py |
"""Unified script for classification problems, with distributed training support.
Adapted from https://github.com/microsoft/vision-longformer
"""
import wandb
import argparse
import logging
import os
import os.path as op
import sys
import torch
import torch.utils.data.distributed
from timm.data import Mixup
from models import build_model
from engine import train, validate
from loss import get_criterion
from utils.miscellaneous import mkdir, set_seed, config_iteration
from utils.comm import synchronize, get_rank
from optim import get_opt, get_lr_scheduler
from utils.checkpoint import Checkpointer
from utils.metric_logger import TensorboardLogger
from dat.loader import make_epoch_data_loader
from config import cfg
try:
this_file = __file__
except NameError:
this_file = sys.argv[0]
this_file = op.abspath(this_file)
logging.getLogger().setLevel(logging.INFO)
def main():
################### parse experiment settings #####################
parser = argparse.ArgumentParser(description='PyTorch for image cls')
parser.add_argument('--config-file',
default="",
metavar="FILE",
help="path to config file",
type=str,
)
parser.add_argument("--local_rank", type=int, default=-1,
help="For distributed training: local_rank")
parser.add_argument('--seed', type=int, default=0,
help='random seed')
parser.add_argument('--data', metavar='DIR', help='path to datasets',
default=os.getenv('PT_DATA_DIR', './datasets'))
parser.add_argument('--output_dir', type=str,
default=os.getenv('PT_OUTPUT_DIR', '/tmp'))
parser.add_argument('--wandb', default=False, action='store_true')
parser.add_argument('--clip-grad', default=-1, type=float)
parser.add_argument('--expname', default="default", type=str)
parser.add_argument('--resume-path', default='.', type=str)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
device = 'cuda' if torch.cuda.is_available() else 'cpu'
assert (device == 'cuda')
# Setup CUDA, GPU & distributed training
args.num_gpus = int(
os.environ["WORLD_SIZE"]) if "WORLD_SIZE" in os.environ else 1
cfg.distributed = args.num_gpus > 1
if 'RANK' in os.environ:
args.local_rank = int(os.environ['LOCAL_RANK'])
args.rank = int(os.environ['RANK'])
if args.local_rank == -1:
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
args.n_gpu = torch.cuda.device_count()
else: # Initializes the distributed backend which will take care of sychronizing nodes/GPUs
torch.cuda.set_device(args.local_rank)
device = torch.device("cuda", args.local_rank)
torch.distributed.init_process_group(backend='nccl', init_method='env://',
world_size=int(os.environ['WORLD_SIZE']), rank=int(os.environ["RANK"]))
args.n_gpu = 1
if int(os.environ['RANK']) == 0 and args.wandb:
# wandb.login(key=YOUR_KEY)
experiment = wandb.init(project="vision-vil", name=args.expname, entity='default', reinit=False,)
wandb.config.update(args)
else:
experiment = None
if args.local_rank == 0:
logging.info("args.n_gpu: {}".format(args.n_gpu))
# Set the random seed manually for reproducibility.
if args.seed != 0:
set_seed(args.seed, args.n_gpu)
cfg.DATA.PATH = args.data
cfg.OUTPUT_DIR = args.output_dir
##################### Data ############################
if args.local_rank == 0:
logging.info('==> Preparing data..')
testloaders = make_epoch_data_loader(cfg, is_train=False, drop_last=False,
is_distributed=cfg.distributed)
## fix warmup based on trainset size, batch size.
iteration = 0
if not cfg.EVALUATE:
trainloader = make_epoch_data_loader(cfg, is_train=True, drop_last=True,
is_distributed=cfg.distributed)
steps_per_epoch = len(trainloader)
cfg.SOLVER.STEPS_PER_EPOCH = steps_per_epoch
warmup = cfg.OPTIM.WARMUP * steps_per_epoch
cfg.OPTIM.WARMUP = warmup
cfg.SOLVER.MAX_ITER = steps_per_epoch * cfg.OPTIM.EPOCHS
# get the starting checkpoint's iteration
iteration = config_iteration(cfg.OUTPUT_DIR, steps_per_epoch)
if args.local_rank == 0:
logging.info("Experiment settings:")
logging.info(cfg)
if cfg.OUTPUT_DIR:
mkdir(cfg.OUTPUT_DIR)
# save full config to a file in output_dir for future reference
with open(os.path.join(cfg.OUTPUT_DIR, 'config.yaml'), 'w') as f:
f.write(str(cfg))
cfg.freeze()
# mix-up
aug = cfg.AUG
mixup_fn = Mixup(
mixup_alpha=aug.MIXUP, cutmix_alpha=aug.MIXCUT,
cutmix_minmax=aug.MIXCUT_MINMAX if aug.MIXCUT_MINMAX else None,
prob=aug.MIXUP_PROB, switch_prob=aug.MIXUP_SWITCH_PROB,
mode=aug.MIXUP_MODE, label_smoothing=cfg.LOSS.LABEL_SMOOTHING,
num_classes=cfg.DATA.NUM_CLASSES
) if aug.MIXUP_PROB > 0.0 else None
##################### Model ############################
net = build_model(cfg)
net = net.to(device)
n_params = 0
for p in net.parameters():
n_params += p.numel()
if args.local_rank == 0:
logging.info("**** Params: {}".format(n_params))
if not cfg.EVALUATE and cfg.AMP.ENABLED and cfg.AMP.MEMORY_FORMAT == 'nhwc':
if args.local_rank == 0:
logging.info('=> convert memory format to nhwc')
net.to(memory_format=torch.channels_last)
# multi-gpu training (should be after apex fp16 initialization)
if args.n_gpu > 1:
net = torch.nn.DataParallel(net)
if args.local_rank == 0:
logging.info("Number of GPUs: {}, using DaraParallel.".format(args.n_gpu))
# Distributed training (should be after apex fp16 initialization)
if args.local_rank != -1 and cfg.distributed:
process_group = torch.distributed.new_group(list(range(args.num_gpus)))
net = torch.nn.SyncBatchNorm.convert_sync_batchnorm(net, process_group)
net = torch.nn.parallel.DistributedDataParallel(
net, device_ids=[args.local_rank], output_device=args.local_rank,
)
if args.local_rank == 0:
logging.info("Number of GPUs: {}, using DistributedDaraParallel.".format(args.num_gpus))
##################### Loss function and optimizer ############################
criterion_eval = get_criterion(cfg, train=False)
criterion_eval.cuda()
optimizer = None
scheduler = None
if not cfg.EVALUATE:
criterion = get_criterion(cfg)
criterion.cuda()
optimizer = get_opt(cfg, net, resume=iteration>0)
scheduler = get_lr_scheduler(cfg, optimizer, last_iter=iteration)
##################### make a checkpoint ############################
best_acc = 0.0
checkpointer = Checkpointer(net, cfg.MODEL.ARCH, best_acc=best_acc,
optimizer=optimizer, scheduler=scheduler,
save_dir=cfg.OUTPUT_DIR,
is_test=cfg.EVALUATE,
only_save_last=cfg.ONLY_SAVE_LAST)
############## tensorboard writers #############################
tb_log_dir = os.path.join(args.output_dir, 'tf_logs')
train_tb_log_dir = os.path.join(tb_log_dir, 'train_logs')
task_names = [task_name.replace('.yaml', '').replace('/', '_')
for task_name in cfg.DATA.TEST]
test_tb_log_dirs = [os.path.join(tb_log_dir, '{}_logs'.format(
task_name)) for task_name in task_names]
train_meters = TensorboardLogger(
log_dir=train_tb_log_dir,
delimiter=" ",
)
test_meters = [
TensorboardLogger(
log_dir=test_tb_log_dir,
delimiter=" ",
) for test_tb_log_dir in test_tb_log_dirs
]
if cfg.EVALUATE:
# first, load the model from the checkpoint
checkpointer.load(args.resume_path)
for task_name, testloader, test_meter in zip(task_names, testloaders, test_meters):
validate(testloader, net, criterion_eval, cfg,
test_meter, global_step=0, device=device,
local_rank=get_rank())
############## training code #############################
if not cfg.EVALUATE:
scaler = torch.cuda.amp.GradScaler(enabled=cfg.AMP.ENABLED)
# start from epoch 0 or last checkpoint epoch
start_epoch = checkpointer.epoch
for epoch in range(start_epoch, cfg.OPTIM.EPOCHS):
# wait for all processes before every epoch
synchronize()
if args.local_rank == 0:
logging.info("PROGRESS: {}%".format(
round(100 * epoch / cfg.OPTIM.EPOCHS, 4)))
global_step = epoch * len(trainloader)
# an empirical rule for redraw projects in Performer
if cfg.MODEL.ARCH.startswith('msvit') and cfg.MODEL.VIT.MSVIT.ATTN_TYPE == "performer":
if hasattr(net, 'module'):
net.module.feature_redraw_interval = 1 + 5 * epoch
else:
net.feature_redraw_interval = 1 + 5 * epoch
if cfg.MODEL.ARCH.startswith('msvit') and cfg.MODEL.VIT.MSVIT.ATTN_TYPE.startswith('longformer'):
vil_swith_mode = cfg.MODEL.VIT.MSVIT.VIL_MODE_SWITCH * cfg.OPTIM.EPOCHS
if cfg.MODEL.VIT.MSVIT.MODE > 0 and epoch >= vil_swith_mode:
# only reset random sample mode to full mode
if hasattr(net, 'module'):
net.module.reset_vil_mode(mode=0)
else:
net.reset_vil_mode(mode=0)
# train for one epoch
with torch.autograd.set_detect_anomaly(cfg.SOLVER.DETECT_ANOMALY):
train(trainloader, net, criterion, optimizer, scheduler, epoch,
cfg, train_meters, global_step=global_step, device=device,
mixup_fn=mixup_fn, scaler=scaler)
# evaluate on validation set
global_step = (epoch + 1) * len(trainloader)
accs = []
for task_name, testloader, test_meter in zip(task_names, testloaders, test_meters):
if args.local_rank == 0:
logging.info("Evaluating dataset: {}".format(task_name))
acc = validate(testloader, net, criterion_eval, cfg,
test_meter, global_step=global_step,
device=device,
local_rank=get_rank())
accs.append(acc)
# remember best prec@1 and save checkpoint
is_best = accs[0] > checkpointer.best_acc
if is_best:
checkpointer.best_acc = accs[0]
elif cfg.OPTIM.VAL and cfg.OPTIM.OPT in ['sgd', 'qhm', 'salsa']:
if args.local_rank == 0:
logging.info("DROPPING LEARNING RATE")
# Anneal the learning rate if no improvement has been seen in the validation dataset.
for group in optimizer.param_groups:
group['lr'] = group['lr'] * 1.0 / cfg.OPTIM.DROP_FACTOR
if cfg.OPTIM.OPT in ['salsa']:
optimizer.state['switched'] = True
if args.local_rank == 0:
logging.info("Switch due to overfiting!")
checkpointer.epoch = epoch + 1
checkpointer.save(is_best)
if experiment is not None and args.rank == 0:
# experiment.log({f'train_{k}': v for k, v in train_stats.items()}, epoch)
experiment.log({f'test_acc': accs[0], 'best_test_acc': checkpointer.best_acc}, epoch)
lr = optimizer.param_groups[0]['lr']
experiment.log({'lr': lr}, epoch)
wd = 0
for param_group in optimizer.param_groups:
if param_group['weight_decay'] > 0:
wd = param_group['weight_decay']
experiment.log({'wd': wd}, epoch)
# exactly evaluate the best checkpoint
# wait for all processes to complete before calculating the score
synchronize()
best_model_path = os.path.join(checkpointer.save_dir, "model_best.pth")
if os.path.isfile(best_model_path):
if args.local_rank == 0:
logging.info("Evaluating the best checkpoint: {}".format(best_model_path))
cfg.defrost()
cfg.EVALUATE = True
checkpointer.is_test = True
cfg.freeze()
for task_name, testloader, test_meter in zip(task_names, testloaders, test_meters):
if args.local_rank == 0:
logging.info("Evaluating dataset: {}".format(task_name))
validate(testloader, net, criterion_eval, cfg,
test_meter, global_step=cfg.SOLVER.MAX_ITER, device=device,
local_rank=get_rank())
# Close meters
train_meters.close()
for meter in test_meters:
meter.close()
return 0
if __name__ == '__main__':
# When run as script, modify path assuming absolute import
sys.path.append(op.join(op.dirname(this_file), '..'))
main()
| transformer-ls-master | imagenet/run_experiment_distributed.py |
"""
This file is from https://github.com/microsoft/vision-longformer
"""
import torch as th
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
def linear_combination(x, y, epsilon):
return epsilon*x + (1-epsilon)*y
def reduce_loss(loss, reduction='mean'):
return loss.mean() if reduction == 'mean' \
else loss.sum() if reduction == 'sum' else loss
class LabelSmoothingCrossEntropy(nn.Module):
def __init__(self, epsilon=0.1, reduction='mean'):
super().__init__()
self.epsilon = epsilon
self.reduction = reduction
def forward(self, preds, target):
n = preds.size()[-1]
log_preds = F.log_softmax(preds, dim=-1)
loss = reduce_loss(-log_preds.sum(dim=-1), self.reduction)
nll = F.nll_loss(log_preds, target, reduction=self.reduction)
return linear_combination(loss/n, nll, self.epsilon)
class FocalLoss(nn.Module):
"""
Origianl code is from https://github.com/richardaecn/class-balanced-loss/blob/master/src/cifar_main.py#L226-L266
"""
def __init__(self, alpha, gamma, normalize):
super().__init__()
self.alpha = alpha
self.gamma = gamma
self.normalize = normalize
def forward(self, preds, targets):
cross_entropy = F.binary_cross_entropy_with_logits(
preds, targets, reduction='none'
)
gamma = self.gamma
if gamma == 0.0:
modulator = 1.0
else:
modulator = th.exp(
-gamma * targets * preds - gamma * th.log1p(
th.exp(-1.0 * preds)
)
)
loss = modulator * cross_entropy
weighted_loss = self.alpha * loss
focal_loss = reduce_loss(weighted_loss, reduction='sum')
return focal_loss / targets.sum() if self.normalize else focal_loss
class MultiSoftmaxCrossEntropyLoss(nn.Module):
def __init__(self, class_weight=None, label_smoothing_value=0):
super(MultiSoftmaxCrossEntropyLoss, self).__init__()
self.class_weight = class_weight
if self.class_weight is not None:
self.class_weight = self.class_weight.cuda()
self.logsoftmax = nn.LogSoftmax(dim=1)
self.label_smoothing_value = label_smoothing_value
def forward(self, input, target):
return self.cross_entropy(input, target, self.class_weight)
def cross_entropy(self, pred, soft_targets, class_weight=None):
if class_weight is not None:
class_weight_matrix = class_weight.expand_as(soft_targets)
used_class_weights = th.where(
soft_targets > 0, class_weight_matrix, soft_targets
)
samples_weight = th.max(used_class_weights, dim=1, keepdim=True)[0]
loss = th.mean(
th.sum(
-samples_weight*soft_targets*self.logsoftmax(pred), 1
), 0
)
else:
if self.label_smoothing_value > 0:
# label smoothing
batch_size, total_classes_count = soft_targets.size()
for sample_index in range(batch_size):
pos_indices = np.where(soft_targets[sample_index, :] > 0)
pos_classes_count = len(pos_indices[0])
if pos_classes_count > 0:
neg_p = self.label_smoothing_value / float(total_classes_count - pos_classes_count)
pos_p = self.label_smoothing_value / pos_classes_count
soft_targets[sample_index, :] += neg_p
soft_targets[sample_index, pos_indices[0]] = soft_targets[sample_index, pos_indices[0]] - pos_p - neg_p
loss = th.sum(-soft_targets * self.logsoftmax(pred))
loss = loss / soft_targets.sum()
return loss
class SoftTargetCrossEntropy(nn.Module):
def __init__(self):
super(SoftTargetCrossEntropy, self).__init__()
def forward(self, x, target):
loss = th.sum(-target * F.log_softmax(x, dim=-1), dim=-1)
return loss.mean()
def get_criterion(config, train=True):
if config.AUG.MIXUP_PROB > 0.0 and config.LOSS.LOSS == 'xentropy':
criterion = SoftTargetCrossEntropy() \
if train else nn.CrossEntropyLoss()
elif config.LOSS.LABEL_SMOOTHING > 0.0 and config.LOSS.LOSS == 'xentropy':
criterion = LabelSmoothingCrossEntropy(config.LOSS.LABEL_SMOOTHING)
elif config.LOSS.LOSS == 'xentropy':
criterion = nn.CrossEntropyLoss()
elif config.LOSS.LOSS == 'sigmoid':
criterion = nn.MultiLabelSoftMarginLoss(reduction='sum')
elif config.LOSS.LOSS == 'focal':
alpha = config.LOSS.FOCAL.ALPHA
gamma = config.LOSS.FOCAL.GAMMA
normalize = config.LOSS.FOCAL.NORMALIZE
criterion = FocalLoss(alpha, gamma, normalize)
elif config.LOSS.LOSS == 'multisoftmax':
criterion = MultiSoftmaxCrossEntropyLoss()
elif config.LOSS.LOSS == 'bce':
criterion = nn.BCEWithLogitsLoss()
elif config.LOSS.LOSS == 'mse':
criterion = nn.MSELoss()
else:
raise ValueError('Unkown loss {}'.format(config.LOSS.LOSS))
return criterion
| transformer-ls-master | imagenet/loss.py |
"""
This file is from https://github.com/microsoft/vision-longformer
"""
import time
import logging
import torch
import os
import json
from torch.cuda.amp import autocast
from utils.comm import _accumulate_predictions_from_multiple_gpus, \
is_main_process
ONLY_OVERLAP_CLASSES = True
def compute_accuracy(output, target, topk=(1,), target_map=None):
"""Computes the precision@k for the specified values of k"""
with torch.no_grad():
if type(output) is not torch.Tensor:
# inception v3 model
output = output[0]
if target_map is not None and ONLY_OVERLAP_CLASSES:
overlap_classes = []
for key, val in target_map.items():
overlap_classes += val
output[:, overlap_classes] += output.max() - output.min() + 10
maxk = max(topk)
_, pred = output.topk(maxk, 1, True, True)
pred = pred.t()
if target_map is None:
correct = pred.eq(target.view(1, -1).expand_as(pred)).float()
else:
target_list = [target_map[t.item()] if t.item() in target_map else
[-1] for t in target]
correct = pred.new_zeros(pred.shape)
for i, tlist in enumerate(target_list):
for j in range(maxk):
correct[j, i] = pred[j, i] in tlist
res = []
for k in topk:
correct_k = (correct[:k].sum(0, keepdim=False) > 0).float() # (B, )
res.append(correct_k)
return torch.stack(res).t() # (B, k)
def output_metrics(scores, targets=None):
avg_scores = 100 * scores.mean(0, keepdim=False)
metrics = {'top1': avg_scores[0], 'top5': avg_scores[1]}
if targets is not None:
assert len(targets) == len(scores), "Length of scores and targets does not match!"
for label in range(targets.max().item() + 1):
label_avg_scores = 100 * scores[targets.view(-1) == label].mean(0, keepdim=False)
metrics.update({'top1/{}'.format(label): label_avg_scores[0],
'top5/{}'.format(label): label_avg_scores[1]})
return metrics
# Training
def train(train_loader, model, criterion, optimizer, scheduler, epoch,
cfg, meters, global_step=0, device='cuda', mixup_fn=None, scaler=None):
print('\nEpoch: %d' % epoch)
if cfg.distributed:
train_loader.sampler.set_epoch(epoch)
total_top1 = 0
total_top5 = 0
total_cnt = 0
end = time.time()
for i, batch in enumerate(train_loader):
image, target, img_id = batch[0], batch[1], batch[2:]
# compute output and record loss
image, target = image.to(device, non_blocking=True), target.to(device,
non_blocking=True)
if mixup_fn:
image, target = mixup_fn(image, target)
# measure data loading time
data_time = time.time() - end
# switch to train mode
model.train()
with autocast(enabled=cfg.AMP.ENABLED):
if cfg.AMP.ENABLED and cfg.AMP.MEMORY_FORMAT == 'nwhc':
image = image.contiguous(memory_format=torch.channels_last)
target = target.contiguous(memory_format=torch.channels_last)
output = model(image)
if cfg.MODEL.ARCH == 'inception_v3':
loss = 0.5 * (criterion(output[0], target) + criterion(output[1],
target))
else:
loss = criterion(output, target)
# compute gradient and do SGD step
optimizer.zero_grad()
scaler.scale(loss).backward()
if getattr(cfg, "clip_grad", -1) > 0:
gnorm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg.clip_grad)
else:
gnorm = -1
# closure function defined for line search used in SGD_SLS
def eval_loss():
# if cfg.ls_eval:
if cfg.OPTIM.LS.EVAL:
model.eval()
with torch.no_grad():
return criterion(model(image), target)
if cfg.OPTIM.OPT in ['salsa', 'ssls', 'slope']:
scaler.step(optimizer, closure=eval_loss)
else:
scaler.step(optimizer)
scaler.update()
# update scheduler
if scheduler and not cfg.SOLVER.EPOCH_BASED_SCHEDULE:
scheduler.step()
# measure and record accuracy
batch_cnt = image.size(0)
total_cnt += batch_cnt
if mixup_fn:
target = torch.argmax(target, dim=1)
if cfg.LOSS.LOSS == "xentropy":
precision = compute_accuracy(output, target, topk=(1, 5))
score = precision.sum(0, keepdim=False)
total_top1 += score[0].item()
total_top5 += score[1].item()
else:
raise ValueError("Only xentropy loss is supported!")
# measure elapsed time
batch_time = time.time() - end
end = time.time()
metrics_to_log = {
'time_info': {'compute': batch_time, 'data': data_time},
'batch_metrics': {'loss': loss, 'qa_cnt': float(batch_cnt),
'top1': 100 * score[0] / batch_cnt,
'top5': 100 * score[1] / batch_cnt}
}
params_to_log = {'params': {'lr': optimizer.param_groups[0]["lr"]}}
if cfg.OPTIM.OPT in ['salsa', 'sasa']:
params_to_log.update(
{
'stats': {'stats_x1d': optimizer.state['stats_x1d'],
'stats_ld2': optimizer.state['stats_ld2'],
'stats_mean': optimizer.state['stats_mean'],
'stats_lb': optimizer.state['stats_lb'],
'stats_ub': optimizer.state['stats_ub'], }
}
)
meters.update_metrics(metrics_to_log)
meters.update_params(params_to_log)
# only log once per cfg.LOG_FREQ param updates. adjust factor because pflug uses
# 3 batches to make 1 param update.
if (i + 1) % cfg.LOG_FREQ == 0:
logging.info(
meters.delimiter.join(
[
"iter: {iter}",
"max mem: {memory:.0f}",
]
).format(
iter=global_step + i + 1,
memory=torch.cuda.max_memory_allocated() / 1024.0 / 1024.0,
) + "\n " + meters.get_logs(global_step + i + 1)
)
# update scheduler
if scheduler and cfg.SOLVER.EPOCH_BASED_SCHEDULE:
scheduler.step()
train_metrics = torch.Tensor([total_top1, total_top5, total_cnt]).to(device)
if cfg.distributed:
torch.distributed.all_reduce(train_metrics)
top1 = 100 * train_metrics[0] / train_metrics[2]
top5 = 100 * train_metrics[1] / train_metrics[2]
logging.info(' * Prec@1 {top1:.3f} Prec@5 {top5:.3f} gnorm {gnorm:.2e}'
.format(top1=top1, top5=top5, gnorm=gnorm))
logging.info("Eval Score: %.3f" % top1)
meters.update_metrics(
{'epoch_metrics': {'total_cnt': float(train_metrics[2])},
'accuracy_metrics': {'top1': top1, 'top5': top5, }
}
)
logging.info(
meters.delimiter.join(
[
"iter: {iter}",
"max mem: {memory:.0f}",
]
).format(
iter=global_step + len(train_loader),
memory=torch.cuda.max_memory_allocated() / 1024.0 / 1024.0,
) + "\n " + meters.get_logs(int(global_step + len(train_loader)))
)
def validate(val_loader, model, criterion,
cfg, meters, global_step=0,
device='cuda', local_rank=-1):
# compute target to model output map from target file
target_map = None
if cfg.DATA.TARGETMAP:
target_file = os.path.join(cfg.DATA.PATH, cfg.DATA.TARGETMAP)
if os.path.isfile(target_file):
target_file = json.load(open(target_file))
target_file = {key: val[:val.rfind('(')] for key, val in target_file.items()}
if hasattr(val_loader.dataset,
'labelmap') and val_loader.dataset.labelmap is not None:
labelmap = val_loader.dataset.labelmap
target_map = {}
for objectname, objectid in labelmap.items():
target_map[objectid] = []
for imagenetname, objectalias in target_file.items():
if objectname == objectalias or objectname.startswith(objectalias + '('):
target_map[objectid].append(int(imagenetname))
else:
logging.warning(
"Given validation dataset does not have labelmap!")
else:
logging.warning("Given target map file {} does not exists!".format(
target_file))
# switch to evaluate mode
model.eval()
results_dict = {}
total_loss = 0
total_cnt = 0
total_top1 = 0
total_top5 = 0
dataset_len = len(val_loader.dataset)
with torch.no_grad():
start = time.time()
for i, batch in enumerate(val_loader):
image, target, img_id = batch[0], batch[1], batch[2:]
if len(img_id) == 0:
img_id = range(dataset_len * local_rank + total_cnt,
dataset_len * local_rank + total_cnt + image.size(
0))
else:
img_id = img_id[0].tolist()
image, target = image.to(device, non_blocking=True), target.to(
device, non_blocking=True)
with autocast(enabled=cfg.AMP.ENABLED):
if cfg.AMP.ENABLED and cfg.AMP.MEMORY_FORMAT == 'nwhc':
image = image.contiguous(memory_format=torch.channels_last)
target = target.contiguous(
memory_format=torch.channels_last)
# compute output and record loss
output = model(image)
loss = criterion(output, target)
total_loss += loss.item()
total_cnt += image.size(0)
# measure and record accuracy
if cfg.LOSS.LOSS == "xentropy":
precision = compute_accuracy(output, target, topk=(1, 5),
target_map=target_map) # B*2
score = precision.sum(0, keepdim=False)
total_top1 += score[0].item()
total_top5 += score[1].item()
if cfg.EVALUATE:
results_dict.update(
{im_id: (prec, label) for im_id, prec, label in
zip(img_id, precision.to(torch.device("cpu")), target.to(torch.device("cpu")))}
)
else:
raise ValueError("Only xentropy loss is supported!")
# measure elapsed time
total_time = time.time() - start
# measure epoch metrics
test_metrics = torch.Tensor([total_loss, total_time, total_cnt, total_top1, total_top5]).to(
device)
if cfg.distributed:
torch.distributed.all_reduce(test_metrics)
if cfg.EVALUATE:
results_dict = _accumulate_predictions_from_multiple_gpus(
results_dict, cfg.GATHER_ON_CPU,)
test_loss_gathered = test_metrics[0] / test_metrics[2]
test_time_gathered = test_metrics[1] / test_metrics[2]
metrics = {
'top1': 100 * test_metrics[3] / test_metrics[2],
'top5': 100 * test_metrics[4] / test_metrics[2]
}
output = metrics['top1'].item()
if not is_main_process():
# let the main process do the final computing
return output
if cfg.EVALUATE:
assert len(results_dict) == len(val_loader.dataset), \
"Number of gathered items {} does not match the dataset size {}!" .format(len(results_dict), len(val_loader.dataset))
scores = torch.stack([val[0] for key, val in results_dict.items()])
targets = torch.stack([val[1] for key, val in results_dict.items()])
metrics = output_metrics(scores, targets=targets if cfg.OUTPUT_PERCLASS_ACC else None)
logging.info("ACCURACY: {}%".format(metrics['top1']))
meters.update_metrics(
{'epoch_metrics': {'total_cnt': float(test_metrics[2]),
'loss': test_loss_gathered,
'time': test_time_gathered},
'accuracy_metrics': metrics
}
)
logging.info(
meters.delimiter.join(
[
"iter: {iter}",
"max mem: {memory:.0f}",
]
).format(
iter=global_step,
memory=torch.cuda.max_memory_allocated() / 1024.0 / 1024.0,
) + "\n " + meters.get_logs(int(global_step))
)
# save per image result
if cfg.EVALUATE and hasattr(val_loader.dataset, 'get_img_key'):
results_dict = {val_loader.dataset.get_img_key(key): val for key, val in results_dict.items()}
torch.save(results_dict, os.path.join(meters.tb_logger.logdir, 'results.pth'))
return output
| transformer-ls-master | imagenet/engine.py |
# Copyright (c) 2021 Microsoft Corporation. Licensed under the MIT license.
from .defaults import _C as cfg
| transformer-ls-master | imagenet/config/__init__.py |
# Copyright (c) 2021 Microsoft Corporation. Licensed under the MIT license.
# Written by Pengchuan Zhang, [email protected]
import os
from yacs.config import CfgNode as CN
# -----------------------------------------------------------------------------
# Config definition
# -----------------------------------------------------------------------------
_C = CN()
# training data augmentation
_C.INPUT = CN()
_C.INPUT.MEAN = [0.485, 0.456, 0.406]
_C.INPUT.STD = [0.229, 0.224, 0.225]
_C.INPUT.IMAGE_SIZE = 224 # 299 for inception_v3
_C.INPUT.CROP_PCT = 0.875 # 0.816 for inception_v3
_C.INPUT.INTERPOLATION = 2
_C.AMP = CN()
_C.AMP.ENABLED = False
_C.AMP.MEMORY_FORMAT = 'nchw'
# data augmentation
_C.AUG = CN()
_C.AUG.SCALE = (0.08, 1.0)
_C.AUG.RATIO = (3.0/4.0, 4.0/3.0)
_C.AUG.COLOR_JITTER = [0.4, 0.4, 0.4, 0.1, 0.0]
_C.AUG.GRAY_SCALE = 0.0
_C.AUG.GAUSSIAN_BLUR = 0.0
_C.AUG.DROPBLOCK_LAYERS = [3, 4]
_C.AUG.DROPBLOCK_KEEP_PROB = 1.0
_C.AUG.DROPBLOCK_BLOCK_SIZE = 7
_C.AUG.MIXUP_PROB = 0.0
_C.AUG.MIXUP = 0.0
_C.AUG.MIXCUT = 0.0
_C.AUG.MIXCUT_MINMAX = []
_C.AUG.MIXUP_SWITCH_PROB = 0.5
_C.AUG.MIXUP_MODE = 'batch'
_C.AUG.MIXCUT_AND_MIXUP = False
_C.AUG.REPEATED_AUG = False
_C.AUG.TIMM_AUG = CN(new_allowed=True)
_C.AUG.TIMM_AUG.USE_TRANSFORM = False
_C.DATA = CN()
# choices=['toy_ill', 'toy_well', 'mnist', 'cifar', 'cifar100', 'imagenet', 'wikitext-2', 'celeba']
_C.DATA.TRAIN = ('imagenet',)
_C.DATA.TEST = ('imagenet',)
_C.DATA.NUM_CLASSES = 1000
_C.DATA.TARGETMAP = ''
# path to datasets, default=os.getenv('PT_DATA_DIR', './datasets')
_C.DATA.PATH = "./datasets"
# path to other necessary data like checkpoints other than datasets.
_C.DATA.DATA_DIR = "./data"
# choices=['mse', 'xentropy', 'bce'], msr for least regression or xentropy for classification
_C.LOSS = CN()
_C.LOSS.LABEL_SMOOTHING = 0.0
_C.LOSS.LOSS = 'xentropy'
_C.LOSS.FOCAL = CN()
_C.LOSS.FOCAL.NORMALIZE = True
_C.LOSS.FOCAL.ALPHA = 1.0
_C.LOSS.FOCAL.GAMMA = 0.5
# dataloader
_C.DATALOADER = CN()
# batch size
_C.DATALOADER.BSZ = 128
# samples are drawn with replacement if yes
_C.DATALOADER.RE = False
# number of data loading workers
_C.DATALOADER.WORKERS = 0
# optimizer
_C.OPTIM = CN()
# optimizer, default='adamw'
_C.OPTIM.OPT = 'adamw'
# effective learning rate
_C.OPTIM.LR = 1.0
# effective momentum value
_C.OPTIM.MOM = 0.9
# nu value for qhm
_C.OPTIM.NU = 1.0
# weight decay lambda
_C.OPTIM.WD = 5e-4
_C.OPTIM.WD0 = 0.0
# Number of Epochs
_C.OPTIM.EPOCHS = 150
# Warm up: epochs of qhm before switching to sasa/salsa
_C.OPTIM.WARMUP = 0
# Drop frequency and factor for all methods
_C.OPTIM.DROP_FREQ = 50
_C.OPTIM.DROP_FACTOR = 10.0
# use validation dataset to adapt learning rate
_C.OPTIM.VAL = 0
_C.OPTIM.TEST_FREQ = 1000
# ADAM's default parameters
_C.OPTIM.ADAM = CN()
_C.OPTIM.ADAM.BETA1 = 0.9
_C.OPTIM.ADAM.BETA2 = 0.999
_C.OPTIM.ADAM.EPS = 1e-8
# LR scheduler
_C.SOLVER = CN()
_C.SOLVER.LR_POLICY = '' # multistep, cosine, linear
_C.SOLVER.WARMUP_FACTOR = 1.0 / 3
_C.SOLVER.WARMUP_EPOCHS = 5.0
_C.SOLVER.WARMUP_METHOD = "linear"
_C.SOLVER.MIN_LR = 0.0 # MAX_LR is _C.OPTIM.LR
_C.SOLVER.DETECT_ANOMALY = False
_C.SOLVER.EPOCH_BASED_SCHEDULE = False
_C.SOLVER.USE_LARC = False
# models
_C.MODEL = CN()
# choices=model_names + my_model_names + seq_model_names,
# help='model architecture: ' +
# ' | '.join(model_names + my_model_names + seq_model_names) +
# ' (default: resnet18)')
_C.MODEL.ARCH = 'msvit'
# nonlinearity, choices=['celu', 'softplus', 'gelu']
_C.MODEL.NONLINEARITY = 'celu'
# relative path of checkpoint relative to DATA_DIR
_C.MODEL.MODEL_PATH = ""
# use pre-trained model from torchvision
_C.MODEL.PRETRAINED = False
_C.MODEL.FREEZE_CONV_BODY_AT = -1
_C.MODEL.VIT = CN()
_C.MODEL.VIT.DROP = 0.0
_C.MODEL.VIT.DROP_PATH = 0.1
# Add LayerNorm in PatchEmbedding
_C.MODEL.VIT.NORM_EMBED = True
# Use average pooled feature instead of CLS token for classification head
_C.MODEL.VIT.AVG_POOL = False
_C.MODEL.VIT.MSVIT = CN()
# multi-scale model arch: see ReadMe.md for explanation
_C.MODEL.VIT.MSVIT.ARCH = 'l1,h3,d192,n1,s1,g1,p16,f7,a1_l2,h6,d384,n10,s0,g1,p2,f7,a1_l3,h12,d796,n1,s0,g1,p2,f7,a1'
# For vision longformer: whether to share the q/k/v projections of global and local tokens
_C.MODEL.VIT.MSVIT.SHARE_W = True
# choices=['full', 'longformerhand', 'longformerauto', 'linformer', 'srformer', 'performer', 'longformer_cuda']
_C.MODEL.VIT.MSVIT.ATTN_TYPE = 'longformerhand'
# For linformer: whether to share the projection matrices of key and value
_C.MODEL.VIT.MSVIT.SHARE_KV = True
# Only use global attention mechanism
_C.MODEL.VIT.MSVIT.ONLY_GLOBAL = False
# Three masking methods of longformer attention with sliding chunk implementation:
# 1: exact conv-like local attention
# 0: blockwise sliding chunk without padding
# -1: blockwise sliding chunk with cyclic padding
_C.MODEL.VIT.MSVIT.SW_EXACT = 0
# Customized LayerNorm eps
_C.MODEL.VIT.MSVIT.LN_EPS = 1e-6
# mode to control the sampling strategy of neighbor blocks
# 0: all 8 blocks; -1: no neighbor block; >0: random sample one block
_C.MODEL.VIT.MSVIT.MODE = 0
# Switching time from mode 1 to mode 0 during training
_C.MODEL.VIT.MSVIT.VIL_MODE_SWITCH = 0.75
# finetune setting
_C.FINETUNE = CN()
_C.FINETUNE.FINETUNE = False
_C.FINETUNE.USE_TRAIN_AUG = False
# ---------------------------------------------------------------------------- #
# Misc options
# ---------------------------------------------------------------------------- #
# default=os.getenv('PT_OUTPUT_DIR', '/tmp')
_C.OUTPUT_DIR = "/tmp"
# default=os.getenv('PHILLY_LOG_DIRECTORY', None)
_C.BACKUP_LOG_DIR = ""
_C.LOG_FREQ = 10
# evaluate model on validation set
_C.EVALUATE = False
_C.OUTPUT_PERCLASS_ACC = False
# Only save the last checkpoint in the checkpointer
_C.ONLY_SAVE_LAST = 0
_C.DISTRIBUTED_BACKEND = "nccl" # could be "nccl", "gloo" or "mpi"
# whether to use CPU to do gather of predictions. Note that this requires
# running with "gloo" (or "mpi") distributed backend
_C.GATHER_ON_CPU = False | transformer-ls-master | imagenet/config/defaults.py |
transformer-ls-master | imagenet/dat/__init__.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.