diff --git a/.vscode/settings.json b/.vscode/settings.json index 14d906b92..49a4a6073 100755 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,3 +1,3 @@ { - "python.pythonPath": "/usr/bin/python3.8" + "python.pythonPath": "C:\\Users\\david\\AppData\\Local\\Programs\\Python\\Python37\\python.exe" } \ No newline at end of file diff --git a/centernet/README.md b/centernet/README.md new file mode 100644 index 000000000..5f17173f7 --- /dev/null +++ b/centernet/README.md @@ -0,0 +1,130 @@ +> :memo: A README.md template for releasing a paper code implementation to a GitHub repository. +> +> * Template version: 1.0.2020.170 +> * Please modify sections depending on needs. + +# CenterNet + +[![Paper](http://img.shields.io/badge/Paper-arXiv.1904.07850-B3181B?logo=arXiv)](https://arxiv.org/abs/1904.07850) + +This repository is the unofficial implementation of the following paper. + +* Paper title: [Objects as Points](https://arxiv.org/abs/1904.07850) + +## Description + +CenterNet [1] builds upon CornerNet [2], an anchor-free model for object +detection. + +Many other models, such as YOLO and RetinaNet, use anchor boxes. These anchor +boxes are predefined to be close to the aspect ratios and scales of the objects +in the training dataset. Anchor-based models do not predict the bounding boxes +of objects directly. They instead predict the location and size/shape +refinements to a predefined anchor box. The detection generator then computes +the final confidences, positions, and size of the detection. + +CornerNet eliminates the need for anchor boxes. RetinaNet needs thousands of +anchor boxes in order to cover the most common ground truth boxes [2]. This adds +unnecessary complexity to the model which slow down training and create +imbalances in positive and negative anchor boxes [2]. Instead, CornerNet creates +heatmaps for each of the corners and pools them together in order to get the +final detection boxes for the objects. CenterNet removes even more complexity +by using the center instead of the corners, meaning that only one set of +heatmaps (one heatmap for each class) is needed to predict the object. CenterNet +proves that this can be done without a significant difference in accuracy. + +## History + +> :memo: Provide a changelog. + +## Authors or Maintainers + +> :memo: Provide maintainer information. + +* Full name ([@GitHub username](https://github.com/username)) +* Full name ([@GitHub username](https://github.com/username)) + +## Table of Contents + +> :memo: Provide a table of contents to help readers navigate a lengthy README document. + +## Requirements + +[![TensorFlow 2.4](https://img.shields.io/badge/TensorFlow-2.4-FF6F00?logo=tensorflow)](https://github.com/tensorflow/tensorflow/releases/tag/v2.4.0) +[![Python 3.7](https://img.shields.io/badge/Python-3.7-3776AB)](https://www.python.org/downloads/release/python-370/) + +```setup +pip install -r requirements.txt +``` + +## Results + +[![TensorFlow Hub](https://img.shields.io/badge/TF%20Hub-Models-FF6F00?logo=tensorflow)](https://tfhub.dev/...) + +> :memo: Provide a table with results. (e.g., accuracy, latency) +> +> * Provide links to the pre-trained models (checkpoint, SavedModel files). +> * Publish TensorFlow SavedModel files on TensorFlow Hub (tfhub.dev) if possible. +> * Add links to [TensorBoard.dev](https://tensorboard.dev/) for visualizing metrics. +> +> An example table for image classification results +> +> ### Image Classification +> +> | Model name | Download | Top 1 Accuracy | Top 5 Accuracy | +> |------------|----------|----------------|----------------| +> | Model name | [Checkpoint](https://drive.google.com/...), [SavedModel](https://tfhub.dev/...) | xx% | xx% | + +## Dataset + +> :memo: Provide information of the dataset used. + +## Training + +> :memo: Provide training information. +> +> * Provide details for preprocessing, hyperparameters, random seeds, and environment. +> * Provide a command line example for training. + +Please run this command line for training. + +```shell +python3 ... +``` + +## Evaluation + +> :memo: Provide an evaluation script with details of how to reproduce results. +> +> * Describe data preprocessing / postprocessing steps. +> * Provide a command line example for evaluation. + +Please run this command line for evaluation. + +```shell +python3 ... +``` + +## References + +[1] CenterNet: Xingyi Zhou, Dequan Wang, and Philipp Krähenbühl. Objects as Points. arXiv preprint arXiv:1904.07850, 2019. (https://arxiv.org/abs/1904.07850) +[2] CornerNet: Hei Law and Jia Deng. CornerNet: Detecting Objects as Paired Keypoints. arXiv preprint arXiv:1808.01244, 2018. (https://arxiv.org/abs/1808.01244) + +## License + +[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) + +> :memo: Place your license text in a file named LICENSE in the root of the repository. +> +> * Include information about your license. +> * Reference: [Adding a license to a repository](https://help.github.com/en/github/building-a-strong-community/adding-a-license-to-a-repository) + +This project is licensed under the terms of the **Apache License 2.0**. + +## Citation + +> :memo: Make your repository citable. +> +> * Reference: [Making Your Code Citable](https://guides.github.com/activities/citable-code/) + +If you want to cite this repository in your research paper, please use the following information. diff --git a/centernet/common/registry_imports.py b/centernet/common/registry_imports.py index bd7398f8b..101cd8be9 100755 --- a/centernet/common/registry_imports.py +++ b/centernet/common/registry_imports.py @@ -14,5 +14,10 @@ # ============================================================================== """All necessary imports for registration.""" +import centernet +from centernet.configs import centernet +from centernet.configs.centernet import CenterNetTask +from centernet.modeling.backbones import hourglass +from centernet.tasks.centernet import CenterNetTask # pylint: disable=unused-import from official.common import registry_imports diff --git a/centernet/configs/backbones.py b/centernet/configs/backbones.py new file mode 100644 index 000000000..6128ac9fa --- /dev/null +++ b/centernet/configs/backbones.py @@ -0,0 +1,41 @@ +# Lint as: python3 +# Copyright 2020 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""Backbones configurations.""" +# Import libraries +import dataclasses +from typing import List + +from official.modeling import hyperparams +from official.vision.beta.configs import backbones + + +@dataclasses.dataclass +class Hourglass(hyperparams.Config): + """Hourglass config.""" + input_channel_dims: int = 128 + channel_dims_per_stage: List[int] = dataclasses.field( + default_factory=lambda: [256, 256, 384, 384, 384, 512]) + blocks_per_stage: List[int] = dataclasses.field( + default_factory=lambda: [2, 2, 2, 2, 2, 4]) + num_hourglasses: int = 2 + initial_downsample: bool = True + norm_momentum: float = 0.1 + norm_episilon: float = 1e-5 + + +@dataclasses.dataclass +class Backbone(backbones.Backbone): + hourglass: Hourglass = Hourglass() diff --git a/centernet/configs/centernet.py b/centernet/configs/centernet.py new file mode 100644 index 000000000..197a7163e --- /dev/null +++ b/centernet/configs/centernet.py @@ -0,0 +1,401 @@ +# Lint as: python3 +# Copyright 2020 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""CenterNet configuration definition.""" +# Import libraries +import dataclasses +from typing import ClassVar, Dict, List, Optional, Tuple, Union + +from centernet.configs import backbones +from official.core import exp_factory +from official.modeling import hyperparams, optimization +from official.modeling.hyperparams import config_definitions as cfg +from official.vision.beta.configs import common + + +# default param classes +@dataclasses.dataclass +class ModelConfig(hyperparams.Config): + + @property + def input_size(self): + if self._input_size is None: + return [None, None, 3] + else: + return self._input_size + + @input_size.setter + def input_size(self, input_size): + self._input_size = input_size + + @property + def backbone(self): + if isinstance(self.base, str): + # TODO: remove the automatic activation setter + # self.norm_activation.activation = Yolo._DEFAULTS[self.base].activation + return CenterNet._DEFAULTS[self.base].backbone + else: + return self.base.backbone + + @backbone.setter + def backbone(self, val): + self.base.backbone = val + + @property + def decoder(self): + if isinstance(self.base, str): + return CenterNet._DEFAULTS[self.base].decoder + else: + return self.base.decoder + + @decoder.setter + def decoder(self, val): + self.base.decoder = val + + @property + def odapi_weights_file(self): + if isinstance(self.base, str): + return CenterNet._DEFAULTS[self.base].odapi_weights + else: + return self.base.odapi_weights + + @property + def extremenet_weights_file(self): + if isinstance(self.base, str): + return CenterNet._DEFAULTS[self.base].extremenet_weights + else: + return self.base.extremenet_weights + +@dataclasses.dataclass +class TfExampleDecoder(hyperparams.Config): + regenerate_source_id: bool = False + +@dataclasses.dataclass +class TfExampleDecoderLabelMap(hyperparams.Config): + regenerate_source_id: bool = False + label_map: str = '' + +@dataclasses.dataclass +class DataDecoder(hyperparams.OneOfConfig): + type: Optional[str] = 'simple_decoder' + simple_decoder: TfExampleDecoder = TfExampleDecoder() + label_map_decoder: TfExampleDecoderLabelMap = TfExampleDecoderLabelMap() + +# dataset parser +@dataclasses.dataclass +class Parser(hyperparams.Config): + image_w: int = 512 + image_h: int = 512 + max_num_instances: int = 128 + bgr_ordering: bool = True + channel_means: List[int] = dataclasses.field( + default_factory=lambda: [104.01362025, 114.03422265, 119.9165958]) + channel_stds: List[int] = dataclasses.field( + default_factory=lambda: [73.6027665, 69.89082075, 70.9150767]) + dtype: str = 'float32' + +@dataclasses.dataclass +class DataConfig(cfg.DataConfig): + """Input config for training.""" + input_path: str = 'gs://tensorflow2/coco_records/val/2017*' + tfds_name: str = None #'coco' + tfds_split: str = None #'train' #'val' + global_batch_size: int = 32 + is_training: bool = True + dtype: str = 'float16' + decoder: DataDecoder = DataDecoder() + parser: Parser = Parser() + shuffle_buffer_size: int = 10000 + tfds_download: bool = False + cache: bool = False + +class Loss(hyperparams.Config): + pass + +@dataclasses.dataclass +class DetectionLoss(Loss): + detection_weight: float = 1.0 + corner_pull_weight: float = 0.1 # alpha + corner_push_weight: float = 0.1 # beta + offset_weight: float = 1.0 # gamma + scale_weight: float = 0.1 + + +@dataclasses.dataclass +class SegmentationLoss(Loss): + pass + + +@dataclasses.dataclass +class Losses(hyperparams.Config): + detection: DetectionLoss = DetectionLoss() + segmentation: SegmentationLoss = SegmentationLoss() + image_h: int = 512 + image_w: int = 512 + output_dims: int = 128 + max_num_instances: int = 128 + use_gaussian_bump: bool = True + gaussian_rad: int = -1 + gaussian_iou: float = 0.7 + class_offset: int = 1 + dtype: str = 'float32' + +@dataclasses.dataclass +class CenterNetDecoder(hyperparams.Config): + heatmap_bias: float = -2.19 + +@dataclasses.dataclass +class CenterNetLayer(hyperparams.Config): + max_detections: int = 100 + peak_error: float = 1e-6 + peak_extract_kernel_size: int = 3 + class_offset: int = 1 + net_down_scale: int = 4 + input_image_dims: int = 512 + use_nms: bool = False + nms_pre_thresh: float = 0.1 + nms_thresh: float = 0.4 + use_reduction_sum: bool = True + +@dataclasses.dataclass +class CenterNetDetection(hyperparams.Config): + use_centers: bool = True + use_corners: bool = False + predict_3d: bool = False + +@dataclasses.dataclass +class CenterNetSubTasks(hyperparams.Config): + detection: CenterNetDetection = CenterNetDetection() + # kp_detection: bool = False + segmentation: bool = False + # pose: bool = False + # reid: bool = False + # temporal: bool = False + +@dataclasses.dataclass +class CenterNetBase(hyperparams.OneOfConfig): + backbone: backbones.Backbone = backbones.Backbone(type='hourglass') + decoder: CenterNetDecoder = CenterNetDecoder() + odapi_weights: str = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\checkpoint' + extremenet_weights: str = 'D:\\weights\extremenet' + backbone_name: str = 'hourglass104_512' + decoder_name: str = 'detection_2d' + +@dataclasses.dataclass +class CenterNet(ModelConfig): + base: Union[str, CenterNetBase] = CenterNetBase() + num_classes: int = 90 + _input_size: Optional[List[int]] = None + filter: CenterNetLayer = CenterNetLayer() + +@dataclasses.dataclass +class CenterNetTask(cfg.TaskConfig): + model: CenterNet = CenterNet() + train_data: DataConfig = DataConfig(is_training=True) + validation_data: DataConfig = DataConfig(is_training=False) + subtasks: CenterNetSubTasks = CenterNetSubTasks() + losses: Losses = Losses() + + per_category_metrics: bool = False + weight_decay: float = 5e-4 + + init_checkpoint: str = None + annotation_file: Optional[str] = None + gradient_clip_norm: float = 0.0 + load_odapi_weights: bool = True + load_extremenet_weights: bool = False + + def _get_output_length_dict(self): + lengths = {} + assert self.subtasks.detection is not None or self.subtasks.kp_detection \ + or self.subtasks.segmentation, "You must specify at least one " \ + "subtask to CenterNet" + + if self.subtasks.detection: + # TODO: locations of the ground truths will also be passed in from the + # data pipeline which need to be mapped accordingly + assert self.subtasks.detection.use_centers or \ + self.subtasks.detection.use_corners, "Cannot use CenterNet without " \ + "heatmaps" + if self.subtasks.detection.use_centers: + lengths.update({ + 'ct_heatmaps': self.model.num_classes, + 'ct_offset': 2, + }) + if not self.subtasks.detection.use_corners: + lengths['ct_size'] = 2 + + if self.subtasks.detection.use_corners: + lengths.update({ + 'tl_heatmaps': self.model.num_classes, + 'tl_offset': 2, + 'br_heatmaps': self.model.num_classes, + 'br_offset': 2 + }) + + if self.subtasks.detection.predict_3d: + lengths.update({ + 'depth': 1, + 'orientation': 8 + }) + + if self.subtasks.segmentation: + lengths['seg_heatmaps'] = self.model.num_classes + + # if self.subtasks.pose: + # lengths.update({ + # 'pose_heatmaps': 17, + # 'joint_locs': 17 * 2, + # 'joint_offset': 2 + # }) + + return lengths + +@exp_factory.register_config_factory('centernet_custom') +def centernet_custom() -> cfg.ExperimentConfig: + """COCO object detection with CenterNet.""" + train_batch_size = 1 + eval_batch_size = 1 + base_default = 1200000 + num_batches = 1200000 * 64 / train_batch_size + + config = cfg.ExperimentConfig( + runtime=cfg.RuntimeConfig( + # mixed_precision_dtype='float16', + # loss_scale='dynamic', + num_gpus=2), + task=CenterNetTask( + model=CenterNet(), + train_data=DataConfig( # input_path=os.path.join( + # COCO_INPUT_PATH_BASE, 'train*'), + is_training=True, + global_batch_size=train_batch_size, + parser=Parser(), + shuffle_buffer_size=2), + validation_data=DataConfig( + # input_path=os.path.join(COCO_INPUT_PATH_BASE, + # 'val*'), + is_training=False, + global_batch_size=eval_batch_size, + shuffle_buffer_size=2)), + trainer=cfg.TrainerConfig( + steps_per_loop=2000, + summary_interval=8000, + checkpoint_interval=10000, + train_steps=num_batches, + validation_steps=625, + validation_interval=10, + optimizer_config=optimization.OptimizationConfig({ + 'optimizer': { + 'type': 'sgd', + 'sgd': { + 'momentum': 0.9 + } + }, + 'learning_rate': { + 'type': 'stepwise', + 'stepwise': { + 'boundaries': [ + int(400000 / base_default * num_batches), + int(450000 / base_default * num_batches) + ], + 'values': [ + 0.00261 * train_batch_size / 64, + 0.000261 * train_batch_size / 64, + 0.0000261 * train_batch_size / 64 + ] + } + }, + 'warmup': { + 'type': 'linear', + 'linear': { + 'warmup_steps': 1000 * 64 // num_batches, + 'warmup_learning_rate': 0 + } + } + })), + restrictions=[ + 'task.train_data.is_training != None', + 'task.validation_data.is_training != None' + ]) + + return config + +@exp_factory.register_config_factory('centernet_tpu') +def centernet_tpu() -> cfg.ExperimentConfig: + """COCO object detection with CenterNet.""" + train_batch_size = 1 + eval_batch_size = 8 + base_default = 1200000 + num_batches = 1200000 * 64 / train_batch_size + + config = cfg.ExperimentConfig( + runtime=cfg.RuntimeConfig(mixed_precision_dtype='bfloat16'), + task=CenterNetTask( + model=CenterNet(), + train_data=DataConfig( # input_path=os.path.join( + # COCO_INPUT_PATH_BASE, 'train*'), + is_training=True, + global_batch_size=train_batch_size, + parser=Parser(), + shuffle_buffer_size=10000), + validation_data=DataConfig( + # input_path=os.path.join(COCO_INPUT_PATH_BASE, + # 'val*'), + is_training=False, + global_batch_size=eval_batch_size, + shuffle_buffer_size=100)), + trainer=cfg.TrainerConfig( + steps_per_loop=2000, + summary_interval=8000, + checkpoint_interval=10000, + train_steps=num_batches, + validation_steps=625, + validation_interval=1, + optimizer_config=optimization.OptimizationConfig({ + 'optimizer': { + 'type': 'sgd', + 'sgd': { + 'momentum': 0.9 + } + }, + 'learning_rate': { + 'type': 'stepwise', + 'stepwise': { + 'boundaries': [ + int(400000 / base_default * num_batches), + int(450000 / base_default * num_batches) + ], + 'values': [ + 0.00261 * train_batch_size / 64, + 0.000261 * train_batch_size / 64, + 0.0000261 * train_batch_size / 64 + ] + } + }, + 'warmup': { + 'type': 'linear', + 'linear': { + 'warmup_steps': 1000 * 64 // num_batches, + 'warmup_learning_rate': 0 + } + } + })), + restrictions=[ + 'task.train_data.is_training != None', + 'task.validation_data.is_training != None' + ]) + + return config diff --git a/centernet/configs/experiments/centernet-eval-tpu.yaml b/centernet/configs/experiments/centernet-eval-tpu.yaml new file mode 100644 index 000000000..7d413cbcc --- /dev/null +++ b/centernet/configs/experiments/centernet-eval-tpu.yaml @@ -0,0 +1,93 @@ +runtime: + distribution_strategy: 'tpu' + mixed_precision_dtype: 'bfloat16' +task: + model: + base: + backbone: + type: hourglass + decoder: + heatmap_bias: -2.19 + odapi_weights: '/home/cam2tensorflow/centernet_hg104_512x512_coco17_tpu-8/checkpoint' + backbone_name: hourglass104_512 + decoder_name: detection_2d + num_classes: 90 + _input_size: [512, 512, 3] # null + filter: + max_detections: 100 + peak_error: 0.000001 + peak_extract_kernel_size: 3 + class_offset: 1 + net_down_scale: 4 + input_image_dims: 512 + use_nms: False + nms_pre_thresh: 0.3 + nms_thresh: 0.4 + use_reduction_sum: True + validation_data: + input_path: 'gs://tensorflow2/coco_records/val/2017*' + global_batch_size: 8 + tfds_download: false + dtype: bfloat16 + is_training: false + drop_remainder: false + parser: + image_h: 512 + image_w: 512 + max_num_instances: 128 + bgr_ordering: True + channel_means: [104.01362025, 114.03422265, 119.9165958] + channel_stds: [73.6027665, 69.89082075, 70.9150767] + dtype: 'float32' + shuffle_buffer_size: 100 + subtasks: + detection: + use_centers: true + use_corners: false + predict_3d: false + segmentation: false + losses: + detection: + detection_weight: 1.0 + corner_pull_weight: 0.1 + corner_push_weight: 0.1 + offset_weight: 1.0 + image_h: 512 + image_w: 512 + output_dims: 128 + max_num_instances: 128 + use_gaussian_bump: true + gaussian_rad: -1 + gaussian_iou: 0.7 + class_offset: 1 + dtype: float32 + per_category_metrics: false + weight_decay: 0.0005 + init_checkpoint: '' + annotation_file: null + gradient_clip_norm: 0.0 + load_odapi_weights: true + load_extremenet_weights: false +trainer: + train_steps: 10000 # 160 epochs at 64 batchsize -> 500500 * 64/16 + validation_steps: 625 # 5063 #625 + steps_per_loop: 10000 + validation_interval: 1 + summary_interval: 10000 + checkpoint_interval: 10000 + optimizer_config: + learning_rate: + type: stepwise + stepwise: + boundaries: [800000, 900000] # [400000, 450000] + name: PiecewiseConstantDecay + values: [0.00065, 0.000065, 0.0000065] #[0.0013, 0.00013, 0.000013] + optimizer: + type: sgd + sgd: + momentum: 0.949 + name: SGD + warmup: + type: 'linear' + linear: + warmup_steps: 1000 #learning rate rises from 0 to 0.0013 over 1000 steps diff --git a/centernet/configs/experiments/centernet-eval.yaml b/centernet/configs/experiments/centernet-eval.yaml new file mode 100644 index 000000000..46b0be69f --- /dev/null +++ b/centernet/configs/experiments/centernet-eval.yaml @@ -0,0 +1,91 @@ +runtime: + distribution_strategy: mirrored + mixed_precision_dtype: float16 + loss_scale: "dynamic" + num_gpus: 1 +task: + model: + base: + backbone: + type: hourglass + decoder: + heatmap_bias: -2.19 + odapi_weights: 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8/checkpoint' + # odapi_weights: '/home/cam2tensorflow/centernet_hg104_512x512_coco17_tpu-8/checkpoint' + # extremenet_weights: 'D:\\weights\extremenet' + backbone_name: hourglass104_512 + decoder_name: detection_2d + num_classes: 90 + _input_size: [512, 512, 3] # null + filter: + max_detections: 100 + peak_error: 0.000001 + peak_extract_kernel_size: 3 + use_nms: false + center_thresh: 0.1 + iou_thresh: 0.4 + class_offset: 1 + validation_data: + # input_path: 'gs://tensorflow2/coco_records/val/2017*' + tfds_data_dir: 'D:\\Datasets' + tfds_name: coco/2017 + tfds_split: validation + global_batch_size: 8 + tfds_download: true + dtype: float16 + is_training: false + drop_remainder: true + parser: + image_h: 512 + image_w: 512 + num_classes: 90 + max_num_instances: 128 + use_gaussian_bump: true + gaussian_rad: -1 + gaussian_iou: 0.7 + output_dims: 128 + dtype: float32 + shuffle_buffer_size: 10000 + subtasks: + detection: + use_centers: true + use_corners: false + predict_3d: false + segmentation: false + losses: + detection: + detection_weight: 1.0 + corner_pull_weight: 0.1 + corner_push_weight: 0.1 + offset_weight: 1.0 + segmentation: + per_category_metrics: false + weight_decay: 0.0005 + init_checkpoint: '' + annotation_file: null + gradient_clip_norm: 0.0 + load_odapi_weights: true + load_extremenet_weights: false +trainer: + train_steps: 10000 # 160 epochs at 64 batchsize -> 500500 * 64/16 + validation_steps: 625 # 5063 #625 + steps_per_loop: 10000 + validation_interval: 1 + summary_interval: 10000 + checkpoint_interval: 10000 + optimizer_config: + learning_rate: + type: stepwise + stepwise: + boundaries: [800000, 900000] # [400000, 450000] + name: PiecewiseConstantDecay + values: [0.00065, 0.000065, 0.0000065] #[0.0013, 0.00013, 0.000013] + optimizer: + type: sgd + sgd: + momentum: 0.949 + name: SGD + warmup: + type: 'linear' + linear: + warmup_steps: 1000 #learning rate rises from 0 to 0.0013 over 1000 steps diff --git a/centernet/dataloaders/centernet_input.py b/centernet/dataloaders/centernet_input.py new file mode 100644 index 000000000..8d96fdaa1 --- /dev/null +++ b/centernet/dataloaders/centernet_input.py @@ -0,0 +1,244 @@ +import time + +import tensorflow as tf + +from centernet.ops import preprocessing_ops +from official.vision.beta.dataloaders import parser, utils +from official.vision.beta.ops.preprocess_ops import normalize_image +from yolo.ops import preprocessing_ops as yolo_preprocessing_ops + +from typing import List + + +def pad_max_instances(value, instances, pad_value=0, pad_axis=0): + shape = tf.shape(value) + if pad_axis < 0: + pad_axis = tf.shape(shape)[0] + pad_axis + dim1 = shape[pad_axis] + take = tf.math.reduce_min([instances, dim1]) + value, _ = tf.split( + value, [take, -1], axis=pad_axis) # value[:instances, ...] + pad = tf.convert_to_tensor([tf.math.reduce_max([instances - dim1, 0])]) + nshape = tf.concat([shape[:pad_axis], pad, shape[(pad_axis + 1):]], axis=0) + pad_tensor = tf.fill(nshape, tf.cast(pad_value, dtype=value.dtype)) + value = tf.concat([value, pad_tensor], axis=pad_axis) + return value + +class CenterNetParser(parser.Parser): + """ Parser to parse an image and its annotations into a dictionary of tensors """ + + def __init__(self, + image_w: int = 512, + image_h: int = 512, + max_num_instances: int = 128, + bgr_ordering: bool = True, + channel_means: List[int] = [104.01362025, 114.03422265, 119.9165958], + channel_stds: List[int] = [73.6027665, 69.89082075, 70.9150767], + dtype: str = 'float32'): + """Initializes parameters for parsing annotations in the dataset. + Args: + image_w: A `Tensor` or `int` for width of input image. + image_h: A `Tensor` or `int` for height of input image. + num_classes: A `Tensor` or `int` for the number of classes. + max_num_instances: An `int` number of maximum number of instances in an image. + use_gaussian_bump: A `boolean` indicating whether or not to splat a + gaussian onto the heatmaps. If set to False, a value of 1 is placed at + the would-be center of the gaussian. + gaussian_rad: A `int` for the desired radius of the gaussian. If this + value is set to -1, then the radius is computed using gaussian_iou. + gaussian_iou: A `float` number for the minimum desired IOU used when + determining the gaussian radius of center locations in the heatmap. + output_dims: A `Tensor` or `int` for output dimensions of the heatmap. + """ + self._image_w = image_w + self._image_h = image_h + self._max_num_instances = max_num_instances + self._bgr_ordering = bgr_ordering + self._channel_means = channel_means + self._channel_stds = channel_stds + + if dtype == 'float16': + self._dtype = tf.float16 + elif dtype == 'bfloat16': + self._dtype = tf.bfloat16 + elif dtype == 'float32': + self._dtype = tf.float32 + else: + raise Exception( + 'Unsupported datatype used in parser only {float16, bfloat16, or float32}' + ) + + def _parse_train_data(self, data): + """Generates images and labels that are usable for model training. + + Args: + data: a dict of Tensors produced by the decoder. + + Returns: + images: the image tensor. + labels: a dict of Tensors that contains labels. + """ + # FIXME: This is a copy of parse eval data + image = data['image'] / 255 + boxes = data['groundtruth_boxes'] + classes = data['groundtruth_classes'] + + image, boxes, info = yolo_preprocessing_ops.letter_box( + image, boxes, xs = 0.5, ys = 0.5, target_dim=self._image_w) + + image = tf.cast(image, self._dtype) + shape = tf.shape(image) + height = shape[0] + width = shape[1] + + image, labels = self._build_label( + image, boxes, classes, width, height, info, data, is_training=False + ) + + return image, labels + + def _parse_eval_data(self, data): + """Generates images and labels that are usable for model evaluation. + + Args: + decoded_tensors: a dict of Tensors produced by the decoder. + + Returns: + images: the image tensor. + labels: a dict of Tensors that contains labels. + """ + image = tf.cast(data['image'], dtype=tf.float32) + + if self._bgr_ordering: + red, green, blue = tf.unstack(image, num=3, axis=2) + image = tf.stack([blue, green, red], axis=2) + + image = normalize_image(image, offset=self._channel_means, scale=self._channel_stds) + + boxes = data['groundtruth_boxes'] + classes = data['groundtruth_classes'] + + image, boxes, info = yolo_preprocessing_ops.letter_box( + image, boxes, xs = 0.5, ys = 0.5, target_dim=self._image_w) + + image = tf.cast(image, self._dtype) + shape = tf.shape(image) + height = shape[0] + width = shape[1] + + image, labels = self._build_label( + image, boxes, classes, width, height, info, data, is_training=False + ) + + return image, labels + + def _build_label(self, image, boxes, classes, width, height, info, data, + is_training): + imshape = image.get_shape().as_list() + imshape[-1] = 3 + image.set_shape(imshape) + + bshape = boxes.get_shape().as_list() + boxes = pad_max_instances(boxes, self._max_num_instances, 0) + bshape[0] = self._max_num_instances + boxes.set_shape(bshape) + + cshape = classes.get_shape().as_list() + classes = pad_max_instances(classes, + self._max_num_instances, -1) + cshape[0] = self._max_num_instances + classes.set_shape(cshape) + + area = data['groundtruth_area'] + ashape = area.get_shape().as_list() + area = pad_max_instances(area, self._max_num_instances,0) + ashape[0] = self._max_num_instances + area.set_shape(ashape) + + is_crowd = data['groundtruth_is_crowd'] + ishape = is_crowd.get_shape().as_list() + is_crowd = pad_max_instances( + tf.cast(is_crowd, tf.int32), self._max_num_instances, 0) + ishape[0] = self._max_num_instances + is_crowd.set_shape(ishape) + + num_detections = tf.shape(data['groundtruth_classes'])[0] + labels = { + 'source_id': utils.process_source_id(data['source_id']), + 'bbox': tf.cast(boxes, self._dtype), + 'classes': tf.cast(classes, self._dtype), + 'area': tf.cast(area, self._dtype), + 'is_crowd': is_crowd, + 'width': width, + 'height': height, + 'info': info, + 'num_detections': num_detections + } + + return image, labels + + def postprocess_fn(self, is_training): + if is_training: #or self._cutmix + return None # if not self._fixed_size or self._mosaic else None + else: + return None + + +if __name__ == '__main__': + # This code is for visualization (outdated since we moved ground truth label + # builder to the loss function) + import matplotlib.pyplot as plt + + + resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='node-8') + tf.config.experimental_connect_to_cluster(resolver) + tf.tpu.experimental.initialize_tpu_system(resolver) + print("All devices: ", tf.config.list_logical_devices('TPU')) + + boxes = tf.constant([ + (10, 300, 15, 370), # center (y, x) = (12, 335) + (100, 300, 150, 370), # center (y, x) = (125, 335) + (15, 100, 200, 170), # center (y, x) = (107, 135) + ], dtype=tf.float32) + + classes = tf.constant((1, 1, 1), dtype=tf.float32) + + boxes = pad_max_instances(boxes, 128, 0) + classes = pad_max_instances(classes, 128, -1) + + parser = CenterNetParser() + + # print("testing original build heatmaps function: ") + # a = time.time() + # with tf.device('/TPU:0'): + # labels1 = parser._build_heatmap_and_regressed_features1( + # labels = { + # 'bbox': boxes, + # 'num_detections': 3, + # 'classes': classes + # }, + # output_size=[512, 512], input_size=[512, 512] + # ) + # b = time.time() + # print("Time taken: {} ms", (b-a) * 1000) + + print("testing new build heatmaps function: ") + a = time.time() + with tf.device('/TPU:0'): + labels = parser._build_heatmap_and_regressed_features( + labels = { + 'bbox': boxes, + 'num_detections': 3, + 'classes': classes + }, + output_size=[512, 512], input_size=[512, 512] + ) + b = time.time() + print("Time taken: {} ms", (b-a) * 1000) + + # tl_heatmaps = labels['tl_heatmaps'] + # br_heatmaps = labels['br_heatmaps'] + # ct_heatmaps = labels['ct_heatmaps'] + + # plt.imshow(ct_heatmaps[..., 0]) + # plt.show() diff --git a/centernet/dataloaders/centernet_input_test.py b/centernet/dataloaders/centernet_input_test.py new file mode 100755 index 000000000..020be0272 --- /dev/null +++ b/centernet/dataloaders/centernet_input_test.py @@ -0,0 +1,139 @@ +import tensorflow as tf +from absl.testing import parameterized + +from centernet.dataloaders.centernet_input import CenterNetParser + + +def pad_max_instances(value, instances, pad_value=0, pad_axis=0): + shape = tf.shape(value) + if pad_axis < 0: + pad_axis = tf.shape(shape)[0] + pad_axis + dim1 = shape[pad_axis] + take = tf.math.reduce_min([instances, dim1]) + value, _ = tf.split( + value, [take, -1], axis=pad_axis) # value[:instances, ...] + pad = tf.convert_to_tensor([tf.math.reduce_max([instances - dim1, 0])]) + nshape = tf.concat([shape[:pad_axis], pad, shape[(pad_axis + 1):]], axis=0) + pad_tensor = tf.fill(nshape, tf.cast(pad_value, dtype=value.dtype)) + value = tf.concat([value, pad_tensor], axis=pad_axis) + return value + +class CenterNetInputTest(tf.test.TestCase, parameterized.TestCase): + def check_labels_correct(self, boxes, classes, output_size, input_size): + parser = CenterNetParser() + num_dets = len(boxes) + boxes = tf.constant(boxes, dtype=tf.float32) + classes = tf.constant(classes, dtype=tf.float32) + + boxes = pad_max_instances(boxes, 128, 0) + classes = pad_max_instances(classes, 128, -1) + + labels = parser._build_heatmap_and_regressed_features( + labels = { + 'bbox': boxes, + 'num_detections': num_dets, + 'classes': classes + }, + output_size=output_size, input_size=input_size) + + tl_heatmaps = labels['tl_heatmaps'] + br_heatmaps = labels['br_heatmaps'] + ct_heatmaps = labels['ct_heatmaps'] + tl_offset = labels['tl_offset'] + br_offset = labels['br_offset'] + ct_offset = labels['ct_offset'] + size = labels['size'] + box_mask = labels['box_mask'] + box_indices = labels['box_indices'] + + boxes = tf.cast(boxes, tf.float32) + classes = tf.cast(classes, tf.float32) + height_ratio = output_size[0] / input_size[0] + width_ratio = output_size[1] / input_size[1] + + # Shape checks + self.assertEqual(tl_heatmaps.shape, (output_size[0], output_size[1], 90)) + self.assertEqual(br_heatmaps.shape, (output_size[0], output_size[1], 90)) + self.assertEqual(ct_heatmaps.shape, (output_size[0], output_size[1], 90)) + + self.assertEqual(tl_offset.shape, (parser._max_num_instances, 2)) + self.assertEqual(br_offset.shape, (parser._max_num_instances, 2)) + self.assertEqual(ct_offset.shape, (parser._max_num_instances, 2)) + + self.assertEqual(size.shape, (parser._max_num_instances, 2)) + self.assertEqual(box_mask.shape, (parser._max_num_instances)) + self.assertEqual(box_indices.shape, (parser._max_num_instances, 2)) + + self.assertAllInRange(tl_heatmaps, 0, 1) + self.assertAllInRange(br_heatmaps, 0, 1) + self.assertAllInRange(ct_heatmaps, 0, 1) + + for i in range(len(boxes)): + # Check sizes + self.assertAllEqual(size[i], + [(boxes[i][3] - boxes[i][1]) * width_ratio, + (boxes[i][2] - boxes[i][0]) * height_ratio]) + + # Check box indices + y = tf.math.floor((boxes[i][0] + boxes[i][2]) / 2 * height_ratio) + x = tf.math.floor((boxes[i][1] + boxes[i][3]) / 2 * width_ratio) + self.assertAllEqual(box_indices[i], [y, x]) + + # check offsets + true_y = (boxes[i][0] + boxes[i][2]) / 2 * height_ratio + true_x = (boxes[i][1] + boxes[i][3]) / 2 * width_ratio + self.assertAllEqual(ct_offset[i], [true_x - x, true_y - y]) + + for i in range(len(boxes), parser._max_num_instances): + # Make sure rest are zero + self.assertAllEqual(size[i], [0, 0]) + self.assertAllEqual(box_indices[i], [0, 0]) + self.assertAllEqual(ct_offset[i], [0, 0]) + + # Check mask indices + self.assertAllEqual(tf.cast(box_mask[3:], tf.int32), + tf.repeat(0, repeats=parser._max_num_instances-3)) + self.assertAllEqual(tf.cast(box_mask[:3], tf.int32), + tf.repeat(1, repeats=3)) + + + def test_generate_heatmap_no_scale(self): + boxes = [ + (10, 300, 15, 370), + (100, 300, 150, 370), + (15, 100, 200, 170), + ] + classes = (1, 2, 3) + sizes = [512, 512] + + self.check_labels_correct(boxes=boxes, classes=classes, + output_size=sizes, input_size=sizes) + + def test_generate_heatmap_scale_1(self): + boxes = [ + (10, 300, 15, 370), + (100, 300, 150, 370), + (15, 100, 200, 170), + ] + classes = (1, 2, 3) + output_size = [128, 128] + input_size = [512, 512] + + self.check_labels_correct(boxes=boxes, classes=classes, + output_size=output_size, input_size=input_size) + + def test_generate_heatmap_scale_2(self): + boxes = [ + (10, 300, 15, 370), + (100, 300, 150, 370), + (15, 100, 200, 170), + ] + classes = (1, 2, 3) + output_size = [128, 128] + input_size = [1024, 1024] + + self.check_labels_correct(boxes=boxes, classes=classes, + output_size=output_size, input_size=input_size) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/demo.py b/centernet/demo.py new file mode 100644 index 000000000..6f66d2927 --- /dev/null +++ b/centernet/demo.py @@ -0,0 +1,52 @@ +import tensorflow as tf + +from centernet.configs.centernet import CenterNetTask +from centernet.modeling.CenterNet import build_centernet +from centernet.utils.weight_utils.load_weights import ( + get_model_weights_as_dict, load_weights_backbone, load_weights_model) +from official.vision.beta.ops.preprocess_ops import normalize_image +from yolo.demos.video_detect_cpu import runner +from yolo.demos.video_detect_gpu import FastVideo +from yolo.utils.run_utils import prep_gpu + +CENTERNET_CKPT_PATH = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\checkpoint' +CLIP_PATH = r'D:\\Documents\Research\Software\nyc_demo_fast.mp4' + +def preprocess_fn(image, + channel_means=(104.01362025, 114.03422265, 119.9165958), + channel_stds=(73.6027665 , 69.89082075, 70.9150767)): + + image = tf.cast(image, dtype=tf.float32) + red, green, blue = tf.unstack(image, num=3, axis=3) + image = tf.stack([blue, green, red], axis=3) + image = normalize_image(image, offset=channel_means, scale=channel_stds) + + return image + + +if __name__ == '__main__': + prep_gpu() + input_specs = tf.keras.layers.InputSpec(shape=[1, 512, 512, 3]) + config = CenterNetTask() + + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + + weights_dict, _ = get_model_weights_as_dict(CENTERNET_CKPT_PATH) + load_weights_model(model, weights_dict, 'hourglass104_512', 'detection_2d') + + cap = FastVideo( + CLIP_PATH, # set to 0 if using webcam + model=model, + preprocess_function=preprocess_fn, + process_width=512, + process_height=512, + preprocess_with_gpu=False, + classes=91, + print_conf=True, + max_batch=1, + disp_h=512, + scale_que=1, + wait_time='dynamic') + cap.run() + runner(model, 0, 512, 512) diff --git a/centernet/differential_testing/config_classes.py b/centernet/differential_testing/config_classes.py new file mode 100644 index 000000000..d5f3e40ec --- /dev/null +++ b/centernet/differential_testing/config_classes.py @@ -0,0 +1,204 @@ +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import ClassVar, Dict, List, Tuple + +import numpy as np + + +class Config(ABC): + def get_weights(self): + return None + + def load_weights(self, layer): + weights = self.get_weights() + layer.set_weights(weights) + n_weights = 0 + + for w in weights: + n_weights += w.size + return n_weights + +@dataclass +class ODAPIconvBnCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + weights: np.array = field(repr=False, default=None) + beta: np.array = field(repr=False, default=None) + gamma: np.array = field(repr=False, default=None) + moving_mean: np.array = field(repr=False, default=None) + moving_variance: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_weights_dict = self.weights_dict['conv'] + norm_weights_dict = self.weights_dict['norm'] + + self.weights = conv_weights_dict['kernel'] + self.beta = norm_weights_dict['beta'] + self.gamma = norm_weights_dict['gamma'] + self.moving_mean = norm_weights_dict['moving_mean'] + self.moving_variance = norm_weights_dict['moving_variance'] + + def get_weights(self): + return [ + self.weights, + self.gamma, + self.beta, + self.moving_mean, + self.moving_variance + ] + +@dataclass +class ODAPIresidualBlockCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + + skip_weights: np.array = field(repr=False, default=None) + skip_beta: np.array = field(repr=False, default=None) + skip_gamma: np.array = field(repr=False, default=None) + skip_moving_mean: np.array = field(repr=False, default=None) + skip_moving_variance: np.array = field(repr=False, default=None) + + conv_weights: np.array = field(repr=False, default=None) + norm_beta: np.array = field(repr=False, default=None) + norm_gamma: np.array = field(repr=False, default=None) + norm_moving_mean: np.array = field(repr=False, default=None) + norm_moving_variance: np.array = field(repr=False, default=None) + + conv_block_weights: np.array = field(repr=False, default=None) + conv_block_beta: np.array = field(repr=False, default=None) + conv_block_gamma: np.array = field(repr=False, default=None) + conv_block_moving_mean: np.array = field(repr=False, default=None) + conv_block_moving_variance: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_weights_dict = self.weights_dict['conv'] + norm_weights_dict = self.weights_dict['norm'] + conv_block_weights_dict = self.weights_dict['conv_block'] + + if 'skip' in self.weights_dict: + skip_weights_dict = self.weights_dict['skip'] + self.skip_weights = skip_weights_dict['conv']['kernel'] + self.skip_beta = skip_weights_dict['norm']['beta'] + self.skip_gamma = skip_weights_dict['norm']['gamma'] + self.skip_moving_mean = skip_weights_dict['norm']['moving_mean'] + self.skip_moving_variance = skip_weights_dict['norm']['moving_variance'] + + self.conv_weights = conv_weights_dict['kernel'] + self.norm_beta = norm_weights_dict['beta'] + self.norm_gamma = norm_weights_dict['gamma'] + self.norm_moving_mean = norm_weights_dict['moving_mean'] + self.norm_moving_variance = norm_weights_dict['moving_variance'] + + self.conv_block_weights = conv_block_weights_dict['conv']['kernel'] + self.conv_block_beta = conv_block_weights_dict['norm']['beta'] + self.conv_block_gamma = conv_block_weights_dict['norm']['gamma'] + self.conv_block_moving_mean = conv_block_weights_dict['norm']['moving_mean'] + self.conv_block_moving_variance = conv_block_weights_dict['norm']['moving_variance'] + + def get_weights(self): + weights = [ + self.conv_block_weights, + self.conv_block_gamma, + self.conv_block_beta, + + self.conv_weights, + self.norm_gamma, + self.norm_beta, + + self.skip_weights, + self.skip_gamma, + self.skip_beta, + + self.conv_block_moving_mean, + self.conv_block_moving_variance, + self.norm_moving_mean, + self.norm_moving_variance, + self.skip_moving_mean, + self.skip_moving_variance, + ] + + weights = [x for x in weights if x is not None] + return weights + + +@dataclass +class ODAPIhourglassCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + is_last_stage: bool = field(repr=False, default=None) + + def __post_init__(self): + self.is_last_stage = False if 'inner_block' in self.weights_dict else True + + def generate_block_weights(self, weights_dict): + reps = len(weights_dict.keys()) + weights = [] + n_weights = 0 + + for i in range(reps): + res_config = ODAPIresidualBlockCFG(weights_dict=weights_dict[str(i)]) + res_weights = res_config.get_weights() + weights += res_weights + + for w in res_weights: + n_weights += w.size + + return weights, n_weights + + def load_block_weights(self, layer, weight_dict): + block_weights, n_weights = self.generate_block_weights(weight_dict) + layer.set_weights(block_weights) + return n_weights + + def load_weights(self, layer): + n_weights = 0 + + enc_dec_layers = [ + layer.submodules[1], + layer.submodules[2], + layer.submodules[4] + ] + enc_dec_weight_dicts = [ + self.weights_dict['encoder_block1'], + self.weights_dict['encoder_block2'], + self.weights_dict['decoder_block'] + ] + + for l, weights_dict in zip(enc_dec_layers, enc_dec_weight_dicts): + n_weights += self.load_block_weights(l, weights_dict) + + if len(self.weights_dict['inner_block']) == 1: # still in an outer hourglass + inner_weights_dict = self.weights_dict['inner_block']['0'] + inner_hg_layer = layer.submodules[3] + inner_hg_cfg = type(self)(weights_dict=inner_weights_dict) + n_weights += inner_hg_cfg.load_weights(inner_hg_layer) + else: + inner_weights_dict = self.weights_dict['inner_block'] # inner residual block chain + inner_layer = layer.submodules[3] + n_weights += self.load_block_weights(inner_layer, inner_weights_dict) + + return n_weights + +@dataclass +class ODAPIdecoderConvCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + + conv_1_weights: np.array = field(repr=False, default=None) + conv_2_bias: np.array = field(repr=False, default=None) + + conv_2_weights: np.array = field(repr=False, default=None) + conv_1_bias: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_1_weights_dict = self.weights_dict['layer_with_weights-0'] + conv_2_weights_dict = self.weights_dict['layer_with_weights-1'] + + self.conv_1_weights = conv_1_weights_dict['kernel'] + self.conv_1_bias = conv_1_weights_dict['bias'] + self.conv_2_weights = conv_2_weights_dict['kernel'] + self.conv_2_bias = conv_2_weights_dict['bias'] + + def get_weights(self): + return [ + self.conv_1_weights, + self.conv_1_bias, + self.conv_2_weights, + self.conv_2_bias + ] diff --git a/centernet/differential_testing/load_weights.py b/centernet/differential_testing/load_weights.py new file mode 100644 index 000000000..0eff6aa74 --- /dev/null +++ b/centernet/differential_testing/load_weights.py @@ -0,0 +1,173 @@ +import numpy as np +import tensorflow as tf + +from centernet.configs.centernet import CenterNetTask +from centernet.differential_testing.config_classes import ( + ODAPIconvBnCFG, ODAPIdecoderConvCFG, ODAPIhourglassCFG, + ODAPIresidualBlockCFG) +from centernet.differential_testing.odapi_backbone import hourglass_104 +from centernet.differential_testing.odapi_decoder import \ + _construct_prediction_heads +from centernet.differential_testing.odapi_detection_generator import \ + ODAPIDetectionGenerator +from centernet.modeling.CenterNet import build_centernet +from centernet.utils.weight_utils.load_weights import ( + get_model_weights_as_dict, load_weights_backbone, load_weights_model) + +CKPT_PATH = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\checkpoint' + +def load_weights_odapi_backbone(weights_dict): + odapi_backbone = hourglass_104() + odapi_backbone.build(input_shape=[1, 512, 512, 3]) + + # load weights for downsample block (comprised of a conv and res block) + downsample_conv_cfg = ODAPIconvBnCFG(weights_dict=weights_dict['downsample_input']['conv_block']) + downsample_res_cfg = ODAPIresidualBlockCFG(weights_dict=weights_dict['downsample_input']['residual_block']) + downsample_conv_cfg.load_weights(odapi_backbone.downsample_input.conv_block) + downsample_res_cfg.load_weights(odapi_backbone.downsample_input.residual_block) + + # load weights for encoder/decoder blocks + hourglass_0_cfg = ODAPIhourglassCFG(weights_dict=weights_dict['hourglass_network']['0']) + hourglass_1_cfg = ODAPIhourglassCFG(weights_dict=weights_dict['hourglass_network']['1']) + hourglass_0_cfg.load_weights(odapi_backbone.hourglass_network[0]) + hourglass_1_cfg.load_weights(odapi_backbone.hourglass_network[1]) + + # load weights for hourglass output conv blocks + out_conv_0_cfg = ODAPIconvBnCFG(weights_dict=weights_dict['output_conv']['0']) + out_conv_1_cfg = ODAPIconvBnCFG(weights_dict=weights_dict['output_conv']['1']) + out_conv_0_cfg.load_weights(odapi_backbone.output_conv[0]) + out_conv_1_cfg.load_weights(odapi_backbone.output_conv[1]) + + # load weights for intermediate conv and residual blocks + inter_conv_1_cfg = ODAPIconvBnCFG(weights_dict=weights_dict['intermediate_conv1']['0']) + inter_conv_2_cfg = ODAPIconvBnCFG(weights_dict=weights_dict['intermediate_conv2']['0']) + inter_res_2_cfg = ODAPIresidualBlockCFG(weights_dict=weights_dict['intermediate_residual']['0']) + inter_conv_1_cfg.load_weights(odapi_backbone.intermediate_conv1[0]) + inter_conv_2_cfg.load_weights(odapi_backbone.intermediate_conv2[0]) + inter_res_2_cfg.load_weights(odapi_backbone.intermediate_residual[0]) + + return odapi_backbone + +def load_weights_odapi_decoder(weights_dict): + odapi_decoder = _construct_prediction_heads(90, 2, -2.19) + for key in odapi_decoder.keys(): + for head in odapi_decoder[key]: + head.build(input_shape=[1, 128, 128, 256]) + + # load weights for downsample block (comprised of a conv and res block) + center_0 = ODAPIdecoderConvCFG(weights_dict=weights_dict['object_center']['0']) + center_1 = ODAPIdecoderConvCFG(weights_dict=weights_dict['object_center']['1']) + offset_0 = ODAPIdecoderConvCFG(weights_dict=weights_dict['box.Soffset']['0']) + offset_1 = ODAPIdecoderConvCFG(weights_dict=weights_dict['box.Soffset']['1']) + scale_0 = ODAPIdecoderConvCFG(weights_dict=weights_dict['box.Sscale']['0']) + scale_1 = ODAPIdecoderConvCFG(weights_dict=weights_dict['box.Sscale']['1']) + + center_0.load_weights(odapi_decoder['ct_heatmaps'][0]) + center_1.load_weights(odapi_decoder['ct_heatmaps'][1]) + offset_0.load_weights(odapi_decoder['ct_offset'][0]) + offset_1.load_weights(odapi_decoder['ct_offset'][1]) + scale_0.load_weights(odapi_decoder['ct_size'][0]) + scale_1.load_weights(odapi_decoder['ct_size'][1]) + + return odapi_decoder + +@tf.function +def compare_det_gen(model_1, model_2, input): + out_1 = model_1(input) + out_2 = model_2(input) + + return out_1, out_2 + +@tf.function +def compare_decoder(model_1, prediction_heads, input): + out_1 = model_1(input) + out_2 = dict() + + for key in prediction_heads.keys(): + out_2[key] = [prediction_heads[key][i](input[i]) for i in range(len(input))] + + return out_1, out_2 + +@tf.function +def compare_backbone(model_1, model_2, input): + out_1 = model_1(input) + out_2 = model_2(input) + return out_1, out_2 + +def differential_test_backbone(tfmg_backbone, odapi_backbone): + print("\n Differential test for backbone \n") + test_input = tf.random.uniform( + shape=[1, 512, 512, 3], minval=0, maxval=1, dtype=tf.dtypes.float32, seed=1439 + ) + + tfmg_output, odapi_output = compare_backbone(odapi_backbone, tfmg_backbone, test_input) + tfmg_hm1 = tfmg_output[0] + tfmg_hm2 = tfmg_output[1] + odapi_hm1 = odapi_output[0] + odapi_hm2 = odapi_output[1] + print("Difference between final output feature maps: ", tf.math.reduce_sum(odapi_hm2-tfmg_hm2)) + print("Difference between intermediate hourglass feature maps: ", tf.math.reduce_sum(odapi_hm1-tfmg_hm1)) + +def differential_test_decoder(tfmg_decoder, odapi_decoder): + print("\n Differential test for decoder \n") + test_input = [ + tf.random.uniform(shape=[1, 128, 128, 256], minval=0, maxval=1, + dtype=tf.dtypes.float32, seed=41965) for _ in range(2)] + + tfmg_output, odapi_output = compare_decoder(tfmg_decoder, odapi_decoder, test_input) + + for key in tfmg_output.keys(): + print("For key: {}, difference between first decoded map: ".format(key)) + print(tf.math.reduce_sum(tfmg_output[key][0] - odapi_output[key][0])) + print("For key: {}, difference between second decoded map: ".format(key)) + print(tf.math.reduce_sum(tfmg_output[key][1] - odapi_output[key][1])) + +def differential_test_det_gen(tfmg_det_gen, odapi_det_gen): + print("\n Differential test for detection generator \n") + ct_heatmaps = [ + tf.random.uniform(shape=[1, 128, 128, 90], minval=0, maxval=1, + dtype=tf.dtypes.float32, seed=475) for _ in range(2)] + offset_heatmaps = [ + tf.random.uniform(shape=[1, 128, 128, 2], minval=0, maxval=1, + dtype=tf.dtypes.float32, seed=425) for _ in range(2)] + size_heatmaps = [ + tf.random.uniform(shape=[1, 128, 128, 2], minval=0, maxval=1, + dtype=tf.dtypes.float32, seed=145) for _ in range(2)] + + test_input = { + 'ct_heatmaps': ct_heatmaps, + 'ct_offset': offset_heatmaps, + 'ct_size': size_heatmaps + } + + tfmg_output, odapi_output = compare_det_gen(model.filter, odapi_det_gen, test_input) + print("all bounding box coodinate differences:", tf.math.reduce_sum(tfmg_output['bbox'] - odapi_output['bbox'])) + print("all class prediction difference: ", tf.math.reduce_sum(tfmg_output['classes'] - odapi_output['classes'])) + print("confidence score prediction difference: ", tf.math.reduce_sum(tfmg_output['confidence'] - odapi_output['confidence'])) + print("number detection difference: ", tf.math.reduce_sum(tfmg_output['num_dets'] - odapi_output['num_dets'])) + +if __name__ == '__main__': + # testing if the output between our backbone and the ODAPI backbone matches + weights_dict, n_weights = get_model_weights_as_dict(CKPT_PATH) + backbone_weights_dict = weights_dict['model']['_feature_extractor']['_network'] + decoder_weights_dict = weights_dict['model']['_prediction_head_dict'] + + # load weights into odapi backbone + odapi_backbone = load_weights_odapi_backbone(backbone_weights_dict) + + # load weights into odapi decoder + odapi_decoder = load_weights_odapi_decoder(decoder_weights_dict) + + # create odapi detection generator + odapi_det_gen = ODAPIDetectionGenerator() + + # load weights into tfmg centernet model + input_specs = tf.keras.layers.InputSpec(shape=[1, 512, 512, 3]) + config = CenterNetTask() + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + load_weights_model(model, weights_dict, 'hourglass104_512', 'detection_2d') + + differential_test_backbone(model.backbone, odapi_backbone) + differential_test_decoder(model.decoder, odapi_decoder) + differential_test_det_gen(model.filter, odapi_det_gen) diff --git a/centernet/differential_testing/odapi_backbone.py b/centernet/differential_testing/odapi_backbone.py new file mode 100644 index 000000000..bec4b9f9a --- /dev/null +++ b/centernet/differential_testing/odapi_backbone.py @@ -0,0 +1,463 @@ +import tensorflow as tf + +BATCH_NORM_EPSILON = 1e-5 +BATCH_NORM_MOMENTUM = 0.1 +BATCH_NORM_FUSED = True + + +class IdentityLayer(tf.keras.layers.Layer): + """A layer which passes through the input as it is.""" + + def call(self, inputs): + return inputs + + +def _get_padding_for_kernel_size(kernel_size): + if kernel_size == 7: + return (3, 3) + elif kernel_size == 3: + return (1, 1) + else: + raise ValueError('Padding for kernel size {} not known.'.format( + kernel_size)) + + +def batchnorm(): + try: + return tf.keras.layers.experimental.SyncBatchNormalization( + name='batchnorm', epsilon=1e-5, momentum=0.1) + except AttributeError: + return tf.keras.layers.BatchNormalization( + name='batchnorm', epsilon=1e-5, momentum=0.1, fused=BATCH_NORM_FUSED) + + +class ConvolutionalBlock(tf.keras.layers.Layer): + """Block that aggregates Convolution + Norm layer + ReLU.""" + + def __init__(self, kernel_size, out_channels, stride=1, relu=True, + padding='same'): + """Initializes the Convolutional block. + Args: + kernel_size: int, convolution kernel size. + out_channels: int, the desired number of output channels. + stride: Integer, stride used in the convolution. + relu: bool, whether to use relu at the end of the layer. + padding: str, the padding scheme to use when kernel_size <= 1 + """ + super(ConvolutionalBlock, self).__init__() + + if kernel_size > 1: + padding = 'valid' + padding_size = _get_padding_for_kernel_size(kernel_size) + + # TODO(vighneshb) Explore if removing and using padding option in conv + # layer works. + self.pad = tf.keras.layers.ZeroPadding2D(padding_size) + else: + self.pad = IdentityLayer() + + self.conv = tf.keras.layers.Conv2D( + filters=out_channels, kernel_size=kernel_size, use_bias=False, + strides=stride, padding=padding) + + self.norm = batchnorm() + + if relu: + self.relu = tf.keras.layers.ReLU() + else: + self.relu = IdentityLayer() + + def call(self, inputs): + net = self.pad(inputs) + net = self.conv(net) + net = self.norm(net) + return self.relu(net) + + +class SkipConvolution(ConvolutionalBlock): + """The skip connection layer for a ResNet.""" + + def __init__(self, out_channels, stride): + """Initializes the skip convolution layer. + Args: + out_channels: int, the desired number of output channels. + stride: int, the stride for the layer. + """ + super(SkipConvolution, self).__init__( + out_channels=out_channels, kernel_size=1, stride=stride, relu=False) + + +class ResidualBlock(tf.keras.layers.Layer): + """A Residual block.""" + + def __init__(self, out_channels, skip_conv=False, kernel_size=3, stride=1, + padding='same'): + """Initializes the Residual block. + Args: + out_channels: int, the desired number of output channels. + skip_conv: bool, whether to use a conv layer for skip connections. + kernel_size: int, convolution kernel size. + stride: Integer, stride used in the convolution. + padding: str, the type of padding to use. + """ + + super(ResidualBlock, self).__init__() + self.conv_block = ConvolutionalBlock( + kernel_size=kernel_size, out_channels=out_channels, stride=stride) + + self.conv = tf.keras.layers.Conv2D( + filters=out_channels, kernel_size=kernel_size, use_bias=False, + strides=1, padding=padding) + self.norm = batchnorm() + + if skip_conv: + self.skip = SkipConvolution(out_channels=out_channels, + stride=stride) + else: + self.skip = IdentityLayer() + + self.relu = tf.keras.layers.ReLU() + + def call(self, inputs): + net = self.conv_block(inputs) + net = self.conv(net) + net = self.norm(net) + net_skip = self.skip(inputs) + return self.relu(net + net_skip) + + +class InputDownsampleBlock(tf.keras.layers.Layer): + """Block for the initial feature downsampling.""" + + def __init__(self, out_channels_initial_conv, out_channels_residual_block): + """Initializes the downsample block. + Args: + out_channels_initial_conv: int, the desired number of output channels + in the initial conv layer. + out_channels_residual_block: int, the desired number of output channels + in the underlying residual block. + """ + + super(InputDownsampleBlock, self).__init__() + self.conv_block = ConvolutionalBlock( + kernel_size=7, out_channels=out_channels_initial_conv, stride=2, + padding='valid') + self.residual_block = ResidualBlock( + out_channels=out_channels_residual_block, stride=2, skip_conv=True) + + def call(self, inputs): + return self.residual_block(self.conv_block(inputs)) + + +class InputConvBlock(tf.keras.layers.Layer): + """Block for the initial feature convolution. + This block is used in the hourglass network when we don't want to downsample + the input. + """ + + def __init__(self, out_channels_initial_conv, out_channels_residual_block): + """Initializes the downsample block. + Args: + out_channels_initial_conv: int, the desired number of output channels + in the initial conv layer. + out_channels_residual_block: int, the desired number of output channels + in the underlying residual block. + """ + + super(InputConvBlock, self).__init__() + + self.conv_block = ConvolutionalBlock( + kernel_size=3, out_channels=out_channels_initial_conv, stride=1, + padding='valid') + self.residual_block = ResidualBlock( + out_channels=out_channels_residual_block, stride=1, skip_conv=True) + + def call(self, inputs): + return self.residual_block(self.conv_block(inputs)) + + +def _make_repeated_residual_blocks(out_channels, num_blocks, + initial_stride=1, residual_channels=None, + initial_skip_conv=False): + """Stack Residual blocks one after the other. + Args: + out_channels: int, the desired number of output channels. + num_blocks: int, the number of residual blocks to be stacked. + initial_stride: int, the stride of the initial residual block. + residual_channels: int, the desired number of output channels in the + intermediate residual blocks. If not specifed, we use out_channels. + initial_skip_conv: bool, if set, the first residual block uses a skip + convolution. This is useful when the number of channels in the input + are not the same as residual_channels. + Returns: + blocks: A list of residual blocks to be applied in sequence. + """ + + blocks = [] + + if residual_channels is None: + residual_channels = out_channels + + for i in range(num_blocks - 1): + # Only use the stride at the first block so we don't repeatedly downsample + # the input + stride = initial_stride if i == 0 else 1 + + # If the stide is more than 1, we cannot use an identity layer for the + # skip connection and are forced to use a conv for the skip connection. + skip_conv = stride > 1 + + if i == 0 and initial_skip_conv: + skip_conv = True + + blocks.append( + ResidualBlock(out_channels=residual_channels, stride=stride, + skip_conv=skip_conv) + ) + + if num_blocks == 1: + # If there is only 1 block, the for loop above is not run, + # therefore we honor the requested stride in the last residual block + stride = initial_stride + # We are forced to use a conv in the skip connection if stride > 1 + skip_conv = stride > 1 + else: + stride = 1 + skip_conv = residual_channels != out_channels + + blocks.append(ResidualBlock(out_channels=out_channels, skip_conv=skip_conv, + stride=stride)) + + # return blocks + return tf.keras.Sequential(blocks) + + +def _apply_blocks(inputs, blocks): + net = inputs + + # for block in blocks: + # net = block(net) + + net = blocks(net) + + return net + + +class EncoderDecoderBlock(tf.keras.layers.Layer): + """An encoder-decoder block which recursively defines the hourglass network.""" + + def __init__(self, num_stages, channel_dims, blocks_per_stage, + stagewise_downsample=True, encoder_decoder_shortcut=True): + """Initializes the encoder-decoder block. + Args: + num_stages: int, Number of stages in the network. At each stage we have 2 + encoder and 1 decoder blocks. The second encoder block downsamples the + input. + channel_dims: int list, the output channels dimensions of stages in + the network. `channel_dims[0]` is used to define the number of + channels in the first encoder block and `channel_dims[1]` is used to + define the number of channels in the second encoder block. The channels + in the recursive inner layers are defined using `channel_dims[1:]` + blocks_per_stage: int list, number of residual blocks to use at each + stage. `blocks_per_stage[0]` defines the number of blocks at the + current stage and `blocks_per_stage[1:]` is used at further stages. + stagewise_downsample: bool, whether or not to downsample before passing + inputs to the next stage. + encoder_decoder_shortcut: bool, whether or not to use shortcut + connections between encoder and decoder. + """ + + super(EncoderDecoderBlock, self).__init__() + + out_channels = channel_dims[0] + out_channels_downsampled = channel_dims[1] + + self.encoder_decoder_shortcut = encoder_decoder_shortcut + + if encoder_decoder_shortcut: + self.merge_features = tf.keras.layers.Add() + self.encoder_block1 = _make_repeated_residual_blocks( + out_channels=out_channels, num_blocks=blocks_per_stage[0], + initial_stride=1) + + initial_stride = 2 if stagewise_downsample else 1 + self.encoder_block2 = _make_repeated_residual_blocks( + out_channels=out_channels_downsampled, + num_blocks=blocks_per_stage[0], initial_stride=initial_stride, + initial_skip_conv=out_channels != out_channels_downsampled) + + if num_stages > 1: + self.inner_block = EncoderDecoderBlock(num_stages - 1, channel_dims[1:], + blocks_per_stage[1:], + stagewise_downsample=stagewise_downsample, + encoder_decoder_shortcut=encoder_decoder_shortcut) + else: + self.inner_block = _make_repeated_residual_blocks( + out_channels=out_channels_downsampled, + num_blocks=blocks_per_stage[1]) + + self.decoder_block = _make_repeated_residual_blocks( + residual_channels=out_channels_downsampled, + out_channels=out_channels, num_blocks=blocks_per_stage[0]) + + self.upsample = tf.keras.layers.UpSampling2D(initial_stride) + + def call(self, inputs): + + if self.encoder_decoder_shortcut: + encoded_outputs = _apply_blocks(inputs, self.encoder_block1) + encoded_downsampled_outputs = _apply_blocks(inputs, self.encoder_block2) + inner_block_outputs = _apply_blocks( + encoded_downsampled_outputs, self.inner_block) + + decoded_outputs = _apply_blocks(inner_block_outputs, self.decoder_block) + upsampled_outputs = self.upsample(decoded_outputs) + + if self.encoder_decoder_shortcut: + return self.merge_features([encoded_outputs, upsampled_outputs]) + else: + return upsampled_outputs + + +class HourglassNetwork(tf.keras.Model): + """The hourglass network.""" + + def __init__(self, num_stages, input_channel_dims, channel_dims_per_stage, + blocks_per_stage, num_hourglasses, initial_downsample=True, + stagewise_downsample=True, encoder_decoder_shortcut=True): + """Intializes the feature extractor. + Args: + num_stages: int, Number of stages in the network. At each stage we have 2 + encoder and 1 decoder blocks. The second encoder block downsamples the + input. + input_channel_dims: int, the number of channels in the input conv blocks. + channel_dims_per_stage: int list, the output channel dimensions of each + stage in the hourglass network. + blocks_per_stage: int list, number of residual blocks to use at each + stage in the hourglass network + num_hourglasses: int, number of hourglas networks to stack + sequentially. + initial_downsample: bool, if set, downsamples the input by a factor of 4 + before applying the rest of the network. Downsampling is done with a 7x7 + convolution kernel, otherwise a 3x3 kernel is used. + stagewise_downsample: bool, whether or not to downsample before passing + inputs to the next stage. + encoder_decoder_shortcut: bool, whether or not to use shortcut + connections between encoder and decoder. + """ + + super(HourglassNetwork, self).__init__() + + self.num_hourglasses = num_hourglasses + self.initial_downsample = initial_downsample + if initial_downsample: + self.downsample_input = InputDownsampleBlock( + out_channels_initial_conv=input_channel_dims, + out_channels_residual_block=channel_dims_per_stage[0] + ) + else: + self.conv_input = InputConvBlock( + out_channels_initial_conv=input_channel_dims, + out_channels_residual_block=channel_dims_per_stage[0] + ) + + self.hourglass_network = [] + self.output_conv = [] + for _ in range(self.num_hourglasses): + self.hourglass_network.append( + EncoderDecoderBlock( + num_stages=num_stages, channel_dims=channel_dims_per_stage, + blocks_per_stage=blocks_per_stage, + stagewise_downsample=stagewise_downsample, + encoder_decoder_shortcut=encoder_decoder_shortcut) + ) + self.output_conv.append( + ConvolutionalBlock(kernel_size=3, + out_channels=channel_dims_per_stage[0]) + ) + + self.intermediate_conv1 = [] + self.intermediate_conv2 = [] + self.intermediate_residual = [] + + for _ in range(self.num_hourglasses - 1): + self.intermediate_conv1.append( + ConvolutionalBlock( + kernel_size=1, out_channels=channel_dims_per_stage[0], relu=False) + ) + self.intermediate_conv2.append( + ConvolutionalBlock( + kernel_size=1, out_channels=channel_dims_per_stage[0], relu=False) + ) + self.intermediate_residual.append( + ResidualBlock(out_channels=channel_dims_per_stage[0]) + ) + + self.intermediate_relu = tf.keras.layers.ReLU() + + def call(self, inputs): + + if self.initial_downsample: + inputs = self.downsample_input(inputs) + else: + inputs = self.conv_input(inputs) + + outputs = [] + + for i in range(self.num_hourglasses): + + hourglass_output = self.hourglass_network[i](inputs) + + output = self.output_conv[i](hourglass_output) + outputs.append(output) + + if i < self.num_hourglasses - 1: + secondary_output = (self.intermediate_conv1[i](inputs) + + self.intermediate_conv2[i](output)) + secondary_output = self.intermediate_relu(secondary_output) + inputs = self.intermediate_residual[i](secondary_output) + + return outputs + + @property + def out_stride(self): + """The stride in the output image of the network.""" + return 4 + + @property + def num_feature_outputs(self): + """Ther number of feature outputs returned by the feature extractor.""" + return self.num_hourglasses + + +def _layer_depth(layer): + """Compute depth of Conv/Residual blocks or lists of them.""" + + if isinstance(layer, list): + return sum([_layer_depth(l) for l in layer]) + + elif isinstance(layer, ConvolutionalBlock): + return 1 + + elif isinstance(layer, ResidualBlock): + return 2 + + else: + raise ValueError('Unknown layer - {}'.format(layer)) + +def hourglass_104(): + """The Hourglass-104 backbone. + The architecture parameters are taken from [1]. + Returns: + network: An HourglassNetwork object implementing the Hourglass-104 + backbone. + [1]: https://arxiv.org/abs/1904.07850 + """ + + return HourglassNetwork( + input_channel_dims=128, + channel_dims_per_stage=[256, 256, 384, 384, 384, 512], + num_hourglasses=2, + num_stages=5, + blocks_per_stage=[2, 2, 2, 2, 2, 4], + ) diff --git a/centernet/differential_testing/odapi_decoder.py b/centernet/differential_testing/odapi_decoder.py new file mode 100644 index 000000000..14acb8a58 --- /dev/null +++ b/centernet/differential_testing/odapi_decoder.py @@ -0,0 +1,109 @@ +import tensorflow as tf + +NUM_SIZE_CHANNELS = 2 +NUM_OFFSET_CHANNELS = 2 + +def _construct_prediction_heads(num_classes, num_feature_outputs, + class_prediction_bias_init): + """Constructs the prediction heads based on the specific parameters. + Args: + num_classes: An integer indicating how many classes in total to predict. + num_feature_outputs: An integer indicating how many feature outputs to use + for calculating the loss. The Objects as Points paper attaches loss + functions to multiple (`num_feature_outputs`) feature maps in the the + backbone. E.g. for the hourglass backbone, `num_feature_outputs` is 2. + class_prediction_bias_init: float, the initial value of bias in the + convolutional kernel of the class prediction head. If set to None, the + bias is initialized with zeros. + Returns: + A dictionary of keras modules generated by calling make_prediction_net + function. It will also create and set a private member of the class when + learning the tracking task. + """ + prediction_heads = {} + prediction_heads['ct_heatmaps'] = _make_prediction_net_list( + num_feature_outputs, + num_classes, + kernel_sizes=(3), + num_filters=(256), + bias_fill=class_prediction_bias_init, + name='center') + + prediction_heads['ct_size'] = _make_prediction_net_list( + num_feature_outputs, NUM_SIZE_CHANNELS, name='box_scale') + prediction_heads['ct_offset'] = _make_prediction_net_list( + num_feature_outputs, NUM_OFFSET_CHANNELS, name='box_offset') + + return prediction_heads + + +def make_prediction_net(num_out_channels, kernel_sizes=(3), num_filters=(256), + bias_fill=None, use_depthwise=False, name=None): + """Creates a network to predict the given number of output channels. + This function is intended to make the prediction heads for the CenterNet + meta architecture. + Args: + num_out_channels: Number of output channels. + kernel_sizes: A list representing the sizes of the conv kernel in the + intermediate layer. Note that the length of the list indicates the number + of intermediate conv layers and it must be the same as the length of the + num_filters. + num_filters: A list representing the number of filters in the intermediate + conv layer. Note that the length of the list indicates the number of + intermediate conv layers. + bias_fill: If not None, is used to initialize the bias in the final conv + layer. + use_depthwise: If true, use SeparableConv2D to construct the Sequential + layers instead of Conv2D. + name: Optional name for the prediction net. + Returns: + net: A keras module which when called on an input tensor of size + [batch_size, height, width, num_in_channels] returns an output + of size [batch_size, height, width, num_out_channels] + """ + if isinstance(kernel_sizes, int) and isinstance(num_filters, int): + kernel_sizes = [kernel_sizes] + num_filters = [num_filters] + assert len(kernel_sizes) == len(num_filters) + if use_depthwise: + conv_fn = tf.keras.layers.SeparableConv2D + else: + conv_fn = tf.keras.layers.Conv2D + + # We name the convolution operations explicitly because Keras, by default, + # uses different names during training and evaluation. By setting the names + # here, we avoid unexpected pipeline breakage in TF1. + out_conv = tf.keras.layers.Conv2D( + num_out_channels, + kernel_size=1) + + if bias_fill is not None: + out_conv.bias_initializer = tf.keras.initializers.constant(bias_fill) + + layers = [] + for idx, (kernel_size, + num_filter) in enumerate(zip(kernel_sizes, num_filters)): + layers.append( + conv_fn( + num_filter, + kernel_size=kernel_size, + padding='same')) + layers.append(tf.keras.layers.ReLU()) + layers.append(out_conv) + net = tf.keras.Sequential(layers, name=name) + return net + +def _make_prediction_net_list(num_feature_outputs, num_out_channels, + kernel_sizes=(3), num_filters=(256), + bias_fill=None, name=None): + prediction_net_list = [] + for i in range(num_feature_outputs): + prediction_net_list.append( + make_prediction_net( + num_out_channels, + kernel_sizes=kernel_sizes, + num_filters=num_filters, + bias_fill=bias_fill, + use_depthwise=False, + name='{}_{}'.format(name, i) if name else name)) + return prediction_net_list diff --git a/centernet/differential_testing/odapi_detection_generator.py b/centernet/differential_testing/odapi_detection_generator.py new file mode 100644 index 000000000..a87ef8709 --- /dev/null +++ b/centernet/differential_testing/odapi_detection_generator.py @@ -0,0 +1,218 @@ +import tensorflow.compat.v1 as tf + +PEAK_EPSILON = 1e-6 + +class ODAPIDetectionGenerator(tf.keras.Model): + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def call(self, inputs): + object_center_prob = tf.nn.sigmoid(inputs['ct_heatmaps'][-1]) + + detection_scores, y_indices, x_indices, channel_indices = ( + top_k_feature_map_locations( + object_center_prob, max_pool_kernel_size=3, + k=100)) + multiclass_scores = tf.gather_nd( + object_center_prob, tf.stack([y_indices, x_indices], -1), batch_dims=1) + + num_detections = tf.reduce_sum(tf.to_int32(detection_scores > 0), axis=1) + boxes_strided = None + + boxes_strided = ( + prediction_tensors_to_boxes(y_indices, x_indices, + inputs['ct_size'][-1], + inputs['ct_offset'][-1])) + boxes = convert_strided_predictions_to_normalized_boxes( + boxes_strided, 4) + return { + 'bbox': boxes, + 'classes': channel_indices, + 'confidence': detection_scores, + 'num_dets': num_detections + } + + +def row_col_channel_indices_from_flattened_indices(indices, num_cols, + num_channels): + """Computes row, column and channel indices from flattened indices. + Args: + indices: An integer tensor of any shape holding the indices in the flattened + space. + num_cols: Number of columns in the image (width). + num_channels: Number of channels in the image. + Returns: + row_indices: The row indices corresponding to each of the input indices. + Same shape as indices. + col_indices: The column indices corresponding to each of the input indices. + Same shape as indices. + channel_indices. The channel indices corresponding to each of the input + indices. + """ + # Be careful with this function when running a model in float16 precision + # (e.g. TF.js with WebGL) because the array indices may not be represented + # accurately if they are too large, resulting in incorrect channel indices. + # See: + # https://en.wikipedia.org/wiki/Half-precision_floating-point_format#Precision_limitations_on_integer_values + # + # Avoid using mod operator to make the ops more easy to be compatible with + # different environments, e.g. WASM. + row_indices = (indices // num_channels) // num_cols + col_indices = (indices // num_channels) - row_indices * num_cols + channel_indices_temp = indices // num_channels + channel_indices = indices - channel_indices_temp * num_channels + + return row_indices, col_indices, channel_indices + +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 + +def _get_shape(tensor, num_dims): + assert len(tensor.shape.as_list()) == num_dims + return combined_static_and_dynamic_shape(tensor) + +def _to_float32(x): + return tf.cast(x, tf.float32) + +def convert_strided_predictions_to_normalized_boxes(boxes, stride): + """Converts predictions in the output space to normalized boxes. + Boxes falling outside the valid image boundary are clipped to be on the + boundary. + Args: + boxes: A tensor of shape [batch_size, num_boxes, 4] holding the raw + coordinates of boxes in the model's output space. + stride: The stride in the output space. + true_image_shapes: A tensor of shape [batch_size, 3] representing the true + shape of the input not considering padding. + Returns: + boxes: A tensor of shape [batch_size, num_boxes, 4] representing the + coordinates of the normalized boxes. + """ + # Note: We use tf ops instead of functions in box_list_ops to make this + # function compatible with dynamic batch size. + boxes = boxes * stride + boxes = boxes / 512 + boxes = tf.clip_by_value(boxes, 0.0, 1.0) + return boxes + +def _multi_range(limit, + value_repetitions=1, + range_repetitions=1, + dtype=tf.int32): + return tf.reshape( + tf.tile( + tf.expand_dims(tf.range(limit, dtype=dtype), axis=-1), + multiples=[range_repetitions, value_repetitions]), [-1]) + +def top_k_feature_map_locations(feature_map, max_pool_kernel_size=3, k=100, + per_channel=False): + + if not max_pool_kernel_size or max_pool_kernel_size == 1: + feature_map_peaks = feature_map + else: + feature_map_max_pool = tf.nn.max_pool( + feature_map, ksize=max_pool_kernel_size, strides=1, padding='SAME') + + feature_map_peak_mask = tf.math.abs( + feature_map - feature_map_max_pool) < PEAK_EPSILON + + # Zero out everything that is not a peak. + feature_map_peaks = ( + feature_map * _to_float32(feature_map_peak_mask)) + + batch_size, _, width, num_channels = _get_shape(feature_map, 4) + + if per_channel: + if k == 1: + feature_map_flattened = tf.reshape( + feature_map_peaks, [batch_size, -1, num_channels]) + scores = tf.math.reduce_max(feature_map_flattened, axis=1) + peak_flat_indices = tf.math.argmax( + feature_map_flattened, axis=1, output_type=tf.dtypes.int32) + peak_flat_indices = tf.expand_dims(peak_flat_indices, axis=-1) + else: + # Perform top k over batch and channels. + feature_map_peaks_transposed = tf.transpose(feature_map_peaks, + perm=[0, 3, 1, 2]) + feature_map_peaks_transposed = tf.reshape( + feature_map_peaks_transposed, [batch_size, num_channels, -1]) + scores, peak_flat_indices = tf.math.top_k( + feature_map_peaks_transposed, k=k) + # Convert the indices such that they represent the location in the full + # (flattened) feature map of size [batch, height * width * channels]. + channel_idx = tf.range(num_channels)[tf.newaxis, :, tf.newaxis] + peak_flat_indices = num_channels * peak_flat_indices + channel_idx + scores = tf.reshape(scores, [batch_size, -1]) + peak_flat_indices = tf.reshape(peak_flat_indices, [batch_size, -1]) + else: + if k == 1: + feature_map_peaks_flat = tf.reshape(feature_map_peaks, [batch_size, -1]) + scores = tf.math.reduce_max(feature_map_peaks_flat, axis=1, keepdims=True) + peak_flat_indices = tf.expand_dims(tf.math.argmax( + feature_map_peaks_flat, axis=1, output_type=tf.dtypes.int32), axis=-1) + else: + feature_map_peaks_flat = tf.reshape(feature_map_peaks, [batch_size, -1]) + scores, peak_flat_indices = tf.math.top_k(feature_map_peaks_flat, k=k) + + # Get x, y and channel indices corresponding to the top indices in the flat + # array. + y_indices, x_indices, channel_indices = ( + row_col_channel_indices_from_flattened_indices( + peak_flat_indices, width, num_channels)) + return scores, y_indices, x_indices, channel_indices + +def prediction_tensors_to_boxes(y_indices, x_indices, height_width_predictions, + offset_predictions): + batch_size, num_boxes = _get_shape(y_indices, 2) + _, height, width, _ = _get_shape(height_width_predictions, 4) + height, width = tf.cast(height, tf.float32), tf.cast(width, tf.float32) + + # TF Lite does not support tf.gather with batch_dims > 0, so we need to use + # tf_gather_nd instead and here we prepare the indices for that. + combined_indices = tf.stack([ + _multi_range(batch_size, value_repetitions=num_boxes), + tf.reshape(y_indices, [-1]), + tf.reshape(x_indices, [-1]) + ], axis=1) + + new_height_width = tf.gather_nd(height_width_predictions, combined_indices) + new_height_width = tf.reshape(new_height_width, [batch_size, num_boxes, 2]) + + new_offsets = tf.gather_nd(offset_predictions, combined_indices) + offsets = tf.reshape(new_offsets, [batch_size, num_boxes, 2]) + + y_indices = _to_float32(y_indices) + x_indices = _to_float32(x_indices) + + height_width = tf.maximum(new_height_width, 0) + heights, widths = tf.unstack(height_width, axis=2) + y_offsets, x_offsets = tf.unstack(offsets, axis=2) + + ymin = y_indices + y_offsets - heights / 2.0 + xmin = x_indices + x_offsets - widths / 2.0 + ymax = y_indices + y_offsets + heights / 2.0 + xmax = x_indices + x_offsets + widths / 2.0 + + ymin = tf.clip_by_value(ymin, 0., height) + xmin = tf.clip_by_value(xmin, 0., width) + ymax = tf.clip_by_value(ymax, 0., height) + xmax = tf.clip_by_value(xmax, 0., width) + boxes = tf.stack([ymin, xmin, ymax, xmax], axis=2) + + return boxes diff --git a/centernet/losses/__init__.py b/centernet/losses/__init__.py index e69de29bb..259e5a25f 100755 --- a/centernet/losses/__init__.py +++ b/centernet/losses/__init__.py @@ -0,0 +1,3 @@ +from centernet.losses.l1_localization_loss import L1LocalizationLoss +from centernet.losses.penalty_reduced_logistic_focal_loss import \ + PenaltyReducedLogisticFocalLoss diff --git a/centernet/losses/gt_builder.py b/centernet/losses/gt_builder.py new file mode 100644 index 000000000..40e6a23d7 --- /dev/null +++ b/centernet/losses/gt_builder.py @@ -0,0 +1,229 @@ +import tensorflow as tf + +from centernet.ops import preprocessing_ops + + +def _build_heatmap_and_regressed_features(labels, + output_size=[128, 128], + input_size=[512, 512], + num_classes=90, + max_num_instances=128, + use_gaussian_bump=True, + gaussian_rad=-1, + gaussian_iou=0.7, + class_offset=1, + dtype='float32'): + """ Generates the ground truth labels for centernet. + + Ground truth labels are generated by splatting gaussians on heatmaps for + corners and centers. Regressed features (offsets and sizes) are also + generated. + + Args: + labels: A dictionary of COCO ground truth labels with at minimum the following fields: + bbox: A `Tensor` of shape [max_num_instances, num_boxes, 4], where the last dimension + corresponds to the top left x, top left y, bottom right x, and + bottom left y coordinates of the bounding box + classes: A `Tensor` of shape [max_num_instances, num_boxes] that contains the class of each + box, given in the same order as the boxes + num_detections: A `Tensor` or int that gives the number of objects in the image + output_size: A `list` of length 2 containing the desired output height + and width of the heatmaps + input_size: A `list` of length 2 the expected input height and width of + the image + Returns: + Dictionary of labels with the following fields: + 'tl_heatmaps': A `Tensor` of shape [output_h, output_w, num_classes], + heatmap with splatted gaussians centered at the positions and channels + corresponding to the top left location and class of the object + 'br_heatmaps': `Tensor` of shape [output_h, output_w, num_classes], + heatmap with splatted gaussians centered at the positions and channels + corresponding to the bottom right location and class of the object + 'ct_heatmaps': Tensor of shape [output_h, output_w, num_classes], + heatmap with splatted gaussians centered at the positions and channels + corresponding to the center location and class of the object + 'tl_offset': `Tensor` of shape [max_num_instances, 2], where the first + num_boxes entries contain the x-offset and y-offset of the top-left + corner of an object. All other entires are 0 + 'br_offset': `Tensor` of shape [max_num_instances, 2], where the first + num_boxes entries contain the x-offset and y-offset of the + bottom-right corner of an object. All other entires are 0 + 'ct_offset': `Tensor` of shape [max_num_instances, 2], where the first + num_boxes entries contain the x-offset and y-offset of the center of + an object. All other entires are 0 + 'size': `Tensor` of shape [max_num_instances, 2], where the first + num_boxes entries contain the width and height of an object. All + other entires are 0 + 'box_mask': `Tensor` of shape [max_num_instances], where the first + num_boxes entries are 1. All other entires are 0 + 'box_indices': `Tensor` of shape [max_num_instances, 2], where the first + num_boxes entries contain the y-center and x-center of a valid box. + These are used to extract the regressed box features from the + prediction when computing the loss + """ + if dtype == 'float16': + dtype = tf.float16 + elif dtype == 'bfloat16': + dtype = tf.bfloat16 + elif dtype == 'float32': + dtype = tf.float32 + else: + raise Exception( + 'Unsupported datatype used in ground truth builder only {float16, bfloat16, or float32}' + ) + # Get relevant bounding box and class information from labels + # only keep the first num_objects boxes and classes + num_objects = labels['num_detections'] + boxes = labels['bbox'] + classes = labels['classes'] - class_offset + + # Compute scaling factors for center/corner positions on heatmap + input_size = tf.cast(input_size, dtype) + output_size = tf.cast(output_size, dtype) + input_h, input_w = input_size[0], input_size[1] + output_h, output_w = output_size[0], output_size[1] + + width_ratio = output_w / input_w + height_ratio = output_h / input_h + + # Original box coordinates + ytl, ybr = boxes[..., 0], boxes[..., 2] + xtl, xbr = boxes[..., 1], boxes[..., 3] + yct = (ytl + ybr) / 2 + xct = (xtl + xbr) / 2 + + # Scaled box coordinates (could be floating point) + fxtl = xtl * width_ratio + fytl = ytl * height_ratio + fxbr = xbr * width_ratio + fybr = ybr * height_ratio + fxct = xct * width_ratio + fyct = yct * height_ratio + + # Floor the scaled box coordinates to be placed on heatmaps + xtl = tf.math.floor(fxtl) + ytl = tf.math.floor(fytl) + xbr = tf.math.floor(fxbr) + ybr = tf.math.floor(fybr) + xct = tf.math.floor(fxct) + yct = tf.math.floor(fyct) + + # Offset computations to make up for discretization error + # used for offset maps + # tl_offset_values = tf.stack([fxtl - xtl, fytl - ytl], axis=-1) + # br_offset_values = tf.stack([fxbr - xbr, fybr - ybr], axis=-1) + ct_offset_values = tf.stack([fxct - xct, fyct - yct], axis=-1) + + # Get the scaled box dimensions for computing the gaussian radius + box_widths = boxes[..., 3] - boxes[..., 1] + box_heights = boxes[..., 2] - boxes[..., 0] + + box_widths = box_widths * width_ratio + box_heights = box_heights * height_ratio + + # Used for size map + box_widths_heights = tf.stack([box_widths, box_heights], axis=-1) + + # Center/corner heatmaps + # tl_heatmap = tf.zeros((output_h, output_w, num_classes), dtype) + # br_heatmap = tf.zeros((output_h, output_w, num_classes), dtype) + ct_heatmap = tf.zeros((output_h, output_w, num_classes), dtype) + + # Maps for offset and size features for each instance of a box + # tl_offset = tf.zeros((max_num_instances, 2), dtype) + # br_offset = tf.zeros((max_num_instances, 2), dtype) + ct_offset = tf.zeros((max_num_instances, 2), dtype) + size = tf.zeros((max_num_instances, 2), dtype) + + # Mask for valid box instances and their center indices in the heatmap + box_mask = tf.zeros((max_num_instances), tf.int32) + box_indices = tf.zeros((max_num_instances, 2), tf.int32) + + if use_gaussian_bump: + # Need to gaussians around the centers and corners of the objects + + # First compute the desired gaussian radius + if gaussian_rad == -1: + print(box_widths_heights) + radius = tf.map_fn(fn=lambda x: preprocessing_ops.gaussian_radius(x), + elems=tf.math.ceil(box_widths_heights)) + print(radius) + radius = tf.math.maximum(tf.math.floor(radius), + tf.cast(1.0, radius.dtype)) + else: + radius = tf.constant([gaussian_rad] * max_num_instances, dtype) + # These blobs contain information needed to draw the gaussian + # tl_blobs = tf.stack([classes, xtl, ytl, radius], axis=-1) + # br_blobs = tf.stack([classes, xbr, ybr, radius], axis=-1) + ct_blobs = tf.stack([classes, xct, yct, radius], axis=-1) + + # Get individual gaussian contributions from each bounding box + # tl_gaussians = tf.map_fn( + # fn=lambda x: preprocessing_ops.draw_gaussian( + # tf.shape(tl_heatmap), x, dtype), elems=tl_blobs) + # br_gaussians = tf.map_fn( + # fn=lambda x: preprocessing_ops.draw_gaussian( + # tf.shape(br_heatmap), x, dtype), elems=br_blobs) + ct_gaussians = tf.map_fn( + fn=lambda x: preprocessing_ops.draw_gaussian( + tf.shape(ct_heatmap), x, dtype), elems=ct_blobs) + + # Combine contributions into single heatmaps + # tl_heatmap = tf.math.reduce_max(tl_gaussians, axis=0) + # br_heatmap = tf.math.reduce_max(br_gaussians, axis=0) + ct_heatmap = tf.math.reduce_max(ct_gaussians, axis=0) + + else: + # Instead of a gaussian, insert 1s in the center and corner heatmaps + # tl_hm_update_indices = tf.cast( + # tf.stack([ytl, xtl, classes], axis=-1), tf.int32) + # br_hm_update_indices = tf.cast( + # tf.stack([ybr, xbr, classes], axis=-1), tf.int32) + ct_hm_update_indices = tf.cast( + tf.stack([yct, xct, classes], axis=-1), tf.int32) + + # tl_heatmap = tf.tensor_scatter_nd_update(tl_heatmap, + # tl_hm_update_indices, [1] * num_objects) + # br_heatmap = tf.tensor_scatter_nd_update(br_heatmap, + # br_hm_update_indices, [1] * num_objects) + ct_heatmap = tf.tensor_scatter_nd_update(ct_heatmap, + ct_hm_update_indices, [1] * num_objects) + + # Indices used to update offsets and sizes for valid box instances + update_indices = preprocessing_ops.cartesian_product( + tf.range(num_objects), tf.range(2)) + update_indices = tf.reshape(update_indices, shape=[num_objects, 2, 2]) + + # Write the offsets of each box instance + # tl_offset = tf.tensor_scatter_nd_update( + # tl_offset, update_indices, tl_offset_values) + # br_offset = tf.tensor_scatter_nd_update( + # br_offset, update_indices, br_offset_values) + ct_offset = tf.tensor_scatter_nd_update( + ct_offset, update_indices, ct_offset_values) + + # Write the size of each bounding box + size = tf.tensor_scatter_nd_update(size, update_indices, box_widths_heights) + + # Initially the mask is zeros, so now we unmask each valid box instance + mask_indices = tf.expand_dims(tf.range(num_objects), -1) + mask_values = tf.repeat(1, num_objects) + box_mask = tf.tensor_scatter_nd_update(box_mask, mask_indices, mask_values) + + # Write the y and x coordinate of each box center in the heatmap + box_index_values = tf.cast(tf.stack([yct, xct], axis=-1), dtype=tf.int32) + box_indices = tf.tensor_scatter_nd_update( + box_indices, update_indices, box_index_values) + + labels = { + # 'tl_heatmaps': tl_heatmap, + # 'br_heatmaps': br_heatmap, + 'ct_heatmaps': ct_heatmap, + # 'tl_offset': tl_offset, + # 'br_offset': br_offset, + 'ct_offset': ct_offset, + 'size': size, + 'box_mask': box_mask, + 'box_indices': box_indices + } + return labels diff --git a/centernet/losses/l1_localization_loss.py b/centernet/losses/l1_localization_loss.py new file mode 100644 index 000000000..bc8fab799 --- /dev/null +++ b/centernet/losses/l1_localization_loss.py @@ -0,0 +1,75 @@ +import tensorflow as tf + +try: + # Try to get TF 1.x version if possible + import tensorflow.compat.v1 as tf_v1 + absolute_difference = tf_v1.losses.absolute_difference +except (ImportError, AttributeError): + # The following code was adapted from https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/ops/losses/losses_impl.py + from tensorflow.python.keras.utils import losses_utils + + def absolute_difference( + labels, predictions, weights=1.0, + reduction=tf.keras.losses.Reduction.SUM_BY_NONZERO_WEIGHTS): + """Adds an Absolute Difference loss to the training procedure. + `weights` acts as a coefficient for the loss. If a scalar is provided, then + the loss is simply scaled by the given value. If `weights` is a `Tensor` of + shape `[batch_size]`, then the total loss for each sample of the batch is + rescaled by the corresponding element in the `weights` vector. If the shape + of `weights` matches the shape of `predictions`, then the loss of each + measurable element of `predictions` is scaled by the corresponding value of + `weights`. + Args: + labels: The ground truth output tensor, same dimensions as 'predictions'. + predictions: The predicted outputs. + weights: Optional `Tensor` whose rank is either 0, or the same rank as + `labels`, and must be broadcastable to `labels` (i.e., all dimensions + must be either `1`, or the same as the corresponding `losses` + dimension). + reduction: Type of reduction to apply to loss. + Returns: + Weighted loss float `Tensor`. If `reduction` is `NONE`, this has the same + shape as `labels`; otherwise, it is scalar. + Raises: + ValueError: If the shape of `predictions` doesn't match that of + `labels` or if the shape of `weights` is invalid or if `labels` + or `predictions` is None. + """ + if labels is None: + raise ValueError("labels must not be None.") + if predictions is None: + raise ValueError("predictions must not be None.") + with tf.name_scope(scope, "absolute_difference", + (predictions, labels, weights)) as scope: + predictions = tf.cast(predictions, dtype=tf.float32) + labels = tf.cast(labels, dtype=tf.float32) + predictions.get_shape().assert_is_compatible_with(labels.get_shape()) + losses = tf.abs(tf.subtract(predictions, labels)) + return losses_utils.compute_weighted_loss( + losses, weights, reduction=reduction) + +class L1LocalizationLoss(tf.keras.losses.Loss): + """L1 loss or absolute difference. + When used in a per-pixel manner, each pixel should be given as an anchor. + """ + + def __call__(self, y_true, y_pred, sample_weight=None): + """Compute loss function. + Args: + y_true: A float tensor of shape [batch_size, num_anchors] + representing the regression targets + y_pred: A float tensor of shape [batch_size, num_anchors] + representing the (encoded) predicted locations of objects. + sample_weight: a float tensor of shape [batch_size, num_anchors] + Returns: + loss: a float tensor of shape [batch_size, num_anchors] tensor + representing the value of the loss function. + """ + return absolute_difference( + y_true, + y_pred, + # weights=sample_weight, + reduction=self._get_reduction() + ) + + call = __call__ diff --git a/centernet/losses/l1_localization_loss_test.py b/centernet/losses/l1_localization_loss_test.py new file mode 100644 index 000000000..6e1aa031e --- /dev/null +++ b/centernet/losses/l1_localization_loss_test.py @@ -0,0 +1,21 @@ +import numpy as np +import tensorflow as tf + +from centernet import losses + + +class L1LocalizationLossTest(tf.test.TestCase): + + def test_returns_correct_loss(self): + def graph_fn(): + loss = losses.L1LocalizationLoss(reduction=tf.keras.losses.Reduction.NONE) + pred = [[0.1, 0.2], [0.7, 0.5]] + target = [[0.9, 1.0], [0.1, 0.4]] + + weights = [[1.0, 0.0], [1.0, 1.0]] + return loss(pred, target, weights) + computed_value = graph_fn() + self.assertAllClose(computed_value, [[0.8, 0.0], [0.6, 0.1]], rtol=1e-6) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/losses/penalty_reduced_logistic_focal_loss.py b/centernet/losses/penalty_reduced_logistic_focal_loss.py new file mode 100644 index 000000000..858788be2 --- /dev/null +++ b/centernet/losses/penalty_reduced_logistic_focal_loss.py @@ -0,0 +1,70 @@ +# may be a dupe of retinanet_losses. need to look later +import tensorflow as tf + + +class PenaltyReducedLogisticFocalLoss(tf.keras.losses.Loss): + """Penalty-reduced pixelwise logistic regression with focal loss. + The loss is defined in Equation (1) of the Objects as Points[1] paper. + Although the loss is defined per-pixel in the output space, this class + assumes that each pixel is an anchor to be compatible with the base class. + [1]: https://arxiv.org/abs/1904.07850 + """ + + def __init__(self, *args, alpha=2.0, beta=4.0, sigmoid_clip_value=1e-4, **kwargs): + """Constructor. + Args: + alpha: Focussing parameter of the focal loss. Increasing this will + decrease the loss contribution of the well classified examples. + beta: The local penalty reduction factor. Increasing this will decrease + the contribution of loss due to negative pixels near the keypoint. + sigmoid_clip_value: The sigmoid operation used internally will be clipped + between [sigmoid_clip_value, 1 - sigmoid_clip_value) + """ + self._alpha = alpha + self._beta = beta + self._sigmoid_clip_value = sigmoid_clip_value + super(PenaltyReducedLogisticFocalLoss, self).__init__(*args, **kwargs) + + def call(self, y_true, y_pred): + """Compute loss function. + In all input tensors, `num_anchors` is the total number of pixels in the + the output space. + Args: + prediction_tensor: A float tensor of shape [batch_size, num_anchors, + num_classes] representing the predicted unscaled logits for each class. + The function will compute sigmoid on this tensor internally. + target_tensor: A float tensor of shape [batch_size, num_anchors, + num_classes] representing a tensor with the 'splatted' keypoints, + possibly using a gaussian kernel. This function assumes that + the target is bounded between [0, 1]. + weights: a float tensor of shape, either [batch_size, num_anchors, + num_classes] or [batch_size, num_anchors, 1]. If the shape is + [batch_size, num_anchors, 1], all the classses are equally weighted. + Returns: + loss: a float tensor of shape [batch_size, num_anchors, num_classes] + representing the value of the loss function. + """ + + target_tensor = y_true + + is_present_tensor = tf.math.equal(target_tensor, 1.0) + prediction_tensor = tf.clip_by_value(tf.sigmoid(y_pred), + self._sigmoid_clip_value, + 1 - self._sigmoid_clip_value) + positive_loss = (tf.math.pow((1 - prediction_tensor), self._alpha)* + tf.math.log(prediction_tensor)) + negative_loss = (tf.math.pow((1 - target_tensor), self._beta)* + tf.math.pow(prediction_tensor, self._alpha)* + tf.math.log(1 - prediction_tensor)) + + loss = -tf.where(is_present_tensor, positive_loss, negative_loss) + return loss + + def get_config(self): + """Returns the config dictionary for a `Loss` instance.""" + return { + 'alpha': self._alpha, + 'beta': self._beta, + 'sigmoid_clip_value': self._sigmoid_clip_value, + **super().get_config() + } diff --git a/centernet/losses/penalty_reduced_logistic_focal_loss_test.py b/centernet/losses/penalty_reduced_logistic_focal_loss_test.py new file mode 100644 index 000000000..1f6d1f402 --- /dev/null +++ b/centernet/losses/penalty_reduced_logistic_focal_loss_test.py @@ -0,0 +1,93 @@ +import numpy as np +import tensorflow as tf + +import centernet.losses.penalty_reduced_logistic_focal_loss as losses + +LOG_2 = np.log(2) +LOG_3 = np.log(3) + +class PenaltyReducedLogisticFocalLossTest(tf.test.TestCase): + """Testing loss function from Equation (1) in [1]. + [1]: https://arxiv.org/abs/1904.07850 + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self._prediction = np.array([ + # First batch + [[1 / 2, 1 / 4, 3 / 4], + [3 / 4, 1 / 3, 1 / 3]], + # Second Batch + [[0.0, 1.0, 1 / 2], + [3 / 4, 2 / 3, 1 / 3]]], np.float32) + self._prediction = np.log(self._prediction/(1 - self._prediction)) + + self._target = np.array([ + # First batch + [[1.0, 0.91, 1.0], + [0.36, 0.84, 1.0]], + # Second Batch + [[0.01, 1.0, 0.75], + [0.96, 1.0, 1.0]]], np.float32) + + def test_returns_correct_loss(self): + def graph_fn(prediction, target): + weights = tf.constant([ + [[1.0], [1.0]], + [[1.0], [1.0]], + ]) + loss = losses.PenaltyReducedLogisticFocalLoss( + alpha=2.0, beta=0.5, reduction=tf.keras.losses.Reduction.NONE) + computed_value = loss(target, prediction, weights) + return computed_value + computed_value = graph_fn(self._prediction, self._target) + expected_value = np.array([ + # First batch + [[1 / 4 * LOG_2, + 0.3 * 0.0625 * (2 * LOG_2 - LOG_3), + 1 / 16 * (2 * LOG_2 - LOG_3)], + [0.8 * 9 / 16 * 2 * LOG_2, + 0.4 * 1 / 9 * (LOG_3 - LOG_2), + 4 / 9 * LOG_3]], + # Second Batch + [[0.0, + 0.0, + 1 / 2 * 1 / 4 * LOG_2], + [0.2 * 9 / 16 * 2 * LOG_2, + 1 / 9 * (LOG_3 - LOG_2), + 4 / 9 * LOG_3]]]) + self.assertAllClose(expected_value, computed_value, rtol=1e-3, atol=1e-3) + + def test_returns_correct_loss_weighted(self): + def graph_fn(prediction, target): + weights = tf.constant([ + [[1.0, 0.0, 1.0], [0.0, 0.0, 1.0]], + [[1.0, 1.0, 1.0], [0.0, 0.0, 0.0]], + ]) + + loss = losses.PenaltyReducedLogisticFocalLoss( + alpha=2.0, beta=0.5, reduction=tf.keras.losses.Reduction.NONE) + + computed_value = loss(target, prediction, weights) + return computed_value + computed_value = graph_fn(self._prediction, self._target) + expected_value = np.array([ + # First batch + [[1 / 4 * LOG_2, + 0.0, + 1 / 16 * (2 * LOG_2 - LOG_3)], + [0.0, + 0.0, + 4 / 9 * LOG_3]], + # Second Batch + [[0.0, + 0.0, + 1 / 2 * 1 / 4 * LOG_2], + [0.0, + 0.0, + 0.0]]]) + + self.assertAllClose(expected_value, computed_value, rtol=1e-3, atol=1e-3) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/modeling/CenterNet.py b/centernet/modeling/CenterNet.py new file mode 100644 index 000000000..4a94e18fb --- /dev/null +++ b/centernet/modeling/CenterNet.py @@ -0,0 +1,101 @@ +import tensorflow as tf +import tensorflow.keras as ks + +from centernet.modeling.backbones.hourglass import Hourglass, build_hourglass +from centernet.modeling.decoders.centernet_decoder import CenterNetDecoder +from centernet.modeling.layers.detection_generator import CenterNetLayer +from official.core import registry +from official.vision.beta.modeling.backbones import factory + + +class CenterNet(ks.Model): + + def __init__(self, + backbone=None, + decoder=None, + head=None, + filter=None, + **kwargs): + super().__init__(**kwargs) + # model components + self._backbone = backbone + self._decoder = decoder + self._head = head + self._filter = filter + return + + def call(self, inputs, training=False): + features = self._backbone(inputs) + decoded_maps = self._decoder(features) + + if training: + return {"raw_output": decoded_maps} + else: + predictions = self._filter(decoded_maps) + predictions.update({"raw_output": decoded_maps}) + return predictions + + @property + def backbone(self): + return self._backbone + + @property + def decoder(self): + return self._decoder + + @property + def head(self): + return self._head + + @property + def filter(self): + return self._filter + +def build_centernet_decoder(input_specs, task_config, num_inputs): + # NOTE: For now just support the default config + # model specific + heatmap_bias = task_config.model.base.decoder.heatmap_bias + + # task specific + task_outputs = task_config._get_output_length_dict() + model = CenterNetDecoder( + input_specs = input_specs, + task_outputs=task_outputs, + heatmap_bias=heatmap_bias, + num_inputs=num_inputs) + + return model + +def build_centernet_filter(model_config): + return CenterNetLayer(max_detections=model_config.filter.max_detections, + peak_error=model_config.filter.peak_error, + peak_extract_kernel_size=model_config.filter.peak_extract_kernel_size, + class_offset=model_config.filter.class_offset, + net_down_scale=model_config.filter.net_down_scale, + input_image_dims=model_config.filter.input_image_dims, + use_nms=model_config.filter.use_nms, + nms_pre_thresh=model_config.filter.nms_pre_thresh, + nms_thresh=model_config.filter.nms_thresh) + +def build_centernet_head(model_config): + return None + +def build_centernet(input_specs, task_config, l2_regularization): + print(task_config.as_dict()) + print(input_specs) + print(l2_regularization) + model_config = task_config.model + backbone = factory.build_backbone(input_specs, model_config.base, + l2_regularization) + + decoder = build_centernet_decoder(backbone.output_specs, task_config, backbone._num_hourglasses) + head = build_centernet_head(model_config) + filter = build_centernet_filter(model_config) + + model = CenterNet(backbone=backbone, decoder=decoder, head=head, filter=filter) + + model.build(input_specs.shape) + model.summary() + + losses = None + return model, losses diff --git a/centernet/modeling/CenterNet_test.py b/centernet/modeling/CenterNet_test.py new file mode 100644 index 000000000..fc0c544e0 --- /dev/null +++ b/centernet/modeling/CenterNet_test.py @@ -0,0 +1,32 @@ +import dataclasses + +import numpy as np +import tensorflow as tf +from absl.testing import parameterized + +from centernet.configs import centernet +from centernet.modeling.CenterNet import build_centernet +from official.modeling import hyperparams +from official.vision.beta.configs import backbones + + +class CenterNetTest(parameterized.TestCase, tf.test.TestCase): + + def testBuildCenterNet(self): + input_specs = tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]) + + config = centernet.CenterNetTask() + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + + outputs = model(tf.zeros((5, 512, 512, 3))) + self.assertEqual(len(outputs['raw_output']), 3) + self.assertEqual(len(outputs['raw_output']['ct_heatmaps']), 2) + self.assertEqual(len(outputs['raw_output']['ct_offset']), 2) + self.assertEqual(len(outputs['raw_output']['ct_size']), 2) + self.assertEqual(outputs['raw_output']['ct_heatmaps'][0].shape, (5, 128, 128, 90)) + self.assertEqual(outputs['raw_output']['ct_offset'][0].shape, (5, 128, 128, 2)) + self.assertEqual(outputs['raw_output']['ct_size'][0].shape, (5, 128, 128, 2)) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/modeling/backbones/hourglass.py b/centernet/modeling/backbones/hourglass.py new file mode 100644 index 000000000..e80d8a6b9 --- /dev/null +++ b/centernet/modeling/backbones/hourglass.py @@ -0,0 +1,173 @@ +from typing import List + +import tensorflow as tf + +from centernet.configs import backbones as cfg +from centernet.modeling.layers import nn_blocks +from utils import register + + +@tf.keras.utils.register_keras_serializable(package='centernet') +class Hourglass(tf.keras.Model): + """ + CenterNet Hourglass backbone + """ + + def __init__( + self, + input_channel_dims: int, + channel_dims_per_stage: List[int], + blocks_per_stage: List[int], + num_hourglasses: int, + initial_downsample: bool = True, + norm_momentum=0.1, + norm_episilon=1e-5, + input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + **kwargs): + """ + Args: + input_channel_dims: integer, number of filters used to downsample the + input image + channel_dims_per_stage: list, containing of number of filters for the + residual blocks in the hourglass blocks + blocks_per_stage: list of residual block repetitions to use in the + hourglass blocks + num_hourglasses: integer, number of hourglass blocks in backbone + initial_downsample: bool, whether or not to downsample the input + norm_momentum: float, momentum for the batch normalization layers + norm_episilon: float, epsilon for the batch normalization layers + """ + # yapf: disable + input = tf.keras.layers.Input(shape=input_specs.shape[1:], name='input') + + inp_filters = channel_dims_per_stage[0] + + # Downsample the input + if initial_downsample: + prelayer_kernel_size = 7 + prelayer_strides = 2 + else: + prelayer_kernel_size = 3 + prelayer_strides = 1 + + x_downsampled = nn_blocks.CenterNetConvBN( + filters=input_channel_dims, + kernel_size=prelayer_kernel_size, + strides=prelayer_strides, + padding='valid', + activation='relu', + use_sync_bn=True, + norm_momentum=norm_momentum, + norm_epsilon=norm_episilon)(input) + + x_downsampled = nn_blocks.CenterNetResidualBlock( + filters=inp_filters, + use_projection=True, + strides=prelayer_strides, + use_sync_bn=True, + norm_momentum=norm_momentum, + norm_epsilon=norm_episilon)(x_downsampled) + + all_heatmaps = [] + for i in range(num_hourglasses): + # Create an hourglass stack + x_hg = nn_blocks.HourglassBlock( + channel_dims_per_stage=channel_dims_per_stage, + blocks_per_stage=blocks_per_stage, + )(x_downsampled) + + x_hg = nn_blocks.CenterNetConvBN( + filters=inp_filters, + kernel_size=(3, 3), + strides=(1, 1), + padding='valid', + activation='relu', + use_sync_bn=True, + norm_momentum=norm_momentum, + norm_epsilon=norm_episilon + )(x_hg) + + all_heatmaps.append(x_hg) + + # Intermediate conv and residual layers between hourglasses + if i < num_hourglasses - 1: + inter_hg_conv1 = nn_blocks.CenterNetConvBN( + filters=inp_filters, + kernel_size=(1, 1), + strides=(1, 1), + padding='same', + activation='identity', + use_sync_bn=True, + norm_momentum=norm_momentum, + norm_epsilon=norm_episilon + )(x_downsampled) + + inter_hg_conv2 = nn_blocks.CenterNetConvBN( + filters=inp_filters, + kernel_size=(1, 1), + strides=(1, 1), + padding='same', + activation='identity', + use_sync_bn=True, + norm_momentum=norm_momentum, + norm_epsilon=norm_episilon + )(x_hg) + + x_downsampled = tf.keras.layers.Add()([inter_hg_conv1, inter_hg_conv2]) + x_downsampled = tf.keras.layers.ReLU()(x_downsampled) + + x_downsampled = nn_blocks.CenterNetResidualBlock( + filters=inp_filters, use_projection=False, strides=1, + use_sync_bn=True, norm_momentum=norm_momentum, + norm_epsilon=norm_episilon + )(x_downsampled) + # yapf: enable + + super().__init__(inputs=input, outputs=all_heatmaps, **kwargs) + + self._input_channel_dims = input_channel_dims + self._channel_dims_per_stage = channel_dims_per_stage + self._blocks_per_stage = blocks_per_stage + self._num_hourglasses = num_hourglasses + self._initial_downsample = initial_downsample + self._norm_momentum = norm_momentum + self._norm_episilon = norm_episilon + self._output_specs = [hm.get_shape() for hm in all_heatmaps] + + def get_config(self): + layer_config = { + 'input_channel_dims': self._input_channel_dims, + 'channel_dims_per_stage': self._channel_dims_per_stage, + 'blocks_per_stage': self._blocks_per_stage, + 'num_hourglasses': self._num_hourglasses, + 'initial_downsample': self._initial_downsample, + 'norm_momentum': self._norm_momentum, + 'norm_episilon': self._norm_episilon + } + layer_config.update(super().get_config()) + return layer_config + + @property + def output_specs(self): + return self._output_specs + +# @factory.register_backbone_builder('hourglass') +@register.backbone('hourglass', cfg.Hourglass) +def build_hourglass(input_specs: tf.keras.layers.InputSpec, + model_config, + l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: + """Builds Hourglass backbone from a config.""" + backbone_type = model_config.backbone.type + backbone_cfg = model_config.backbone.get() + assert backbone_type == 'hourglass', (f'Inconsistent backbone type ' + f'{backbone_type}') + + return Hourglass( + input_channel_dims=backbone_cfg.input_channel_dims, + channel_dims_per_stage=backbone_cfg.channel_dims_per_stage, + blocks_per_stage=backbone_cfg.blocks_per_stage, + num_hourglasses=backbone_cfg.num_hourglasses, + initial_downsample=backbone_cfg.initial_downsample, + norm_momentum=backbone_cfg.norm_momentum, + norm_episilon=backbone_cfg.norm_episilon, + input_specs=input_specs) diff --git a/centernet/modeling/backbones/hourglass_test.py b/centernet/modeling/backbones/hourglass_test.py new file mode 100644 index 000000000..ba6c598e1 --- /dev/null +++ b/centernet/modeling/backbones/hourglass_test.py @@ -0,0 +1,39 @@ +import dataclasses + +import numpy as np +import tensorflow as tf +from absl.testing import parameterized + +from centernet.configs import backbones as cfg +from centernet.modeling.backbones import hourglass +from official.modeling import hyperparams +from official.vision.beta.configs import backbones + + +@dataclasses.dataclass +class CenterNet(hyperparams.Config): + backbone: backbones.Backbone = backbones.Backbone(type='hourglass') + + +class HourglassTest(tf.test.TestCase, parameterized.TestCase): + + def test_hourglass(self): + model = hourglass.Hourglass( + blocks_per_stage=[2, 3, 4, 5, 6], + input_channel_dims=4, + channel_dims_per_stage=[6, 8, 10, 12, 14], + num_hourglasses=2) + outputs = model(np.zeros((2, 64, 64, 3), dtype=np.float32)) + self.assertEqual(outputs[0].shape, (2, 16, 16, 6)) + self.assertEqual(outputs[1].shape, (2, 16, 16, 6)) + + backbone = hourglass.build_hourglass( + tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]), CenterNet()) + input = np.zeros((2, 512, 512, 3), dtype=np.float32) + outputs = backbone(input) + self.assertEqual(outputs[0].shape, (2, 128, 128, 256)) + self.assertEqual(outputs[1].shape, (2, 128, 128, 256)) + + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/modeling/decoders/centernet_decoder.py b/centernet/modeling/decoders/centernet_decoder.py new file mode 100644 index 000000000..29de964c0 --- /dev/null +++ b/centernet/modeling/decoders/centernet_decoder.py @@ -0,0 +1,64 @@ +import tensorflow as tf + +from centernet.configs import centernet as cfg +from centernet.modeling.layers.nn_blocks import CenterNetDecoderConv + + +@tf.keras.utils.register_keras_serializable(package='centernet') +class CenterNetDecoder(tf.keras.Model): + """ + CenterNet Decoder + """ + def __init__(self, + input_specs, + task_outputs: dict, + heatmap_bias: float = -2.19, + num_inputs: int = 2, + **kwargs): + """ + Args: + task_outputs: dict, with key-value pairs denoting the names of the outputs + and the desired channel depth of each output + heatmap_bias: float, constant value to initialize the convolution layer + bias vector if it is responsible for generating a heatmap (not for + regressed predictions) + + call Returns: + dictionary where the keys-value pairs denote the names of the output + and the respective output tensor + """ + self._input_specs = input_specs + self._task_outputs = task_outputs + self._heatmap_bias = heatmap_bias + self._num_inputs = num_inputs + + inputs = [tf.keras.layers.Input(shape=value[1:]) for value in self._input_specs] + outputs = dict() + + for key in self._task_outputs: + num_filters = self._task_outputs[key] + bias = 0 + if 'heatmaps' in key: + bias = self._heatmap_bias + + outputs[key] = [CenterNetDecoderConv(output_filters=num_filters, + name=key + str(i), bias_init=bias)(inputs[i]) for i in range(self._num_inputs)] + + self._output_specs = { + key: [value[i].get_shape() for i in range(num_inputs)] + for key, value in outputs.items() + } + + super().__init__(inputs=inputs, outputs=outputs, name='CenterNetDecoder') + + @property + def output_specs(self): + return self._output_specs + + def get_config(self): + layer_config = { + 'task_outputs': self._task_outputs, + 'heatmap_bias': self._heatmap_bias + } + + return layer_config diff --git a/centernet/modeling/decoders/centernet_decoder_test.py b/centernet/modeling/decoders/centernet_decoder_test.py new file mode 100644 index 000000000..67b6a0ce1 --- /dev/null +++ b/centernet/modeling/decoders/centernet_decoder_test.py @@ -0,0 +1,50 @@ +import numpy as np +import tensorflow as tf +from absl.testing import parameterized + +from centernet.configs import centernet as cfg +from centernet.modeling.CenterNet import build_centernet_decoder +from centernet.modeling.decoders import centernet_decoder + + +class CenterNetDecoderTest(tf.test.TestCase, parameterized.TestCase): + + def test_create_decoder(self): + decoder = build_centernet_decoder( + task_config=cfg.CenterNetTask(), + input_specs=[(None, 128, 128, 256), (None, 128, 128, 256)], + num_inputs=2) + + config = decoder.get_config() + self.assertEqual(len(config), 2) + self.assertEqual(config['heatmap_bias'], -2.19) + + def test_decoder_shape(self): + decoder = build_centernet_decoder( + task_config=cfg.CenterNetTask(), + input_specs=[(None, 128, 128, 256), (None, 128, 128, 256)], + num_inputs=2) + + # Output shape tests + outputs = decoder([np.zeros((2, 128, 128, 256), dtype=np.float32), + np.zeros((2, 128, 128, 256), dtype=np.float32)]) + self.assertEqual(len(outputs), 3) + self.assertEqual(outputs['ct_heatmaps'][0].shape, (2, 128, 128, 90)) + self.assertEqual(outputs['ct_offset'][0].shape, (2, 128, 128, 2)) + self.assertEqual(outputs['ct_size'][0].shape, (2, 128, 128, 2)) + + # Weight initialization tests + tf.print("\n\n{}\n\n".format(decoder.layers)) + hm_bias_vector = np.asarray(decoder.layers[2].weights[-1]) + off_bias_vector = np.asarray(decoder.layers[4].weights[-1]) + size_bias_vector = np.asarray(decoder.layers[6].weights[-1]) + + self.assertArrayNear(hm_bias_vector, + np.repeat(-2.19, repeats=90), err=1.00e-6) + self.assertArrayNear(off_bias_vector, + np.repeat(0, repeats=2), err=1.00e-6) + self.assertArrayNear(size_bias_vector, + np.repeat(0, repeats=2), err=1.00e-6) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/modeling/layers/detection_generator.py b/centernet/modeling/layers/detection_generator.py new file mode 100644 index 000000000..b336e767a --- /dev/null +++ b/centernet/modeling/layers/detection_generator.py @@ -0,0 +1,341 @@ +import tensorflow as tf +import tensorflow.keras as ks + +from yolo.ops.nms_ops import nms + + +@tf.keras.utils.register_keras_serializable(package='centernet') +class CenterNetLayer(ks.Model): + """ CenterNet Detection Generator + + Parses predictions from the CenterNet decoder into the final bounding boxes, + confidences, and classes. This class contains repurposed methods from the + TensorFlow Object Detection API + in: https://github.com/tensorflow/models/blob/master/research/object_detection/meta_architectures/center_net_meta_arch.py + """ + def __init__(self, + max_detections=100, + peak_error=1e-6, + peak_extract_kernel_size=3, + class_offset=1, + net_down_scale=4, + input_image_dims=512, + use_nms=False, + nms_pre_thresh=0.1, + nms_thresh=0.4, + **kwargs): + """ + Args: + max_detections: An integer specifying the maximum number of bounding + boxes generated. This is an upper bound, so the number of generated + boxes may be less than this due to thresholding/non-maximum suppression. + peak_error: A float for determining non-valid heatmap locations to mask. + peak_extract_kernel_size: An integer indicating the kernel size used when + performing max-pool over the heatmaps to detect valid center locations + from its neighbors. From the paper, set this to 3 to detect valid. + locations that have responses greater than its 8-connected neighbors + use_nms: Boolean for whether or not to use non-maximum suppression to + filter the bounding boxes. + class_offset: An integer indicating to add an offset to the class + prediction if the dataset labels have been shifted. + net_down_scale: An integer that specifies + + call Returns: + Dictionary with keys 'bbox', 'classes', 'confidence', and 'num_dets' + storing each bounding box in [y_min, x_min, y_max, x_max] format, + its respective class and confidence score, and the number of detections + made. + """ + super().__init__(**kwargs) + + # Object center selection parameters + self._max_detections = max_detections + self._peak_error = peak_error + self._peak_extract_kernel_size = peak_extract_kernel_size + + # Used for adjusting class prediction + self._class_offset = class_offset + + # Box normalization parameters + self._net_down_scale = net_down_scale + self._input_image_dims = input_image_dims + + self._use_nms = use_nms + self._nms_pre_thresh = nms_pre_thresh + self._nms_thresh = nms_thresh + + def process_heatmap(self, + feature_map, + kernel_size): + """ Processes the heatmap into peaks for box selection. + + Given a heatmap, this function first masks out nearby heatmap locations of + the same class using max-pooling such that, ideally, only one center for the + object remains. Then, center locations are masked according to their scores + in comparison to a threshold. NOTE: Repurposed from Google OD API. + + Args: + feature_map: A Tensor with shape [batch_size, height, width, num_classes] + which is the center heatmap predictions. + kernel_size: An integer value for max-pool kernel size. + + Returns: + A Tensor with the same shape as the input but with non-valid center + prediction locations masked out. + """ + + feature_map = tf.math.sigmoid(feature_map) + if not kernel_size or kernel_size == 1: + feature_map_peaks = feature_map + else: + feature_map_max_pool = tf.nn.max_pool( + feature_map, ksize=kernel_size, + strides=1, padding='SAME') + + feature_map_peak_mask = tf.math.abs( + feature_map - feature_map_max_pool) < self._peak_error + + # Zero out everything that is not a peak. + feature_map_peaks = ( + feature_map * tf.cast(feature_map_peak_mask, feature_map.dtype)) + + return feature_map_peaks + + def get_row_col_channel_indices_from_flattened_indices(self, + indices, + num_cols, + num_channels): + """ Computes row, column and channel indices from flattened indices. + + NOTE: Repurposed from Google OD API. + + Args: + indices: An integer tensor of any shape holding the indices in the flattened + space. + num_cols: Number of columns in the image (width). + num_channels: Number of channels in the image. + + Returns: + row_indices: The row indices corresponding to each of the input indices. + Same shape as indices. + col_indices: The column indices corresponding to each of the input indices. + Same shape as indices. + channel_indices. The channel indices corresponding to each of the input + indices. + """ + # Avoid using mod operator to make the ops more easy to be compatible with + # different environments, e.g. WASM. + + # all inputs and outputs are dtype int32 + row_indices = (indices // num_channels) // num_cols + col_indices = (indices // num_channels) - row_indices * num_cols + channel_indices_temp = indices // num_channels + channel_indices = indices - channel_indices_temp * num_channels + + return row_indices, col_indices, channel_indices + + def multi_range(self, + limit, + value_repetitions=1, + range_repetitions=1, + dtype=tf.int32): + """ Creates a sequence with optional value duplication and range repetition. + + As an example (see the Args section for more details), + _multi_range(limit=2, value_repetitions=3, range_repetitions=4) returns: + [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1] + NOTE: Repurposed from Google OD API. + + Args: + limit: A 0-D Tensor (scalar). Upper limit of sequence, exclusive. + value_repetitions: Integer. The number of times a value in the sequence is + repeated. With value_repetitions=3, the result is [0, 0, 0, 1, 1, 1, ..]. + range_repetitions: Integer. The number of times the range is repeated. With + range_repetitions=3, the result is [0, 1, 2, .., 0, 1, 2, ..]. + dtype: The type of the elements of the resulting tensor. + + Returns: + A 1-D tensor of type `dtype` and size + [`limit` * `value_repetitions` * `range_repetitions`] that contains the + specified range with given repetitions. + """ + return tf.reshape( + tf.tile( + tf.expand_dims(tf.range(limit, dtype=dtype), axis=-1), + multiples=[range_repetitions, value_repetitions]), [-1]) + + def get_top_k_peaks(self, + feature_map_peaks, + batch_size, + width, + num_classes, + k=100): + """ Gets the scores and indices of the top-k peaks from the feature map + + This function flattens the feature map in order to retrieve the top-k + peaks, then computes the x, y, and class indices for those scores. + NOTE: Repurposed from Google OD API. + + Args: + feature_map_peaks: A Tensor with shape [batch_size, height, width, num_classes] + which is the processed center heatmap peaks. + batch_size: An integer that indicates the batch size of the input. + width: An integer that indicates the width (and also height) of the input. + num_classes: An integer for the number of possible classes. This is also + the channel depth of the input. + k: Integer that controls how many peaks to select. + + Returns: + top_scores: A Tensor with shape [batch_size, k] containing the top-k scores. + y_indices: A Tensor with shape [batch_size, k] containing the top-k + y-indices corresponding to top_scores. + x_indices: A Tensor with shape [batch_size, k] containing the top-k + x-indices corresponding to top_scores. + channel_indices: A Tensor with shape [batch_size, k] containing the top-k + channel indices corresponding to top_scores. + """ + # Flatten the entire prediction per batch + feature_map_peaks_flat = tf.reshape(feature_map_peaks, [batch_size, -1]) + + # top_scores and top_indices have shape [batch_size, k] + top_scores, top_indices = tf.math.top_k(feature_map_peaks_flat, k=k) + + # Get x, y and channel indices corresponding to the top indices in the flat + # array. + y_indices, x_indices, channel_indices = ( + self.get_row_col_channel_indices_from_flattened_indices( + top_indices, width, num_classes)) + + return top_scores, y_indices, x_indices, channel_indices + + def get_boxes(self, + y_indices, + x_indices, + channel_indices, + height_width_predictions, + offset_predictions, + num_boxes): + """ Organizes prediction information into the final bounding boxes. + + NOTE: Repurposed from Google OD API. + + Args: + y_indices: A Tensor with shape [batch_size, k] containing the top-k + y-indices corresponding to top_scores. + x_indices: A Tensor with shape [batch_size, k] containing the top-k + x-indices corresponding to top_scores. + channel_indices: A Tensor with shape [batch_size, k] containing the top-k + channel indices corresponding to top_scores. + height_width_predictions: A Tensor with shape [batch_size, height, width, 2] + containing the object size predictions. + offset_predictions: A Tensor with shape [batch_size, height, width, 2] + containing the object local offset predictions. + num_boxes: The number of boxes. + + Returns: + boxes: A Tensor with shape [batch_size, num_boxes, 4] that contains the + bounding box coordinates in [y_min, x_min, y_max, x_max] format. + detection_classes: A Tensor with shape [batch_size, 100] that gives the + class prediction for each box. + num_detections: Number of non-zero confidence detections made. + """ + # TF Lite does not support tf.gather with batch_dims > 0, so we need to use + # tf_gather_nd instead and here we prepare the indices for that. + + # shapes of heatmap output + shape = tf.shape(height_width_predictions) + batch_size, height, width = shape[0], shape[1], shape[2] + + # combined indices dtype=int32 + combined_indices = tf.stack([ + self.multi_range(batch_size, value_repetitions=num_boxes), + tf.reshape(y_indices, [-1]), + tf.reshape(x_indices, [-1]) + ], axis=1) + + new_height_width = tf.gather_nd(height_width_predictions, combined_indices) + new_height_width = tf.reshape(new_height_width, [batch_size, num_boxes, 2]) + height_width = tf.maximum(new_height_width, 0.0) + + # height and widths dtype=float32 + heights = height_width[..., 0] + widths = height_width[..., 1] + + # Get the offsets of center points + new_offsets = tf.gather_nd(offset_predictions, combined_indices) + offsets = tf.reshape(new_offsets, [batch_size, num_boxes, 2]) + + # offsets are dtype=float32 + y_offsets = offsets[..., 0] + x_offsets = offsets[..., 1] + + y_indices = tf.cast(y_indices, dtype=heights.dtype) + x_indices = tf.cast(x_indices, dtype=widths.dtype) + + detection_classes = channel_indices + self._class_offset + ymin = y_indices + y_offsets - heights / 2.0 + xmin = x_indices + x_offsets - widths / 2.0 + ymax = y_indices + y_offsets + heights / 2.0 + xmax = x_indices + x_offsets + widths / 2.0 + + ymin = tf.clip_by_value(ymin, 0., tf.cast(height, ymin.dtype)) + xmin = tf.clip_by_value(xmin, 0., tf.cast(width, xmin.dtype)) + ymax = tf.clip_by_value(ymax, 0., tf.cast(height, ymax.dtype)) + xmax = tf.clip_by_value(xmax, 0., tf.cast(width, xmax.dtype)) + boxes = tf.stack([ymin, xmin, ymax, xmax], axis=2) + + return boxes, detection_classes + + def convert_strided_predictions_to_normalized_boxes(self, + boxes): + boxes = boxes * tf.cast(self._net_down_scale, boxes.dtype) + boxes = boxes / tf.cast(self._input_image_dims, boxes.dtype) + boxes = tf.clip_by_value(boxes, 0.0, 1.0) + return boxes + + def call(self, inputs): + # Get heatmaps from decoded outputs via final hourglass stack output + all_ct_heatmaps = inputs['ct_heatmaps'] + all_ct_sizes = inputs['ct_size'] + all_ct_offsets = inputs['ct_offset'] + + ct_heatmaps = all_ct_heatmaps[-1] + ct_sizes = all_ct_sizes[-1] + ct_offsets = all_ct_offsets[-1] + + shape = tf.shape(ct_heatmaps) + + batch_size, height, width, num_channels = shape[0], shape[1], shape[2], shape[3] + + # Process heatmaps using 3x3 max pool and applying sigmoid + peaks = self.process_heatmap(ct_heatmaps, + kernel_size=self._peak_extract_kernel_size) + + # Get top scores along with their x, y, and class + scores, y_indices, x_indices, channel_indices = self.get_top_k_peaks(peaks, + batch_size, width, num_channels, k=self._max_detections) + + # Parse the score and indices into bounding boxes + boxes, classes = self.get_boxes(y_indices, x_indices, channel_indices, ct_sizes, ct_offsets, self._max_detections) + + # Normalize bounding boxes + boxes = self.convert_strided_predictions_to_normalized_boxes(boxes) + + # Apply nms + if self._use_nms: + boxes = tf.expand_dims(boxes, axis=-2) + multi_class_scores = tf.gather_nd(peaks, + tf.stack([y_indices, x_indices], -1), batch_dims=1) + + boxes, _, scores = nms(boxes=boxes, classes=multi_class_scores, + confidence=scores, k=self._max_detections, limit_pre_thresh=True, + pre_nms_thresh=0.1, nms_thresh=0.4) + + num_det = tf.reduce_sum(tf.cast(scores > 0, dtype=tf.int32), axis=1) + + return { + 'bbox': boxes, + 'classes': classes, + 'confidence': scores, + 'num_dets': num_det + } diff --git a/centernet/modeling/layers/nn_blocks.py b/centernet/modeling/layers/nn_blocks.py new file mode 100644 index 000000000..5a01337fd --- /dev/null +++ b/centernet/modeling/layers/nn_blocks.py @@ -0,0 +1,538 @@ +import tensorflow as tf + +from official.modeling import tf_utils +from official.vision.beta.modeling.layers import \ + nn_blocks as official_nn_blocks + + +@tf.keras.utils.register_keras_serializable(package='centernet') +class Identity(tf.keras.layers.Layer): + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def call(self, input): + return input + +@tf.keras.utils.register_keras_serializable(package='centernet') +class CenterNetResidualBlock(tf.keras.layers.Layer): + """A residual block.""" + + def __init__(self, + filters, + strides, + use_projection=False, + se_ratio=None, + resnetd_shortcut=False, + stochastic_depth_drop_rate=None, + kernel_initializer='VarianceScaling', + kernel_regularizer=None, + bias_regularizer=None, + activation='relu', + use_sync_bn=False, + norm_momentum=0.99, + norm_epsilon=0.001, + **kwargs): + """A residual block with BN after convolutions. Modified with padding for + the CenterNet model. The input is first padded with 0 along the top, bottom, + left, and right prior to the first convolutional layer. + + Args: + filters: `int` number of filters for the first two convolutions. Note that + the third and final convolution will use 4 times as many filters. + strides: `int` block stride. If greater than 1, this block will ultimately + downsample the input. + use_projection: `bool` for whether this block should use a projection + shortcut (versus the default identity shortcut). This is usually `True` + for the first block of a block group, which may change the number of + filters and the resolution. + se_ratio: `float` or None. Ratio of the Squeeze-and-Excitation layer. + resnetd_shortcut: `bool` if True, apply the resnetd style modification to + the shortcut connection. Not implemented in residual blocks. + stochastic_depth_drop_rate: `float` or None. if not None, drop rate for + the stochastic depth layer. + kernel_initializer: kernel_initializer for convolutional layers. + kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + Default to None. + bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + Default to None. + activation: `str` name of the activation function. + use_sync_bn: if True, use synchronized batch normalization. + norm_momentum: `float` normalization omentum for the moving average. + norm_epsilon: `float` small float added to variance to avoid dividing by + zero. + **kwargs: keyword arguments to be passed. + """ + super(CenterNetResidualBlock, self).__init__(**kwargs) + + self._filters = filters + self._strides = strides + self._use_projection = use_projection + self._se_ratio = se_ratio + self._resnetd_shortcut = resnetd_shortcut + self._use_sync_bn = use_sync_bn + self._activation = activation + self._stochastic_depth_drop_rate = stochastic_depth_drop_rate + self._kernel_initializer = kernel_initializer + self._norm_momentum = norm_momentum + self._norm_epsilon = norm_epsilon + self._kernel_regularizer = kernel_regularizer + self._bias_regularizer = bias_regularizer + + if use_sync_bn: + self._norm = tf.keras.layers.experimental.SyncBatchNormalization + else: + self._norm = tf.keras.layers.BatchNormalization + if tf.keras.backend.image_data_format() == 'channels_last': + self._bn_axis = -1 + else: + self._bn_axis = 1 + self._activation_fn = tf_utils.get_activation(activation) + + def build(self, input_shape): + if self._use_projection: + self._shortcut = tf.keras.layers.Conv2D( + filters=self._filters, + kernel_size=1, + strides=self._strides, + use_bias=False, + kernel_initializer=self._kernel_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer) + self._norm0 = self._norm( + axis=self._bn_axis, + momentum=self._norm_momentum, + epsilon=self._norm_epsilon) + self.pad = tf.keras.layers.ZeroPadding2D(padding=(1, 1)) + self._conv1 = tf.keras.layers.Conv2D( + filters=self._filters, + kernel_size=3, + strides=self._strides, + padding='valid', + use_bias=False, + kernel_initializer=self._kernel_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer) + self._norm1 = self._norm( + axis=self._bn_axis, + momentum=self._norm_momentum, + epsilon=self._norm_epsilon) + + self._conv2 = tf.keras.layers.Conv2D( + filters=self._filters, + kernel_size=3, + strides=1, + padding='same', + use_bias=False, + kernel_initializer=self._kernel_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer) + self._norm2 = self._norm( + axis=self._bn_axis, + momentum=self._norm_momentum, + epsilon=self._norm_epsilon) + + if self._se_ratio and self._se_ratio > 0 and self._se_ratio <= 1: + self._squeeze_excitation = nn_layers.SqueezeExcitation( + in_filters=self._filters, + out_filters=self._filters, + se_ratio=self._se_ratio, + kernel_initializer=self._kernel_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer) + else: + self._squeeze_excitation = None + + if self._stochastic_depth_drop_rate: + self._stochastic_depth = nn_layers.StochasticDepth( + self._stochastic_depth_drop_rate) + else: + self._stochastic_depth = None + + super(CenterNetResidualBlock, self).build(input_shape) + + def get_config(self): + config = { + 'filters': self._filters, + 'strides': self._strides, + 'use_projection': self._use_projection, + 'se_ratio': self._se_ratio, + 'resnetd_shortcut': self._resnetd_shortcut, + 'stochastic_depth_drop_rate': self._stochastic_depth_drop_rate, + 'kernel_initializer': self._kernel_initializer, + 'kernel_regularizer': self._kernel_regularizer, + 'bias_regularizer': self._bias_regularizer, + 'activation': self._activation, + 'use_sync_bn': self._use_sync_bn, + 'norm_momentum': self._norm_momentum, + 'norm_epsilon': self._norm_epsilon + } + base_config = super(CenterNetResidualBlock, self).get_config() + return dict(list(base_config.items()) + list(config.items())) + + def call(self, inputs, training=None): + shortcut = inputs + if self._use_projection: + shortcut = self._shortcut(shortcut) + shortcut = self._norm0(shortcut) + + x = self.pad(inputs) + x = self._conv1(x) + x = self._norm1(x) + x = self._activation_fn(x) + + x = self._conv2(x) + x = self._norm2(x) + + if self._squeeze_excitation: + x = self._squeeze_excitation(x) + + if self._stochastic_depth: + x = self._stochastic_depth(x, training=training) + + return self._activation_fn(x + shortcut) + +@tf.keras.utils.register_keras_serializable(package='centernet') +class CenterNetConvBN(tf.keras.layers.Layer): + def __init__(self, + filters=1, + kernel_size=(1, 1), + strides=(1, 1), + padding='same', + dilation_rate=(1, 1), + kernel_initializer='glorot_uniform', + bias_initializer='zeros', + subdivisions=1, + bias_regularizer=None, + kernel_regularizer=None, + use_bn=True, + use_sync_bn=False, + norm_momentum=0.99, + norm_epsilon=0.001, + activation='leaky', + leaky_alpha=0.1, + **kwargs): + """ + Modified Convolution layer based on the DarkNet Library, with changes + such that it is compatiable with the CenterNet backbone. + The Layer is a standards combination of Conv BatchNorm Activation, + however, the use of bias in the conv is determined by the use of batch + normalization. Modified with padding for the CenterNet model. The input is + first padded with 0 along the top, bottom, left, and right prior to the + first convolutional layer. + Cross Stage Partial networks (CSPNets) were proposed in: + [1] Chien-Yao Wang, Hong-Yuan Mark Liao, I-Hau Yeh, Yueh-Hua Wu, + Ping-Yang Chen, Jun-Wei Hsieh + CSPNet: A New Backbone that can Enhance Learning Capability of CNN. + arXiv:1911.11929 + Args: + filters: integer for output depth, or the number of features to learn + kernel_size: integer or tuple for the shape of the weight matrix or kernel + to learn + strides: integer of tuple how much to move the kernel after each kernel + use + padding: string 'valid' or 'same', if same, then pad the image, else do + not + dialtion_rate: tuple to indicate how much to modulate kernel weights and + how many pixels in a feature map to skip + kernel_initializer: string to indicate which function to use to initialize + weights + bias_initializer: string to indicate which function to use to initialize + bias + kernel_regularizer: string to indicate which function to use to + regularizer weights + bias_regularizer: string to indicate which function to use to regularizer + bias + use_bn: boolean for whether to use batch normalization + use_sync_bn: boolean for whether sync batch normalization statistics + of all batch norm layers to the models global statistics + (across all input batches) + norm_momentum: float for moment to use for batch normalization + norm_epsilon: float for batch normalization epsilon + activation: string or None for activation function to use in layer, + if None activation is replaced by linear + leaky_alpha: float to use as alpha if activation function is leaky + **kwargs: Keyword Arguments + """ + + # convolution params + self._filters = filters + self._kernel_size = kernel_size + self._strides = strides + self._padding = padding + self._dilation_rate = dilation_rate + self._kernel_initializer = kernel_initializer + self._bias_initializer = bias_initializer + self._kernel_regularizer = kernel_regularizer + + self._bias_regularizer = bias_regularizer + self._subdivisions = subdivisions + + # batch normalization params + self._use_bn = use_bn + self._use_sync_bn = use_sync_bn + self._norm_momentum = norm_momentum + self._norm_epsilon = norm_epsilon + + if tf.keras.backend.image_data_format() == 'channels_last': + # format: (batch_size, height, width, channels) + self._bn_axis = -1 + else: + # format: (batch_size, channels, width, height) + self._bn_axis = 1 + + # activation params + self._activation = activation + self._leaky_alpha = leaky_alpha + + super().__init__(**kwargs) + + def build(self, input_shape): + use_bias = not self._use_bn + padding = self._padding + + kernel_size = self._kernel_size if isinstance( + self._kernel_size, int) else self._kernel_size[0] + + if kernel_size > 1: + padding = 'valid' + if kernel_size == 7: + padding_size = (3, 3) + if kernel_size == 3: + padding_size = (1, 1) + + self.pad = tf.keras.layers.ZeroPadding2D(padding_size) + else: + self.pad = Identity() + + self.conv = tf.keras.layers.Conv2D( + filters=self._filters, + kernel_size=self._kernel_size, + strides=self._strides, + padding=padding, + dilation_rate=self._dilation_rate, + use_bias=use_bias, + kernel_initializer=self._kernel_initializer, + bias_initializer=self._bias_initializer, + kernel_regularizer=self._kernel_regularizer, + bias_regularizer=self._bias_regularizer) + + if self._use_bn: + if self._use_sync_bn: + self.bn = tf.keras.layers.experimental.SyncBatchNormalization( + momentum=self._norm_momentum, + epsilon=self._norm_epsilon, + axis=self._bn_axis) + else: + self.bn = tf.keras.layers.BatchNormalization( + momentum=self._norm_momentum, + epsilon=self._norm_epsilon, + axis=self._bn_axis) + + if self._activation == 'leaky': + self._activation_fn = tf.keras.layers.LeakyReLU(alpha=self._leaky_alpha) + elif self._activation == 'mish': + self._activation_fn = lambda x: x * tf.math.tanh(tf.math.softplus(x)) + else: + self._activation_fn = tf_utils.get_activation( + self._activation) # tf.keras.layers.Activation(self._activation) + + def call(self, x): + x = self.pad(x) + x = self.conv(x) + if self._use_bn: + x = self.bn(x) + x = self._activation_fn(x) + return x + + def get_config(self): + # used to store/share parameters to reconstruct the model + layer_config = { + 'filters': self._filters, + 'kernel_size': self._kernel_size, + 'strides': self._strides, + 'padding': self._padding, + 'dilation_rate': self._dilation_rate, + 'kernel_initializer': self._kernel_initializer, + 'bias_initializer': self._bias_initializer, + 'bias_regularizer': self._bias_regularizer, + 'kernel_regularizer': self._kernel_regularizer, + 'use_bn': self._use_bn, + 'use_sync_bn': self._use_sync_bn, + 'norm_momentum': self._norm_momentum, + 'norm_epsilon': self._norm_epsilon, + 'activation': self._activation, + 'leaky_alpha': self._leaky_alpha + } + layer_config.update(super().get_config()) + return layer_config + +@tf.keras.utils.register_keras_serializable(package='centernet') +class HourglassBlock(tf.keras.layers.Layer): + """ + Hourglass module + """ + + def __init__(self, + channel_dims_per_stage, + blocks_per_stage, + strides=1, + norm_momentum=0.1, + norm_epsilon=1e-5, + **kwargs): + """ + Args: + channel_dims_per_stage: list of filter sizes for Residual blocks + blocks_per_stage: list of residual block repetitions per down/upsample + strides: integer, stride parameter to the Residual block + norm_momentum: float, momentum for the batch normalization layers + norm_episilon: float, epsilon for the batch normalization layers + """ + self._order = len(channel_dims_per_stage) - 1 + self._channel_dims_per_stage = channel_dims_per_stage + self._blocks_per_stage = blocks_per_stage + self._strides = strides + self._norm_momentum = norm_momentum + self._norm_epsilon = norm_epsilon + + assert len(channel_dims_per_stage) == len(blocks_per_stage), 'filter ' \ + 'size and residual block repetition lists must have the same length' + + self._filters = channel_dims_per_stage[0] + if self._order > 0: + self._filters_downsampled = channel_dims_per_stage[1] + self._reps = blocks_per_stage[0] + + super().__init__(**kwargs) + + def make_repeated_residual_blocks(self, reps, out_channels, + residual_channels=None, + initial_stride=1): + """ + Args: + reps: int for desired number of residual blocks + out_channels: int, filter depth of the final residual block + residual_channels: int, filter depth for the first reps - 1 residual + blocks. If None, defaults to the same value as out_channels. If not + equal to out_channels, then uses a projection shortcut in the final + residual block + initial_stride: int, stride for the first residual block + """ + blocks = [] + + if residual_channels is None: + residual_channels = out_channels + + for i in range(reps - 1): + stride = initial_stride if i == 0 else 1 + skip_conv = stride > 1 + + blocks.append(CenterNetResidualBlock( + filters=residual_channels, strides=stride, + use_projection=skip_conv, use_sync_bn=True, + norm_momentum=self._norm_momentum, norm_epsilon=self._norm_epsilon)) + + if reps == 1: + stride = initial_stride + skip_conv = stride > 1 + else: + stride = 1 + skip_conv = residual_channels != out_channels + + blocks.append(CenterNetResidualBlock( + filters=out_channels, strides=stride, + use_projection=skip_conv, use_sync_bn=True, + norm_momentum=self._norm_momentum, norm_epsilon=self._norm_epsilon)) + + return tf.keras.Sequential(blocks) + + def build(self, input_shape): + if self._order == 0: + # base case, residual block repetitions in most inner part of hourglass + self.blocks = self.make_repeated_residual_blocks(reps=self._reps, + out_channels=self._filters) + + else: + # outer hourglass structures + self.encoder_block1 = self.make_repeated_residual_blocks(reps=self._reps, + out_channels=self._filters) + + self.encoder_block2 = self.make_repeated_residual_blocks(reps=self._reps, + out_channels=self._filters_downsampled, initial_stride=2) + + # recursively define inner hourglasses + self.inner_hg = type(self)( + channel_dims_per_stage=self._channel_dims_per_stage[1:], + blocks_per_stage=self._blocks_per_stage[1:], + strides=self._strides) + + # outer hourglass structures + self.decoder_block = self.make_repeated_residual_blocks(reps=self._reps, + residual_channels=self._filters_downsampled, out_channels=self._filters) + + self.upsample_layer = tf.keras.layers.UpSampling2D( + size=2, interpolation='nearest') + + super().build(input_shape) + + def call(self, x): + if self._order == 0: + return self.blocks(x) + else: + encoded_outputs = self.encoder_block1(x) + encoded_downsampled_outputs = self.encoder_block2(x) + inner_outputs = self.inner_hg(encoded_downsampled_outputs) + hg_output = self.decoder_block(inner_outputs) + return self.upsample_layer(hg_output) + encoded_outputs + + def get_config(self): + layer_config = { + 'channel_dims_per_stage': self._channel_dims_per_stage, + 'blocks_per_stage': self._blocks_per_stage, + 'strides': self._strides + } + layer_config.update(super().get_config()) + return layer_config + +@tf.keras.utils.register_keras_serializable(package='centernet') +class CenterNetDecoderConv(tf.keras.layers.Layer): + """ + Convolution block for the CenterNet head. This is used to generate + both the confidence heatmaps and other regressed predictions such as + center offsets, object size, etc. + """ + def __init__(self, + output_filters: int, + bias_init : float, + name: str, + **kwargs): + """ + Args: + output_filters: int, channel depth of layer output + bias_init: float, value to initialize the bias vector for the final + convolution layer + name: string, layer name + """ + super().__init__(name=name, **kwargs) + self._output_filters = output_filters + self._bias_init = bias_init + + + def build(self, input_shape): + n_channels = input_shape[-1] + + self.conv1 = tf.keras.layers.Conv2D(filters=n_channels, + kernel_size=(3, 3), padding='same') + + self.relu = tf.keras.layers.ReLU() + + # Initialize bias to the last Conv2D Layer + self.conv2 = tf.keras.layers.Conv2D(filters=self._output_filters, + kernel_size=(1, 1), padding='valid', + bias_initializer=tf.constant_initializer(self._bias_init)) + + def call(self, x): + x = self.conv1(x) + x = self.relu(x) + x = self.conv2(x) + return x diff --git a/centernet/modeling/layers/nn_blocks_test.py b/centernet/modeling/layers/nn_blocks_test.py new file mode 100644 index 000000000..87f61cad5 --- /dev/null +++ b/centernet/modeling/layers/nn_blocks_test.py @@ -0,0 +1,146 @@ +import numpy as np +import tensorflow as tf +from absl.testing import parameterized + +from centernet.modeling.layers import nn_blocks +# the following is a literal translation of the PyTorch implementation +# https://github.com/xingyizhou/CenterNet/blob/master/src/lib/models/networks/large_hourglass.py +from official.vision.beta.modeling.layers.nn_blocks import ResidualBlock + + +class HourglassBlockPyTorch(tf.keras.layers.Layer): + """ + An CornerNet-style implementation of the hourglass block used in the + Hourglass-104 backbone. + """ + + def __init__(self, dims, modules, k=0, **kwargs): + """ + Initializes a block for the hourglass backbone. The first k entries of dims + and modules are ignored. + + Args: + dims: input sizes of residual blocks + modules: number of repetitions of the residual blocks in each hourglass + upsampling and downsampling + k: recursive parameter + """ + super().__init__() + + self.n = len(dims) - 1 + self.k = k + self.modules = modules + self.dims = dims + + assert len(dims) == len(modules), 'dims and modules lists must have the ' \ + 'same length' + + self._kwargs = kwargs + + def build(self, input_shape): + modules = self.modules + dims = self.dims + k = self.k + kwargs = self._kwargs + + curr_mod = modules[k] + next_mod = modules[k + 1] + + curr_dim = dims[k + 0] + next_dim = dims[k + 1] + + self.up1 = self.make_up_layer(3, curr_dim, curr_dim, curr_mod, **kwargs) + self.max1 = self.make_pool_layer(curr_dim) + self.low1 = self.make_hg_layer(3, curr_dim, next_dim, curr_mod, **kwargs) + self.low2 = type(self)( + dims, modules, k=k + 1, **kwargs + ) if self.n - k > 1 else \ + self.make_low_layer( + 3, next_dim, next_dim, next_mod, **kwargs + ) + self.low3 = self.make_hg_layer_revr(3, next_dim, curr_dim, curr_mod, + **kwargs) + self.up2 = self.make_unpool_layer(curr_dim) + + self.merge = self.make_merge_layer(curr_dim) + + def call(self, x): + up1 = self.up1(x) + max1 = self.max1(x) + low1 = self.low1(max1) + low2 = self.low2(low1) + low3 = self.low3(low2) + up2 = self.up2(low3) + return self.merge([up1, up2]) + + def make_layer(self, k, inp_dim, out_dim, modules, **kwargs): + layers = [ResidualBlock(out_dim, 1, use_projection=True, **kwargs)] + for _ in range(1, modules): + layers.append(ResidualBlock(out_dim, 1, **kwargs)) + return tf.keras.Sequential(layers) + + def make_layer_revr(self, k, inp_dim, out_dim, modules, **kwargs): + layers = [] + for _ in range(modules - 1): + layers.append(ResidualBlock(inp_dim, 1, **kwargs)) # inp_dim is not a bug + layers.append(ResidualBlock(out_dim, 1, use_projection=True, **kwargs)) + return tf.keras.Sequential(layers) + + def make_up_layer(self, k, inp_dim, out_dim, modules, **kwargs): + return self.make_layer(k, inp_dim, out_dim, modules, **kwargs) + + def make_low_layer(self, k, inp_dim, out_dim, modules, **kwargs): + return self.make_layer(k, inp_dim, out_dim, modules, **kwargs) + + def make_hg_layer(self, k, inp_dim, out_dim, modules, **kwargs): + return self.make_layer(k, inp_dim, out_dim, modules, **kwargs) + + def make_hg_layer_revr(self, k, inp_dim, out_dim, modules, **kwargs): + return self.make_layer_revr(k, inp_dim, out_dim, modules, **kwargs) + + def make_pool_layer(self, dim): + return tf.keras.layers.MaxPool2D(strides=2) + + def make_unpool_layer(self, dim): + return tf.keras.layers.UpSampling2D(2) + + def make_merge_layer(self, dim): + return tf.keras.layers.Add() + + +class NNBlocksTest(parameterized.TestCase, tf.test.TestCase): + + def test_hourglass_block(self): + dims = [256, 256, 384, 384, 384, 512] + modules = [2, 2, 2, 2, 2, 4] + model = nn_blocks.HourglassBlock(dims, modules) + test_input = tf.keras.Input((512, 512, 256)) + _ = model(test_input) + + filter_sizes = [256, 256, 384, 384, 384, 512] + rep_sizes = [2, 2, 2, 2, 2, 4] + + hg_test_input_shape = (1, 512, 512, 256) + bb_test_input_shape = (1, 512, 512, 3) + x_hg = tf.ones(shape=hg_test_input_shape) + x_bb = tf.ones(shape=bb_test_input_shape) + + hg = nn_blocks.HourglassBlock( + channel_dims_per_stage=filter_sizes, blocks_per_stage=rep_sizes) + + hg.build(input_shape=hg_test_input_shape) + out = hg(x_hg) + self.assertAllEqual( + tf.shape(out), hg_test_input_shape, + 'Hourglass module output shape and expected shape differ') + + # ODAPI Test + layer = nn_blocks.HourglassBlock( + blocks_per_stage=[2, 3, 4, 5, 6], + channel_dims_per_stage=[4, 6, 8, 10, 12]) + output = layer(np.zeros((2, 64, 64, 4), dtype=np.float32)) + self.assertEqual(output.shape, (2, 64, 64, 4)) + + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/modeling/plot_models.py b/centernet/modeling/plot_models.py new file mode 100644 index 000000000..1a42b25bb --- /dev/null +++ b/centernet/modeling/plot_models.py @@ -0,0 +1,39 @@ +import tensorflow as tf + +from centernet.configs import centernet as cfg +from centernet.modeling.backbones import hourglass +from centernet.modeling.CenterNet import build_centernet +from centernet.modeling.decoders import centernet_decoder +from centernet.modeling.layers import nn_blocks + +BACKBONE_OUT = "./centernet/modeling/backbone.png" +DECODER_OUT = "./centernet/modeling/decoder.png" +MODEL_OUT = "./centernet/modeling/model.png" + + + +if __name__ == '__main__': + dims = [256, 256, 384, 384, 384, 512] + modules = [2, 2, 2, 2, 2, 4] + + backbone = hourglass.build_hourglass( + tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]), cfg.CenterNetBase()) + + hg_block = nn_blocks.HourglassBlock(dims, modules) + hg_block.build((1, 512, 512, 256)) + + decoder = centernet_decoder.build_centernet_decoder( + task_config=cfg.CenterNetTask(), + input_specs=(None, 128, 128, 256)) + + input_specs = tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]) + + config = cfg.CenterNetTask() + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + + tf.keras.utils.plot_model(backbone, to_file=BACKBONE_OUT, show_shapes=True, dpi=300) + tf.keras.utils.plot_model(decoder, to_file=DECODER_OUT, show_shapes=True, dpi=300) + + hg_block.summary() + model.summary() diff --git a/centernet/ops/loss_ops.py b/centernet/ops/loss_ops.py new file mode 100644 index 000000000..b0f25c4fe --- /dev/null +++ b/centernet/ops/loss_ops.py @@ -0,0 +1,118 @@ +import tensorflow as tf + + +def _to_float32(x): + return tf.cast(x, tf.float32) + +def _get_shape(tensor, num_dims): + assert len(tensor.shape.as_list()) == num_dims + return combined_static_and_dynamic_shape(tensor) + +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 + +def _flatten_spatial_dimensions(batch_images): + batch_size, height, width, channels = _get_shape(batch_images, 4) + return tf.reshape(batch_images, [batch_size, height * width, + channels]) + +def get_num_instances_from_weights(groundtruth_weights_list): + """Computes the number of instances/boxes from the weights in a batch. + Args: + groundtruth_weights_list: A list of float tensors with shape + [max_num_instances] representing whether there is an actual instance in + the image (with non-zero value) or is padded to match the + max_num_instances (with value 0.0). The list represents the batch + dimension. + Returns: + A scalar integer tensor incidating how many instances/boxes are in the + images in the batch. Note that this function is usually used to normalize + the loss so the minimum return value is 1 to avoid weird behavior. + """ + # num_instances = tf.reduce_sum( + # [tf.math.count_nonzero(w) for w in groundtruth_weights_list]) + + # This can execute in graph mode + groundtruth_weights_list = tf.convert_to_tensor( + groundtruth_weights_list, dtype=groundtruth_weights_list[0].dtype) + num_instances = tf.map_fn( + fn=lambda x: tf.math.count_nonzero(x, dtype=groundtruth_weights_list[0].dtype), + elems=groundtruth_weights_list) + + num_instances = tf.reduce_sum(num_instances) + num_instances = tf.maximum(num_instances, 1) + return num_instances + +def multi_range(limit, + value_repetitions=1, + range_repetitions=1, + dtype=tf.int32): + """ Creates a sequence with optional value duplication and range repetition. + + As an example (see the Args section for more details), + _multi_range(limit=2, value_repetitions=3, range_repetitions=4) returns: + [0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1] + NOTE: Repurposed from Google OD API. + + Args: + limit: A 0-D Tensor (scalar). Upper limit of sequence, exclusive. + value_repetitions: Integer. The number of times a value in the sequence is + repeated. With value_repetitions=3, the result is [0, 0, 0, 1, 1, 1, ..]. + range_repetitions: Integer. The number of times the range is repeated. With + range_repetitions=3, the result is [0, 1, 2, .., 0, 1, 2, ..]. + dtype: The type of the elements of the resulting tensor. + + Returns: + A 1-D tensor of type `dtype` and size + [`limit` * `value_repetitions` * `range_repetitions`] that contains the + specified range with given repetitions. + """ + return tf.reshape( + tf.tile( + tf.expand_dims(tf.range(limit, dtype=dtype), axis=-1), + multiples=[range_repetitions, value_repetitions]), [-1]) + +def get_batch_predictions_from_indices(batch_predictions, indices): + """Gets the values of predictions in a batch at the given indices. + The indices are expected to come from the offset targets generation functions + in this library. The returned value is intended to be used inside a loss + function. + Args: + batch_predictions: A tensor of shape [batch_size, height, width, channels] + or [batch_size, height, width, class, channels] for class-specific + features (e.g. keypoint joint offsets). + indices: A tensor of shape [num_instances, 3] for single class features or + [num_instances, 4] for multiple classes features. + Returns: + values: A tensor of shape [num_instances, channels] holding the predicted + values at the given indices. + """ + # indices right now is shape (8, 128, 2), we need to make it (8, 128, 3), where + # the last dimension corresponds to the batch it belongs t + + return tf.gather_nd(batch_predictions, indices) + +def add_batch_to_indices(indices): + shape = tf.shape(indices) + batch_size = shape[0] + num_instances = shape[1] + batch_range = multi_range(limit=batch_size, value_repetitions=num_instances) + batch_range = tf.reshape(batch_range, shape=(batch_size, num_instances, 1)) + + return tf.concat([indices, batch_range], axis=-1) diff --git a/centernet/ops/preprocessing_ops.py b/centernet/ops/preprocessing_ops.py new file mode 100644 index 000000000..0c1da6ae7 --- /dev/null +++ b/centernet/ops/preprocessing_ops.py @@ -0,0 +1,165 @@ +# Moved groundtruth.py here +import tensorflow as tf + +from yolo.ops import preprocessing_ops + +LARGE_NUM = 1. / tf.keras.backend.epsilon() + +def _smallest_positive_root(a, b, c) -> tf.Tensor: + """ + Returns the smallest positive root of a quadratic equation. + This implements the fixed version in https://github.com/princeton-vl/CornerNet. + """ + + discriminant = b ** 2 - 4 * a * c + discriminant_sqrt = tf.sqrt(discriminant) + + root1 = (-b - discriminant_sqrt) / (2 * a) + root2 = (-b + discriminant_sqrt) / (2 * a) + + return tf.where(tf.less(discriminant, 0), tf.cast(LARGE_NUM, b.dtype), (-b + discriminant_sqrt) / (2)) + # return tf.where(tf.less(discriminant, 0), LARGE_NUM, tf.where(tf.less(root1, 0), root2, root1)) + +def gaussian_radius(det_size, min_overlap=0.7) -> int: + """ + Given a bounding box size, returns a lower bound on how far apart the + corners of another bounding box can lie while still maintaining the given + minimum overlap, or IoU. Modified from implementation found in + https://github.com/tensorflow/models/blob/master/research/object_detection/core/target_assigner.py. + + Params: + det_size (tuple): tuple of integers representing height and width + min_overlap (tf.float32): minimum IoU desired + Returns: + int representing desired gaussian radius + """ + height, width = det_size[0], det_size[1] + + # Case where detected box is offset from ground truth and no box completely + # contains the other. + + a1 = 1 + b1 = -(height + width) + c1 = width * height * (1 - min_overlap) / (1 + min_overlap) + r1 = _smallest_positive_root(a1, b1, c1) + + # Case where detection is smaller than ground truth and completely contained + # in it. + + a2 = 4 + b2 = -2 * (height + width) + c2 = (1 - min_overlap) * width * height + r2 = _smallest_positive_root(a2, b2, c2) + + # Case where ground truth is smaller than detection and completely contained + # in it. + + a3 = 4 * min_overlap + b3 = 2 * min_overlap * (height + width) + c3 = (min_overlap - 1) * width * height + r3 = _smallest_positive_root(a3, b3, c3) + # TODO discuss whether to return scalar or tensor + # return tf.reduce_min([r1, r2, r3], axis=0) + + # print(r1, r2, r3) + return tf.reduce_min([r1, r2, r3], axis=0) + +def _gaussian_penalty(radius: int, dtype=tf.float32) -> tf.Tensor: + """ + This represents the penalty reduction around a point. + Params: + radius (int): integer for radius of penalty reduction + type (tf.dtypes.DType): datatype of returned tensor + Returns: + tf.Tensor of shape (2 * radius + 1, 2 * radius + 1). + """ + width = 2 * radius + 1 + sigma = tf.cast(radius / 3, dtype=dtype) + + range_width = tf.range(width) + range_width = tf.cast(range_width - tf.expand_dims(radius, axis=-1), dtype=dtype) + + x = tf.expand_dims(range_width, axis=-1) + y = tf.expand_dims(range_width, axis=-2) + + exponent = ((-1 * (x ** 2) - (y ** 2)) / (2 * sigma ** 2)) + return tf.math.exp(exponent) + +@tf.function +def cartesian_product(*tensors, repeat=1): + """ + Equivalent of itertools.product except for TensorFlow tensors. + + Example: + cartesian_product(tf.range(3), tf.range(4)) + + array([[0, 0], + [0, 1], + [0, 2], + [0, 3], + [1, 0], + [1, 1], + [1, 2], + [1, 3], + [2, 0], + [2, 1], + [2, 2], + [2, 3]], dtype=int32)> + + Params: + tensors (list[tf.Tensor]): a list of 1D tensors to compute the product of + repeat (int): number of times to repeat the tensors + (https://docs.python.org/3/library/itertools.html#itertools.product) + + Returns: + An nD tensor where n is the number of tensors + """ + tensors = tensors * repeat + return tf.reshape(tf.transpose(tf.stack(tf.meshgrid(*tensors, indexing='ij')), + [*[i + 1 for i in range(len(tensors))], 0]), (-1, len(tensors))) + +def write_all(ta, index, values): + for i in range(tf.shape(values)[0]): + ta = ta.write(index + i, values[i, ...]) + return ta, index + i + +@tf.function +def draw_gaussian(hm_shape, blob, dtype, scaling_factor=1): + """ Draws an instance of a 2D gaussian on a heatmap. + + A heatmap with shape hm_shape and of type dtype is generated with + a gaussian with a given center, radius, and scaling factor + + Args: + hm_shape: A `list` of `Tensor` of shape [3] that gives the height, width, + and number of channels in the heatmap + blob: A `Tensor` of shape [4] that gives the channel number, x, y, and + radius for the desired gaussian to be drawn onto + dtype: The desired type of the heatmap + scaling_factor: A `int` that can be used to scale the magnitude of the + gaussian + Returns: + A `Tensor` with shape hm_shape and type dtype with a 2D gaussian + """ + gaussian_heatmap = tf.zeros(shape=hm_shape, dtype=dtype) + + blob = tf.cast(blob, tf.int32) + obj_class, x, y, radius = blob[0], blob[1], blob[2], blob[3] + + height, width = hm_shape[0], hm_shape[1] + + left = tf.math.minimum(x, radius) + right = tf.math.minimum(width - x, radius + 1) + top = tf.math.minimum(y, radius) + bottom = tf.math.minimum(height - y, radius + 1) + + gaussian = _gaussian_penalty(radius=radius, dtype=dtype) + gaussian = gaussian[radius-top:radius+bottom, radius-left:radius+right] + gaussian = tf.reshape(gaussian, [-1]) + + heatmap_indices = cartesian_product( + tf.range(y - top, y + bottom), tf.range(x - left, x + right), [obj_class]) + gaussian_heatmap = tf.tensor_scatter_nd_update( + gaussian_heatmap, heatmap_indices, gaussian * scaling_factor) + + return gaussian_heatmap diff --git a/centernet/ops/preprocessing_ops2.py b/centernet/ops/preprocessing_ops2.py new file mode 100644 index 000000000..b56bf15ea --- /dev/null +++ b/centernet/ops/preprocessing_ops2.py @@ -0,0 +1,50 @@ +def draw_gaussian(heatmap, blobs, scaling_factor=1, dtype=tf.float32): + """ + Draws a gaussian heatmap around a center point given a radius. + Params: + heatmap (tf.Tensor): heatmap placeholder to fill + blobs (tf.Tensor): a tensor whose last dimension is 4 integers for + the category of the object, center (x, y), and for radius of the + gaussian + scaling_factor (int): scaling factor for gaussian + """ + blobs = tf.cast(blobs, tf.int32) + category = blobs[..., 0] + x = blobs[..., 1] + y = blobs[..., 2] + radius = blobs[..., 3] + + diameter = 2 * radius + 1 + + num_boxes = tf.shape(radius)[0] + + heatmap_shape = tf.shape(heatmap) + height, width = heatmap_shape[-2], heatmap_shape[-1] + + left, right = tf.math.minimum(x, radius), tf.math.minimum(width - x, radius + 1) + top, bottom = tf.math.minimum(y, radius), tf.math.minimum(height - y, radius + 1) + + update_count = tf.reduce_sum((bottom + top) * (right + left)) + masked_gaussian_ta = tf.TensorArray(dtype, size=update_count) + heatmap_mask_ta = tf.TensorArray(tf.int32, element_shape=tf.TensorShape((3,)), size=update_count) + i = 0 + for j in range(num_boxes): + cat = category[j] + X = x[j] + Y = y[j] + R = radius[j] + l = left[j] + r = right[j] + t = top[j] + b = bottom[j] + + gaussian = _gaussian_penalty(R, dtype=dtype) + masked_gaussian_instance = tf.reshape(gaussian[R - t:R + b, R - l:R + r], (-1,)) + heatmap_mask_instance = cartesian_product([cat], tf.range(Y - t, Y + b), tf.range(X - l, X + r)) + masked_gaussian_ta, _ = write_all(masked_gaussian_ta, i, masked_gaussian_instance) + heatmap_mask_ta, i = write_all(heatmap_mask_ta, i, heatmap_mask_instance) + masked_gaussian = masked_gaussian_ta.stack() + heatmap_mask = heatmap_mask_ta.stack() + heatmap_mask = tf.reshape(heatmap_mask, (-1, 3)) + heatmap = tf.tensor_scatter_nd_max(heatmap, heatmap_mask, tf.cast(masked_gaussian * scaling_factor, heatmap.dtype)) + return heatmap diff --git a/centernet/ops/preprocessing_ops_test.py b/centernet/ops/preprocessing_ops_test.py new file mode 100644 index 000000000..9245e2e15 --- /dev/null +++ b/centernet/ops/preprocessing_ops_test.py @@ -0,0 +1,184 @@ +import numpy as np +import tensorflow as tf +from absl.testing import parameterized + +import centernet.utils.groundtruth as preprocessing_ops +from yolo.ops import box_ops + + +def image_shape_to_grids(height, width): + """Computes xy-grids given the shape of the image. + Args: + height: The height of the image. + width: The width of the image. + Returns: + A tuple of two tensors: + y_grid: A float tensor with shape [height, width] representing the + y-coordinate of each pixel grid. + x_grid: A float tensor with shape [height, width] representing the + x-coordinate of each pixel grid. + """ + out_height = tf.cast(height, tf.float32) + out_width = tf.cast(width, tf.float32) + x_range = tf.range(out_width, dtype=tf.float32) + y_range = tf.range(out_height, dtype=tf.float32) + x_grid, y_grid = tf.meshgrid(x_range, y_range, indexing='xy') + return (y_grid, x_grid) + + +class CenterNetBoxTargetAssignerTest(parameterized.TestCase, tf.test.TestCase): + + def __init__(self, *args, **kwargs): + super(CenterNetBoxTargetAssignerTest, self).__init__(*args, **kwargs) + self._box_center = [0.0, 0.0, 1.0, 1.0] + self._box_center_small = [0.25, 0.25, 0.75, 0.75] + self._box_lower_left = [0.5, 0.0, 1.0, 0.5] + self._box_center_offset = [0.1, 0.05, 1.0, 1.0] + self._box_odd_coordinates = [0.1625, 0.2125, 0.5625, 0.9625] + + def test_max_distance_for_overlap(self): + """Test that the distance ensures the IoU with random boxes.""" + + # TODO(vighneshb) remove this after the `_smallest_positive_root` + # function if fixed. + self.skipTest(('Skipping test because we are using an incorrect version of' + 'the `max_distance_for_overlap` function to reproduce' + ' results.')) + + rng = np.random.RandomState(0) + n_samples = 100 + + width = rng.uniform(1, 100, size=n_samples) + height = rng.uniform(1, 100, size=n_samples) + min_iou = rng.uniform(0.1, 1.0, size=n_samples) + + max_dist = preprocessing_ops.gaussian_radius((height, width), min_iou) + + xmin1 = np.zeros(n_samples) + ymin1 = np.zeros(n_samples) + xmax1 = np.zeros(n_samples) + width + ymax1 = np.zeros(n_samples) + height + + xmin2 = max_dist * np.cos(rng.uniform(0, 2 * np.pi)) + ymin2 = max_dist * np.sin(rng.uniform(0, 2 * np.pi)) + xmax2 = width + max_dist * np.cos(rng.uniform(0, 2 * np.pi)) + ymax2 = height + max_dist * np.sin(rng.uniform(0, 2 * np.pi)) + + boxes1 = np.vstack([ymin1, xmin1, ymax1, xmax1]).T + boxes2 = np.vstack([ymin2, xmin2, ymax2, xmax2]).T + + iou = box_ops.compute_iou(boxes1, boxes2) + + self.assertTrue(np.all(iou >= min_iou)) + + def test_max_distance_for_overlap_centernet(self): + """Test the version of the function used in the CenterNet paper.""" + distance = preprocessing_ops.gaussian_radius((10, 5), 0.5) + self.assertAlmostEqual(2.807764064, distance.numpy()) + + @parameterized.parameters((False,), (True,)) + def test_coordinates_to_heatmap(self, sparse): + self.skipTest('Not yet functioning.') + + (y_grid, x_grid) = image_shape_to_grids(height=3, width=5) + y_coordinates = tf.constant([1.5, 0.5], dtype=tf.float32) + x_coordinates = tf.constant([2.5, 4.5], dtype=tf.float32) + sigma = tf.constant([0.1, 0.5], dtype=tf.float32) + channel_onehot = tf.constant([[1, 0, 0], [0, 1, 0]], dtype=tf.float32) + channel_weights = tf.constant([1, 1], dtype=tf.float32) + heatmap = ta_utils.coordinates_to_heatmap(y_grid, x_grid, y_coordinates, + x_coordinates, sigma, + channel_onehot, + channel_weights, sparse=sparse) + + # Peak at (1, 2) for the first class. + self.assertAlmostEqual(1.0, heatmap[1, 2, 0]) + # Peak at (0, 4) for the second class. + self.assertAlmostEqual(1.0, heatmap[0, 4, 1]) + + + + + def coordinates_to_heatmap(y_grid, + x_grid, + y_coordinates, + x_coordinates, + sigma, + channel_onehot, + channel_weights=None, + sparse=False): + """Returns the heatmap targets from a set of point coordinates. + This function maps a set of point coordinates to the output heatmap image + applied using a Gaussian kernel. Note that this function be can used by both + object detection and keypoint estimation tasks. For object detection, the + "channel" refers to the object class. For keypoint estimation, the "channel" + refers to the number of keypoint types. + Args: + y_grid: A 2D tensor with shape [height, width] which contains the grid + y-coordinates given in the (output) image dimensions. + x_grid: A 2D tensor with shape [height, width] which contains the grid + x-coordinates given in the (output) image dimensions. + y_coordinates: A 1D tensor with shape [num_instances] representing the + y-coordinates of the instances in the output space coordinates. + x_coordinates: A 1D tensor with shape [num_instances] representing the + x-coordinates of the instances in the output space coordinates. + sigma: A 1D tensor with shape [num_instances] representing the standard + deviation of the Gaussian kernel to be applied to the point. + channel_onehot: A 2D tensor with shape [num_instances, num_channels] + representing the one-hot encoded channel labels for each point. + channel_weights: A 1D tensor with shape [num_instances] corresponding to the + weight of each instance. + sparse: bool, indicating whether or not to use the sparse implementation + of the function. The sparse version scales better with number of channels, + but in some cases is known to cause OOM error. See (b/170989061). + Returns: + heatmap: A tensor of size [height, width, num_channels] representing the + heatmap. Output (height, width) match the dimensions of the input grids. + """ + + # if sparse: + # return _coordinates_to_heatmap_sparse( + # y_grid, x_grid, y_coordinates, x_coordinates, sigma, channel_onehot, + # channel_weights) + # else: + return _coordinates_to_heatmap_dense( + y_grid, x_grid, y_coordinates, x_coordinates, sigma, channel_onehot, + channel_weights) + + + def _coordinates_to_heatmap_dense(y_grid, x_grid, y_coordinates, x_coordinates, + sigma, channel_onehot, channel_weights=None): + """Dense version of coordinates to heatmap that uses an outer product.""" + num_instances, num_channels = ( + shape_utils.combined_static_and_dynamic_shape(channel_onehot)) + + x_grid = tf.expand_dims(x_grid, 2) + y_grid = tf.expand_dims(y_grid, 2) + # The raw center coordinates in the output space. + x_diff = x_grid - tf.math.floor(x_coordinates) + y_diff = y_grid - tf.math.floor(y_coordinates) + squared_distance = x_diff**2 + y_diff**2 + + gaussian_map = tf.exp(-squared_distance / (2 * sigma * sigma)) + + reshaped_gaussian_map = tf.expand_dims(gaussian_map, axis=-1) + reshaped_channel_onehot = tf.reshape(channel_onehot, + (1, 1, num_instances, num_channels)) + gaussian_per_box_per_class_map = ( + reshaped_gaussian_map * reshaped_channel_onehot) + + if channel_weights is not None: + reshaped_weights = tf.reshape(channel_weights, (1, 1, num_instances, 1)) + gaussian_per_box_per_class_map *= reshaped_weights + + # Take maximum along the "instance" dimension so that all per-instance + # heatmaps of the same class are merged together. + heatmap = tf.reduce_max(gaussian_per_box_per_class_map, axis=2) + + # Maximum of an empty tensor is -inf, the following is to avoid that. + heatmap = tf.maximum(heatmap, 0) + + return tf.stop_gradient(heatmap) + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/requirements.txt b/centernet/requirements.txt new file mode 100644 index 000000000..180e930be --- /dev/null +++ b/centernet/requirements.txt @@ -0,0 +1,3 @@ +# When using a wheel for the model garden, use the commented line instead of the requirements file +# tf-models-official +-r ../official/requirements.txt diff --git a/centernet/tasks/centernet.py b/centernet/tasks/centernet.py new file mode 100644 index 000000000..c4f519420 --- /dev/null +++ b/centernet/tasks/centernet.py @@ -0,0 +1,330 @@ +import tensorflow as tf +from absl import logging +from tensorflow.keras.mixed_precision import experimental as mixed_precision + +from centernet.configs import centernet as exp_cfg +from centernet.dataloaders import centernet_input +from centernet.losses import (gt_builder, l1_localization_loss, + penalty_reduced_logistic_focal_loss) +from centernet.ops import loss_ops +from official.core import base_task, input_reader, task_factory +from official.vision.beta.dataloaders import (tf_example_decoder, + tf_example_label_map_decoder, + tfds_detection_decoders) +from official.vision.beta.evaluation import coco_evaluator +from official.vision.beta.ops import box_ops + + +@task_factory.register_task_cls(exp_cfg.CenterNetTask) +class CenterNetTask(base_task.Task): + + def __init__(self, params, logging_dir: str = None): + super().__init__(params, logging_dir) + self._loss_dict = None + + self.coco_metric = None + self._metric_names = [] + self._metrics = [] + + def build_inputs(self, params, input_context=None): + """Build input dataset.""" + decoder = self.get_decoder(params) + model = self.task_config.model + + parser = centernet_input.CenterNetParser( + image_w=params.parser.image_w, + image_h=params.parser.image_h, + max_num_instances=params.parser.max_num_instances, + bgr_ordering=params.parser.bgr_ordering, + channel_means=params.parser.channel_means, + channel_stds=params.parser.channel_stds, + dtype=params.parser.dtype + ) + + reader = input_reader.InputReader( + params, + dataset_fn=tf.data.TFRecordDataset, + decoder_fn=decoder.decode, + parser_fn=parser.parse_fn(params.is_training), + postprocess_fn=parser.postprocess_fn(params.is_training)) + dataset = reader.read(input_context=input_context) + print(dataset) + return dataset + + def build_model(self): + """get an instance of CenterNet""" + from centernet.modeling.CenterNet import build_centernet + params = self.task_config.train_data + model_base_cfg = self.task_config.model + l2_weight_decay = self.task_config.weight_decay / 2.0 + + input_specs = tf.keras.layers.InputSpec(shape=[None] + + model_base_cfg.input_size) + l2_regularizer = ( + tf.keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None) + + model, losses = build_centernet(input_specs, self.task_config, l2_regularizer) + self._loss_dict = losses + return model + + def initialize(self, model: tf.keras.Model): + """Initializes CenterNet model by loading pretrained weights """ + if self.task_config.load_odapi_weights and self.task_config.load_extremenet_weights: + raise ValueError('Only 1 of odapi or extremenet weights should be loaded') + + if self.task_config.load_odapi_weights or self.task_config.load_extremenet_weights: + from centernet.utils.weight_utils.tf_to_dict import get_model_weights_as_dict + from centernet.utils.weight_utils.load_weights import load_weights_model + from centernet.utils.weight_utils.load_weights import load_weights_backbone + + # Load entire model weights from the ODAPI checkpoint + if self.task_config.load_odapi_weights: + weights_file = self.task_config.model.base.odapi_weights + weights_dict, n_weights = get_model_weights_as_dict(weights_file) + load_weights_model(model, weights_dict, + backbone_name=self.task_config.model.base.backbone_name, + decoder_name=self.task_config.model.base.decoder_name) + + # Load backbone weights from ExtremeNet + else: + weights_file = self.task_config.model.base.extremenet_weights + weights_dict, n_weights = get_model_weights_as_dict(weights_file) + load_weights_backbone(model.backbone, weights_dict['feature_extractor'], + backbone_name=self.task_config.model.base.backbone_name) + + def get_decoder(self, params): + if params.tfds_name: + if params.tfds_name in tfds_detection_decoders.TFDS_ID_TO_DECODER_MAP: + decoder = tfds_detection_decoders.TFDS_ID_TO_DECODER_MAP[ + params.tfds_name]() + else: + raise ValueError('TFDS {} is not supported'.format(params.tfds_name)) + else: + decoder_cfg = params.decoder.get() + if params.decoder.type == 'simple_decoder': + decoder = tf_example_decoder.TfExampleDecoder( + regenerate_source_id=decoder_cfg.regenerate_source_id) + elif params.decoder.type == 'label_map_decoder': + decoder = tf_example_label_map_decoder.TfExampleDecoderLabelMap( + label_map=decoder_cfg.label_map, + regenerate_source_id=decoder_cfg.regenerate_source_id) + else: + raise ValueError('Unknown decoder type: {}!'.format( + params.decoder.type)) + return decoder + + + def build_losses(self, outputs, labels, num_replicas=1, scale_replicas=1, aux_losses=None): + total_loss = 0.0 + loss = 0.0 + loss_params = self.task_config.losses + + metric_dict = dict() + + # TODO: The loss components in centernet/losses are tested but + # returning 0 for now, just trying to run eval + metric_dict['total_loss'] = total_loss + return total_loss, metric_dict + + gt_label = tf.map_fn( + fn=lambda x: gt_builder._build_heatmap_and_regressed_features( + labels=x, + output_size=[loss_params.image_h, loss_params.image_w], + input_size=[loss_params.output_dims, loss_params.output_dims], + num_classes=self.task_config.model.num_classes, + max_num_instances=loss_params.max_num_instances, + use_gaussian_bump=loss_params.use_gaussian_bump, + gaussian_rad=loss_params.gaussian_rad, + gaussian_iou=loss_params.gaussian_iou, + class_offset=loss_params.class_offset, + dtype=loss_params.dtype), + elems=labels, + dtype={ + 'ct_heatmaps': tf.float32, + 'ct_offset': tf.float32, + 'size': tf.float32, + 'box_mask': tf.int32, + 'box_indices': tf.int32 + } + ) + + # Create loss functions + object_center_loss_fn = penalty_reduced_logistic_focal_loss.PenaltyReducedLogisticFocalLoss(reduction=tf.keras.losses.Reduction.NONE) + localization_loss_fn = l1_localization_loss.L1LocalizationLoss(reduction=tf.keras.losses.Reduction.NONE) + + # Set up box indices so that they have a batch element as well + box_indices = loss_ops.add_batch_to_indices(gt_label['box_indices']) + + box_mask = tf.cast(gt_label['box_mask'], dtype=tf.float32) + num_boxes = loss_ops._to_float32(loss_ops.get_num_instances_from_weights(gt_label['box_mask'])) + + # Calculate center heatmap loss + pred_ct_heatmap_list = outputs['ct_heatmaps'] + true_flattened_ct_heatmap = loss_ops._flatten_spatial_dimensions( + gt_label['ct_heatmaps']) + + true_flattened_ct_heatmap = tf.cast(true_flattened_ct_heatmap, tf.float32) + total_center_loss = 0.0 + for ct_heatmap in pred_ct_heatmap_list: + pred_flattened_ct_heatmap = loss_ops._flatten_spatial_dimensions( + ct_heatmap) + pred_flattened_ct_heatmap = tf.cast(pred_flattened_ct_heatmap, tf.float32) + total_center_loss += object_center_loss_fn( + pred_flattened_ct_heatmap, true_flattened_ct_heatmap) + + center_loss = tf.reduce_sum(total_center_loss) / float(len(pred_ct_heatmap_list) * num_boxes) + metric_dict['ct_loss'] = center_loss + + # Calculate scale loss + pred_scale_list = outputs['ct_size'] + true_scale = gt_label['size'] + true_scale = tf.cast(true_scale, tf.float32) + + total_scale_loss = 0.0 + for scale_map in pred_scale_list: + pred_scale = loss_ops.get_batch_predictions_from_indices(scale_map, box_indices) + pred_scale = tf.cast(pred_scale, tf.float32) + # Only apply loss for boxes that appear in the ground truth + total_scale_loss += tf.reduce_sum(localization_loss_fn(pred_scale, true_scale), axis=-1) * box_mask + + scale_loss = tf.reduce_sum(total_scale_loss) / float(len(pred_scale_list) * num_boxes) + metric_dict['scale_loss'] = scale_loss + + # Calculate offset loss + pred_offset_list = outputs['ct_offset'] + true_offset = gt_label['ct_offset'] + true_offset = tf.cast(true_offset, tf.float32) + + total_offset_loss = 0.0 + for offset_map in pred_offset_list: + pred_offset = loss_ops.get_batch_predictions_from_indices(offset_map, box_indices) + pred_offset = tf.cast(pred_offset, tf.float32) + # Only apply loss for boxes that appear in the ground truth + total_offset_loss += tf.reduce_sum(localization_loss_fn(pred_offset, true_offset), axis=-1) * box_mask + + offset_loss = tf.reduce_sum(total_offset_loss) / float(len(pred_offset_list) * num_boxes) + metric_dict['ct_offset_loss'] = offset_loss + + # Aggregate and finalize loss + loss_weights = self.task_config.losses.detection + total_loss = (center_loss + + loss_weights.scale_weight * scale_loss + + loss_weights.offset_weight * offset_loss) + + metric_dict['total_loss'] = total_loss + return total_loss, metric_dict + + def build_metrics(self, training=True): + metrics = [] + metric_names = self._metric_names + + for name in metric_names: + metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + + self._metrics = metrics + if not training: + self.coco_metric = coco_evaluator.COCOEvaluator( + annotation_file=self.task_config.annotation_file, + include_mask=False, + need_rescale_bboxes=False, + per_category_metrics=self._task_config.per_category_metrics) + return metrics + + def train_step(self, inputs, model, optimizer, metrics=None): + # get the data point + image, label = inputs + + with tf.GradientTape() as tape: + # compute a prediction + # cast to float32 + y_pred = model(image, training=True) + y_pred = tf.nest.map_structure(lambda x: tf.cast(x, tf.float32), y_pred['raw_output']) + loss_metrics = self.build_losses(y_pred, label) + + #scale the loss for numerical stability + if isinstance(optimizer, mixed_precision.LossScaleOptimizer): + total_loss = optimizer.get_scaled_loss(loss_metrics['total_loss']) + + #compute the gradient + train_vars = model.trainable_variables + gradients = tape.gradient(total_loss, train_vars) + + #get unscaled loss if the scaled loss was used + if isinstance(optimizer, mixed_precision.LossScaleOptimizer): + gradients = optimizer.get_unscaled_gradients(gradients) + + if self.task_config.gradient_clip_norm > 0.0: + gradients, _ = tf.clip_by_global_norm(gradients, + self.task_config.gradient_clip_norm) + + optimizer.apply_gradients(zip(gradients, train_vars)) + + logs = {self.loss: loss_metrics['total_loss']} + if metrics: + for m in metrics: + m.update_state(loss_metrics[m.name]) + logs.update({m.name: m.result()}) + + tf.print(logs, end='\n') + ret = '\033[F' * (len(logs.keys()) + 1) + tf.print(ret, end='\n') + return logs + + def validation_step(self, inputs, model, metrics=None): + # get the data point + image, label = inputs + + scale_replicas = tf.distribute.get_strategy().num_replicas_in_sync + if self._task_config.model.filter.use_reduction_sum: + num_replicas = 1 + else: + num_replicas = scale_replicas + + y_pred = model(image, training=False) + y_pred = tf.nest.map_structure(lambda x: tf.cast(x, tf.float32), y_pred) + loss, loss_metrics = self.build_losses( + y_pred['raw_output'], + label, + num_replicas=num_replicas, + scale_replicas=1) + logs = {self.loss: loss_metrics['total_loss']} + + image_shape = tf.shape(image)[1:-1] + + label['boxes'] = box_ops.denormalize_boxes( + tf.cast(label['bbox'], tf.float32), image_shape) + del label['bbox'] + + coco_model_outputs = { + 'detection_boxes': + box_ops.denormalize_boxes( + tf.cast(y_pred['bbox'], tf.float32), image_shape), + 'detection_scores': + y_pred['confidence'], + 'detection_classes': + y_pred['classes'], + 'num_detections': + y_pred['num_dets'], + 'source_id': + label['source_id'], + } + + logs.update({self.coco_metric.name: (label, coco_model_outputs)}) + + if metrics: + for m in metrics: + m.update_state(loss_metrics[m.name]) + logs.update({m.name: m.result()}) + return logs + + def aggregate_logs(self, state=None, step_outputs=None): + if not state: + self.coco_metric.reset_states() + state = self.coco_metric + + self.coco_metric.update_state(step_outputs[self.coco_metric.name][0], + step_outputs[self.coco_metric.name][1]) + return state + + def reduce_aggregated_logs(self, aggregated_logs): + return self.coco_metric.result() diff --git a/centernet/tasks/centernet_test.py b/centernet/tasks/centernet_test.py new file mode 100644 index 000000000..d3450685c --- /dev/null +++ b/centernet/tasks/centernet_test.py @@ -0,0 +1,52 @@ +import tensorflow as tf +from absl.testing import parameterized + +import orbit +from centernet.tasks import centernet +from official.core import exp_factory + + +class CenterNetTaskTest(parameterized.TestCase, tf.test.TestCase): + + # def testCenterNetTask(self): + # model_config = exp_cfg.CenterNet(input_size=[512, 512, 3]) + # config = exp_cfg.CenterNetTask(model=model_config) + # task = CenterNetTask(config) + + # model = task.build_model() + # outputs = model(tf.zeros((3, 512, 512, 3))) + + # self.assertEqual(len(outputs['raw_output']), 3) + # self.assertEqual(outputs['raw_output']['ct_heatmaps'][0].shape, (3, 128, 128, 90)) + # self.assertEqual(outputs['raw_output']['ct_offset'][0].shape, (3, 128, 128, 2)) + # self.assertEqual(outputs['raw_output']['ct_size'][0].shape, (3, 128, 128, 2)) + + # model.summary() + + @parameterized.parameters(("centernet_tpu",)) + def testCenterNetValidation(self, config_name): + resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='node-8') + tf.config.experimental_connect_to_cluster(resolver) + tf.tpu.experimental.initialize_tpu_system(resolver) + + config = exp_factory.get_exp_config(config_name) + + task = centernet.CenterNetTask(config.task) + model = task.build_model() + metrics = task.build_metrics(training=False) + strategy = tf.distribute.get_strategy() + + dataset = orbit.utils.make_distributed_dataset(strategy, task.build_inputs, + config.task.validation_data) + + iterator = iter(dataset) + + with strategy.scope(): + logs = task.validation_step(next(iterator), model, metrics=metrics) + logs = task.validation_step(next(iterator), model, metrics=metrics) + + self.assertIn("loss", logs) + + +if __name__ == '__main__': + tf.test.main() diff --git a/centernet/train.py b/centernet/train.py index b00fc5986..c36ded527 100755 --- a/centernet/train.py +++ b/centernet/train.py @@ -1,4 +1,4 @@ -# Lint as: python3 +# Lint as: python3 # Copyright 2020 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,42 +14,103 @@ # limitations under the License. # ============================================================================== """TensorFlow Model Garden Vision training driver.""" -from yolo.utils.run_utils import prep_gpu -try: - prep_gpu() -except BaseException: - print('GPUs ready') +import pprint +import sys -from absl import app -from absl import flags import gin +from absl import app, flags -from official.core import train_utils # pylint: disable=unused-import -from yolo.common import registry_imports +from centernet.common import registry_imports # pylint: enable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib +from official.core import task_factory, train_lib, train_utils from official.modeling import performance +from yolo.utils.run_utils import prep_gpu + +try: + prep_gpu() +except BaseException: + print('GPUs ready') + + FLAGS = flags.FLAGS """ -python3 -m yolo.train --mode=train_and_eval --experiment=darknet_classification --model_dir=training_dir --config_file=yolo/configs/experiments/darknet53.yaml +export LD_LIBRARY_PATH=/usr/local/cuda/lib64 """ """ -python3 -m yolo.train --mode=train_and_eval --experiment=yolo_v4_coco --model_dir=training_dir --config_file=yolo/configs/experiments/yolov4.yaml +get the cache file: +scp -i ./jaeyounkim-purdue-1 cache.zip purdue@34.105.118.198:~/ +train darknet: +python3 -m yolo.train --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/darknet53 --config_file=yolo/configs/experiments/darknet53.yaml +python3.8 -m yolo.train --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/dilated_darknet53 --config_file=yolo/configs/experiments/dilated_darknet53.yaml +finetune darknet: +nohup python3 -m yolo.train --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/darknet53_remap_fn --config_file=yolo/configs/experiments/darknet53_leaky_fn_tune.yaml >> darknet53.log & tail -f darknet53.log +train yolo-v4: +nohup python3 -m yolo.train --mode=train_and_eval --experiment=yolo_custom --model_dir=../checkpoints/yolov4- --config_file=yolo/configs/experiments/yolov4.yaml >> yolov4.log & tail -f yolov4.log +nohup python3.8 -m yolo.train --mode=train_and_eval --experiment=yolo_subdiv_custom --model_dir=../checkpoints/yolov4_subdiv64 --config_file=yolo/configs/experiments/yolov4_subdiv.yaml >> yolov4.log & tail -f yolov4.log +nohup python3 -m yolo.train --mode=train_and_eval --experiment=yolo_custom --model_dir=../checkpoints/yolov4- --config_file=yolo/configs/experiments/yolov4-1gpu.yaml >> yolov4-1gpu.log & tail -f yolov4-1gpu.log +nohup python3.8 -m yolo.train --mode=train_and_eval --experiment=yolo_custom --model_dir=../checkpoints/yolov3-1gpu_mosaic --config_file=yolo/configs/experiments/yolov3-1gpu.yaml >> yolov3-1gpu.log & tail -f yolov3-1gpu.log +evalaute CenterNet: +nohup python -m centernet.train --mode=train_and_eval --experiment=centernet_custom --model_dir=../checkpoints/centernet- --config_file=centernet/configs/experiments/centernet-eval-tpu.yaml >> centernet-eval.log & tail -f centernet-eval.log +evalaute CenterNet on TPU: +nohup python3 -m centernet.train --mode=eval --tpu=node-8 --experiment=centernet_tpu --model_dir=gs://tensorflow2/centernet-eval-tpu --config_file=centernet/configs/experiments/centernet-eval-tpu.yaml > centernet-eval.log & tail -f centernet-eval.log """ +def subdivison_adjustment(params): + + if hasattr(params.task.model, + 'subdivisions') and params.task.model.subdivisions > 1: + print('adjustment is needed') + subdivisons = params.task.model.subdivisions + params.task.train_data.global_batch_size //= subdivisons + # params.task.validation_data.global_batch_size //= subdivisons + params.trainer.train_steps *= subdivisons + # params.trainer.validation_steps *= subdivisons + params.trainer.validation_interval = (params.trainer.validation_interval // + subdivisons) * subdivisons + params.trainer.checkpoint_interval = (params.trainer.checkpoint_interval // + subdivisons) * subdivisons + params.trainer.steps_per_loop = (params.trainer.steps_per_loop // + subdivisons) * subdivisons + params.trainer.summary_interval = (params.trainer.summary_interval // + subdivisons) * subdivisons + + if params.trainer.optimizer_config.learning_rate.type == 'stepwise': + bounds = params.trainer.optimizer_config.learning_rate.stepwise.boundaries + params.trainer.optimizer_config.learning_rate.stepwise.boundaries = [ + subdivisons * bound for bound in bounds + ] + + if params.trainer.optimizer_config.learning_rate.type == 'polynomial': + params.trainer.optimizer_config.learning_rate.polynomial.decay_steps *= subdivisons + + if params.trainer.optimizer_config.optimizer.type == 'sgd': + print(params.trainer.optimizer_config.optimizer.type) + params.trainer.optimizer_config.optimizer.type = 'sgd_accum' + params.trainer.optimizer_config.optimizer.sgd_accum.accumulation_steps = subdivisons + params.trainer.optimizer_config.optimizer.sgd_accum.momentum = params.trainer.optimizer_config.optimizer.sgd.momentum + params.trainer.optimizer_config.optimizer.sgd_accum.decay = params.trainer.optimizer_config.optimizer.sgd.decay + + if params.trainer.optimizer_config.warmup.type == 'linear': + params.trainer.optimizer_config.warmup.linear.warmup_steps *= subdivisons + + print(params.as_dict()) + # sys.exit() + return params + + def main(_): gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_params) print(FLAGS.experiment) params = train_utils.parse_configuration(FLAGS) + params = subdivison_adjustment(params) model_dir = FLAGS.model_dir - if 'train' in FLAGS.mode: + if 'train' in FLAGS.mode and model_dir != None: # Pure eval modes do not output yaml files. Otherwise continuous eval job # may race against the train job for writing the same file. train_utils.serialize_config(params, model_dir) @@ -61,11 +122,17 @@ def main(_): if params.runtime.mixed_precision_dtype: performance.set_mixed_precision_policy(params.runtime.mixed_precision_dtype, params.runtime.loss_scale) + if params.runtime.worker_hosts != '' and params.runtime.worker_hosts is not None: + num_workers = distribute_utils.configure_cluster( + worker_hosts=params.runtime.worker_hosts, + task_index=params.runtime.task_index) + print(num_workers) distribution_strategy = distribute_utils.get_distribution_strategy( distribution_strategy=params.runtime.distribution_strategy, all_reduce_alg=params.runtime.all_reduce_alg, num_gpus=params.runtime.num_gpus, tpu_address=params.runtime.tpu) + with distribution_strategy.scope(): task = task_factory.get_task(params.task, logging_dir=model_dir) diff --git a/centernet/train_vm.py b/centernet/train_vm.py new file mode 100644 index 000000000..f067caac5 --- /dev/null +++ b/centernet/train_vm.py @@ -0,0 +1,147 @@ +# Lint as: python3 +# Copyright 2020 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +"""TensorFlow Model Garden Vision training driver.""" +import sys + +import gin +import tensorflow as tf +from absl import app, flags + +# pylint: disable=unused-import +from centernet.common import registry_imports +# pylint: enable=unused-import +from official.common import distribute_utils +from official.common import flags as tfm_flags +from official.core import task_factory, train_lib, train_utils +from official.modeling import performance +from yolo.utils.run_utils import prep_gpu + +FLAGS = flags.FLAGS +""" +get the cache file: +scp -i cache.zip purdue@:~/ +tensorboard: +on the vm: +nohup tensorboard --logdir ../checkpoints/yolov4-model --port 6006 >> temp.log +on your device: +ssh -i -N -f -L localhost:16006:localhost:6006 purdue@ +get the checkpoint from device: +scp -i purdue@:/checkpoints/.zip . +train darknet: +python3.8 -m yolo.train_vm --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/darknet53 --config_file=yolo/configs/experiments/darknet/darknet53.yaml +python3 -m yolo.train_vm --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/dilated_darknet53 --config_file=yolo/configs/experiments/dilated_darknet53.yaml +finetune darknet: +nohup python3 -m yolo.train_vm --mode=train_and_eval --experiment=darknet_classification --model_dir=../checkpoints/darknet53_remap_fn --config_file=yolo/configs/experiments/darknet53_leaky_fn_tune.yaml >> darknet53.log & tail -f darknet53.log +train yolo-v4: +nohup python3 -m yolo.train_vm --mode=train_and_eval --experiment=yolo_custom --model_dir=../checkpoints/yolov4-model --config_file=yolo/configs/experiments/yolov4.yaml >> yolov4.log & tail -f yolov4.log +nohup python3 -m yolo.train_vm --mode=train_and_eval --experiment=yolo_custom --model_dir=../checkpoints/yolov4- --config_file=yolo/configs/experiments/yolov4-1gpu.yaml >> yolov4-1gpu.log & tail -f yolov4-1gpu.log +evalaute CenterNet on TPU: +nohup python3 -m centernet.train_vm --mode=eval --tpu=node-8 --experiment=centernet_tpu --model_dir=gs://tensorflow2/centernet-eval-tpu --config_file=centernet/configs/experiments/centernet-eval-tpu.yaml > centernet-eval.log & tail -f centernet-eval.log +""" + + +def subdivison_adjustment(params): + tf.config.set_soft_device_placement(True) + if hasattr(params.task.model, + 'subdivisions') and params.task.model.subdivisions > 1: + print('adjustment is needed') + subdivisons = params.task.model.subdivisions + params.task.train_data.global_batch_size //= subdivisons + # params.task.validation_data.global_batch_size //= subdivisons + params.trainer.train_steps *= subdivisons + # params.trainer.validation_steps = subdivisons + params.trainer.validation_interval = (params.trainer.validation_interval // + subdivisons) * subdivisons + params.trainer.checkpoint_interval = (params.trainer.checkpoint_interval // + subdivisons) * subdivisons + params.trainer.steps_per_loop = (params.trainer.steps_per_loop // + subdivisons) * subdivisons + params.trainer.summary_interval = (params.trainer.summary_interval // + subdivisons) * subdivisons + + if params.trainer.optimizer_config.learning_rate.type == 'stepwise': + bounds = params.trainer.optimizer_config.learning_rate.stepwise.boundaries + params.trainer.optimizer_config.learning_rate.stepwise.boundaries = [ + subdivisons * bound for bound in bounds + ] + + if params.trainer.optimizer_config.learning_rate.type == 'polynomial': + params.trainer.optimizer_config.learning_rate.polynomial.decay_steps *= subdivisons + + if params.trainer.optimizer_config.optimizer.type == 'sgd': + print(params.trainer.optimizer_config.optimizer.type) + params.trainer.optimizer_config.optimizer.type = 'sgd_accum' + params.trainer.optimizer_config.optimizer.sgd_accum.accumulation_steps = subdivisons + params.trainer.optimizer_config.optimizer.sgd_accum.momentum = params.trainer.optimizer_config.optimizer.sgd.momentum + params.trainer.optimizer_config.optimizer.sgd_accum.decay = params.trainer.optimizer_config.optimizer.sgd.decay + + if params.trainer.optimizer_config.warmup.type == 'linear': + params.trainer.optimizer_config.warmup.linear.warmup_steps *= subdivisons + + print(params.as_dict()) + # sys.exit() + return params + + +def main(_): + gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_params) + print(FLAGS.experiment) + params = train_utils.parse_configuration(FLAGS) + + params = subdivison_adjustment(params) + model_dir = FLAGS.model_dir + if 'train' in FLAGS.mode and model_dir != None: + # Pure eval modes do not output yaml files. Otherwise continuous eval job + # may race against the train job for writing the same file. + train_utils.serialize_config(params, model_dir) + + # Sets mixed_precision policy. Using 'mixed_float16' or 'mixed_bfloat16' + # can have significant impact on model speeds by utilizing float16 in case of + # GPUs, and bfloat16 in the case of TPUs. loss_scale takes effect only when + # dtype is float16 + if params.runtime.mixed_precision_dtype: + performance.set_mixed_precision_policy(params.runtime.mixed_precision_dtype, + params.runtime.loss_scale) + if params.runtime.worker_hosts != '' and params.runtime.worker_hosts is not None: + num_workers = distribute_utils.configure_cluster( + worker_hosts=params.runtime.worker_hosts, + task_index=params.runtime.task_index) + print(num_workers) + distribution_strategy = distribute_utils.get_distribution_strategy( + distribution_strategy=params.runtime.distribution_strategy, + all_reduce_alg=params.runtime.all_reduce_alg, + num_gpus=params.runtime.num_gpus, + tpu_address=params.runtime.tpu) + with distribution_strategy.scope(): + task = task_factory.get_task(params.task, logging_dir=model_dir) + + train_lib.run_experiment( + distribution_strategy=distribution_strategy, + task=task, + mode=FLAGS.mode, + params=params, + model_dir=model_dir) + + +if __name__ == '__main__': + import datetime + + a = datetime.datetime.now() + tfm_flags.define_flags() + app.run(main) + b = datetime.datetime.now() + + print('\n\n\n\n\n\n\n {b - a}') diff --git a/centernet/utils/__init__.py b/centernet/utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/centernet/utils/weight_utils/EXTREME_NET_VARS.txt b/centernet/utils/weight_utils/EXTREME_NET_VARS.txt new file mode 100644 index 000000000..144f2c156 --- /dev/null +++ b/centernet/utils/weight_utils/EXTREME_NET_VARS.txt @@ -0,0 +1,1338 @@ +feature_extractor + hourglass_network + 0 + encoder_block1 + 0 + norm + moving_mean + moving_variance + beta + gamma + conv_block + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + beta + gamma + moving_variance + moving_mean + conv + kernel + inner_block + 0 + decoder_block + 1 + skip + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + beta + gamma + moving_mean + moving_variance + inner_block + 0 + inner_block + 0 + encoder_block2 + 1 + conv_block + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + skip + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + inner_block + 0 + decoder_block + 0 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + skip + conv + kernel + norm + gamma + beta + moving_variance + moving_mean + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + encoder_block1 + 0 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + encoder_block2 + 0 + conv_block + conv + kernel + norm + moving_mean + moving_variance + beta + gamma + norm + gamma + moving_mean + moving_variance + beta + conv + kernel + skip + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + 1 + conv_block + norm + moving_variance + gamma + moving_mean + beta + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + inner_block + 3 + conv_block + norm + gamma + beta + moving_variance + moving_mean + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + 2 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + 1 + norm + moving_variance + beta + gamma + moving_mean + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + 0 + conv_block + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + decoder_block + 0 + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + 1 + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + encoder_block1 + 0 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + 1 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 0 + norm + gamma + beta + moving_mean + moving_variance + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + conv + kernel + 1 + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + gamma + beta + moving_mean + moving_variance + encoder_block2 + 0 + conv_block + norm + gamma + beta + moving_variance + moving_mean + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + skip + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + decoder_block + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + 0 + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block2 + 0 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + beta + gamma + moving_mean + moving_variance + 1 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 1 + norm + moving_variance + moving_mean + beta + gamma + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + 0 + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block2 + 0 + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + norm + moving_mean + beta + moving_variance + gamma + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + decoder_block + 1 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + inner_block + 0 + inner_block + 0 + inner_block + 0 + inner_block + 0 + encoder_block1 + 0 + conv_block + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + 1 + conv + kernel + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + encoder_block2 + 1 + conv + kernel + conv_block + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + skip + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + decoder_block + 1 + skip + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + norm + moving_variance + moving_mean + beta + gamma + conv_block + conv + kernel + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + 0 + conv_block + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + inner_block + 3 + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + norm + moving_mean + moving_variance + beta + gamma + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + 2 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + encoder_block2 + 0 + norm + moving_variance + gamma + beta + moving_mean + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + skip + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + encoder_block1 + 0 + norm + beta + gamma + moving_mean + moving_variance + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + 1 + conv_block + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + decoder_block + 0 + conv_block + norm + moving_variance + beta + moving_mean + gamma + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + encoder_block1 + 0 + norm + moving_mean + beta + gamma + moving_variance + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block2 + 0 + conv_block + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + conv + kernel + norm + moving_variance + gamma + moving_mean + beta + skip + norm + gamma + moving_mean + moving_variance + beta + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + decoder_block + 0 + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + 1 + conv_block + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + encoder_block1 + 1 + conv + kernel + conv_block + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + conv + kernel + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block2 + 1 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + 0 + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + decoder_block + 0 + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + gamma + beta + moving_variance + moving_mean + conv + kernel + 1 + conv + kernel + norm + gamma + beta + moving_variance + moving_mean + skip + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv_block + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + encoder_block1 + 1 + conv + kernel + conv_block + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + beta + moving_variance + moving_mean + gamma + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + encoder_block2 + 0 + skip + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv_block + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + 1 + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + decoder_block + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + 0 + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + downsample_input + residual_block + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + moving_variance + moving_mean + beta + gamma + skip + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + conv_block + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + intermediate_conv2 + 0 + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + output_conv + 1 + conv + kernel + norm + moving_variance + moving_mean + gamma + beta + 0 + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + intermediate_residual + 0 + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + intermediate_conv1 + 0 + conv + kernel + norm + beta + gamma + moving_mean + moving_variance +save_counter diff --git a/centernet/utils/weight_utils/MODEL_VARS.txt b/centernet/utils/weight_utils/MODEL_VARS.txt new file mode 100644 index 000000000..119fb548c --- /dev/null +++ b/centernet/utils/weight_utils/MODEL_VARS.txt @@ -0,0 +1,1386 @@ +model + _feature_extractor + _network + downsample_input + residual_block + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + moving_mean + gamma + beta + moving_variance + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + hourglass_network + 0 + encoder_block2 + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + 0 + skip + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv_block + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + inner_block + 0 + inner_block + 0 + inner_block + 0 + encoder_block2 + 0 + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + skip + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + 1 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + inner_block + 0 + encoder_block2 + 0 + skip + norm + beta + gamma + moving_variance + moving_mean + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + moving_mean + gamma + beta + moving_variance + inner_block + 3 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 2 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + 1 + norm + moving_mean + beta + gamma + moving_variance + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + decoder_block + 1 + norm + gamma + beta + moving_mean + moving_variance + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + encoder_block1 + 0 + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + norm + beta + gamma + moving_mean + moving_variance + 1 + conv_block + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + decoder_block + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 0 + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + norm + moving_mean + beta + gamma + moving_variance + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + encoder_block2 + 1 + norm + gamma + beta + moving_mean + moving_variance + conv_block + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + 0 + norm + moving_variance + beta + gamma + moving_mean + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 0 + norm + moving_variance + beta + gamma + moving_mean + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + conv + kernel + 1 + norm + gamma + beta + moving_mean + moving_variance + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + decoder_block + 0 + conv_block + norm + gamma + moving_variance + moving_mean + beta + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + 1 + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 0 + norm + gamma + beta + moving_mean + moving_variance + conv_block + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + 1 + norm + moving_variance + beta + gamma + moving_mean + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + decoder_block + 0 + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block2 + 0 + skip + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + norm + beta + gamma + moving_mean + moving_variance + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + encoder_block1 + 0 + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + 1 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + decoder_block + 0 + norm + moving_mean + moving_variance + beta + gamma + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + 1 + inner_block + 0 + inner_block + 0 + inner_block + 0 + encoder_block1 + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + 0 + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + inner_block + 0 + inner_block + 2 + norm + gamma + moving_mean + moving_variance + beta + conv_block + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + 0 + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + norm + beta + gamma + moving_variance + moving_mean + conv_block + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + conv + kernel + 3 + norm + beta + moving_variance + gamma + moving_mean + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + encoder_block1 + 0 + conv_block + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + encoder_block2 + 1 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + 0 + norm + beta + moving_mean + gamma + moving_variance + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + skip + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + decoder_block + 1 + norm + moving_mean + moving_variance + beta + gamma + conv_block + norm + beta + moving_mean + moving_variance + gamma + conv + kernel + conv + kernel + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + norm + beta + gamma + moving_variance + moving_mean + conv_block + conv + kernel + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + decoder_block + 1 + norm + moving_variance + beta + gamma + moving_mean + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + 0 + conv_block + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + norm + gamma + moving_variance + beta + moving_mean + conv + kernel + encoder_block2 + 0 + skip + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + 1 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + decoder_block + 1 + conv_block + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 0 + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + encoder_block2 + 0 + conv_block + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + norm + moving_variance + gamma + beta + moving_mean + skip + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + conv + kernel + 1 + conv + kernel + conv_block + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + norm + gamma + moving_mean + beta + moving_variance + encoder_block1 + 0 + conv_block + norm + moving_variance + moving_mean + beta + gamma + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + 1 + conv + kernel + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + encoder_block1 + 0 + norm + beta + moving_mean + gamma + moving_variance + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + 1 + conv_block + norm + moving_mean + moving_variance + gamma + beta + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + encoder_block2 + 0 + conv + kernel + conv_block + norm + moving_mean + gamma + beta + moving_variance + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + skip + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + 1 + norm + beta + gamma + moving_mean + moving_variance + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + conv + kernel + decoder_block + 0 + norm + gamma + beta + moving_variance + moving_mean + conv_block + conv + kernel + norm + gamma + moving_mean + beta + moving_variance + conv + kernel + 1 + skip + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + conv_block + conv + kernel + norm + beta + gamma + moving_mean + moving_variance + decoder_block + 1 + norm + moving_mean + moving_variance + beta + gamma + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + conv + kernel + 0 + conv_block + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + norm + moving_variance + beta + gamma + moving_mean + conv + kernel + encoder_block2 + 1 + conv_block + norm + beta + moving_variance + moving_mean + gamma + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + conv + kernel + 0 + conv_block + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + norm + moving_variance + moving_mean + beta + gamma + skip + norm + moving_mean + moving_variance + beta + gamma + conv + kernel + conv + kernel + encoder_block1 + 1 + conv_block + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + norm + beta + moving_variance + gamma + moving_mean + conv + kernel + 0 + conv + kernel + conv_block + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + norm + moving_mean + beta + gamma + moving_variance + output_conv + 0 + norm + moving_variance + gamma + beta + moving_mean + conv + kernel + 1 + norm + gamma + beta + moving_mean + moving_variance + conv + kernel + intermediate_residual + 0 + conv_block + norm + gamma + moving_variance + moving_mean + beta + conv + kernel + norm + beta + moving_mean + gamma + moving_variance + conv + kernel + intermediate_conv1 + 0 + norm + moving_mean + moving_variance + gamma + beta + conv + kernel + intermediate_conv2 + 0 + norm + beta + gamma + moving_mean + moving_variance + conv + kernel + _prediction_head_dict + box.Soffset + 0 + layer_with_weights-0 + bias + kernel + layer_with_weights-1 + bias + kernel + 1 + layer_with_weights-0 + bias + kernel + layer_with_weights-1 + kernel + bias + box.Sscale + 1 + layer_with_weights-0 + kernel + bias + layer_with_weights-1 + bias + kernel + 0 + layer_with_weights-0 + kernel + bias + layer_with_weights-1 + bias + kernel + object_center + 1 + layer_with_weights-1 + bias + kernel + layer_with_weights-0 + bias + kernel + 0 + layer_with_weights-0 + kernel + bias + layer_with_weights-1 + bias + kernel +save_counter diff --git a/centernet/utils/weight_utils/__init__.py b/centernet/utils/weight_utils/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/centernet/utils/weight_utils/config_classes.py b/centernet/utils/weight_utils/config_classes.py new file mode 100644 index 000000000..e5a8e9342 --- /dev/null +++ b/centernet/utils/weight_utils/config_classes.py @@ -0,0 +1,225 @@ +""" +This file contains the layers (Config objects) that are used for parsing the +ODAPI checkpoint weights for CenterNet. + +Currently, the parser is incomplete and has only been tested on +CenterNet Hourglass-104 512x512. +""" + +from abc import ABC, abstractmethod +from dataclasses import dataclass, field +from typing import ClassVar, Dict, List, Tuple + +import numpy as np +import tensorflow as tf + + +class Config(ABC): + def get_weights(self): + """ + This function generates the weights needed to be loaded into the layer. + """ + return None + + def load_weights(self, layer: tf.keras.layers.Layer) -> int: + """ + Given a layer, this function retrives the weights for that layer in an + appropriate format, and loads them into the layer. Additionally, + the number of weights loaded are returned. If the weights are in an + incorrect format, a ValueError will be raised by set_weights(). + """ + weights = self.get_weights() + layer.set_weights(weights) + n_weights = 0 + + for w in weights: + n_weights += w.size + return n_weights + +@dataclass +class convBnCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + weights: np.array = field(repr=False, default=None) + beta: np.array = field(repr=False, default=None) + gamma: np.array = field(repr=False, default=None) + moving_mean: np.array = field(repr=False, default=None) + moving_variance: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_weights_dict = self.weights_dict['conv'] + norm_weights_dict = self.weights_dict['norm'] + + self.weights = conv_weights_dict['kernel'] + self.beta = norm_weights_dict['beta'] + self.gamma = norm_weights_dict['gamma'] + self.moving_mean = norm_weights_dict['moving_mean'] + self.moving_variance = norm_weights_dict['moving_variance'] + + def get_weights(self): + return [ + self.weights, + self.gamma, + self.beta, + self.moving_mean, + self.moving_variance + ] + +@dataclass +class residualBlockCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + + skip_weights: np.array = field(repr=False, default=None) + skip_beta: np.array = field(repr=False, default=None) + skip_gamma: np.array = field(repr=False, default=None) + skip_moving_mean: np.array = field(repr=False, default=None) + skip_moving_variance: np.array = field(repr=False, default=None) + + conv_weights: np.array = field(repr=False, default=None) + norm_beta: np.array = field(repr=False, default=None) + norm_gamma: np.array = field(repr=False, default=None) + norm_moving_mean: np.array = field(repr=False, default=None) + norm_moving_variance: np.array = field(repr=False, default=None) + + conv_block_weights: np.array = field(repr=False, default=None) + conv_block_beta: np.array = field(repr=False, default=None) + conv_block_gamma: np.array = field(repr=False, default=None) + conv_block_moving_mean: np.array = field(repr=False, default=None) + conv_block_moving_variance: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_weights_dict = self.weights_dict['conv'] + norm_weights_dict = self.weights_dict['norm'] + conv_block_weights_dict = self.weights_dict['conv_block'] + + if 'skip' in self.weights_dict: + skip_weights_dict = self.weights_dict['skip'] + self.skip_weights = skip_weights_dict['conv']['kernel'] + self.skip_beta = skip_weights_dict['norm']['beta'] + self.skip_gamma = skip_weights_dict['norm']['gamma'] + self.skip_moving_mean = skip_weights_dict['norm']['moving_mean'] + self.skip_moving_variance = skip_weights_dict['norm']['moving_variance'] + + self.conv_weights = conv_weights_dict['kernel'] + self.norm_beta = norm_weights_dict['beta'] + self.norm_gamma = norm_weights_dict['gamma'] + self.norm_moving_mean = norm_weights_dict['moving_mean'] + self.norm_moving_variance = norm_weights_dict['moving_variance'] + + self.conv_block_weights = conv_block_weights_dict['conv']['kernel'] + self.conv_block_beta = conv_block_weights_dict['norm']['beta'] + self.conv_block_gamma = conv_block_weights_dict['norm']['gamma'] + self.conv_block_moving_mean = conv_block_weights_dict['norm']['moving_mean'] + self.conv_block_moving_variance = conv_block_weights_dict['norm']['moving_variance'] + + def get_weights(self): + weights = [ + self.skip_weights, + self.skip_gamma, + self.skip_beta, + + self.conv_block_weights, + self.conv_block_gamma, + self.conv_block_beta, + + self.conv_weights, + self.norm_gamma, + self.norm_beta, + + self.skip_moving_mean, + self.skip_moving_variance, + self.conv_block_moving_mean, + self.conv_block_moving_variance, + self.norm_moving_mean, + self.norm_moving_variance, + ] + + weights = [x for x in weights if x is not None] + return weights + +@dataclass +class hourglassCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + is_last_stage: bool = field(repr=False, default=None) + + def __post_init__(self): + self.is_last_stage = False if 'inner_block' in self.weights_dict else True + + def generate_block_weights(self, weights_dict): + reps = len(weights_dict.keys()) + weights = [] + n_weights = 0 + + for i in range(reps): + res_config = residualBlockCFG(weights_dict=weights_dict[str(i)]) + res_weights = res_config.get_weights() + weights += res_weights + + for w in res_weights: + n_weights += w.size + + return weights, n_weights + + def load_block_weights(self, layer, weight_dict): + block_weights, n_weights = self.generate_block_weights(weight_dict) + layer.set_weights(block_weights) + return n_weights + + def load_weights(self, layer): + n_weights = 0 + + if not self.is_last_stage: + enc_dec_layers = [ + layer.submodules[0], + layer.submodules[1], + layer.submodules[3] + ] + enc_dec_weight_dicts = [ + self.weights_dict['encoder_block1'], + self.weights_dict['encoder_block2'], + self.weights_dict['decoder_block'] + ] + + for l, weights_dict in zip(enc_dec_layers, enc_dec_weight_dicts): + n_weights += self.load_block_weights(l, weights_dict) + + if len(self.weights_dict['inner_block']) == 1: # still in an outer hourglass + inner_weights_dict = self.weights_dict['inner_block']['0'] + else: + inner_weights_dict = self.weights_dict['inner_block'] # inner residual block chain + + inner_hg_layer = layer.submodules[2] + inner_hg_cfg = type(self)(weights_dict=inner_weights_dict) + n_weights += inner_hg_cfg.load_weights(inner_hg_layer) + + else: + inner_layer = layer.submodules[0] + n_weights += self.load_block_weights(inner_layer, self.weights_dict) + + return n_weights + +@dataclass +class decoderConvCFG(Config): + weights_dict: Dict = field(repr=False, default=None) + + conv_1_weights: np.array = field(repr=False, default=None) + conv_2_bias: np.array = field(repr=False, default=None) + + conv_2_weights: np.array = field(repr=False, default=None) + conv_1_bias: np.array = field(repr=False, default=None) + + def __post_init__(self): + conv_1_weights_dict = self.weights_dict['layer_with_weights-0'] + conv_2_weights_dict = self.weights_dict['layer_with_weights-1'] + + self.conv_1_weights = conv_1_weights_dict['kernel'] + self.conv_1_bias = conv_1_weights_dict['bias'] + self.conv_2_weights = conv_2_weights_dict['kernel'] + self.conv_2_bias = conv_2_weights_dict['bias'] + + def get_weights(self): + return [ + self.conv_1_weights, + self.conv_1_bias, + self.conv_2_weights, + self.conv_2_bias + ] diff --git a/centernet/utils/weight_utils/config_data.py b/centernet/utils/weight_utils/config_data.py new file mode 100644 index 000000000..bf12de17c --- /dev/null +++ b/centernet/utils/weight_utils/config_data.py @@ -0,0 +1,62 @@ +from dataclasses import dataclass, field +from typing import Dict + +from centernet.utils.weight_utils.config_classes import (convBnCFG, + decoderConvCFG, + hourglassCFG, + residualBlockCFG) + + +@dataclass +class BackboneConfigData(): + weights_dict: Dict = field(repr=False, default=None) + + def get_cfg_list(self, name): + if name == 'hourglass104_512': + return [ + # Downsampling Layers + convBnCFG(weights_dict=self.weights_dict['downsample_input']['conv_block']), + residualBlockCFG(weights_dict=self.weights_dict['downsample_input']['residual_block']), + # Hourglass + hourglassCFG(weights_dict=self.weights_dict['hourglass_network']['0']), + convBnCFG(weights_dict=self.weights_dict['output_conv']['0']), + # Intermediate + convBnCFG(weights_dict=self.weights_dict['intermediate_conv1']['0']), + convBnCFG(weights_dict=self.weights_dict['intermediate_conv2']['0']), + residualBlockCFG(weights_dict=self.weights_dict['intermediate_residual']['0']), + # Hourglass + hourglassCFG(weights_dict=self.weights_dict['hourglass_network']['1']), + convBnCFG(weights_dict=self.weights_dict['output_conv']['1']), + ] + + elif name == 'extremenet': + return [ + # Downsampling Layers + convBnCFG(weights_dict=self.weights_dict['downsample_input']['conv_block']), + residualBlockCFG(weights_dict=self.weights_dict['downsample_input']['residual_block']), + # Hourglass + hourglassCFG(weights_dict=self.weights_dict['hourglass_network']['0']), + convBnCFG(weights_dict=self.weights_dict['output_conv']['0']), + # Intermediate + convBnCFG(weights_dict=self.weights_dict['intermediate_conv1']['0']), + convBnCFG(weights_dict=self.weights_dict['intermediate_conv2']['0']), + residualBlockCFG(weights_dict=self.weights_dict['intermediate_residual']['0']), + # Hourglass + hourglassCFG(weights_dict=self.weights_dict['hourglass_network']['1']), + convBnCFG(weights_dict=self.weights_dict['output_conv']['1']), + ] + +@dataclass +class DecoderConfigData(): + weights_dict: Dict = field(repr=False, default=None) + + def get_cfg_list(self, name): + if name == 'detection_2d': + return [ + decoderConvCFG(weights_dict=self.weights_dict['object_center']['0']), + decoderConvCFG(weights_dict=self.weights_dict['object_center']['1']), + decoderConvCFG(weights_dict=self.weights_dict['box.Soffset']['0']), + decoderConvCFG(weights_dict=self.weights_dict['box.Soffset']['1']), + decoderConvCFG(weights_dict=self.weights_dict['box.Sscale']['0']), + decoderConvCFG(weights_dict=self.weights_dict['box.Sscale']['1']) + ] diff --git a/centernet/utils/weight_utils/load_weights.py b/centernet/utils/weight_utils/load_weights.py new file mode 100644 index 000000000..64bcb26e9 --- /dev/null +++ b/centernet/utils/weight_utils/load_weights.py @@ -0,0 +1,158 @@ +""" +This file contains functions used to load the ODAPI CenterNet checkpoint +weights into CenterNet model. +""" + +import numpy as np +import tensorflow as tf + +from centernet.configs.centernet import CenterNetTask +from centernet.modeling.CenterNet import build_centernet +from centernet.modeling.layers.nn_blocks import (CenterNetConvBN, + CenterNetDecoderConv, + CenterNetResidualBlock, + HourglassBlock) +from centernet.utils.weight_utils.config_classes import (convBnCFG, + decoderConvCFG, + hourglassCFG, + residualBlockCFG) +from centernet.utils.weight_utils.config_data import (BackboneConfigData, + DecoderConfigData) +from centernet.utils.weight_utils.tf_to_dict import ( + get_model_weights_as_dict, write_dict_as_tree) + +CKPT_PATH = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\checkpoint' +SAVED_MODEL_PATH = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\saved_model' + +def load_weights_model(model, weights_dict, backbone_name, decoder_name): + """ Loads weights into the model. + + Args: + model: keras.Model to load weights into + weights_dict: Dictionary that stores the weights of the model + backbone_name: String, indicating the desired backbone configuration + decoder_name: String, indicating the desired decoder configuration + """ + print("Loading model weights\n") + n_weights = 0 + n_weights += load_weights_backbone(model.backbone, + weights_dict['model']['_feature_extractor']['_network'], + backbone_name) + + n_weights += load_weights_decoder(model.decoder, + weights_dict['model']['_prediction_head_dict'], + decoder_name) + print("Successfully loaded {} model weights.\n".format(n_weights)) + +def get_backbone_layer_cfgs(weights_dict, backbone_name): + """ Fetches the config classes for the backbone. + + This function generates a list of config classes corresponding to + each building block in the backbone. + + Args: + weights_dict: Dictionary that stores the backbone model weights + backbone_name: String, indicating the desired backbone configuration + Returns: + A list containing the config classe of the backbone building block + """ + + print("Fetching backbone config classes for {}\n".format(backbone_name)) + cfgs = BackboneConfigData(weights_dict=weights_dict).get_cfg_list(backbone_name) + return cfgs + +def load_weights_backbone(backbone, weights_dict, backbone_name): + """ Loads the weights defined in the weights_dict into the backbone. + + This function loads the backbone weights by first fetching the necesary + config classes for the backbone, then loads them in one by one for + each layer that has weights associated with it. + + Args: + backbone: keras.Model backbone + weights_dict: Dictionary that stores the backbone model weights + backbone_name: String, indicating the desired backbone configuration + Returns: + Number of weights loaded in + """ + print("Loading backbone weights\n") + backbone_layers = backbone.layers + cfgs = get_backbone_layer_cfgs(weights_dict, backbone_name) + n_weights_total = 0 + + cfg = cfgs.pop(0) + for i in range(len(backbone_layers)): + layer = backbone_layers[i] + if isinstance(layer, (CenterNetConvBN, HourglassBlock, CenterNetResidualBlock)): + n_weights = cfg.load_weights(layer) + print("Loading weights for: {}, weights loaded: {}".format(cfg, n_weights)) + n_weights_total += n_weights + if len(cfgs) == 0: + print("{} Weights have been loaded for {} / {} layers\n".format(n_weights_total, i+1, len(backbone_layers))) + return n_weights_total + cfg = cfgs.pop(0) + +def get_decoder_layer_cfgs(weights_dict, decoder_name): + """ Fetches the config classes for the decoder. + + This function generates a list of config classes corresponding to + each building block in the decoder. + + Args: + weights_dict: Dictionary that stores the decoder model weights + decoder_name: String, indicating the desired decoder configuration + Returns: + A list containing the config classes of the backbone building block + """ + print("Fetching decoder config classes for {}\n".format(decoder_name)) + + cfgs = DecoderConfigData(weights_dict=weights_dict).get_cfg_list(decoder_name) + return cfgs + +def load_weights_decoder(decoder, weights_dict, decoder_name): + """ Loads the weights defined in the weights_dict into the decoder. + + This function loads the decoder weights by first fetching the necesary + config classes for the decoder, then loads them in one by one for + each layer that has weights associated with it. + + Args: + decoder: keras.Model decoder + weights_dict: Dictionary that stores the decoder model weights + decoder_name: String, indicating the desired decoder configuration + Returns: + Number of weights loaded in + """ + print("Loading decoder weights\n") + decoder_layers = decoder.layers + cfgs = get_decoder_layer_cfgs(weights_dict, decoder_name) + n_weights_total = 0 + + cfg = cfgs.pop(0) + for i in range(len(decoder_layers)): + layer = decoder_layers[i] + if isinstance(layer, CenterNetDecoderConv): + n_weights = cfg.load_weights(layer) + print("Loading weights for: {}, weights loaded: {}".format(cfg, n_weights)) + n_weights_total += n_weights + if len(cfgs) == 0: + print("{} Weights have been loaded for {} / {} layers\n".format(n_weights_total, i+1, len(decoder_layers))) + return n_weights_total + cfg = cfgs.pop(0) + +if __name__ == '__main__': + input_specs = tf.keras.layers.InputSpec(shape=[1, 512, 512, 3]) + config = CenterNetTask() + + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + + weights_dict, n_weights = get_model_weights_as_dict(CKPT_PATH) + load_weights_model(model, weights_dict, 'hourglass104_512', 'detection_2d') + + # Note number of weights read and loaded differ by two because + # we also read in the checkpoint save_counter and object_graph + # that are not weights to the model + + # Uncomment line below to write weights dict key names to a file + # write_dict_as_tree(weights_dict, filename="centernet/utils/weight_utils/MODEL_VARS.txt") diff --git a/centernet/utils/weight_utils/test_load_weights.py b/centernet/utils/weight_utils/test_load_weights.py new file mode 100644 index 000000000..e875b91f9 --- /dev/null +++ b/centernet/utils/weight_utils/test_load_weights.py @@ -0,0 +1,42 @@ +import tensorflow as tf + +from centernet.configs.centernet import CenterNetTask +from centernet.modeling.CenterNet import build_centernet +from centernet.utils.weight_utils.load_weights import ( + get_model_weights_as_dict, load_weights_backbone, load_weights_model) +from yolo.demos.video_detect_cpu import runner +from yolo.demos.video_detect_gpu import FastVideo + +CENTERNET_CKPT_PATH = 'D:\\weights\centernet_hg104_512x512_coco17_tpu-8\checkpoint' +EXTREMENET_CKPT_PATH = 'D:\\weights\extremenet' + +if __name__ == '__main__': + input_specs = tf.keras.layers.InputSpec(shape=[1, 512, 512, 3]) + config = CenterNetTask() + + model, loss = build_centernet(input_specs=input_specs, + task_config=config, l2_regularization=0) + + + # # Test for loading extremenet backbone weights + # extreme_net_weights_dict, _ = get_model_weights_as_dict(EXTREMENET_CKPT_PATH) + # load_weights_backbone(model.backbone, extreme_net_weights_dict['feature_extractor'], backbone_name='extremenet') + + # Test for loading ODAPI weights and running inference using webcam + weights_dict, _ = get_model_weights_as_dict(CENTERNET_CKPT_PATH) + load_weights_model(model, weights_dict, 'hourglass104_512', 'detection_2d') + + cap = FastVideo( + 0, + model=model, + process_width=512, + process_height=512, + preprocess_with_gpu=False, + classes=91, + print_conf=True, + max_batch=1, + disp_h=512, + scale_que=1, + wait_time='dynamic') + cap.run() + runner(model, 0, 512, 512) diff --git a/centernet/utils/weight_utils/tf_to_dict.py b/centernet/utils/weight_utils/tf_to_dict.py new file mode 100644 index 000000000..2ab60016d --- /dev/null +++ b/centernet/utils/weight_utils/tf_to_dict.py @@ -0,0 +1,97 @@ +""" +This file contains functions used to convert a TF checkpoint into a dictionary, +which streamlines the way of loading weights from one model to another. +""" + +import tensorflow as tf + + +def update_weights_dict(weights_dict, variable_key, value): + """ Inserts weight value into a weight dictionary. + + This function inserts a weight value into a weights_dict based on the + variable key. It is designed to organize TF checkpoint weights by organizing + them by submodules. + + Args: + weights_dict: Dictionary to store weights + variable_key: String, name of the variable assocaited with the value + value: An ndarray that stores the weights assocaited to the variable key + """ + current_dict = weights_dict + variable_key_list = variable_key.split('/') + + key = variable_key_list.pop(0) + while len(variable_key_list): + if variable_key_list[0] == '.ATTRIBUTES': + current_dict[key] = value + return + + if key not in current_dict.keys(): + current_dict[key] = {} + current_dict = current_dict[key] + key = variable_key_list.pop(0) + +def get_model_weights_as_dict(ckpt_path): + """ Converts a TF checkpoint into a nested dictionary of weights. + + Args: + ckpt_path: String, indicating filepath of the TF checkpoint + Returns: + Dictionary where the checkpoint weights are stored + Number of weights read + """ + print("\nConverting model checkpoint from {} to weights dictionary\n".format(ckpt_path)) + reader = tf.train.load_checkpoint(ckpt_path) + shape_from_key = reader.get_variable_to_shape_map() + dtype_from_key = reader.get_variable_to_dtype_map() + + variable_keys = shape_from_key.keys() + weights_dict = {} + n_read = 0 + + for key in variable_keys: + shape = shape_from_key[key] + dtype = dtype_from_key[key] + value = reader.get_tensor(key) + n_read += tf.size(value) + update_weights_dict(weights_dict, key, value) + + print("Successfully read {} checkpoint weights\n".format(n_read)) + return weights_dict, n_read + + +def write_dict_as_tree(dictionary, filename, spaces=0): + """ Writes nested dictionary keys to a file. + + Given a dictionary that contains nested dictionaries, this function + writes the name of the keys recursively to a specified file as a tree + + Args: + dictionary: Desired dictionary to write to a file + filename: String, name of file to write dictionary to + spaces: Optional; Number of spaces to insert before writing + the dictionary key names + """ + if type(dictionary) is dict: + mode = "w" if spaces == 0 else "a" + for key in dictionary.keys(): + with open(filename, mode) as fp: + fp.write(" " * spaces + key + '\n') + mode = "a" + write_dict_as_tree(dictionary[key], filename, spaces + 2) + +def print_layer_weights_and_shape(layer): + """ Prints variables information corresponding to a Keras layer. + + This function prints the name and the shape of its associated weights + of all variables (trainable and untrainable) in a Keras layer. + + Args: + layer: A Keras.layer.Layer object + """ + weights = layer.get_weights() + variables = layer.variables + + for i in range(len(weights)): + tf.print(np.shape(weights[i]), variables[i].name) diff --git a/fixefficientnet/train.py b/fixefficientnet/train.py index b00fc5986..111646212 100755 --- a/fixefficientnet/train.py +++ b/fixefficientnet/train.py @@ -14,25 +14,24 @@ # limitations under the License. # ============================================================================== """TensorFlow Model Garden Vision training driver.""" +import gin +from absl import app, flags + +# pylint: enable=unused-import +from official.common import distribute_utils +from official.common import flags as tfm_flags +from official.core import task_factory, train_lib, train_utils +from official.modeling import performance +# pylint: disable=unused-import +from yolo.common import registry_imports from yolo.utils.run_utils import prep_gpu + try: prep_gpu() except BaseException: print('GPUs ready') -from absl import app -from absl import flags -import gin -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports -# pylint: enable=unused-import -from official.common import distribute_utils -from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.modeling import performance FLAGS = flags.FLAGS """ diff --git a/hooks/install.sh b/hooks/install.sh new file mode 100644 index 000000000..f5c907b93 --- /dev/null +++ b/hooks/install.sh @@ -0,0 +1,13 @@ +#!bin/bash +# +# Script that installs the requirements for custom +# git precommit hook and creates symbolic link between +# hook in the repository and local git hook + +printf ">>> Installing required python packages...\n" +python -m pip install -r requirements.txt + +printf "\n>>> Creating symbolic link between pre-commit file and local git pre-commit hook..." +ln -s -f ../../hooks/pre-commit .git/hooks/pre-commit + +printf "\n\nInstallation complete." \ No newline at end of file diff --git a/hooks/pre-commit b/hooks/pre-commit new file mode 100644 index 000000000..cffbfcb96 --- /dev/null +++ b/hooks/pre-commit @@ -0,0 +1,23 @@ + +#!/bin/bash +# +# Git hook that runs whenever a user types "git commit"; +# It runs pylint on any files that were changed, saves the linter +# output into a .txt file, prints the contents of the file out, +# and adds the file to the commit. + +echo ">>> Running isort on your project repo..." +isort --recursive . + +echo +echo ">>> Running mypy on your project repo..." +mypy . + +echo +echo ">>> Running pylint on your changed python files -- please wait..." +bash pylint.sh > linter_log.txt +cat linter_log.txt + +git add . + +exit 0 \ No newline at end of file diff --git a/hooks/readme.md b/hooks/readme.md new file mode 100644 index 000000000..437b5c63f --- /dev/null +++ b/hooks/readme.md @@ -0,0 +1,55 @@ +# About +This folder contains a pre-commit hook that runs the following +modules in bash when a user types "git commit": +- isort +- mypy +- pylint.sh + +# Dependencies +You will need to have the following installed on your machine: +- isort +- mypy +- pylint + +They will be installed through the ```install.sh``` script, or you can +install them manually. + +# Setup +## Required Files +You will need to have the following in the root directory of your project: +- ```hooks``` directory, which contains the ```pre-commit``` hook script +- ```pylint.sh``` script +- ```pylintrc``` config file + +The files are located [here](https://github.com/PurdueCAM2Project/TensorFlowModels/tree/yolo_debug_linter) +in the root folder of the ```yolo_linter_debug``` branch: + +![necessary_files](./screenshots/necessary_files.png) + +## install.sh +You can easily set everything up by navigating into the ```hooks``` folder and running the +install script with the following command in your terminal: ```bash install.sh```. + +__NOTE__: make sure your ```install.sh``` file is set up as an executable; if it isn't, run +the command ```chmod +x install.sh```. + +## Manual Installation +If you want to set things up manually, what you can do is the following: +- copy and paste the ```pre-commit``` script into your local ```.git/hooks``` directory like so: +![mv_command](./screenshots/mv_command.png) +, OR +- create a symbolic link from the ```hooks``` directory to the ```.git/hooks``` directory +using the following command (run the command in project root directory): +```ln -s -f ../../hooks/pre-commit .git/hooks/pre-commit``` + +And that's it! Now when you run ```git commit``` command on your local machine, +you will see the following output: + +![git_commit](./screenshots/git_commit.png) + +# Important Notes +- You need to make sure the ```pre-commit``` and the ```pylint.sh``` files are +executables; if they're not, use the command ```sudo chmod +x {FILENAME}``` to +make them executables +- If you run into permission issues with "git add . " command when running the pre-commit hook, +use the following command to fix the issue: ```sudo chown -R "${USER:-$(id -un)}" . ``` \ No newline at end of file diff --git a/hooks/requirements.txt b/hooks/requirements.txt new file mode 100644 index 000000000..df907d2c9 --- /dev/null +++ b/hooks/requirements.txt @@ -0,0 +1,3 @@ +isort==4.3.21 +mypy==0.812 +pylint==2.4.2 \ No newline at end of file diff --git a/hooks/screenshots/git_commit.png b/hooks/screenshots/git_commit.png new file mode 100644 index 000000000..3e11ee648 Binary files /dev/null and b/hooks/screenshots/git_commit.png differ diff --git a/hooks/screenshots/mv_command.png b/hooks/screenshots/mv_command.png new file mode 100644 index 000000000..89bf88bad Binary files /dev/null and b/hooks/screenshots/mv_command.png differ diff --git a/hooks/screenshots/necessary_files.png b/hooks/screenshots/necessary_files.png new file mode 100644 index 000000000..cf0455f35 Binary files /dev/null and b/hooks/screenshots/necessary_files.png differ diff --git a/hooks/screenshots/readme.txt b/hooks/screenshots/readme.txt new file mode 100644 index 000000000..a87f9057a --- /dev/null +++ b/hooks/screenshots/readme.txt @@ -0,0 +1 @@ +Screenshots pertaining to the readme.md file in hooks folder. \ No newline at end of file diff --git a/linter/yapf_contrib/fixers/fixers_api.py b/linter/yapf_contrib/fixers/fixers_api.py index f1425a9af..96dda284f 100755 --- a/linter/yapf_contrib/fixers/fixers_api.py +++ b/linter/yapf_contrib/fixers/fixers_api.py @@ -13,12 +13,11 @@ # limitations under the License. """Entry point for refactoring via the lib2to3 fixer.""" +import logging from lib2to3 import refactor as lib2to3_refactor from lib2to3.pgen2 import parse as pgen2_parse from lib2to3.pgen2 import tokenize as pgen2_tokenize -import logging - # Our path in the source tree. MODULE_NAME_PREFIX = 'yapf_contrib.fixers.fix_' diff --git a/linter/yapf_contrib/fixers/line_conditional_fix.py b/linter/yapf_contrib/fixers/line_conditional_fix.py index f414a2232..63d02eed8 100755 --- a/linter/yapf_contrib/fixers/line_conditional_fix.py +++ b/linter/yapf_contrib/fixers/line_conditional_fix.py @@ -15,9 +15,7 @@ import collections import re - -from lib2to3 import fixer_base -from lib2to3 import pytree +from lib2to3 import fixer_base, pytree class LineConditionalFix(fixer_base.BaseFix): diff --git a/linter_log.txt b/linter_log.txt new file mode 100644 index 000000000..e69de29bb diff --git a/official/common/__init__.py b/official/common/__init__.py index a25710c22..e04127d3f 100755 --- a/official/common/__init__.py +++ b/official/common/__init__.py @@ -11,5 +11,3 @@ # 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. - - diff --git a/official/common/dataset_fn.py b/official/common/dataset_fn.py index 4ac16a31b..5807a7350 100755 --- a/official/common/dataset_fn.py +++ b/official/common/dataset_fn.py @@ -28,7 +28,7 @@ # ============================================================================== """Utility library for picking an appropriate dataset function.""" -from typing import Any, Callable, Union, Type +from typing import Any, Callable, Type, Union import tensorflow as tf diff --git a/official/common/distribute_utils.py b/official/common/distribute_utils.py index 4dec9346c..62740f69b 100755 --- a/official/common/distribute_utils.py +++ b/official/common/distribute_utils.py @@ -16,6 +16,7 @@ import json import os + import tensorflow as tf diff --git a/official/core/__init__.py b/official/core/__init__.py index e419af524..e04127d3f 100755 --- a/official/core/__init__.py +++ b/official/core/__init__.py @@ -11,4 +11,3 @@ # 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. - diff --git a/official/core/base_task.py b/official/core/base_task.py index cefa5e916..835aac35c 100755 --- a/official/core/base_task.py +++ b/official/core/base_task.py @@ -16,12 +16,11 @@ import abc from typing import Optional -from absl import logging import tensorflow as tf +from absl import logging from official.core import config_definitions -from official.modeling import optimization -from official.modeling import performance +from official.modeling import optimization, performance OptimizationConfig = optimization.OptimizationConfig RuntimeConfig = config_definitions.RuntimeConfig diff --git a/official/core/base_trainer.py b/official/core/base_trainer.py index 19a39410e..a626a8e37 100755 --- a/official/core/base_trainer.py +++ b/official/core/base_trainer.py @@ -19,16 +19,14 @@ interchangable and independent on model architectures and tasks. """ -from absl import logging import gin -import orbit import tensorflow as tf +from absl import logging -from official.core import base_task -from official.core import config_definitions +import orbit +from official.core import base_task, config_definitions from official.modeling import optimization - ExperimentConfig = config_definitions.ExperimentConfig TrainerConfig = config_definitions.TrainerConfig @@ -310,7 +308,6 @@ def eval_begin(self): def eval_step(self, iterator): """See base class.""" - def step_fn(inputs): logs = self.task.validation_step( inputs, model=self.model, metrics=self.validation_metrics) diff --git a/official/core/base_trainer_test.py b/official/core/base_trainer_test.py index 5fe7deba8..b79154acf 100755 --- a/official/core/base_trainer_test.py +++ b/official/core/base_trainer_test.py @@ -15,12 +15,12 @@ """Tests for tensorflow_models.core.trainers.trainer.""" # pylint: disable=g-direct-tensorflow-import import os -from absl.testing import parameterized + import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.core import base_trainer as trainer_lib from official.core import config_definitions as cfg from official.core import train_lib diff --git a/official/core/config_definitions.py b/official/core/config_definitions.py index 0e6072431..21369d517 100755 --- a/official/core/config_definitions.py +++ b/official/core/config_definitions.py @@ -14,9 +14,8 @@ """Common configuration settings.""" -from typing import Optional, Sequence, Union - import dataclasses +from typing import Optional, Sequence, Union from official.modeling.hyperparams import base_config from official.modeling.optimization.configs import optimization_config diff --git a/official/core/exp_factory.py b/official/core/exp_factory.py index 7536c0f8f..6cd3dbd37 100755 --- a/official/core/exp_factory.py +++ b/official/core/exp_factory.py @@ -17,7 +17,6 @@ from official.core import config_definitions as cfg from official.core import registry - _REGISTERED_CONFIGS = {} diff --git a/official/core/input_reader.py b/official/core/input_reader.py index 6343b34bb..fb8cb4269 100755 --- a/official/core/input_reader.py +++ b/official/core/input_reader.py @@ -16,9 +16,9 @@ import random from typing import Any, Callable, List, Optional -from absl import logging import tensorflow as tf import tensorflow_datasets as tfds +from absl import logging from official.core import config_definitions as cfg diff --git a/official/core/registry_test.py b/official/core/registry_test.py index eb43dfba9..9e75f99cf 100755 --- a/official/core/registry_test.py +++ b/official/core/registry_test.py @@ -14,11 +14,10 @@ """Tests for registry.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf + from official.core import registry diff --git a/official/core/train_lib.py b/official/core/train_lib.py index 1c73858ad..f6db7875f 100755 --- a/official/core/train_lib.py +++ b/official/core/train_lib.py @@ -17,14 +17,12 @@ import os from typing import Any, Mapping, Tuple +import tensorflow as tf # Import libraries from absl import logging -import orbit -import tensorflow as tf -from official.core import base_task -from official.core import config_definitions -from official.core import train_utils +import orbit +from official.core import base_task, config_definitions, train_utils BestCheckpointExporter = train_utils.BestCheckpointExporter maybe_create_best_ckpt_exporter = train_utils.maybe_create_best_ckpt_exporter @@ -57,7 +55,7 @@ def run_experiment(distribution_strategy: tf.distribute.Strategy, eval_logs: returns eval metrics logs when run_post_eval is set to True, otherwise, returns {}. """ - + with distribution_strategy.scope(): trainer = train_utils.create_trainer( params, diff --git a/official/core/train_lib_test.py b/official/core/train_lib_test.py index 368023876..d4db1bf13 100755 --- a/official/core/train_lib_test.py +++ b/official/core/train_lib_test.py @@ -16,20 +16,16 @@ import json import os -from absl import flags -from absl.testing import flagsaver -from absl.testing import parameterized import tensorflow as tf +from absl import flags +from absl.testing import flagsaver, parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations -from official.common import flags as tfm_flags # pylint: disable=unused-import +from official.common import flags as tfm_flags from official.common import registry_imports # pylint: enable=unused-import -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.core import task_factory, train_lib, train_utils FLAGS = flags.FLAGS diff --git a/official/core/train_utils.py b/official/core/train_utils.py index 8bc38fd13..ffd5da4b3 100755 --- a/official/core/train_utils.py +++ b/official/core/train_utils.py @@ -14,21 +14,19 @@ """Training utils.""" import copy +import dataclasses import json import os import pprint from typing import Any, Callable, Dict, List, Optional -from absl import logging -import dataclasses import gin -import orbit import tensorflow as tf +from absl import logging -from official.core import base_task -from official.core import base_trainer -from official.core import config_definitions -from official.core import exp_factory +import orbit +from official.core import (base_task, base_trainer, config_definitions, + exp_factory) from official.modeling import hyperparams diff --git a/official/modeling/__init__.py b/official/modeling/__init__.py index e419af524..e04127d3f 100755 --- a/official/modeling/__init__.py +++ b/official/modeling/__init__.py @@ -11,4 +11,3 @@ # 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. - diff --git a/official/modeling/activations/__init__.py b/official/modeling/activations/__init__.py index 086e1fb97..96ec9cf63 100755 --- a/official/modeling/activations/__init__.py +++ b/official/modeling/activations/__init__.py @@ -16,6 +16,5 @@ from official.modeling.activations.gelu import gelu from official.modeling.activations.relu import relu6 from official.modeling.activations.sigmoid import hard_sigmoid -from official.modeling.activations.swish import hard_swish -from official.modeling.activations.swish import identity -from official.modeling.activations.swish import simple_swish +from official.modeling.activations.swish import (hard_swish, identity, + simple_swish) diff --git a/official/modeling/activations/gelu_test.py b/official/modeling/activations/gelu_test.py index cfe1950d9..2b3b70e25 100755 --- a/official/modeling/activations/gelu_test.py +++ b/official/modeling/activations/gelu_test.py @@ -15,8 +15,9 @@ """Tests for the Gaussian error linear unit.""" import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.modeling import activations diff --git a/official/modeling/activations/relu_test.py b/official/modeling/activations/relu_test.py index 215f189ea..91dbe28ba 100755 --- a/official/modeling/activations/relu_test.py +++ b/official/modeling/activations/relu_test.py @@ -15,9 +15,9 @@ """Tests for the customized Relu activation.""" import tensorflow as tf - from tensorflow.python.keras import \ - keras_parameterized # pylint: disable=g-direct-tensorflow-import + keras_parameterized # pylint: disable=g-direct-tensorflow-import + from official.modeling import activations diff --git a/official/modeling/activations/sigmoid_test.py b/official/modeling/activations/sigmoid_test.py index 6aad90ef3..6cdbcd93d 100755 --- a/official/modeling/activations/sigmoid_test.py +++ b/official/modeling/activations/sigmoid_test.py @@ -16,9 +16,9 @@ import numpy as np import tensorflow as tf - from tensorflow.python.keras import \ - keras_parameterized # pylint: disable=g-direct-tensorflow-import + keras_parameterized # pylint: disable=g-direct-tensorflow-import + from official.modeling import activations diff --git a/official/modeling/activations/swish_test.py b/official/modeling/activations/swish_test.py index 3cb9495d8..72c98ea7a 100755 --- a/official/modeling/activations/swish_test.py +++ b/official/modeling/activations/swish_test.py @@ -15,8 +15,9 @@ """Tests for the customized Swish activation.""" import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.modeling import activations diff --git a/official/modeling/hyperparams/__init__.py b/official/modeling/hyperparams/__init__.py index bcbc0aedd..1cad5540c 100755 --- a/official/modeling/hyperparams/__init__.py +++ b/official/modeling/hyperparams/__init__.py @@ -13,8 +13,6 @@ # limitations under the License. """Hyperparams package definition.""" -# pylint: disable=g-multiple-import from official.modeling.hyperparams.base_config import * from official.modeling.hyperparams.oneof import * from official.modeling.hyperparams.params_dict import * - diff --git a/official/modeling/hyperparams/base_config.py b/official/modeling/hyperparams/base_config.py index 871f76df9..d0f2a6f56 100755 --- a/official/modeling/hyperparams/base_config.py +++ b/official/modeling/hyperparams/base_config.py @@ -15,13 +15,13 @@ """Base configurations to standardize experiments.""" import copy +import dataclasses import functools from typing import Any, List, Mapping, Optional, Type -from absl import logging -import dataclasses import tensorflow as tf import yaml +from absl import logging from official.modeling.hyperparams import params_dict diff --git a/official/modeling/hyperparams/base_config_test.py b/official/modeling/hyperparams/base_config_test.py index 3e64ec532..b27be5c4f 100755 --- a/official/modeling/hyperparams/base_config_test.py +++ b/official/modeling/hyperparams/base_config_test.py @@ -12,12 +12,13 @@ # See the License for the specific language governing permissions and # limitations under the License. +import dataclasses import pprint from typing import List, Tuple -from absl.testing import parameterized -import dataclasses import tensorflow as tf +from absl.testing import parameterized + from official.modeling.hyperparams import base_config diff --git a/official/modeling/hyperparams/oneof.py b/official/modeling/hyperparams/oneof.py index 61591496e..311d8c059 100755 --- a/official/modeling/hyperparams/oneof.py +++ b/official/modeling/hyperparams/oneof.py @@ -14,9 +14,9 @@ """Config class that supports oneof functionality.""" +import dataclasses from typing import Optional -import dataclasses from official.modeling.hyperparams import base_config diff --git a/official/modeling/hyperparams/oneof_test.py b/official/modeling/hyperparams/oneof_test.py index 2cde73c15..b0f82ef56 100755 --- a/official/modeling/hyperparams/oneof_test.py +++ b/official/modeling/hyperparams/oneof_test.py @@ -13,9 +13,10 @@ # limitations under the License. import dataclasses + import tensorflow as tf -from official.modeling.hyperparams import base_config -from official.modeling.hyperparams import oneof + +from official.modeling.hyperparams import base_config, oneof @dataclasses.dataclass diff --git a/official/modeling/multitask/__init__.py b/official/modeling/multitask/__init__.py index e419af524..e04127d3f 100755 --- a/official/modeling/multitask/__init__.py +++ b/official/modeling/multitask/__init__.py @@ -11,4 +11,3 @@ # 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. - diff --git a/official/modeling/multitask/base_model.py b/official/modeling/multitask/base_model.py index 976b0d8e3..c30d7187c 100755 --- a/official/modeling/multitask/base_model.py +++ b/official/modeling/multitask/base_model.py @@ -28,7 +28,7 @@ # limitations under the License. # ============================================================================== """Abstraction of multi-task model.""" -from typing import Text, Dict +from typing import Dict, Text import tensorflow as tf diff --git a/official/modeling/multitask/configs.py b/official/modeling/multitask/configs.py index faaf41ae4..5e776e268 100755 --- a/official/modeling/multitask/configs.py +++ b/official/modeling/multitask/configs.py @@ -13,9 +13,8 @@ # limitations under the License. """Configuration definitions for multi-task training.""" -from typing import Optional, Tuple - import dataclasses +from typing import Optional, Tuple from official.core import config_definitions as cfg from official.modeling import hyperparams diff --git a/official/modeling/multitask/evaluator.py b/official/modeling/multitask/evaluator.py index 806f5a6d3..054f10d65 100755 --- a/official/modeling/multitask/evaluator.py +++ b/official/modeling/multitask/evaluator.py @@ -17,13 +17,13 @@ The evaluator implements the Orbit `AbstractEvaluator` interface. """ from typing import Optional, Union + import gin -import orbit import tensorflow as tf +import orbit from official.core import train_utils -from official.modeling.multitask import base_model -from official.modeling.multitask import multitask +from official.modeling.multitask import base_model, multitask @gin.configurable diff --git a/official/modeling/multitask/evaluator_test.py b/official/modeling/multitask/evaluator_test.py index fa141292d..f9fbf9793 100755 --- a/official/modeling/multitask/evaluator_test.py +++ b/official/modeling/multitask/evaluator_test.py @@ -13,16 +13,14 @@ # limitations under the License. """Tests for multitask.evaluator.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.core import base_task from official.core import config_definitions as cfg -from official.modeling.multitask import evaluator -from official.modeling.multitask import multitask +from official.modeling.multitask import evaluator, multitask def all_strategy_combinations(): diff --git a/official/modeling/multitask/multitask.py b/official/modeling/multitask/multitask.py index 701d7141d..9b10b011e 100755 --- a/official/modeling/multitask/multitask.py +++ b/official/modeling/multitask/multitask.py @@ -17,9 +17,8 @@ from typing import Dict, List, Optional, Text, Union import tensorflow as tf -from official.core import base_task -from official.core import config_definitions -from official.core import task_factory + +from official.core import base_task, config_definitions, task_factory from official.modeling import optimization from official.modeling.multitask import configs diff --git a/official/modeling/multitask/train_lib.py b/official/modeling/multitask/train_lib.py index abfb9a6b1..4759930a9 100755 --- a/official/modeling/multitask/train_lib.py +++ b/official/modeling/multitask/train_lib.py @@ -15,9 +15,11 @@ """Multitask training driver library.""" # pytype: disable=attribute-error import os + +import tensorflow as tf from absl import logging + import orbit -import tensorflow as tf from official.core import base_task from official.core import base_trainer as core_lib from official.core import train_utils diff --git a/official/modeling/optimization/SGDAccumulated.py b/official/modeling/optimization/SGDAccumulated.py index 34b33e6c2..9ea6e9cc6 100755 --- a/official/modeling/optimization/SGDAccumulated.py +++ b/official/modeling/optimization/SGDAccumulated.py @@ -1,7 +1,9 @@ import tensorflow as tf +from tensorflow.python import ops from tensorflow.python.keras.optimizer_v2.optimizer_v2 import OptimizerV2 -from tensorflow.python.ops import math_ops, state_ops, control_flow_ops, array_ops -from tensorflow.python import ops +from tensorflow.python.ops import (array_ops, control_flow_ops, math_ops, + state_ops) + # from tensorflow.python.keras.utils import control_flow_util # from tensorflow.python.keras import backend_config @@ -216,4 +218,4 @@ def get_config(self): # train_data = task.build_inputs(task.task_config.train_data) # validation_data = task.build_inputs(task.task_config.train_data) -# model.compile(optimizer = optimizer) \ No newline at end of file +# model.compile(optimizer = optimizer) diff --git a/official/modeling/optimization/SGDAccumulated__.py b/official/modeling/optimization/SGDAccumulated__.py index 4ceaad57f..04b07a530 100755 --- a/official/modeling/optimization/SGDAccumulated__.py +++ b/official/modeling/optimization/SGDAccumulated__.py @@ -1,7 +1,9 @@ import tensorflow as tf -from tensorflow.python.ops import math_ops, state_ops, control_flow_ops, array_ops -from tensorflow.python import ops +from tensorflow.python import ops from tensorflow.python.keras.utils import control_flow_util +from tensorflow.python.ops import (array_ops, control_flow_ops, math_ops, + state_ops) + # from tensorflow.python.keras import backend_config @@ -181,4 +183,4 @@ def from_config(cls, config, custom_objects=None): # train_data = task.build_inputs(task.task_config.train_data) # validation_data = task.build_inputs(task.task_config.train_data) -# model.compile(optimizer = optimizer) \ No newline at end of file +# model.compile(optimizer = optimizer) diff --git a/official/modeling/optimization/__init__.py b/official/modeling/optimization/__init__.py index 9829683a2..6bd63845a 100755 --- a/official/modeling/optimization/__init__.py +++ b/official/modeling/optimization/__init__.py @@ -14,9 +14,9 @@ """Optimization package definition.""" -# pylint: disable=wildcard-import from official.modeling.optimization.configs.learning_rate_config import * from official.modeling.optimization.configs.optimization_config import * from official.modeling.optimization.configs.optimizer_config import * -from official.modeling.optimization.ema_optimizer import ExponentialMovingAverage +from official.modeling.optimization.ema_optimizer import \ + ExponentialMovingAverage from official.modeling.optimization.optimizer_factory import OptimizerFactory diff --git a/official/modeling/optimization/configs/__init__.py b/official/modeling/optimization/configs/__init__.py index e419af524..e04127d3f 100755 --- a/official/modeling/optimization/configs/__init__.py +++ b/official/modeling/optimization/configs/__init__.py @@ -11,4 +11,3 @@ # 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. - diff --git a/official/modeling/optimization/configs/learning_rate_config.py b/official/modeling/optimization/configs/learning_rate_config.py index 520a0b961..6903ad077 100755 --- a/official/modeling/optimization/configs/learning_rate_config.py +++ b/official/modeling/optimization/configs/learning_rate_config.py @@ -13,9 +13,9 @@ # limitations under the License. """Dataclasses for learning rate schedule config.""" +import dataclasses from typing import List, Optional -import dataclasses from official.modeling.hyperparams import base_config diff --git a/official/modeling/optimization/configs/optimization_config.py b/official/modeling/optimization/configs/optimization_config.py index 09db8a158..4ef9f4167 100755 --- a/official/modeling/optimization/configs/optimization_config.py +++ b/official/modeling/optimization/configs/optimization_config.py @@ -18,13 +18,12 @@ It also has two helper functions get_optimizer_config, and get_lr_config from an OptimizationConfig class. """ -from typing import Optional - import dataclasses +from typing import Optional -from official.modeling.hyperparams import base_config -from official.modeling.hyperparams import oneof -from official.modeling.optimization.configs import learning_rate_config as lr_cfg +from official.modeling.hyperparams import base_config, oneof +from official.modeling.optimization.configs import \ + learning_rate_config as lr_cfg from official.modeling.optimization.configs import optimizer_config as opt_cfg diff --git a/official/modeling/optimization/configs/optimization_config_test.py b/official/modeling/optimization/configs/optimization_config_test.py index 02b99f592..c95525cb8 100755 --- a/official/modeling/optimization/configs/optimization_config_test.py +++ b/official/modeling/optimization/configs/optimization_config_test.py @@ -16,7 +16,8 @@ import tensorflow as tf -from official.modeling.optimization.configs import learning_rate_config as lr_cfg +from official.modeling.optimization.configs import \ + learning_rate_config as lr_cfg from official.modeling.optimization.configs import optimization_config from official.modeling.optimization.configs import optimizer_config as opt_cfg diff --git a/official/modeling/optimization/configs/optimizer_config.py b/official/modeling/optimization/configs/optimizer_config.py index 16e216208..d263fa5f1 100755 --- a/official/modeling/optimization/configs/optimizer_config.py +++ b/official/modeling/optimization/configs/optimizer_config.py @@ -13,9 +13,9 @@ # limitations under the License. """Dataclasses for optimizer configs.""" +import dataclasses from typing import List, Optional -import dataclasses from official.modeling.hyperparams import base_config diff --git a/official/modeling/optimization/ema_optimizer.py b/official/modeling/optimization/ema_optimizer.py index a20bd7c80..ee5e57542 100755 --- a/official/modeling/optimization/ema_optimizer.py +++ b/official/modeling/optimization/ema_optimizer.py @@ -14,7 +14,7 @@ """Exponential moving average optimizer.""" -from typing import Text, List +from typing import List, Text import tensorflow as tf diff --git a/official/modeling/optimization/lr_schedule.py b/official/modeling/optimization/lr_schedule.py index b5c1ef349..dcc2a8b70 100755 --- a/official/modeling/optimization/lr_schedule.py +++ b/official/modeling/optimization/lr_schedule.py @@ -14,7 +14,7 @@ """Learning rate schedule classes.""" -from typing import Mapping, Any, Union, Optional +from typing import Any, Mapping, Optional, Union import tensorflow as tf diff --git a/official/modeling/optimization/optimizer_factory.py b/official/modeling/optimization/optimizer_factory.py index 27d74d71e..5fe9bb314 100755 --- a/official/modeling/optimization/optimizer_factory.py +++ b/official/modeling/optimization/optimizer_factory.py @@ -15,14 +15,14 @@ """Optimizer factory class.""" from typing import Callable, Union - import gin import tensorflow as tf import tensorflow_addons.optimizers as tfa_optimizers -from official.modeling.optimization import ema_optimizer, SGDAccumulated -from official.modeling.optimization import lr_schedule -from official.modeling.optimization.configs import optimization_config as opt_cfg +from official.modeling.optimization import (SGDAccumulated, ema_optimizer, + lr_schedule) +from official.modeling.optimization.configs import \ + optimization_config as opt_cfg from official.nlp import optimization as nlp_optimization OPTIMIZERS_CLS = { diff --git a/official/modeling/optimization/optimizer_factory_test.py b/official/modeling/optimization/optimizer_factory_test.py index 5e670c296..0899c9e56 100755 --- a/official/modeling/optimization/optimizer_factory_test.py +++ b/official/modeling/optimization/optimizer_factory_test.py @@ -13,9 +13,9 @@ # limitations under the License. """Tests for optimizer_factory.py.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.modeling.optimization import optimizer_factory from official.modeling.optimization.configs import optimization_config diff --git a/official/modeling/progressive/policies.py b/official/modeling/progressive/policies.py index cf9598d97..4b7eba5c4 100755 --- a/official/modeling/progressive/policies.py +++ b/official/modeling/progressive/policies.py @@ -19,11 +19,13 @@ """ import abc -from typing import Any, Mapping -from absl import logging import dataclasses +from typing import Any, Mapping + import six import tensorflow as tf +from absl import logging + from official.modeling.hyperparams import base_config from official.modeling.progressive import utils diff --git a/official/modeling/progressive/train.py b/official/modeling/progressive/train.py index dc1fb5d9e..ef43137c6 100755 --- a/official/modeling/progressive/train.py +++ b/official/modeling/progressive/train.py @@ -14,17 +14,15 @@ """TFM binary for the progressive trainer.""" -from absl import app -from absl import flags import gin +from absl import app, flags -from official.common import distribute_utils -# pylint: disable=unused-import -from official.common import registry_imports # pylint: enable=unused-import +# pylint: disable=unused-import +from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_utils +from official.common import registry_imports +from official.core import task_factory, train_utils from official.modeling import performance from official.modeling.progressive import train_lib diff --git a/official/modeling/progressive/train_lib.py b/official/modeling/progressive/train_lib.py index a096aebf1..2dd5e904c 100755 --- a/official/modeling/progressive/train_lib.py +++ b/official/modeling/progressive/train_lib.py @@ -22,12 +22,12 @@ import os from typing import Any, Mapping, Tuple +import tensorflow as tf # Import libraries from absl import logging + import orbit -import tensorflow as tf -from official.core import base_task -from official.core import config_definitions +from official.core import base_task, config_definitions from official.core import train_lib as base_train_lib from official.modeling.progressive import trainer as prog_trainer_lib diff --git a/official/modeling/progressive/train_lib_test.py b/official/modeling/progressive/train_lib_test.py index 178fc6df7..6ccd15d53 100755 --- a/official/modeling/progressive/train_lib_test.py +++ b/official/modeling/progressive/train_lib_test.py @@ -13,26 +13,24 @@ # limitations under the License. """Tests for the progressive train_lib.""" +import dataclasses import os +import tensorflow as tf from absl import flags from absl.testing import parameterized -import dataclasses -import orbit -import tensorflow as tf +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations -from official.common import flags as tfm_flags +import orbit # pylint: disable=unused-import +from official.common import flags as tfm_flags from official.common import registry_imports # pylint: enable=unused-import from official.core import config_definitions as cfg from official.core import task_factory from official.modeling import optimization from official.modeling.hyperparams import params_dict -from official.modeling.progressive import policies -from official.modeling.progressive import train_lib +from official.modeling.progressive import policies, train_lib from official.modeling.progressive import trainer as prog_trainer_lib from official.utils.testing import mock_task diff --git a/official/modeling/progressive/trainer.py b/official/modeling/progressive/trainer.py index 6c970ecbc..46f19a9a1 100755 --- a/official/modeling/progressive/trainer.py +++ b/official/modeling/progressive/trainer.py @@ -18,21 +18,20 @@ `StandardEvaluable` interfaces. Trainers inside this project should be interchangable and independent on model architectures and tasks. """ +import dataclasses import os from typing import Any, Optional +import gin +import tensorflow as tf # Import libraries from absl import logging -import dataclasses -import gin import orbit -import tensorflow as tf from official.core import base_task from official.core import base_trainer as trainer_lib from official.core import config_definitions -from official.modeling.progressive import policies -from official.modeling.progressive import utils +from official.modeling.progressive import policies, utils ExperimentConfig = config_definitions.ExperimentConfig diff --git a/official/modeling/progressive/trainer_test.py b/official/modeling/progressive/trainer_test.py index 7d4ab3e22..ede4b696a 100755 --- a/official/modeling/progressive/trainer_test.py +++ b/official/modeling/progressive/trainer_test.py @@ -16,12 +16,11 @@ # pylint: disable=g-direct-tensorflow-import import os -from absl.testing import parameterized -import orbit import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations +import orbit from official.core import config_definitions as cfg from official.modeling import optimization from official.modeling.progressive import policies diff --git a/official/modeling/progressive/utils.py b/official/modeling/progressive/utils.py index 192170cb8..105634cf0 100755 --- a/official/modeling/progressive/utils.py +++ b/official/modeling/progressive/utils.py @@ -14,9 +14,8 @@ """Util classes and functions.""" -from absl import logging import tensorflow as tf - +from absl import logging # pylint: disable=g-direct-tensorflow-import from tensorflow.python.training.tracking import tracking diff --git a/official/modeling/tf_utils.py b/official/modeling/tf_utils.py index ca9e2362f..254a69257 100755 --- a/official/modeling/tf_utils.py +++ b/official/modeling/tf_utils.py @@ -16,8 +16,8 @@ import six import tensorflow as tf - from tensorflow.python.util import deprecation + from official.modeling import activations diff --git a/official/nlp/albert/export_albert_tfhub.py b/official/nlp/albert/export_albert_tfhub.py index 8b48476f3..b7b8247e8 100755 --- a/official/nlp/albert/export_albert_tfhub.py +++ b/official/nlp/albert/export_albert_tfhub.py @@ -14,12 +14,12 @@ # ============================================================================== """A script to export the ALBERT core model as a TF-Hub SavedModel.""" -# Import libraries -from absl import app -from absl import flags -import tensorflow as tf from typing import Text +import tensorflow as tf +# Import libraries +from absl import app, flags + from official.nlp.albert import configs from official.nlp.bert import bert_models diff --git a/official/nlp/albert/export_albert_tfhub_test.py b/official/nlp/albert/export_albert_tfhub_test.py index 8e87f325a..a55845c56 100755 --- a/official/nlp/albert/export_albert_tfhub_test.py +++ b/official/nlp/albert/export_albert_tfhub_test.py @@ -16,12 +16,10 @@ import os import numpy as np - import tensorflow as tf import tensorflow_hub as hub -from official.nlp.albert import configs -from official.nlp.albert import export_albert_tfhub +from official.nlp.albert import configs, export_albert_tfhub class ExportAlbertTfhubTest(tf.test.TestCase): diff --git a/official/nlp/albert/run_classifier.py b/official/nlp/albert/run_classifier.py index 5a0b5a109..7d4376335 100755 --- a/official/nlp/albert/run_classifier.py +++ b/official/nlp/albert/run_classifier.py @@ -16,17 +16,16 @@ import json import os -# Import libraries -from absl import app -from absl import flags -from absl import logging + import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.nlp.albert import configs as albert_configs from official.nlp.bert import bert_models from official.nlp.bert import run_classifier as run_classifier_bert - FLAGS = flags.FLAGS diff --git a/official/nlp/albert/run_squad.py b/official/nlp/albert/run_squad.py index 154e19e38..0257db473 100755 --- a/official/nlp/albert/run_squad.py +++ b/official/nlp/albert/run_squad.py @@ -18,15 +18,13 @@ import os import time -# Import libraries -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.nlp.albert import configs as albert_configs -from official.nlp.bert import run_squad_helper -from official.nlp.bert import tokenization +from official.nlp.bert import run_squad_helper, tokenization from official.nlp.data import squad_lib_sp flags.DEFINE_string( diff --git a/official/nlp/albert/tf2_albert_encoder_checkpoint_converter.py b/official/nlp/albert/tf2_albert_encoder_checkpoint_converter.py index 64c2dc222..3a0ea5b66 100755 --- a/official/nlp/albert/tf2_albert_encoder_checkpoint_converter.py +++ b/official/nlp/albert/tf2_albert_encoder_checkpoint_converter.py @@ -19,15 +19,13 @@ """ import os -from absl import app -from absl import flags - import tensorflow as tf +from absl import app, flags + from official.modeling import tf_utils from official.nlp.albert import configs from official.nlp.bert import tf1_checkpoint_converter_lib -from official.nlp.modeling import models -from official.nlp.modeling import networks +from official.nlp.modeling import models, networks FLAGS = flags.FLAGS diff --git a/official/nlp/bert/__init__.py b/official/nlp/bert/__init__.py index 8b1378917..e69de29bb 100755 --- a/official/nlp/bert/__init__.py +++ b/official/nlp/bert/__init__.py @@ -1 +0,0 @@ - diff --git a/official/nlp/bert/bert_models.py b/official/nlp/bert/bert_models.py index c4f73ffbd..1dbaee579 100755 --- a/official/nlp/bert/bert_models.py +++ b/official/nlp/bert/bert_models.py @@ -21,8 +21,7 @@ from official.modeling import tf_utils from official.nlp.albert import configs as albert_configs from official.nlp.bert import configs -from official.nlp.modeling import models -from official.nlp.modeling import networks +from official.nlp.modeling import models, networks class BertPretrainLossAndMetricLayer(tf.keras.layers.Layer): diff --git a/official/nlp/bert/common_flags.py b/official/nlp/bert/common_flags.py index 22292673d..82aa264e5 100755 --- a/official/nlp/bert/common_flags.py +++ b/official/nlp/bert/common_flags.py @@ -14,8 +14,8 @@ # ============================================================================== """Defining common flags used across all BERT models/applications.""" -from absl import flags import tensorflow as tf +from absl import flags from official.utils import hyperparams_flags from official.utils.flags import core as flags_core diff --git a/official/nlp/bert/export_tfhub.py b/official/nlp/bert/export_tfhub.py index bf40bd066..14de4921c 100755 --- a/official/nlp/bert/export_tfhub.py +++ b/official/nlp/bert/export_tfhub.py @@ -14,14 +14,13 @@ # ============================================================================== """A script to export the BERT core model as a TF-Hub SavedModel.""" -# Import libraries -from absl import app -from absl import flags -from absl import logging -import tensorflow as tf from typing import Text -from official.nlp.bert import bert_models -from official.nlp.bert import configs + +import tensorflow as tf +# Import libraries +from absl import app, flags, logging + +from official.nlp.bert import bert_models, configs FLAGS = flags.FLAGS diff --git a/official/nlp/bert/export_tfhub_test.py b/official/nlp/bert/export_tfhub_test.py index 98462ce92..ea7d68fa5 100755 --- a/official/nlp/bert/export_tfhub_test.py +++ b/official/nlp/bert/export_tfhub_test.py @@ -16,13 +16,12 @@ import os -from absl.testing import parameterized import numpy as np import tensorflow as tf import tensorflow_hub as hub +from absl.testing import parameterized -from official.nlp.bert import configs -from official.nlp.bert import export_tfhub +from official.nlp.bert import configs, export_tfhub class ExportTfhubTest(tf.test.TestCase, parameterized.TestCase): diff --git a/official/nlp/bert/model_saving_utils.py b/official/nlp/bert/model_saving_utils.py index 059fa8080..2464f4991 100755 --- a/official/nlp/bert/model_saving_utils.py +++ b/official/nlp/bert/model_saving_utils.py @@ -15,10 +15,10 @@ """Utilities to save models.""" import os +import typing -from absl import logging import tensorflow as tf -import typing +from absl import logging def export_bert_model(model_export_path: typing.Text, diff --git a/official/nlp/bert/model_training_utils.py b/official/nlp/bert/model_training_utils.py index 7d03e0ffc..fd21795b7 100755 --- a/official/nlp/bert/model_training_utils.py +++ b/official/nlp/bert/model_training_utils.py @@ -18,9 +18,10 @@ import os import tempfile -from absl import logging import tensorflow as tf +from absl import logging from tensorflow.python.util import deprecation + from official.common import distribute_utils from official.staging.training import grad_utils diff --git a/official/nlp/bert/model_training_utils_test.py b/official/nlp/bert/model_training_utils_test.py index 32b88a36c..131f415ca 100755 --- a/official/nlp/bert/model_training_utils_test.py +++ b/official/nlp/bert/model_training_utils_test.py @@ -16,18 +16,14 @@ import os -from absl import logging -from absl.testing import flagsaver -from absl.testing import parameterized -from absl.testing.absltest import mock import numpy as np import tensorflow as tf +from absl import logging +from absl.testing import flagsaver, parameterized +from absl.testing.absltest import mock +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations -from official.nlp.bert import common_flags -from official.nlp.bert import model_training_utils - +from official.nlp.bert import common_flags, model_training_utils common_flags.define_common_bert_flags() diff --git a/official/nlp/bert/run_classifier.py b/official/nlp/bert/run_classifier.py index 1a5a9462e..bf9ab78d5 100755 --- a/official/nlp/bert/run_classifier.py +++ b/official/nlp/bert/run_classifier.py @@ -19,20 +19,17 @@ import math import os -# Import libraries -from absl import app -from absl import flags -from absl import logging import gin import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.modeling import performance from official.nlp import optimization -from official.nlp.bert import bert_models -from official.nlp.bert import common_flags +from official.nlp.bert import bert_models, common_flags from official.nlp.bert import configs as bert_configs -from official.nlp.bert import input_pipeline -from official.nlp.bert import model_saving_utils +from official.nlp.bert import input_pipeline, model_saving_utils from official.utils.misc import keras_utils flags.DEFINE_enum( diff --git a/official/nlp/bert/run_pretraining.py b/official/nlp/bert/run_pretraining.py index 76d669f19..f00bd070c 100755 --- a/official/nlp/bert/run_pretraining.py +++ b/official/nlp/bert/run_pretraining.py @@ -14,21 +14,16 @@ # ============================================================================== """Run masked LM/next sentence pre-training for BERT in TF 2.x.""" -# Import libraries -from absl import app -from absl import flags -from absl import logging import gin import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.modeling import performance from official.nlp import optimization -from official.nlp.bert import bert_models -from official.nlp.bert import common_flags -from official.nlp.bert import configs -from official.nlp.bert import input_pipeline -from official.nlp.bert import model_training_utils - +from official.nlp.bert import (bert_models, common_flags, configs, + input_pipeline, model_training_utils) flags.DEFINE_string('input_files', None, 'File path to retrieve training data for pre-training.') diff --git a/official/nlp/bert/run_squad.py b/official/nlp/bert/run_squad.py index ca1e766f2..7e12d5b2b 100755 --- a/official/nlp/bert/run_squad.py +++ b/official/nlp/bert/run_squad.py @@ -18,20 +18,17 @@ import os import time -# Import libraries -from absl import app -from absl import flags -from absl import logging import gin import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.nlp.bert import configs as bert_configs -from official.nlp.bert import run_squad_helper -from official.nlp.bert import tokenization +from official.nlp.bert import run_squad_helper, tokenization from official.nlp.data import squad_lib as squad_lib_wp from official.utils.misc import keras_utils - flags.DEFINE_string('vocab_file', None, 'The vocabulary file that the BERT model was trained on.') diff --git a/official/nlp/bert/run_squad_helper.py b/official/nlp/bert/run_squad_helper.py index 3c3630cb0..a1301a4ec 100755 --- a/official/nlp/bert/run_squad_helper.py +++ b/official/nlp/bert/run_squad_helper.py @@ -18,18 +18,14 @@ import json import os -from absl import flags -from absl import logging import tensorflow as tf +from absl import flags, logging + from official.modeling import performance from official.nlp import optimization -from official.nlp.bert import bert_models -from official.nlp.bert import common_flags -from official.nlp.bert import input_pipeline -from official.nlp.bert import model_saving_utils -from official.nlp.bert import model_training_utils -from official.nlp.bert import squad_evaluate_v1_1 -from official.nlp.bert import squad_evaluate_v2_0 +from official.nlp.bert import (bert_models, common_flags, input_pipeline, + model_saving_utils, model_training_utils, + squad_evaluate_v1_1, squad_evaluate_v2_0) from official.nlp.data import squad_lib_sp from official.utils.misc import keras_utils diff --git a/official/nlp/bert/serving.py b/official/nlp/bert/serving.py index 4085fb822..7d84e19b1 100755 --- a/official/nlp/bert/serving.py +++ b/official/nlp/bert/serving.py @@ -15,12 +15,10 @@ # ============================================================================== """Examples of SavedModel export for tf-serving.""" -from absl import app -from absl import flags import tensorflow as tf +from absl import app, flags -from official.nlp.bert import bert_models -from official.nlp.bert import configs +from official.nlp.bert import bert_models, configs flags.DEFINE_integer( "sequence_length", None, "Sequence length to parse the tf.Example. If " diff --git a/official/nlp/bert/squad_evaluate_v1_1.py b/official/nlp/bert/squad_evaluate_v1_1.py index 1cc4430bc..eb3f8cc04 100755 --- a/official/nlp/bert/squad_evaluate_v1_1.py +++ b/official/nlp/bert/squad_evaluate_v1_1.py @@ -26,9 +26,10 @@ import re import string +from absl import logging + # pylint: disable=g-bad-import-order -from absl import logging # pylint: enable=g-bad-import-order diff --git a/official/nlp/bert/tf2_encoder_checkpoint_converter.py b/official/nlp/bert/tf2_encoder_checkpoint_converter.py index e81c0d6a5..87d136fd4 100755 --- a/official/nlp/bert/tf2_encoder_checkpoint_converter.py +++ b/official/nlp/bert/tf2_encoder_checkpoint_converter.py @@ -21,15 +21,12 @@ import os -from absl import app -from absl import flags - import tensorflow as tf +from absl import app, flags + from official.modeling import tf_utils -from official.nlp.bert import configs -from official.nlp.bert import tf1_checkpoint_converter_lib -from official.nlp.modeling import models -from official.nlp.modeling import networks +from official.nlp.bert import configs, tf1_checkpoint_converter_lib +from official.nlp.modeling import models, networks FLAGS = flags.FLAGS diff --git a/official/nlp/bert/tokenization.py b/official/nlp/bert/tokenization.py index 684be103f..16e09962b 100755 --- a/official/nlp/bert/tokenization.py +++ b/official/nlp/bert/tokenization.py @@ -23,11 +23,10 @@ import re import unicodedata +import sentencepiece as spm import six import tensorflow as tf -import sentencepiece as spm - SPIECE_UNDERLINE = "▁" diff --git a/official/nlp/configs/bert.py b/official/nlp/configs/bert.py index e0a64b78b..bafd847b8 100755 --- a/official/nlp/configs/bert.py +++ b/official/nlp/configs/bert.py @@ -17,9 +17,8 @@ Includes configurations and instantiation methods. """ -from typing import List, Optional, Text - import dataclasses +from typing import List, Optional, Text from official.modeling.hyperparams import base_config from official.nlp.configs import encoders diff --git a/official/nlp/configs/electra.py b/official/nlp/configs/electra.py index 527cde521..eb0308c75 100755 --- a/official/nlp/configs/electra.py +++ b/official/nlp/configs/electra.py @@ -14,13 +14,11 @@ # limitations under the License. # ============================================================================== """ELECTRA model configurations and instantiation methods.""" -from typing import List - import dataclasses +from typing import List from official.modeling.hyperparams import base_config -from official.nlp.configs import bert -from official.nlp.configs import encoders +from official.nlp.configs import bert, encoders @dataclasses.dataclass diff --git a/official/nlp/configs/encoders.py b/official/nlp/configs/encoders.py index 9d2807bd6..481de3996 100755 --- a/official/nlp/configs/encoders.py +++ b/official/nlp/configs/encoders.py @@ -17,15 +17,14 @@ Includes configurations and factory methods. """ +import dataclasses from typing import Optional -from absl import logging -import dataclasses import gin import tensorflow as tf +from absl import logging -from official.modeling import hyperparams -from official.modeling import tf_utils +from official.modeling import hyperparams, tf_utils from official.nlp.modeling import networks from official.nlp.projects.bigbird import encoder as bigbird_encoder diff --git a/official/nlp/configs/experiment_configs.py b/official/nlp/configs/experiment_configs.py index 4f274ce41..a4dd100af 100755 --- a/official/nlp/configs/experiment_configs.py +++ b/official/nlp/configs/experiment_configs.py @@ -15,5 +15,5 @@ # ============================================================================== """Experiments definition.""" # pylint: disable=unused-import -from official.nlp.configs import finetuning_experiments -from official.nlp.configs import pretraining_experiments +from official.nlp.configs import (finetuning_experiments, + pretraining_experiments) diff --git a/official/nlp/configs/finetuning_experiments.py b/official/nlp/configs/finetuning_experiments.py index 9a8d25992..2366af89e 100755 --- a/official/nlp/configs/finetuning_experiments.py +++ b/official/nlp/configs/finetuning_experiments.py @@ -17,10 +17,9 @@ from official.core import config_definitions as cfg from official.core import exp_factory from official.modeling import optimization -from official.nlp.data import question_answering_dataloader -from official.nlp.data import sentence_prediction_dataloader -from official.nlp.tasks import question_answering -from official.nlp.tasks import sentence_prediction +from official.nlp.data import (question_answering_dataloader, + sentence_prediction_dataloader) +from official.nlp.tasks import question_answering, sentence_prediction @exp_factory.register_config_factory('bert/sentence_prediction') diff --git a/official/nlp/continuous_finetune_lib.py b/official/nlp/continuous_finetune_lib.py index 0554d3115..c387b2fb9 100755 --- a/official/nlp/continuous_finetune_lib.py +++ b/official/nlp/continuous_finetune_lib.py @@ -18,17 +18,14 @@ import time from typing import Any, Mapping, Optional -from absl import logging import tensorflow as tf +from absl import logging from official.common import distribute_utils -from official.core import config_definitions -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.core import (config_definitions, task_factory, train_lib, + train_utils) from official.modeling import performance -from official.modeling.multitask import configs -from official.modeling.multitask import multitask +from official.modeling.multitask import configs, multitask from official.modeling.multitask import train_lib as multitask_train_lib diff --git a/official/nlp/continuous_finetune_lib_test.py b/official/nlp/continuous_finetune_lib_test.py index a478b2ce9..17845879a 100755 --- a/official/nlp/continuous_finetune_lib_test.py +++ b/official/nlp/continuous_finetune_lib_test.py @@ -14,18 +14,15 @@ # ============================================================================== import os -from absl import flags -from absl.testing import flagsaver -from absl.testing import parameterized import tensorflow as tf +from absl import flags +from absl.testing import flagsaver, parameterized -# pylint: disable=unused-import -from official.common import registry_imports # pylint: enable=unused-import +# pylint: disable=unused-import from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.common import registry_imports +from official.core import task_factory, train_lib, train_utils from official.nlp import continuous_finetune_lib FLAGS = flags.FLAGS diff --git a/official/nlp/data/classifier_data_lib.py b/official/nlp/data/classifier_data_lib.py index 80d4fda09..322172548 100755 --- a/official/nlp/data/classifier_data_lib.py +++ b/official/nlp/data/classifier_data_lib.py @@ -20,9 +20,9 @@ import json import os -from absl import logging import tensorflow as tf import tensorflow_datasets as tfds +from absl import logging from official.nlp.bert import tokenization diff --git a/official/nlp/data/create_finetuning_data.py b/official/nlp/data/create_finetuning_data.py index 706757d58..c0b4f478a 100755 --- a/official/nlp/data/create_finetuning_data.py +++ b/official/nlp/data/create_finetuning_data.py @@ -18,18 +18,16 @@ import json import os -# Import libraries -from absl import app -from absl import flags import tensorflow as tf +# Import libraries +from absl import app, flags + from official.nlp.bert import tokenization -from official.nlp.data import classifier_data_lib -from official.nlp.data import sentence_retrieval_lib +# sentence-piece tokenizer based squad_lib # word-piece tokenizer based squad_lib +from official.nlp.data import classifier_data_lib, sentence_retrieval_lib from official.nlp.data import squad_lib as squad_lib_wp -# sentence-piece tokenizer based squad_lib -from official.nlp.data import squad_lib_sp -from official.nlp.data import tagging_data_lib +from official.nlp.data import squad_lib_sp, tagging_data_lib FLAGS = flags.FLAGS diff --git a/official/nlp/data/create_pretraining_data.py b/official/nlp/data/create_pretraining_data.py index 6e3d8b557..18030cf6a 100755 --- a/official/nlp/data/create_pretraining_data.py +++ b/official/nlp/data/create_pretraining_data.py @@ -18,11 +18,9 @@ import itertools import random -# Import libraries -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +# Import libraries +from absl import app, flags, logging from official.nlp.bert import tokenization diff --git a/official/nlp/data/create_xlnet_pretraining_data.py b/official/nlp/data/create_xlnet_pretraining_data.py index b8c1b962c..7c93f89a2 100755 --- a/official/nlp/data/create_xlnet_pretraining_data.py +++ b/official/nlp/data/create_xlnet_pretraining_data.py @@ -14,26 +14,25 @@ # ============================================================================== """Create LM TF examples for XLNet.""" +import dataclasses import json import math import os - import random -from typing import Iterable, Mapping, List, Optional, Tuple import unicodedata +from typing import Iterable, List, Mapping, Optional, Tuple -# Import libraries - -from absl import app -from absl import flags -from absl import logging - -import dataclasses import numpy as np import tensorflow as tf +from absl import app, flags, logging from official.nlp.bert import tokenization +# Import libraries + + + + special_symbols = { "": 0, "": 1, diff --git a/official/nlp/data/create_xlnet_pretraining_data_test.py b/official/nlp/data/create_xlnet_pretraining_data_test.py index 095361ee9..d82ad7e59 100755 --- a/official/nlp/data/create_xlnet_pretraining_data_test.py +++ b/official/nlp/data/create_xlnet_pretraining_data_test.py @@ -18,11 +18,10 @@ import tempfile from typing import List -from absl import logging -from absl.testing import parameterized - import numpy as np import tensorflow as tf +from absl import logging +from absl.testing import parameterized from official.nlp.data import create_xlnet_pretraining_data as cpd diff --git a/official/nlp/data/data_loader_factory_test.py b/official/nlp/data/data_loader_factory_test.py index 9818a4965..aceb82ffb 100755 --- a/official/nlp/data/data_loader_factory_test.py +++ b/official/nlp/data/data_loader_factory_test.py @@ -16,6 +16,7 @@ """Tests for official.nlp.data.data_loader_factory.""" import dataclasses + import tensorflow as tf from official.core import config_definitions as cfg diff --git a/official/nlp/data/pretrain_dataloader.py b/official/nlp/data/pretrain_dataloader.py index 29cb662c5..407d0cdc1 100755 --- a/official/nlp/data/pretrain_dataloader.py +++ b/official/nlp/data/pretrain_dataloader.py @@ -14,17 +14,16 @@ # limitations under the License. # ============================================================================== """Loads dataset for the BERT pretraining task.""" +import dataclasses from typing import Mapping, Optional -from absl import logging - -import dataclasses import numpy as np import tensorflow as tf +from absl import logging + from official.core import config_definitions as cfg from official.core import input_reader -from official.nlp.data import data_loader -from official.nlp.data import data_loader_factory +from official.nlp.data import data_loader, data_loader_factory @dataclasses.dataclass diff --git a/official/nlp/data/pretrain_dataloader_test.py b/official/nlp/data/pretrain_dataloader_test.py index a3441f1aa..07f6339f8 100755 --- a/official/nlp/data/pretrain_dataloader_test.py +++ b/official/nlp/data/pretrain_dataloader_test.py @@ -17,9 +17,9 @@ import itertools import os -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.nlp.data import pretrain_dataloader diff --git a/official/nlp/data/question_answering_dataloader.py b/official/nlp/data/question_answering_dataloader.py index eaa4f021e..e74c36433 100755 --- a/official/nlp/data/question_answering_dataloader.py +++ b/official/nlp/data/question_answering_dataloader.py @@ -14,14 +14,14 @@ # limitations under the License. # ============================================================================== """Loads dataset for the question answering (e.g, SQuAD) task.""" +import dataclasses from typing import Mapping, Optional -import dataclasses import tensorflow as tf + from official.core import config_definitions as cfg from official.core import input_reader -from official.nlp.data import data_loader -from official.nlp.data import data_loader_factory +from official.nlp.data import data_loader, data_loader_factory @dataclasses.dataclass diff --git a/official/nlp/data/sentence_prediction_dataloader.py b/official/nlp/data/sentence_prediction_dataloader.py index 88779c24b..c887f587d 100755 --- a/official/nlp/data/sentence_prediction_dataloader.py +++ b/official/nlp/data/sentence_prediction_dataloader.py @@ -14,9 +14,9 @@ # limitations under the License. # ============================================================================== """Loads dataset for the sentence prediction (classification) task.""" +import dataclasses from typing import List, Mapping, Optional -import dataclasses import tensorflow as tf import tensorflow_hub as hub @@ -24,8 +24,7 @@ from official.core import config_definitions as cfg from official.core import input_reader from official.nlp import modeling -from official.nlp.data import data_loader -from official.nlp.data import data_loader_factory +from official.nlp.data import data_loader, data_loader_factory LABEL_TYPES_MAP = {'int': tf.int64, 'float': tf.float32} diff --git a/official/nlp/data/sentence_prediction_dataloader_test.py b/official/nlp/data/sentence_prediction_dataloader_test.py index 06aa6f92f..caf371eaf 100755 --- a/official/nlp/data/sentence_prediction_dataloader_test.py +++ b/official/nlp/data/sentence_prediction_dataloader_test.py @@ -16,11 +16,11 @@ """Tests for official.nlp.data.sentence_prediction_dataloader.""" import os -from absl.testing import parameterized import numpy as np import tensorflow as tf - +from absl.testing import parameterized from sentencepiece import SentencePieceTrainer + from official.nlp.data import sentence_prediction_dataloader as loader diff --git a/official/nlp/data/sentence_retrieval_lib.py b/official/nlp/data/sentence_retrieval_lib.py index b89d3e7a1..fdc11c235 100755 --- a/official/nlp/data/sentence_retrieval_lib.py +++ b/official/nlp/data/sentence_retrieval_lib.py @@ -17,6 +17,7 @@ import os from absl import logging + from official.nlp.bert import tokenization from official.nlp.data import classifier_data_lib diff --git a/official/nlp/data/squad_lib.py b/official/nlp/data/squad_lib.py index 7f28f6deb..36640f378 100755 --- a/official/nlp/data/squad_lib.py +++ b/official/nlp/data/squad_lib.py @@ -21,9 +21,8 @@ import os import six - -from absl import logging import tensorflow as tf +from absl import logging from official.nlp.bert import tokenization diff --git a/official/nlp/data/squad_lib_sp.py b/official/nlp/data/squad_lib_sp.py index dfb3ee828..02f1acf08 100755 --- a/official/nlp/data/squad_lib_sp.py +++ b/official/nlp/data/squad_lib_sp.py @@ -24,9 +24,9 @@ import math import os -from absl import logging import numpy as np import tensorflow as tf +from absl import logging from official.nlp.bert import tokenization diff --git a/official/nlp/data/tagging_data_lib.py b/official/nlp/data/tagging_data_lib.py index d71fcb1d9..c79b7ca0f 100755 --- a/official/nlp/data/tagging_data_lib.py +++ b/official/nlp/data/tagging_data_lib.py @@ -16,8 +16,8 @@ import collections import os -from absl import logging import tensorflow as tf +from absl import logging from official.nlp.bert import tokenization from official.nlp.data import classifier_data_lib diff --git a/official/nlp/data/tagging_data_lib_test.py b/official/nlp/data/tagging_data_lib_test.py index 940ec01f3..bac37bbee 100755 --- a/official/nlp/data/tagging_data_lib_test.py +++ b/official/nlp/data/tagging_data_lib_test.py @@ -17,8 +17,8 @@ import os import random -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from official.nlp.bert import tokenization from official.nlp.data import tagging_data_lib diff --git a/official/nlp/data/tagging_dataloader.py b/official/nlp/data/tagging_dataloader.py index e50cad5bf..4bdf470bd 100755 --- a/official/nlp/data/tagging_dataloader.py +++ b/official/nlp/data/tagging_dataloader.py @@ -14,14 +14,14 @@ # limitations under the License. # ============================================================================== """Loads dataset for the tagging (e.g., NER/POS) task.""" +import dataclasses from typing import Mapping, Optional -import dataclasses import tensorflow as tf + from official.core import config_definitions as cfg from official.core import input_reader -from official.nlp.data import data_loader -from official.nlp.data import data_loader_factory +from official.nlp.data import data_loader, data_loader_factory @dataclasses.dataclass diff --git a/official/nlp/data/tagging_dataloader_test.py b/official/nlp/data/tagging_dataloader_test.py index ce67640f5..6a82eb482 100755 --- a/official/nlp/data/tagging_dataloader_test.py +++ b/official/nlp/data/tagging_dataloader_test.py @@ -16,9 +16,9 @@ """Tests for official.nlp.data.tagging_data_loader.""" import os -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.nlp.data import tagging_dataloader diff --git a/official/nlp/data/train_sentencepiece.py b/official/nlp/data/train_sentencepiece.py index a4528937e..d54d90ede 100755 --- a/official/nlp/data/train_sentencepiece.py +++ b/official/nlp/data/train_sentencepiece.py @@ -25,15 +25,11 @@ import tempfile from typing import List, Tuple -from absl import app -from absl import flags -from absl import logging import tensorflow as tf import tensorflow_datasets as tfds - +from absl import app, flags, logging from sentencepiece import SentencePieceTrainer - FLAGS = flags.FLAGS flags.DEFINE_string("output_model_path", None, "Path to save the the sentencepiece model.") diff --git a/official/nlp/data/wmt_dataloader.py b/official/nlp/data/wmt_dataloader.py index 424839676..e026c7df6 100755 --- a/official/nlp/data/wmt_dataloader.py +++ b/official/nlp/data/wmt_dataloader.py @@ -31,15 +31,15 @@ This batching scheme decreases the fraction of padding tokens per training batch, thus improving the training speed significantly. """ +import dataclasses from typing import Dict, Optional -import dataclasses import tensorflow as tf + import tensorflow_text as tftxt from official.core import config_definitions as cfg from official.core import input_reader -from official.nlp.data import data_loader -from official.nlp.data import data_loader_factory +from official.nlp.data import data_loader, data_loader_factory # Example grouping constants. Defines length boundaries for each group. # These values are the defaults used in Tensor2Tensor. diff --git a/official/nlp/data/wmt_dataloader_test.py b/official/nlp/data/wmt_dataloader_test.py index 6644f886c..ffb27662b 100755 --- a/official/nlp/data/wmt_dataloader_test.py +++ b/official/nlp/data/wmt_dataloader_test.py @@ -15,11 +15,11 @@ # ============================================================================== """Tests for official.nlp.data.wmt_dataloader.""" import os -from absl.testing import parameterized import tensorflow as tf - +from absl.testing import parameterized from sentencepiece import SentencePieceTrainer + from official.nlp.data import wmt_dataloader diff --git a/official/nlp/keras_nlp/__init__.py b/official/nlp/keras_nlp/__init__.py index 68aae1196..7462fa3c8 100755 --- a/official/nlp/keras_nlp/__init__.py +++ b/official/nlp/keras_nlp/__init__.py @@ -14,5 +14,4 @@ # ============================================================================== """Keras-NLP package definition.""" # pylint: disable=wildcard-import -from official.nlp.keras_nlp import encoders -from official.nlp.keras_nlp import layers +from official.nlp.keras_nlp import encoders, layers diff --git a/official/nlp/keras_nlp/encoders/bert_encoder.py b/official/nlp/keras_nlp/encoders/bert_encoder.py index f488ea565..030494c49 100755 --- a/official/nlp/keras_nlp/encoders/bert_encoder.py +++ b/official/nlp/keras_nlp/encoders/bert_encoder.py @@ -16,8 +16,9 @@ # pylint: disable=g-classes-have-attributes import collections -from absl import logging + import tensorflow as tf +from absl import logging from official.nlp.keras_nlp import layers diff --git a/official/nlp/keras_nlp/encoders/bert_encoder_test.py b/official/nlp/keras_nlp/encoders/bert_encoder_test.py index 3fab59fd0..aef82b9a6 100755 --- a/official/nlp/keras_nlp/encoders/bert_encoder_test.py +++ b/official/nlp/keras_nlp/encoders/bert_encoder_test.py @@ -14,11 +14,12 @@ # ============================================================================== """Tests for transformer-based bert encoder network.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.keras_nlp.encoders import bert_encoder diff --git a/official/nlp/keras_nlp/layers/__init__.py b/official/nlp/keras_nlp/layers/__init__.py index 4476cbb05..79a750163 100755 --- a/official/nlp/keras_nlp/layers/__init__.py +++ b/official/nlp/keras_nlp/layers/__init__.py @@ -17,4 +17,5 @@ from official.nlp.keras_nlp.layers.on_device_embedding import OnDeviceEmbedding from official.nlp.keras_nlp.layers.position_embedding import PositionEmbedding from official.nlp.keras_nlp.layers.self_attention_mask import SelfAttentionMask -from official.nlp.keras_nlp.layers.transformer_encoder_block import TransformerEncoderBlock +from official.nlp.keras_nlp.layers.transformer_encoder_block import \ + TransformerEncoderBlock diff --git a/official/nlp/keras_nlp/layers/on_device_embedding_test.py b/official/nlp/keras_nlp/layers/on_device_embedding_test.py index 7fd4b0efe..ba399bf57 100755 --- a/official/nlp/keras_nlp/layers/on_device_embedding_test.py +++ b/official/nlp/keras_nlp/layers/on_device_embedding_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.keras_nlp.layers import on_device_embedding diff --git a/official/nlp/keras_nlp/layers/position_embedding_test.py b/official/nlp/keras_nlp/layers/position_embedding_test.py index 3dea2741b..4628bb3fd 100755 --- a/official/nlp/keras_nlp/layers/position_embedding_test.py +++ b/official/nlp/keras_nlp/layers/position_embedding_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.keras_nlp.layers import position_embedding diff --git a/official/nlp/keras_nlp/layers/transformer_encoder_block_test.py b/official/nlp/keras_nlp/layers/transformer_encoder_block_test.py index 7e422fdc1..f0fac7275 100755 --- a/official/nlp/keras_nlp/layers/transformer_encoder_block_test.py +++ b/official/nlp/keras_nlp/layers/transformer_encoder_block_test.py @@ -14,12 +14,14 @@ # ============================================================================== """Tests for Keras-based transformer block layer.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import -from official.nlp.keras_nlp.layers.transformer_encoder_block import TransformerEncoderBlock +from official.nlp.keras_nlp.layers.transformer_encoder_block import \ + TransformerEncoderBlock @keras_parameterized.run_all_keras_modes diff --git a/official/nlp/keras_nlp/setup.py b/official/nlp/keras_nlp/setup.py index a7e674141..9a0869d5b 100755 --- a/official/nlp/keras_nlp/setup.py +++ b/official/nlp/keras_nlp/setup.py @@ -16,8 +16,7 @@ import os -from setuptools import find_packages -from setuptools import setup +from setuptools import find_packages, setup version = '0.0.1' diff --git a/official/nlp/modeling/__init__.py b/official/nlp/modeling/__init__.py index df56aec85..3522909fb 100755 --- a/official/nlp/modeling/__init__.py +++ b/official/nlp/modeling/__init__.py @@ -13,7 +13,4 @@ # limitations under the License. # ============================================================================== """Modeling package definition.""" -from official.nlp.modeling import layers -from official.nlp.modeling import losses -from official.nlp.modeling import models -from official.nlp.modeling import networks +from official.nlp.modeling import layers, losses, models, networks diff --git a/official/nlp/modeling/layers/__init__.py b/official/nlp/modeling/layers/__init__.py index 97c2afd59..92c170d44 100755 --- a/official/nlp/modeling/layers/__init__.py +++ b/official/nlp/modeling/layers/__init__.py @@ -13,7 +13,6 @@ # limitations under the License. # ============================================================================== """Layers package definition.""" -# pylint: disable=wildcard-import from official.nlp.modeling.layers.attention import * from official.nlp.modeling.layers.cls_head import * from official.nlp.modeling.layers.dense_einsum import DenseEinsum @@ -21,23 +20,25 @@ from official.nlp.modeling.layers.masked_lm import MaskedLM from official.nlp.modeling.layers.masked_softmax import MaskedSoftmax from official.nlp.modeling.layers.mat_mul_with_margin import MatMulWithMargin -from official.nlp.modeling.layers.mobile_bert_layers import MobileBertEmbedding -from official.nlp.modeling.layers.mobile_bert_layers import MobileBertMaskedLM -from official.nlp.modeling.layers.mobile_bert_layers import MobileBertTransformer +from official.nlp.modeling.layers.mobile_bert_layers import ( + MobileBertEmbedding, MobileBertMaskedLM, MobileBertTransformer) from official.nlp.modeling.layers.multi_channel_attention import * from official.nlp.modeling.layers.on_device_embedding import OnDeviceEmbedding -from official.nlp.modeling.layers.position_embedding import RelativePositionBias -from official.nlp.modeling.layers.position_embedding import RelativePositionEmbedding -from official.nlp.modeling.layers.relative_attention import MultiHeadRelativeAttention -from official.nlp.modeling.layers.relative_attention import TwoStreamRelativeAttention +from official.nlp.modeling.layers.position_embedding import ( + RelativePositionBias, RelativePositionEmbedding) +from official.nlp.modeling.layers.relative_attention import ( + MultiHeadRelativeAttention, TwoStreamRelativeAttention) from official.nlp.modeling.layers.rezero_transformer import ReZeroTransformer from official.nlp.modeling.layers.self_attention_mask import SelfAttentionMask -from official.nlp.modeling.layers.talking_heads_attention import TalkingHeadsAttention -from official.nlp.modeling.layers.text_layers import BertPackInputs -from official.nlp.modeling.layers.text_layers import BertTokenizer -from official.nlp.modeling.layers.text_layers import SentencepieceTokenizer -from official.nlp.modeling.layers.tn_transformer_expand_condense import TNTransformerExpandCondense +from official.nlp.modeling.layers.talking_heads_attention import \ + TalkingHeadsAttention +from official.nlp.modeling.layers.text_layers import (BertPackInputs, + BertTokenizer, + SentencepieceTokenizer) +from official.nlp.modeling.layers.tn_transformer_expand_condense import \ + TNTransformerExpandCondense from official.nlp.modeling.layers.transformer import * -from official.nlp.modeling.layers.transformer_scaffold import TransformerScaffold -from official.nlp.modeling.layers.transformer_xl import TransformerXL -from official.nlp.modeling.layers.transformer_xl import TransformerXLBlock +from official.nlp.modeling.layers.transformer_scaffold import \ + TransformerScaffold +from official.nlp.modeling.layers.transformer_xl import (TransformerXL, + TransformerXLBlock) diff --git a/official/nlp/modeling/layers/attention_test.py b/official/nlp/modeling/layers/attention_test.py index c1ea089a2..faae39712 100755 --- a/official/nlp/modeling/layers/attention_test.py +++ b/official/nlp/modeling/layers/attention_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import attention diff --git a/official/nlp/modeling/layers/dense_einsum.py b/official/nlp/modeling/layers/dense_einsum.py index 7fa14e243..02c89711a 100755 --- a/official/nlp/modeling/layers/dense_einsum.py +++ b/official/nlp/modeling/layers/dense_einsum.py @@ -16,7 +16,6 @@ # pylint: disable=g-classes-have-attributes import tensorflow as tf - from tensorflow.python.util import deprecation _CHR_IDX = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"] diff --git a/official/nlp/modeling/layers/dense_einsum_test.py b/official/nlp/modeling/layers/dense_einsum_test.py index af302c529..5bf4aec7b 100755 --- a/official/nlp/modeling/layers/dense_einsum_test.py +++ b/official/nlp/modeling/layers/dense_einsum_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import dense_einsum diff --git a/official/nlp/modeling/layers/gated_feedforward_test.py b/official/nlp/modeling/layers/gated_feedforward_test.py index 342cf5cf1..03792b23e 100755 --- a/official/nlp/modeling/layers/gated_feedforward_test.py +++ b/official/nlp/modeling/layers/gated_feedforward_test.py @@ -14,11 +14,12 @@ # ============================================================================== """Tests for Keras-based gated feedforward layer.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import gated_feedforward diff --git a/official/nlp/modeling/layers/masked_lm.py b/official/nlp/modeling/layers/masked_lm.py index 6196f36dd..dc338a4f6 100755 --- a/official/nlp/modeling/layers/masked_lm.py +++ b/official/nlp/modeling/layers/masked_lm.py @@ -16,5 +16,4 @@ # pylint: disable=g-classes-have-attributes from official.nlp import keras_nlp - MaskedLM = keras_nlp.layers.MaskedLM diff --git a/official/nlp/modeling/layers/masked_lm_test.py b/official/nlp/modeling/layers/masked_lm_test.py index f47adf93c..241150301 100755 --- a/official/nlp/modeling/layers/masked_lm_test.py +++ b/official/nlp/modeling/layers/masked_lm_test.py @@ -16,8 +16,8 @@ import numpy as np import tensorflow as tf - -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import masked_lm from official.nlp.modeling.networks import bert_encoder diff --git a/official/nlp/modeling/layers/masked_softmax_test.py b/official/nlp/modeling/layers/masked_softmax_test.py index 6c0a5c416..695eb9e1b 100755 --- a/official/nlp/modeling/layers/masked_softmax_test.py +++ b/official/nlp/modeling/layers/masked_softmax_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import masked_softmax diff --git a/official/nlp/modeling/layers/mat_mul_with_margin.py b/official/nlp/modeling/layers/mat_mul_with_margin.py index 2a0895298..c990c76b7 100755 --- a/official/nlp/modeling/layers/mat_mul_with_margin.py +++ b/official/nlp/modeling/layers/mat_mul_with_margin.py @@ -16,6 +16,7 @@ # pylint: disable=g-classes-have-attributes from typing import Tuple + # Import libraries import tensorflow as tf diff --git a/official/nlp/modeling/layers/mat_mul_with_margin_test.py b/official/nlp/modeling/layers/mat_mul_with_margin_test.py index 7134196b1..e6bdc77f9 100755 --- a/official/nlp/modeling/layers/mat_mul_with_margin_test.py +++ b/official/nlp/modeling/layers/mat_mul_with_margin_test.py @@ -15,8 +15,9 @@ """Tests for mat_mul_with_margin layer.""" import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import mat_mul_with_margin diff --git a/official/nlp/modeling/layers/mobile_bert_layers_test.py b/official/nlp/modeling/layers/mobile_bert_layers_test.py index 7861217bd..d539d630c 100755 --- a/official/nlp/modeling/layers/mobile_bert_layers_test.py +++ b/official/nlp/modeling/layers/mobile_bert_layers_test.py @@ -12,10 +12,9 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -from absl.testing import parameterized - import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.nlp.modeling.layers import mobile_bert_layers from official.nlp.modeling.networks import mobile_bert_encoder diff --git a/official/nlp/modeling/layers/multi_channel_attention.py b/official/nlp/modeling/layers/multi_channel_attention.py index 2c70ecf9c..9e9949a56 100755 --- a/official/nlp/modeling/layers/multi_channel_attention.py +++ b/official/nlp/modeling/layers/multi_channel_attention.py @@ -19,6 +19,7 @@ import math import tensorflow as tf + from official.modeling import tf_utils from official.nlp.modeling.layers import masked_softmax diff --git a/official/nlp/modeling/layers/on_device_embedding.py b/official/nlp/modeling/layers/on_device_embedding.py index 85c34c24b..7083f9ad0 100755 --- a/official/nlp/modeling/layers/on_device_embedding.py +++ b/official/nlp/modeling/layers/on_device_embedding.py @@ -17,5 +17,4 @@ from official.nlp import keras_nlp - OnDeviceEmbedding = keras_nlp.layers.OnDeviceEmbedding diff --git a/official/nlp/modeling/layers/position_embedding_test.py b/official/nlp/modeling/layers/position_embedding_test.py index 4e2d475cd..01260a932 100755 --- a/official/nlp/modeling/layers/position_embedding_test.py +++ b/official/nlp/modeling/layers/position_embedding_test.py @@ -14,11 +14,12 @@ # ============================================================================== """Tests for Keras-based positional embedding layer.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import position_embedding diff --git a/official/nlp/modeling/layers/relative_attention.py b/official/nlp/modeling/layers/relative_attention.py index cb3fb374c..91f7275be 100755 --- a/official/nlp/modeling/layers/relative_attention.py +++ b/official/nlp/modeling/layers/relative_attention.py @@ -16,6 +16,7 @@ """Keras-based relative attention layers.""" import math import string + import tensorflow as tf _CHR_IDX = string.ascii_lowercase @@ -497,4 +498,3 @@ def call(self, query_attention_output = self._output_dense(query_attention_output) return content_attention_output, query_attention_output - diff --git a/official/nlp/modeling/layers/relative_attention_test.py b/official/nlp/modeling/layers/relative_attention_test.py index aff5eda21..8792b79b0 100755 --- a/official/nlp/modeling/layers/relative_attention_test.py +++ b/official/nlp/modeling/layers/relative_attention_test.py @@ -16,9 +16,10 @@ import numpy as np import tensorflow as tf - from tensorflow.python.distribute import combinations -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import + from official.nlp.modeling.layers import relative_attention diff --git a/official/nlp/modeling/layers/rezero_transformer_test.py b/official/nlp/modeling/layers/rezero_transformer_test.py index 69a2e7d9e..7aaf63341 100755 --- a/official/nlp/modeling/layers/rezero_transformer_test.py +++ b/official/nlp/modeling/layers/rezero_transformer_test.py @@ -16,8 +16,9 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import rezero_transformer diff --git a/official/nlp/modeling/layers/talking_heads_attention_test.py b/official/nlp/modeling/layers/talking_heads_attention_test.py index 1ee71223b..ce3ab3035 100755 --- a/official/nlp/modeling/layers/talking_heads_attention_test.py +++ b/official/nlp/modeling/layers/talking_heads_attention_test.py @@ -14,11 +14,12 @@ # ============================================================================== """Tests for the attention layer.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import talking_heads_attention diff --git a/official/nlp/modeling/layers/text_layers.py b/official/nlp/modeling/layers/text_layers.py index c7b80f4d5..1ce9f869b 100755 --- a/official/nlp/modeling/layers/text_layers.py +++ b/official/nlp/modeling/layers/text_layers.py @@ -15,8 +15,8 @@ """Keras Layers for BERT-specific preprocessing.""" from typing import Any, Dict, List, Optional, Union -from absl import logging import tensorflow as tf +from absl import logging try: import tensorflow_text as text # pylint: disable=g-import-not-at-top diff --git a/official/nlp/modeling/layers/text_layers_test.py b/official/nlp/modeling/layers/text_layers_test.py index 4fabd7d02..f762b1e93 100755 --- a/official/nlp/modeling/layers/text_layers_test.py +++ b/official/nlp/modeling/layers/text_layers_test.py @@ -19,8 +19,8 @@ import numpy as np import tensorflow as tf - from sentencepiece import SentencePieceTrainer + from official.nlp.modeling.layers import text_layers diff --git a/official/nlp/modeling/layers/tn_expand_condense.py b/official/nlp/modeling/layers/tn_expand_condense.py index b4f830b3b..310a76a26 100755 --- a/official/nlp/modeling/layers/tn_expand_condense.py +++ b/official/nlp/modeling/layers/tn_expand_condense.py @@ -14,7 +14,8 @@ # ============================================================================== """ExpandCondense tensor network layer used in TN-BERT.""" # pylint: disable=g-classes-have-attributes -from typing import List, Optional, Text, Any, Dict +from typing import Any, Dict, List, Optional, Text + import tensorflow as tf Layer = tf.keras.layers.Layer diff --git a/official/nlp/modeling/layers/tn_expand_condense_test.py b/official/nlp/modeling/layers/tn_expand_condense_test.py index 4accc5867..6c5c49b9b 100755 --- a/official/nlp/modeling/layers/tn_expand_condense_test.py +++ b/official/nlp/modeling/layers/tn_expand_condense_test.py @@ -16,11 +16,12 @@ import os -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized # pylint: disable=g-direct-tensorflow-import from tensorflow.python.keras.testing_utils import layer_test + from official.nlp.modeling.layers.tn_expand_condense import TNExpandCondense diff --git a/official/nlp/modeling/layers/tn_transformer_test.py b/official/nlp/modeling/layers/tn_transformer_test.py index 1a1b41128..321483adf 100755 --- a/official/nlp/modeling/layers/tn_transformer_test.py +++ b/official/nlp/modeling/layers/tn_transformer_test.py @@ -14,12 +14,14 @@ # ============================================================================== """Tests for TN-BERT transformer.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import -from official.nlp.modeling.layers.tn_transformer_expand_condense import TNTransformerExpandCondense +from official.nlp.modeling.layers.tn_transformer_expand_condense import \ + TNTransformerExpandCondense # This decorator runs the test in V1, V2-Eager, and V2-Functional mode. It diff --git a/official/nlp/modeling/layers/transformer.py b/official/nlp/modeling/layers/transformer.py index 511ba9dbb..b5e3ae8bc 100755 --- a/official/nlp/modeling/layers/transformer.py +++ b/official/nlp/modeling/layers/transformer.py @@ -19,8 +19,7 @@ import tensorflow as tf from official.nlp import keras_nlp -from official.nlp.modeling.layers import attention -from official.nlp.modeling.layers import multi_channel_attention +from official.nlp.modeling.layers import attention, multi_channel_attention from official.nlp.modeling.layers.util import tf_function_if_eager diff --git a/official/nlp/modeling/layers/transformer_scaffold.py b/official/nlp/modeling/layers/transformer_scaffold.py index 34d06d49c..e934b7ea7 100755 --- a/official/nlp/modeling/layers/transformer_scaffold.py +++ b/official/nlp/modeling/layers/transformer_scaffold.py @@ -15,9 +15,9 @@ """Keras-based transformer scaffold layer.""" # pylint: disable=g-classes-have-attributes -from absl import logging import gin import tensorflow as tf +from absl import logging from official.nlp.modeling.layers import attention diff --git a/official/nlp/modeling/layers/transformer_scaffold_test.py b/official/nlp/modeling/layers/transformer_scaffold_test.py index 14bb8c23d..088fb5a63 100755 --- a/official/nlp/modeling/layers/transformer_scaffold_test.py +++ b/official/nlp/modeling/layers/transformer_scaffold_test.py @@ -16,10 +16,10 @@ import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import -from official.nlp.modeling.layers import attention -from official.nlp.modeling.layers import transformer_scaffold +from official.nlp.modeling.layers import attention, transformer_scaffold # Test class that wraps a standard attention layer. If this layer is called diff --git a/official/nlp/modeling/layers/transformer_test.py b/official/nlp/modeling/layers/transformer_test.py index aef245c9d..bbce7790d 100755 --- a/official/nlp/modeling/layers/transformer_test.py +++ b/official/nlp/modeling/layers/transformer_test.py @@ -15,8 +15,9 @@ """Tests for Keras-based transformer block layer.""" import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import transformer diff --git a/official/nlp/modeling/layers/transformer_xl.py b/official/nlp/modeling/layers/transformer_xl.py index f0fff2efb..62bfc455a 100755 --- a/official/nlp/modeling/layers/transformer_xl.py +++ b/official/nlp/modeling/layers/transformer_xl.py @@ -15,9 +15,8 @@ # ============================================================================== """Keras-based Transformer XL layer.""" -from absl import logging - import tensorflow as tf +from absl import logging from official.nlp.modeling.layers import relative_attention diff --git a/official/nlp/modeling/layers/transformer_xl_test.py b/official/nlp/modeling/layers/transformer_xl_test.py index 443b26968..7c2cdc4dc 100755 --- a/official/nlp/modeling/layers/transformer_xl_test.py +++ b/official/nlp/modeling/layers/transformer_xl_test.py @@ -16,9 +16,9 @@ import numpy as np import tensorflow as tf - from tensorflow.python.distribute import combinations -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.layers import transformer_xl diff --git a/official/nlp/modeling/losses/__init__.py b/official/nlp/modeling/losses/__init__.py index 7a396eb98..6fc0f991b 100755 --- a/official/nlp/modeling/losses/__init__.py +++ b/official/nlp/modeling/losses/__init__.py @@ -13,4 +13,5 @@ # limitations under the License. # ============================================================================== """Activations package definition. Subject to change.""" -from official.nlp.modeling.losses.weighted_sparse_categorical_crossentropy import loss as weighted_sparse_categorical_crossentropy_loss +from official.nlp.modeling.losses.weighted_sparse_categorical_crossentropy import \ + loss as weighted_sparse_categorical_crossentropy_loss diff --git a/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py b/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py index 9e6c09cde..5e30424a3 100755 --- a/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py +++ b/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py @@ -14,13 +14,13 @@ # ============================================================================== """Tests for masked LM loss.""" import numpy as np - import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import -from official.nlp.modeling import layers -from official.nlp.modeling import networks -from official.nlp.modeling.losses import weighted_sparse_categorical_crossentropy +from official.nlp.modeling import layers, networks +from official.nlp.modeling.losses import \ + weighted_sparse_categorical_crossentropy @keras_parameterized.run_all_keras_modes diff --git a/official/nlp/modeling/models/__init__.py b/official/nlp/modeling/models/__init__.py index c5c4eb610..2f567394a 100755 --- a/official/nlp/modeling/models/__init__.py +++ b/official/nlp/modeling/models/__init__.py @@ -16,10 +16,11 @@ from official.nlp.modeling.models.bert_classifier import BertClassifier from official.nlp.modeling.models.bert_pretrainer import * from official.nlp.modeling.models.bert_span_labeler import BertSpanLabeler -from official.nlp.modeling.models.bert_token_classifier import BertTokenClassifier +from official.nlp.modeling.models.bert_token_classifier import \ + BertTokenClassifier from official.nlp.modeling.models.dual_encoder import DualEncoder from official.nlp.modeling.models.electra_pretrainer import ElectraPretrainer from official.nlp.modeling.models.seq2seq_transformer import * -from official.nlp.modeling.models.xlnet import XLNetClassifier -from official.nlp.modeling.models.xlnet import XLNetPretrainer -from official.nlp.modeling.models.xlnet import XLNetSpanLabeler +from official.nlp.modeling.models.xlnet import (XLNetClassifier, + XLNetPretrainer, + XLNetSpanLabeler) diff --git a/official/nlp/modeling/models/bert_classifier.py b/official/nlp/modeling/models/bert_classifier.py index aba240a7c..e47e20285 100755 --- a/official/nlp/modeling/models/bert_classifier.py +++ b/official/nlp/modeling/models/bert_classifier.py @@ -15,10 +15,10 @@ """BERT cls-token classifier.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf -from official.nlp.modeling import layers -from official.nlp.modeling import networks +from official.nlp.modeling import layers, networks @tf.keras.utils.register_keras_serializable(package='Text') diff --git a/official/nlp/modeling/models/bert_classifier_test.py b/official/nlp/modeling/models/bert_classifier_test.py index ed3c5b09e..044a13a5a 100755 --- a/official/nlp/modeling/models/bert_classifier_test.py +++ b/official/nlp/modeling/models/bert_classifier_test.py @@ -14,10 +14,11 @@ # ============================================================================== """Tests for BERT trainer network.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import bert_classifier diff --git a/official/nlp/modeling/models/bert_pretrainer.py b/official/nlp/modeling/models/bert_pretrainer.py index a4bade2af..3b09866b0 100755 --- a/official/nlp/modeling/models/bert_pretrainer.py +++ b/official/nlp/modeling/models/bert_pretrainer.py @@ -18,12 +18,11 @@ import copy from typing import List, Optional -from absl import logging import gin import tensorflow as tf +from absl import logging -from official.nlp.modeling import layers -from official.nlp.modeling import networks +from official.nlp.modeling import layers, networks @tf.keras.utils.register_keras_serializable(package='Text') diff --git a/official/nlp/modeling/models/bert_pretrainer_test.py b/official/nlp/modeling/models/bert_pretrainer_test.py index cb438630a..cb8be43b9 100755 --- a/official/nlp/modeling/models/bert_pretrainer_test.py +++ b/official/nlp/modeling/models/bert_pretrainer_test.py @@ -15,12 +15,12 @@ """Tests for BERT pretrainer model.""" import itertools -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import -from official.nlp.modeling import layers -from official.nlp.modeling import networks +from official.nlp.modeling import layers, networks from official.nlp.modeling.models import bert_pretrainer diff --git a/official/nlp/modeling/models/bert_span_labeler.py b/official/nlp/modeling/models/bert_span_labeler.py index 8e4b10da1..566035973 100755 --- a/official/nlp/modeling/models/bert_span_labeler.py +++ b/official/nlp/modeling/models/bert_span_labeler.py @@ -15,6 +15,7 @@ """BERT Question Answering model.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf from official.nlp.modeling import networks diff --git a/official/nlp/modeling/models/bert_span_labeler_test.py b/official/nlp/modeling/models/bert_span_labeler_test.py index 2c613ccdb..0ff7fe01d 100755 --- a/official/nlp/modeling/models/bert_span_labeler_test.py +++ b/official/nlp/modeling/models/bert_span_labeler_test.py @@ -14,10 +14,11 @@ # ============================================================================== """Tests for BERT trainer network.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import bert_span_labeler diff --git a/official/nlp/modeling/models/bert_token_classifier.py b/official/nlp/modeling/models/bert_token_classifier.py index 92ac76da7..e9a96767f 100755 --- a/official/nlp/modeling/models/bert_token_classifier.py +++ b/official/nlp/modeling/models/bert_token_classifier.py @@ -15,6 +15,7 @@ """BERT token classifier.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf diff --git a/official/nlp/modeling/models/bert_token_classifier_test.py b/official/nlp/modeling/models/bert_token_classifier_test.py index 43c255b73..97a98d7e8 100755 --- a/official/nlp/modeling/models/bert_token_classifier_test.py +++ b/official/nlp/modeling/models/bert_token_classifier_test.py @@ -14,10 +14,11 @@ # ============================================================================== """Tests for BERT token classifier.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import bert_token_classifier diff --git a/official/nlp/modeling/models/dual_encoder.py b/official/nlp/modeling/models/dual_encoder.py index 190f63fe5..dde94d60f 100755 --- a/official/nlp/modeling/models/dual_encoder.py +++ b/official/nlp/modeling/models/dual_encoder.py @@ -15,6 +15,7 @@ """Trainer network for dual encoder style models.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf from official.nlp.modeling import layers diff --git a/official/nlp/modeling/models/dual_encoder_test.py b/official/nlp/modeling/models/dual_encoder_test.py index 2bdf71f4b..17ee59d8c 100755 --- a/official/nlp/modeling/models/dual_encoder_test.py +++ b/official/nlp/modeling/models/dual_encoder_test.py @@ -14,10 +14,11 @@ # ============================================================================== """Tests for dual encoder network.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import dual_encoder diff --git a/official/nlp/modeling/models/electra_pretrainer_test.py b/official/nlp/modeling/models/electra_pretrainer_test.py index 2d16b87ac..a1e327741 100755 --- a/official/nlp/modeling/models/electra_pretrainer_test.py +++ b/official/nlp/modeling/models/electra_pretrainer_test.py @@ -15,8 +15,9 @@ """Tests for ELECTRA pre trainer network.""" import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import electra_pretrainer diff --git a/official/nlp/modeling/models/seq2seq_transformer.py b/official/nlp/modeling/models/seq2seq_transformer.py index e8f9de673..3809da116 100755 --- a/official/nlp/modeling/models/seq2seq_transformer.py +++ b/official/nlp/modeling/models/seq2seq_transformer.py @@ -19,6 +19,7 @@ import math import tensorflow as tf + from official.modeling import tf_utils from official.nlp import keras_nlp from official.nlp.modeling import layers diff --git a/official/nlp/modeling/models/seq2seq_transformer_test.py b/official/nlp/modeling/models/seq2seq_transformer_test.py index 0ba82f67f..d3dc73237 100755 --- a/official/nlp/modeling/models/seq2seq_transformer_test.py +++ b/official/nlp/modeling/models/seq2seq_transformer_test.py @@ -14,13 +14,12 @@ # ============================================================================== """Test Transformer model.""" -from absl import logging -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl import logging +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.nlp.modeling.models import seq2seq_transformer diff --git a/official/nlp/modeling/models/xlnet.py b/official/nlp/modeling/models/xlnet.py index 87ee65a92..3e35eaeaf 100755 --- a/official/nlp/modeling/models/xlnet.py +++ b/official/nlp/modeling/models/xlnet.py @@ -19,8 +19,7 @@ import tensorflow as tf -from official.nlp.modeling import layers -from official.nlp.modeling import networks +from official.nlp.modeling import layers, networks class XLNetMaskedLM(tf.keras.layers.Layer): @@ -339,4 +338,3 @@ def get_config(self): @classmethod def from_config(cls, config, custom_objects=None): return cls(**config) - diff --git a/official/nlp/modeling/models/xlnet_test.py b/official/nlp/modeling/models/xlnet_test.py index 67b8fe4d7..ccfe96d43 100755 --- a/official/nlp/modeling/models/xlnet_test.py +++ b/official/nlp/modeling/models/xlnet_test.py @@ -14,12 +14,12 @@ # ============================================================================== """Tests for XLNet classifier network.""" -from absl.testing import parameterized - import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling import networks from official.nlp.modeling.models import xlnet diff --git a/official/nlp/modeling/networks/__init__.py b/official/nlp/modeling/networks/__init__.py index f716985e6..29e83811d 100755 --- a/official/nlp/modeling/networks/__init__.py +++ b/official/nlp/modeling/networks/__init__.py @@ -17,10 +17,13 @@ from official.nlp.modeling.networks.bert_encoder import BertEncoder from official.nlp.modeling.networks.classification import Classification from official.nlp.modeling.networks.encoder_scaffold import EncoderScaffold -from official.nlp.modeling.networks.mobile_bert_encoder import MobileBERTEncoder -from official.nlp.modeling.networks.packed_sequence_embedding import PackedSequenceEmbedding -from official.nlp.modeling.networks.span_labeling import SpanLabeling -from official.nlp.modeling.networks.span_labeling import XLNetSpanLabeling +from official.nlp.modeling.networks.mobile_bert_encoder import \ + MobileBERTEncoder +from official.nlp.modeling.networks.packed_sequence_embedding import \ + PackedSequenceEmbedding +from official.nlp.modeling.networks.span_labeling import (SpanLabeling, + XLNetSpanLabeling) from official.nlp.modeling.networks.xlnet_base import XLNetBase + # Backward compatibility. The modules are deprecated. TransformerEncoder = BertEncoder diff --git a/official/nlp/modeling/networks/albert_encoder.py b/official/nlp/modeling/networks/albert_encoder.py index 473b4f08e..47aab8e36 100755 --- a/official/nlp/modeling/networks/albert_encoder.py +++ b/official/nlp/modeling/networks/albert_encoder.py @@ -15,6 +15,7 @@ """ALBERT (https://arxiv.org/abs/1810.04805) text encoder network.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf from official.modeling import activations diff --git a/official/nlp/modeling/networks/albert_encoder_test.py b/official/nlp/modeling/networks/albert_encoder_test.py index c29031788..b7b680a00 100755 --- a/official/nlp/modeling/networks/albert_encoder_test.py +++ b/official/nlp/modeling/networks/albert_encoder_test.py @@ -14,15 +14,14 @@ # ============================================================================== """Tests for ALBERT transformer-based text encoder network.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.networks import albert_encoder diff --git a/official/nlp/modeling/networks/bert_encoder.py b/official/nlp/modeling/networks/bert_encoder.py index a0647e7c3..15cb461ee 100755 --- a/official/nlp/modeling/networks/bert_encoder.py +++ b/official/nlp/modeling/networks/bert_encoder.py @@ -15,6 +15,7 @@ """Transformer-based text encoder network.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf from official.modeling import activations diff --git a/official/nlp/modeling/networks/bert_encoder_test.py b/official/nlp/modeling/networks/bert_encoder_test.py index d58bb094e..1c46fa394 100755 --- a/official/nlp/modeling/networks/bert_encoder_test.py +++ b/official/nlp/modeling/networks/bert_encoder_test.py @@ -14,12 +14,13 @@ # ============================================================================== """Tests for transformer-based bert encoder network.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.networks import bert_encoder diff --git a/official/nlp/modeling/networks/classification.py b/official/nlp/modeling/networks/classification.py index c0a71c4d4..17fa18cfa 100755 --- a/official/nlp/modeling/networks/classification.py +++ b/official/nlp/modeling/networks/classification.py @@ -15,6 +15,7 @@ """Classification and regression network.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf diff --git a/official/nlp/modeling/networks/classification_test.py b/official/nlp/modeling/networks/classification_test.py index 600e16c47..9a850013d 100755 --- a/official/nlp/modeling/networks/classification_test.py +++ b/official/nlp/modeling/networks/classification_test.py @@ -14,15 +14,14 @@ # ============================================================================== """Tests for classification network.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.networks import classification diff --git a/official/nlp/modeling/networks/encoder_scaffold.py b/official/nlp/modeling/networks/encoder_scaffold.py index e278199c5..5e5b93947 100755 --- a/official/nlp/modeling/networks/encoder_scaffold.py +++ b/official/nlp/modeling/networks/encoder_scaffold.py @@ -17,9 +17,9 @@ # pylint: disable=g-classes-have-attributes import inspect -from absl import logging import gin import tensorflow as tf +from absl import logging from official.nlp import keras_nlp from official.nlp.modeling import layers diff --git a/official/nlp/modeling/networks/encoder_scaffold_test.py b/official/nlp/modeling/networks/encoder_scaffold_test.py index 1ca9e2a6b..95f0d3c85 100755 --- a/official/nlp/modeling/networks/encoder_scaffold_test.py +++ b/official/nlp/modeling/networks/encoder_scaffold_test.py @@ -14,11 +14,12 @@ # ============================================================================== """Tests for EncoderScaffold network.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.modeling import activations from official.nlp.modeling import layers from official.nlp.modeling.networks import encoder_scaffold diff --git a/official/nlp/modeling/networks/mobile_bert_encoder_test.py b/official/nlp/modeling/networks/mobile_bert_encoder_test.py index f2f2b0c26..3cdca4387 100755 --- a/official/nlp/modeling/networks/mobile_bert_encoder_test.py +++ b/official/nlp/modeling/networks/mobile_bert_encoder_test.py @@ -12,10 +12,10 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -from absl.testing import parameterized - import numpy as np import tensorflow as tf +from absl.testing import parameterized + from official.nlp.modeling import models from official.nlp.modeling.networks import mobile_bert_encoder diff --git a/official/nlp/modeling/networks/packed_sequence_embedding.py b/official/nlp/modeling/networks/packed_sequence_embedding.py index f73355985..d2a3b9539 100755 --- a/official/nlp/modeling/networks/packed_sequence_embedding.py +++ b/official/nlp/modeling/networks/packed_sequence_embedding.py @@ -16,6 +16,7 @@ """An embedding network supporting packed sequences and position ids.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf from official.modeling import tf_utils diff --git a/official/nlp/modeling/networks/packed_sequence_embedding_test.py b/official/nlp/modeling/networks/packed_sequence_embedding_test.py index 4d2b2354d..dcf6abe51 100755 --- a/official/nlp/modeling/networks/packed_sequence_embedding_test.py +++ b/official/nlp/modeling/networks/packed_sequence_embedding_test.py @@ -17,9 +17,9 @@ # Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.nlp.modeling.networks import packed_sequence_embedding diff --git a/official/nlp/modeling/networks/span_labeling.py b/official/nlp/modeling/networks/span_labeling.py index 896df2034..6133de710 100755 --- a/official/nlp/modeling/networks/span_labeling.py +++ b/official/nlp/modeling/networks/span_labeling.py @@ -15,6 +15,7 @@ """Span labeling network.""" # pylint: disable=g-classes-have-attributes import collections + import tensorflow as tf diff --git a/official/nlp/modeling/networks/span_labeling_test.py b/official/nlp/modeling/networks/span_labeling_test.py index ac1cb1f46..67bd1451e 100755 --- a/official/nlp/modeling/networks/span_labeling_test.py +++ b/official/nlp/modeling/networks/span_labeling_test.py @@ -15,8 +15,9 @@ """Tests for span_labeling network.""" import numpy as np import tensorflow as tf +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import from official.nlp.modeling.networks import span_labeling diff --git a/official/nlp/modeling/networks/xlnet_base.py b/official/nlp/modeling/networks/xlnet_base.py index 3ee785d07..fdd3d968c 100755 --- a/official/nlp/modeling/networks/xlnet_base.py +++ b/official/nlp/modeling/networks/xlnet_base.py @@ -15,9 +15,8 @@ # ============================================================================== """Keras-based XLNet Model.""" -from absl import logging - import tensorflow as tf +from absl import logging from official.nlp.modeling import layers from official.nlp.modeling.layers import transformer_xl diff --git a/official/nlp/modeling/networks/xlnet_base_test.py b/official/nlp/modeling/networks/xlnet_base_test.py index cbc008501..eff523b26 100755 --- a/official/nlp/modeling/networks/xlnet_base_test.py +++ b/official/nlp/modeling/networks/xlnet_base_test.py @@ -12,15 +12,14 @@ # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import numpy as np import tensorflow as tf - from tensorflow.python.distribute import combinations -from tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import +from tensorflow.python.keras import \ + keras_parameterized # pylint: disable=g-direct-tensorflow-import + from official.nlp.modeling.networks import xlnet_base diff --git a/official/nlp/modeling/ops/__init__.py b/official/nlp/modeling/ops/__init__.py index 558748001..ddf4e6b0e 100755 --- a/official/nlp/modeling/ops/__init__.py +++ b/official/nlp/modeling/ops/__init__.py @@ -14,5 +14,5 @@ # ============================================================================== """Ops package definition.""" from official.nlp.modeling.ops.beam_search import sequence_beam_search -from official.nlp.modeling.ops.segment_extractor import get_next_sentence_labels -from official.nlp.modeling.ops.segment_extractor import get_sentence_order_labels +from official.nlp.modeling.ops.segment_extractor import ( + get_next_sentence_labels, get_sentence_order_labels) diff --git a/official/nlp/modeling/ops/beam_search_test.py b/official/nlp/modeling/ops/beam_search_test.py index 6db022434..2da96affe 100755 --- a/official/nlp/modeling/ops/beam_search_test.py +++ b/official/nlp/modeling/ops/beam_search_test.py @@ -14,8 +14,8 @@ # ============================================================================== """Test beam search helper methods.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from official.nlp.modeling.ops import beam_search diff --git a/official/nlp/modeling/ops/decoding_module.py b/official/nlp/modeling/ops/decoding_module.py index 7a59841ff..d54e34411 100755 --- a/official/nlp/modeling/ops/decoding_module.py +++ b/official/nlp/modeling/ops/decoding_module.py @@ -18,7 +18,6 @@ from typing import Any, Callable, Dict, Tuple import tensorflow as tf - from tensorflow.python.framework import dtypes Output = Tuple[tf.Tensor, tf.Tensor] @@ -284,6 +283,3 @@ def inf(self): return dtypes.float16.max else: raise AssertionError("Invalid dtype: %s" % self.dtype) - - - diff --git a/official/nlp/modeling/ops/decoding_module_test.py b/official/nlp/modeling/ops/decoding_module_test.py index 41f40cfb8..a51ed8736 100755 --- a/official/nlp/modeling/ops/decoding_module_test.py +++ b/official/nlp/modeling/ops/decoding_module_test.py @@ -15,6 +15,7 @@ """Test decoding utility methods.""" import abc + import tensorflow as tf from official.nlp.modeling.ops import decoding_module diff --git a/official/nlp/modeling/ops/sampling_module.py b/official/nlp/modeling/ops/sampling_module.py index 181965bdb..992738061 100755 --- a/official/nlp/modeling/ops/sampling_module.py +++ b/official/nlp/modeling/ops/sampling_module.py @@ -438,10 +438,3 @@ def _finished_flags(self, topk_ids, state) -> tf.Tensor: new_finished_flags = tf.logical_or( new_finished_flags, state[decoding_module.StateKeys.FINISHED_FLAGS]) return new_finished_flags - - - - - - - diff --git a/official/nlp/modeling/ops/segment_extractor_test.py b/official/nlp/modeling/ops/segment_extractor_test.py index 6c9fef013..d8f3064a2 100755 --- a/official/nlp/modeling/ops/segment_extractor_test.py +++ b/official/nlp/modeling/ops/segment_extractor_test.py @@ -18,8 +18,8 @@ """Tests for sentence prediction labels.""" import functools -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from official.nlp.modeling.ops import segment_extractor diff --git a/official/nlp/nhnet/configs.py b/official/nlp/nhnet/configs.py index 41cfa6117..e646136e7 100755 --- a/official/nlp/nhnet/configs.py +++ b/official/nlp/nhnet/configs.py @@ -15,9 +15,8 @@ # ============================================================================== """Common NHNet/Bert2Bert configuration.""" -from typing import List, Text - import dataclasses +from typing import List, Text from official.modeling.hyperparams import base_config diff --git a/official/nlp/nhnet/configs_test.py b/official/nlp/nhnet/configs_test.py index 1260b646c..556860a27 100755 --- a/official/nlp/nhnet/configs_test.py +++ b/official/nlp/nhnet/configs_test.py @@ -15,6 +15,7 @@ """Tests for configs.""" import tensorflow as tf + from official.nlp.nhnet import configs BERT2BERT_CONFIG = { diff --git a/official/nlp/nhnet/decoder.py b/official/nlp/nhnet/decoder.py index 8f8ffa4a6..6a955c6a1 100755 --- a/official/nlp/nhnet/decoder.py +++ b/official/nlp/nhnet/decoder.py @@ -15,6 +15,7 @@ """Transformer decoder that mimics a BERT encoder, to load BERT checkpoints.""" import tensorflow as tf + from official.modeling import tf_utils from official.nlp.modeling import layers from official.nlp.transformer import model_utils as transformer_utils diff --git a/official/nlp/nhnet/decoder_test.py b/official/nlp/nhnet/decoder_test.py index 9ec4ae721..304e0df18 100755 --- a/official/nlp/nhnet/decoder_test.py +++ b/official/nlp/nhnet/decoder_test.py @@ -16,10 +16,9 @@ import numpy as np import tensorflow as tf + from official.nlp.modeling import layers -from official.nlp.nhnet import configs -from official.nlp.nhnet import decoder -from official.nlp.nhnet import utils +from official.nlp.nhnet import configs, decoder, utils class DecoderTest(tf.test.TestCase): diff --git a/official/nlp/nhnet/evaluation.py b/official/nlp/nhnet/evaluation.py index 76f9e3113..012201e7f 100755 --- a/official/nlp/nhnet/evaluation.py +++ b/official/nlp/nhnet/evaluation.py @@ -16,13 +16,13 @@ """Evaluation for Bert2Bert.""" import os -# Import libraries -from absl import logging + import numpy as np import tensorflow as tf +# Import libraries +from absl import logging -from official.nlp.nhnet import input_pipeline -from official.nlp.nhnet import models +from official.nlp.nhnet import input_pipeline, models from official.nlp.transformer import metrics as metrics_v2 from official.nlp.transformer.utils import metrics diff --git a/official/nlp/nhnet/models.py b/official/nlp/nhnet/models.py index 805557139..3a3e38a43 100755 --- a/official/nlp/nhnet/models.py +++ b/official/nlp/nhnet/models.py @@ -13,19 +13,18 @@ # limitations under the License. # ============================================================================== """tf.keras Models for NHNet.""" -from absl import logging +from typing import Optional, Text + import gin import tensorflow as tf -from typing import Optional, Text +from absl import logging from official.modeling import tf_utils from official.modeling.hyperparams import params_dict from official.nlp.modeling import networks from official.nlp.modeling.layers import multi_channel_attention -from official.nlp.nhnet import configs -from official.nlp.nhnet import decoder -from official.nlp.nhnet import utils from official.nlp.modeling.ops import beam_search +from official.nlp.nhnet import configs, decoder, utils def embedding_linear(embedding_matrix, x): diff --git a/official/nlp/nhnet/models_test.py b/official/nlp/nhnet/models_test.py index c79242adf..b110b3b0b 100755 --- a/official/nlp/nhnet/models_test.py +++ b/official/nlp/nhnet/models_test.py @@ -16,18 +16,15 @@ import os -from absl import logging -from absl.testing import parameterized import numpy as np import tensorflow as tf - +from absl import logging +from absl.testing import parameterized # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations +from tensorflow.python.distribute import combinations, strategy_combinations + # pylint: enable=g-direct-tensorflow-import -from official.nlp.nhnet import configs -from official.nlp.nhnet import models -from official.nlp.nhnet import utils +from official.nlp.nhnet import configs, models, utils def all_strategy_combinations(): diff --git a/official/nlp/nhnet/raw_data_process.py b/official/nlp/nhnet/raw_data_process.py index eccb1ed7a..216e09c71 100755 --- a/official/nlp/nhnet/raw_data_process.py +++ b/official/nlp/nhnet/raw_data_process.py @@ -17,8 +17,8 @@ import os -from absl import app -from absl import flags +from absl import app, flags + from official.nlp.nhnet import raw_data_processor FLAGS = flags.FLAGS diff --git a/official/nlp/nhnet/trainer.py b/official/nlp/nhnet/trainer.py index 3eda18510..dce214422 100755 --- a/official/nlp/nhnet/trainer.py +++ b/official/nlp/nhnet/trainer.py @@ -17,18 +17,14 @@ import os +import tensorflow as tf # Import libraries -from absl import app -from absl import flags -from absl import logging +from absl import app, flags, logging from six.moves import zip -import tensorflow as tf + from official.common import distribute_utils from official.modeling.hyperparams import params_dict -from official.nlp.nhnet import evaluation -from official.nlp.nhnet import input_pipeline -from official.nlp.nhnet import models -from official.nlp.nhnet import optimizer +from official.nlp.nhnet import evaluation, input_pipeline, models, optimizer from official.nlp.transformer import metrics as transformer_metrics from official.utils.misc import keras_utils diff --git a/official/nlp/nhnet/trainer_test.py b/official/nlp/nhnet/trainer_test.py index dba70651c..7666ae844 100755 --- a/official/nlp/nhnet/trainer_test.py +++ b/official/nlp/nhnet/trainer_test.py @@ -17,16 +17,14 @@ import os +import tensorflow as tf from absl import flags from absl.testing import parameterized -import tensorflow as tf - # pylint: disable=g-direct-tensorflow-import -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations +from tensorflow.python.distribute import combinations, strategy_combinations + # pylint: enable=g-direct-tensorflow-import -from official.nlp.nhnet import trainer -from official.nlp.nhnet import utils +from official.nlp.nhnet import trainer, utils FLAGS = flags.FLAGS trainer.define_flags() diff --git a/official/nlp/nhnet/utils.py b/official/nlp/nhnet/utils.py index a61f89035..dd6f87764 100755 --- a/official/nlp/nhnet/utils.py +++ b/official/nlp/nhnet/utils.py @@ -13,9 +13,11 @@ # limitations under the License. # ============================================================================== """Utility helpers for Bert2Bert.""" -from absl import logging -import tensorflow as tf from typing import Optional, Text + +import tensorflow as tf +from absl import logging + from official.modeling.hyperparams import params_dict from official.nlp.bert import configs from official.nlp.nhnet import configs as nhnet_configs diff --git a/official/nlp/optimization.py b/official/nlp/optimization.py index 033d942cb..71a079677 100755 --- a/official/nlp/optimization.py +++ b/official/nlp/optimization.py @@ -16,10 +16,10 @@ import re -from absl import logging import gin import tensorflow as tf import tensorflow_addons.optimizers as tfa_optimizers +from absl import logging class WarmUp(tf.keras.optimizers.schedules.LearningRateSchedule): diff --git a/official/nlp/projects/triviaqa/dataset.py b/official/nlp/projects/triviaqa/dataset.py index 6dc57d29b..2e02b715c 100755 --- a/official/nlp/projects/triviaqa/dataset.py +++ b/official/nlp/projects/triviaqa/dataset.py @@ -16,12 +16,12 @@ import json import os -from absl import logging -import apache_beam as beam import six import tensorflow as tf import tensorflow_datasets.public_api as tfds +from absl import logging +import apache_beam as beam from official.nlp.projects.triviaqa import preprocess _CITATION = """ diff --git a/official/nlp/projects/triviaqa/download_and_prepare.py b/official/nlp/projects/triviaqa/download_and_prepare.py index 2400dee43..0346f178e 100755 --- a/official/nlp/projects/triviaqa/download_and_prepare.py +++ b/official/nlp/projects/triviaqa/download_and_prepare.py @@ -14,13 +14,12 @@ """Downloads and prepares TriviaQA dataset.""" from unittest import mock -from absl import app -from absl import flags -from absl import logging -import apache_beam as beam import tensorflow_datasets as tfds +from absl import app, flags, logging -from official.nlp.projects.triviaqa import dataset # pylint: disable=unused-import +import apache_beam as beam +from official.nlp.projects.triviaqa import \ + dataset # pylint: disable=unused-import flags.DEFINE_integer('sequence_length', 4096, 'Max number of tokens.') diff --git a/official/nlp/projects/triviaqa/evaluate.py b/official/nlp/projects/triviaqa/evaluate.py index b91bd436f..fda843afa 100755 --- a/official/nlp/projects/triviaqa/evaluate.py +++ b/official/nlp/projects/triviaqa/evaluate.py @@ -14,10 +14,8 @@ """Evalutes TriviaQA predictions.""" import json -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +from absl import app, flags, logging from official.nlp.projects.triviaqa import evaluation diff --git a/official/nlp/projects/triviaqa/inputs.py b/official/nlp/projects/triviaqa/inputs.py index 15b9065f5..c4af97cfe 100755 --- a/official/nlp/projects/triviaqa/inputs.py +++ b/official/nlp/projects/triviaqa/inputs.py @@ -20,7 +20,8 @@ import tensorflow_datasets as tfds from official.modeling import tf_utils -from official.nlp.projects.triviaqa import dataset # pylint: disable=unused-import +from official.nlp.projects.triviaqa import \ + dataset # pylint: disable=unused-import def _flatten_dims(tensor: tf.Tensor, diff --git a/official/nlp/projects/triviaqa/predict.py b/official/nlp/projects/triviaqa/predict.py index 844a3103c..8b0b734ba 100755 --- a/official/nlp/projects/triviaqa/predict.py +++ b/official/nlp/projects/triviaqa/predict.py @@ -18,17 +18,13 @@ import json import operator -from absl import app -from absl import flags -from absl import logging +import sentencepiece as spm import tensorflow as tf import tensorflow_datasets as tfds +from absl import app, flags, logging -import sentencepiece as spm from official.nlp.configs import encoders # pylint: disable=unused-import -from official.nlp.projects.triviaqa import evaluation -from official.nlp.projects.triviaqa import inputs -from official.nlp.projects.triviaqa import prediction +from official.nlp.projects.triviaqa import evaluation, inputs, prediction flags.DEFINE_string('data_dir', None, 'TensorFlow Datasets directory.') diff --git a/official/nlp/projects/triviaqa/preprocess.py b/official/nlp/projects/triviaqa/preprocess.py index dfe6c3332..74ca84851 100755 --- a/official/nlp/projects/triviaqa/preprocess.py +++ b/official/nlp/projects/triviaqa/preprocess.py @@ -13,6 +13,7 @@ # limitations under the License. """Utilities for preprocessing TriviaQA data.""" import bisect +import dataclasses import json import operator import os @@ -20,17 +21,15 @@ import string from typing import Any, Dict, Generator, List, Optional, Set, Text, Tuple -from absl import logging -import apache_beam as beam -from apache_beam import metrics -import dataclasses import nltk import numpy as np +import sentencepiece as spm import tensorflow.io.gfile as gfile +from absl import logging -import sentencepiece as spm -from official.nlp.projects.triviaqa import evaluation -from official.nlp.projects.triviaqa import sentencepiece_pb2 +import apache_beam as beam +from apache_beam import metrics +from official.nlp.projects.triviaqa import evaluation, sentencepiece_pb2 @dataclasses.dataclass diff --git a/official/nlp/projects/triviaqa/sentencepiece_pb2.py b/official/nlp/projects/triviaqa/sentencepiece_pb2.py index 8ee94567c..5e53cc2de 100755 --- a/official/nlp/projects/triviaqa/sentencepiece_pb2.py +++ b/official/nlp/projects/triviaqa/sentencepiece_pb2.py @@ -20,6 +20,7 @@ from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import symbol_database as _symbol_database + # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() diff --git a/official/nlp/projects/triviaqa/train.py b/official/nlp/projects/triviaqa/train.py index 35e5f278e..77768cf88 100755 --- a/official/nlp/projects/triviaqa/train.py +++ b/official/nlp/projects/triviaqa/train.py @@ -19,20 +19,16 @@ import operator import os -from absl import app -from absl import flags -from absl import logging import gin +import sentencepiece as spm import tensorflow as tf import tensorflow_datasets as tfds +from absl import app, flags, logging -import sentencepiece as spm from official.nlp import optimization as nlp_optimization from official.nlp.configs import encoders -from official.nlp.projects.triviaqa import evaluation -from official.nlp.projects.triviaqa import inputs -from official.nlp.projects.triviaqa import modeling -from official.nlp.projects.triviaqa import prediction +from official.nlp.projects.triviaqa import (evaluation, inputs, modeling, + prediction) flags.DEFINE_string('data_dir', None, 'Data directory for TensorFlow Datasets.') diff --git a/official/nlp/tasks/electra_task.py b/official/nlp/tasks/electra_task.py index cb8d8d45f..4468d993d 100755 --- a/official/nlp/tasks/electra_task.py +++ b/official/nlp/tasks/electra_task.py @@ -16,18 +16,16 @@ """ELECTRA pretraining task (Joint Masked LM and Replaced Token Detection).""" import dataclasses + import tensorflow as tf from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory from official.modeling import tf_utils -from official.nlp.configs import bert -from official.nlp.configs import electra -from official.nlp.configs import encoders +from official.nlp.configs import bert, electra, encoders from official.nlp.data import pretrain_dataloader -from official.nlp.modeling import layers -from official.nlp.modeling import models +from official.nlp.modeling import layers, models @dataclasses.dataclass diff --git a/official/nlp/tasks/electra_task_test.py b/official/nlp/tasks/electra_task_test.py index 061ee35af..dbb018ab0 100755 --- a/official/nlp/tasks/electra_task_test.py +++ b/official/nlp/tasks/electra_task_test.py @@ -17,9 +17,7 @@ import tensorflow as tf -from official.nlp.configs import bert -from official.nlp.configs import electra -from official.nlp.configs import encoders +from official.nlp.configs import bert, electra, encoders from official.nlp.data import pretrain_dataloader from official.nlp.tasks import electra_task diff --git a/official/nlp/tasks/masked_lm.py b/official/nlp/tasks/masked_lm.py index 44fb43ca2..3fddd38af 100755 --- a/official/nlp/tasks/masked_lm.py +++ b/official/nlp/tasks/masked_lm.py @@ -16,17 +16,16 @@ """Masked language task.""" import dataclasses + import tensorflow as tf from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory from official.modeling import tf_utils -from official.nlp.configs import bert -from official.nlp.configs import encoders +from official.nlp.configs import bert, encoders from official.nlp.data import data_loader_factory -from official.nlp.modeling import layers -from official.nlp.modeling import models +from official.nlp.modeling import layers, models @dataclasses.dataclass diff --git a/official/nlp/tasks/masked_lm_test.py b/official/nlp/tasks/masked_lm_test.py index 937862da2..261c5f65b 100755 --- a/official/nlp/tasks/masked_lm_test.py +++ b/official/nlp/tasks/masked_lm_test.py @@ -17,8 +17,7 @@ import tensorflow as tf -from official.nlp.configs import bert -from official.nlp.configs import encoders +from official.nlp.configs import bert, encoders from official.nlp.data import pretrain_dataloader from official.nlp.tasks import masked_lm diff --git a/official/nlp/tasks/question_answering.py b/official/nlp/tasks/question_answering.py index 698baf820..1502394c3 100755 --- a/official/nlp/tasks/question_answering.py +++ b/official/nlp/tasks/question_answering.py @@ -14,23 +14,22 @@ # limitations under the License. # ============================================================================== """Question answering task.""" +import dataclasses import functools import json import os from typing import List, Optional -from absl import logging -import dataclasses -import orbit import tensorflow as tf +from absl import logging +import orbit from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory from official.modeling.hyperparams import base_config -from official.nlp.bert import squad_evaluate_v1_1 -from official.nlp.bert import squad_evaluate_v2_0 -from official.nlp.bert import tokenization +from official.nlp.bert import (squad_evaluate_v1_1, squad_evaluate_v2_0, + tokenization) from official.nlp.configs import encoders from official.nlp.data import data_loader_factory from official.nlp.data import squad_lib as squad_lib_wp diff --git a/official/nlp/tasks/question_answering_test.py b/official/nlp/tasks/question_answering_test.py index 114149473..556a90359 100755 --- a/official/nlp/tasks/question_answering_test.py +++ b/official/nlp/tasks/question_answering_test.py @@ -18,14 +18,12 @@ import json import os -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized -from official.nlp.configs import bert -from official.nlp.configs import encoders +from official.nlp.configs import bert, encoders from official.nlp.data import question_answering_dataloader -from official.nlp.tasks import masked_lm -from official.nlp.tasks import question_answering +from official.nlp.tasks import masked_lm, question_answering class QuestionAnsweringTaskTest(tf.test.TestCase, parameterized.TestCase): diff --git a/official/nlp/tasks/sentence_prediction.py b/official/nlp/tasks/sentence_prediction.py index 1896b67b1..61500d503 100755 --- a/official/nlp/tasks/sentence_prediction.py +++ b/official/nlp/tasks/sentence_prediction.py @@ -14,16 +14,16 @@ # limitations under the License. # ============================================================================== """Sentence prediction (classification) task.""" -from typing import List, Union, Optional - -from absl import logging import dataclasses +from typing import List, Optional, Union + import numpy as np -import orbit +import tensorflow as tf +from absl import logging from scipy import stats from sklearn import metrics as sklearn_metrics -import tensorflow as tf +import orbit from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory diff --git a/official/nlp/tasks/sentence_prediction_test.py b/official/nlp/tasks/sentence_prediction_test.py index 5341405b6..cb9504ffc 100755 --- a/official/nlp/tasks/sentence_prediction_test.py +++ b/official/nlp/tasks/sentence_prediction_test.py @@ -17,15 +17,13 @@ import functools import os -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized -from official.nlp.configs import bert -from official.nlp.configs import encoders +from official.nlp.configs import bert, encoders from official.nlp.data import sentence_prediction_dataloader -from official.nlp.tasks import masked_lm -from official.nlp.tasks import sentence_prediction +from official.nlp.tasks import masked_lm, sentence_prediction def _create_fake_dataset(output_path, seq_length, num_classes, num_examples): diff --git a/official/nlp/tasks/tagging.py b/official/nlp/tasks/tagging.py index 0ebda401f..106c38493 100755 --- a/official/nlp/tasks/tagging.py +++ b/official/nlp/tasks/tagging.py @@ -14,15 +14,12 @@ # limitations under the License. # ============================================================================== """Tagging (e.g., NER/POS) task.""" -from typing import List, Optional, Tuple - import dataclasses -import orbit - -from seqeval import metrics as seqeval_metrics +from typing import List, Optional, Tuple import tensorflow as tf +import orbit from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory @@ -31,6 +28,7 @@ from official.nlp.data import data_loader_factory from official.nlp.modeling import models from official.nlp.tasks import utils +from seqeval import metrics as seqeval_metrics @dataclasses.dataclass diff --git a/official/nlp/tasks/translation.py b/official/nlp/tasks/translation.py index d09c7b76f..b24fdd115 100755 --- a/official/nlp/tasks/translation.py +++ b/official/nlp/tasks/translation.py @@ -14,15 +14,15 @@ # limitations under the License. # ============================================================================== """Defines the translation task.""" +import dataclasses import os from typing import Optional +import tensorflow as tf from absl import logging -import dataclasses + import sacrebleu -import tensorflow as tf import tensorflow_text as tftxt - from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory diff --git a/official/nlp/tasks/translation_test.py b/official/nlp/tasks/translation_test.py index 0010c0828..20f0a302d 100755 --- a/official/nlp/tasks/translation_test.py +++ b/official/nlp/tasks/translation_test.py @@ -17,10 +17,10 @@ import functools import os -import orbit import tensorflow as tf - from sentencepiece import SentencePieceTrainer + +import orbit from official.nlp.data import wmt_dataloader from official.nlp.tasks import translation diff --git a/official/nlp/tasks/utils.py b/official/nlp/tasks/utils.py index 66228f912..e4ba9226a 100755 --- a/official/nlp/tasks/utils.py +++ b/official/nlp/tasks/utils.py @@ -16,10 +16,11 @@ """Common utils for tasks.""" from typing import Any, Callable -import orbit import tensorflow as tf import tensorflow_hub as hub +import orbit + def get_encoder_from_hub(hub_model_path: str) -> tf.keras.Model: """Gets an encoder from hub. diff --git a/official/nlp/train.py b/official/nlp/train.py index 8bb637b9b..4ddaf613a 100755 --- a/official/nlp/train.py +++ b/official/nlp/train.py @@ -15,18 +15,15 @@ # ============================================================================== """TFM common training driver.""" -from absl import app -from absl import flags import gin +from absl import app, flags -from official.common import distribute_utils -# pylint: disable=unused-import -from official.common import registry_imports # pylint: enable=unused-import +# pylint: disable=unused-import +from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.common import registry_imports +from official.core import task_factory, train_lib, train_utils from official.modeling import performance FLAGS = flags.FLAGS diff --git a/official/nlp/train_ctl_continuous_finetune.py b/official/nlp/train_ctl_continuous_finetune.py index b8af9a7f6..51872276d 100755 --- a/official/nlp/train_ctl_continuous_finetune.py +++ b/official/nlp/train_ctl_continuous_finetune.py @@ -14,14 +14,13 @@ # limitations under the License. # ============================================================================== """TFM continuous finetuning+eval training driver.""" -from absl import app -from absl import flags import gin +from absl import app, flags -# pylint: disable=unused-import -from official.common import registry_imports # pylint: enable=unused-import +# pylint: disable=unused-import from official.common import flags as tfm_flags +from official.common import registry_imports from official.core import train_utils from official.nlp import continuous_finetune_lib diff --git a/official/nlp/transformer/attention_layer.py b/official/nlp/transformer/attention_layer.py index 6581162f5..122a80852 100755 --- a/official/nlp/transformer/attention_layer.py +++ b/official/nlp/transformer/attention_layer.py @@ -16,6 +16,7 @@ import math import tensorflow as tf + from official.nlp.modeling import layers diff --git a/official/nlp/transformer/beam_search_v1.py b/official/nlp/transformer/beam_search_v1.py index 580402589..a2e4e6686 100755 --- a/official/nlp/transformer/beam_search_v1.py +++ b/official/nlp/transformer/beam_search_v1.py @@ -15,6 +15,7 @@ """Beam search to find the translated sequence with the highest probability.""" import tensorflow.compat.v1 as tf + from official.nlp.modeling.ops import beam_search _StateKeys = beam_search._StateKeys # pylint: disable=protected-access diff --git a/official/nlp/transformer/compute_bleu.py b/official/nlp/transformer/compute_bleu.py index 46ee23dfd..558f1bb7b 100755 --- a/official/nlp/transformer/compute_bleu.py +++ b/official/nlp/transformer/compute_bleu.py @@ -22,14 +22,12 @@ import sys import unicodedata -from absl import app -from absl import flags import six -from six.moves import range import tensorflow as tf +from absl import app, flags +from six.moves import range -from official.nlp.transformer.utils import metrics -from official.nlp.transformer.utils import tokenizer +from official.nlp.transformer.utils import metrics, tokenizer from official.utils.flags import core as flags_core diff --git a/official/nlp/transformer/data_download.py b/official/nlp/transformer/data_download.py index e3ce7fceb..9142a1f22 100755 --- a/official/nlp/transformer/data_download.py +++ b/official/nlp/transformer/data_download.py @@ -18,19 +18,17 @@ import random import tarfile -# pylint: disable=g-bad-import-order - -from absl import app -from absl import flags -from absl import logging import six -from six.moves import range -from six.moves import urllib -from six.moves import zip import tensorflow.compat.v1 as tf +from absl import app, flags, logging +from six.moves import range, urllib, zip from official.nlp.transformer.utils import tokenizer from official.utils.flags import core as flags_core + +# pylint: disable=g-bad-import-order + + # pylint: enable=g-bad-import-order # Data sources for training/evaluating the transformer translation model. diff --git a/official/nlp/transformer/data_pipeline.py b/official/nlp/transformer/data_pipeline.py index 684615cb2..751fb32cf 100755 --- a/official/nlp/transformer/data_pipeline.py +++ b/official/nlp/transformer/data_pipeline.py @@ -49,8 +49,8 @@ import os -from absl import logging import tensorflow as tf +from absl import logging from official.utils.misc import model_helpers diff --git a/official/nlp/transformer/misc.py b/official/nlp/transformer/misc.py index 424fd000d..7e47d982e 100755 --- a/official/nlp/transformer/misc.py +++ b/official/nlp/transformer/misc.py @@ -16,8 +16,8 @@ # pylint: disable=g-bad-import-order -from absl import flags import tensorflow as tf +from absl import flags from official.nlp.transformer import model_params from official.utils.flags import core as flags_core diff --git a/official/nlp/transformer/model_params.py b/official/nlp/transformer/model_params.py index e978abeaf..b4eecdea6 100755 --- a/official/nlp/transformer/model_params.py +++ b/official/nlp/transformer/model_params.py @@ -16,7 +16,6 @@ from collections import defaultdict - BASE_PARAMS = defaultdict( lambda: None, # Set default value to None. diff --git a/official/nlp/transformer/transformer.py b/official/nlp/transformer/transformer.py index c5e167a2b..077ba5966 100755 --- a/official/nlp/transformer/transformer.py +++ b/official/nlp/transformer/transformer.py @@ -19,13 +19,11 @@ """ import tensorflow as tf + from official.nlp.modeling.layers import position_embedding from official.nlp.modeling.ops import beam_search -from official.nlp.transformer import attention_layer -from official.nlp.transformer import embedding_layer -from official.nlp.transformer import ffn_layer -from official.nlp.transformer import metrics -from official.nlp.transformer import model_utils +from official.nlp.transformer import (attention_layer, embedding_layer, + ffn_layer, metrics, model_utils) from official.nlp.transformer.utils.tokenizer import EOS_ID # Disable the not-callable lint error, since it claims many objects are not diff --git a/official/nlp/transformer/transformer_forward_test.py b/official/nlp/transformer/transformer_forward_test.py index 5f76f948d..9c217e248 100755 --- a/official/nlp/transformer/transformer_forward_test.py +++ b/official/nlp/transformer/transformer_forward_test.py @@ -15,13 +15,10 @@ """Forward pass test for Transformer model refactoring.""" import numpy as np - import tensorflow as tf from official.nlp.modeling import models -from official.nlp.transformer import metrics -from official.nlp.transformer import model_params -from official.nlp.transformer import transformer +from official.nlp.transformer import metrics, model_params, transformer def _count_params(layer, trainable_only=True): diff --git a/official/nlp/transformer/transformer_layers_test.py b/official/nlp/transformer/transformer_layers_test.py index ac64c545b..a02f085e5 100755 --- a/official/nlp/transformer/transformer_layers_test.py +++ b/official/nlp/transformer/transformer_layers_test.py @@ -16,10 +16,8 @@ import tensorflow as tf -from official.nlp.transformer import attention_layer -from official.nlp.transformer import embedding_layer -from official.nlp.transformer import ffn_layer -from official.nlp.transformer import metrics +from official.nlp.transformer import (attention_layer, embedding_layer, + ffn_layer, metrics) class TransformerLayersTest(tf.test.TestCase): diff --git a/official/nlp/transformer/transformer_main.py b/official/nlp/transformer/transformer_main.py index 6b368a868..48e66b6cd 100755 --- a/official/nlp/transformer/transformer_main.py +++ b/official/nlp/transformer/transformer_main.py @@ -21,20 +21,14 @@ import os import tempfile -# Import libraries -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.modeling import performance -from official.nlp.transformer import compute_bleu -from official.nlp.transformer import data_pipeline -from official.nlp.transformer import metrics -from official.nlp.transformer import misc -from official.nlp.transformer import optimizer -from official.nlp.transformer import transformer -from official.nlp.transformer import translate +from official.nlp.transformer import (compute_bleu, data_pipeline, metrics, + misc, optimizer, transformer, translate) from official.nlp.transformer.utils import tokenizer from official.utils.flags import core as flags_core from official.utils.misc import keras_utils diff --git a/official/nlp/transformer/transformer_main_test.py b/official/nlp/transformer/transformer_main_test.py index d85549e08..16d23f0a1 100755 --- a/official/nlp/transformer/transformer_main_test.py +++ b/official/nlp/transformer/transformer_main_test.py @@ -19,12 +19,13 @@ import sys import unittest +import tensorflow as tf from absl import flags from absl.testing import flagsaver -import tensorflow as tf -from tensorflow.python.eager import context # pylint: disable=ungrouped-imports -from official.nlp.transformer import misc -from official.nlp.transformer import transformer_main +from tensorflow.python.eager import \ + context # pylint: disable=ungrouped-imports + +from official.nlp.transformer import misc, transformer_main from official.utils.misc import keras_utils FLAGS = flags.FLAGS diff --git a/official/nlp/transformer/transformer_test.py b/official/nlp/transformer/transformer_test.py index 3068c9f73..79afcf092 100755 --- a/official/nlp/transformer/transformer_test.py +++ b/official/nlp/transformer/transformer_test.py @@ -16,8 +16,7 @@ import tensorflow as tf -from official.nlp.transformer import model_params -from official.nlp.transformer import transformer +from official.nlp.transformer import model_params, transformer class TransformerV2Test(tf.test.TestCase): diff --git a/official/nlp/transformer/translate.py b/official/nlp/transformer/translate.py index 68ef6bc14..fd2bcb250 100755 --- a/official/nlp/transformer/translate.py +++ b/official/nlp/transformer/translate.py @@ -14,10 +14,10 @@ # ============================================================================== """Translate text or files using trained transformer model.""" -# Import libraries -from absl import logging import numpy as np import tensorflow as tf +# Import libraries +from absl import logging from official.nlp.transformer.utils import tokenizer diff --git a/official/nlp/transformer/utils/metrics.py b/official/nlp/transformer/utils/metrics.py index 6b8d1f7d2..1f97fbe04 100755 --- a/official/nlp/transformer/utils/metrics.py +++ b/official/nlp/transformer/utils/metrics.py @@ -23,17 +23,15 @@ https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/rouge.py """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import collections import math import numpy as np import six -from six.moves import xrange # pylint: disable=redefined-builtin import tensorflow.compat.v1 as tf +from six.moves import xrange # pylint: disable=redefined-builtin def _pad_tensors_to_same_length(x, y): diff --git a/official/nlp/transformer/utils/tokenizer.py b/official/nlp/transformer/utils/tokenizer.py index 0520c2e9f..f062d5b1c 100755 --- a/official/nlp/transformer/utils/tokenizer.py +++ b/official/nlp/transformer/utils/tokenizer.py @@ -14,21 +14,18 @@ # ============================================================================== """Defines Subtokenizer class to encode and decode strings.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import collections import re import sys import unicodedata -from absl import logging - import numpy as np import six -from six.moves import xrange # pylint: disable=redefined-builtin import tensorflow as tf +from absl import logging +from six.moves import xrange # pylint: disable=redefined-builtin # pylint: disable=g-complex-comprehension PAD = "" diff --git a/official/nlp/xlnet/__init__.py b/official/nlp/xlnet/__init__.py index 8b1378917..e69de29bb 100755 --- a/official/nlp/xlnet/__init__.py +++ b/official/nlp/xlnet/__init__.py @@ -1 +0,0 @@ - diff --git a/official/nlp/xlnet/data_utils.py b/official/nlp/xlnet/data_utils.py index ec3b1ff5c..f8e8b34a5 100755 --- a/official/nlp/xlnet/data_utils.py +++ b/official/nlp/xlnet/data_utils.py @@ -18,10 +18,9 @@ import json import os -from absl import logging - import numpy as np import tensorflow as tf +from absl import logging special_symbols = { "": 0, diff --git a/official/nlp/xlnet/optimization.py b/official/nlp/xlnet/optimization.py index aff1304c6..b082cc4d0 100755 --- a/official/nlp/xlnet/optimization.py +++ b/official/nlp/xlnet/optimization.py @@ -14,8 +14,9 @@ # ============================================================================== """Functions and classes related to optimization (weight updates).""" -from absl import logging import tensorflow as tf +from absl import logging + from official.nlp import optimization diff --git a/official/nlp/xlnet/preprocess_classification_data.py b/official/nlp/xlnet/preprocess_classification_data.py index b6cbf3057..f65fa9677 100755 --- a/official/nlp/xlnet/preprocess_classification_data.py +++ b/official/nlp/xlnet/preprocess_classification_data.py @@ -18,17 +18,13 @@ import csv import os -# Import libraries -from absl import app -from absl import flags -from absl import logging import numpy as np -import tensorflow as tf - import sentencepiece as spm -from official.nlp.xlnet import classifier_utils -from official.nlp.xlnet import preprocess_utils +import tensorflow as tf +# Import libraries +from absl import app, flags, logging +from official.nlp.xlnet import classifier_utils, preprocess_utils flags.DEFINE_bool( "overwrite_data", diff --git a/official/nlp/xlnet/preprocess_pretrain_data.py b/official/nlp/xlnet/preprocess_pretrain_data.py index a9b096eb2..13fffb3fb 100755 --- a/official/nlp/xlnet/preprocess_pretrain_data.py +++ b/official/nlp/xlnet/preprocess_pretrain_data.py @@ -19,18 +19,14 @@ import os import random -# Import libraries -from absl import app -from absl import flags import absl.logging as _logging # pylint: disable=unused-import - import numpy as np - - -import tensorflow.google as tf -from official.nlp.xlnet import preprocess_utils import sentencepiece as spm +import tensorflow.google as tf +# Import libraries +from absl import app, flags +from official.nlp.xlnet import preprocess_utils special_symbols = { "" : 0, diff --git a/official/nlp/xlnet/preprocess_squad_data.py b/official/nlp/xlnet/preprocess_squad_data.py index 18f1bb316..4759819c6 100755 --- a/official/nlp/xlnet/preprocess_squad_data.py +++ b/official/nlp/xlnet/preprocess_squad_data.py @@ -18,13 +18,11 @@ import os import random -# Import libraries -from absl import app -from absl import flags -from absl import logging +import sentencepiece as spm import tensorflow as tf +# Import libraries +from absl import app, flags, logging -import sentencepiece as spm from official.nlp.xlnet import squad_utils flags.DEFINE_integer( diff --git a/official/nlp/xlnet/run_classifier.py b/official/nlp/xlnet/run_classifier.py index 0e878430d..65b06b086 100755 --- a/official/nlp/xlnet/run_classifier.py +++ b/official/nlp/xlnet/run_classifier.py @@ -15,20 +15,16 @@ """XLNet classification finetuning runner in tf2.0.""" import functools -# Import libraries -from absl import app -from absl import flags -from absl import logging import numpy as np import tensorflow as tf +# Import libraries +from absl import app, flags, logging + # pylint: disable=unused-import from official.common import distribute_utils -from official.nlp.xlnet import common_flags -from official.nlp.xlnet import data_utils -from official.nlp.xlnet import optimization -from official.nlp.xlnet import training_utils -from official.nlp.xlnet import xlnet_config +from official.nlp.xlnet import (common_flags, data_utils, optimization, + training_utils, xlnet_config) from official.nlp.xlnet import xlnet_modeling as modeling flags.DEFINE_integer("n_class", default=2, help="Number of classes.") diff --git a/official/nlp/xlnet/run_pretrain.py b/official/nlp/xlnet/run_pretrain.py index 68710ba9b..1f017863c 100755 --- a/official/nlp/xlnet/run_pretrain.py +++ b/official/nlp/xlnet/run_pretrain.py @@ -17,18 +17,14 @@ import functools import os -# Import libraries -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +# Import libraries +from absl import app, flags, logging + # pylint: disable=unused-import from official.common import distribute_utils -from official.nlp.xlnet import common_flags -from official.nlp.xlnet import data_utils -from official.nlp.xlnet import optimization -from official.nlp.xlnet import training_utils -from official.nlp.xlnet import xlnet_config +from official.nlp.xlnet import (common_flags, data_utils, optimization, + training_utils, xlnet_config) from official.nlp.xlnet import xlnet_modeling as modeling flags.DEFINE_integer( diff --git a/official/nlp/xlnet/run_squad.py b/official/nlp/xlnet/run_squad.py index be3a27079..066215f0a 100755 --- a/official/nlp/xlnet/run_squad.py +++ b/official/nlp/xlnet/run_squad.py @@ -19,21 +19,15 @@ import os import pickle -# Import libraries -from absl import app -from absl import flags -from absl import logging - -import tensorflow as tf # pylint: disable=unused-import import sentencepiece as spm +import tensorflow as tf +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils -from official.nlp.xlnet import common_flags -from official.nlp.xlnet import data_utils -from official.nlp.xlnet import optimization -from official.nlp.xlnet import squad_utils -from official.nlp.xlnet import training_utils -from official.nlp.xlnet import xlnet_config +from official.nlp.xlnet import (common_flags, data_utils, optimization, + squad_utils, training_utils, xlnet_config) from official.nlp.xlnet import xlnet_modeling as modeling flags.DEFINE_string( diff --git a/official/nlp/xlnet/squad_utils.py b/official/nlp/xlnet/squad_utils.py index efab6da6f..089c19619 100755 --- a/official/nlp/xlnet/squad_utils.py +++ b/official/nlp/xlnet/squad_utils.py @@ -14,10 +14,8 @@ # ============================================================================== # coding=utf-8 """Utilities used in SQUAD task.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import collections import gc @@ -28,13 +26,12 @@ import re import string -from absl import logging import numpy as np import six import tensorflow as tf +from absl import logging -from official.nlp.xlnet import data_utils -from official.nlp.xlnet import preprocess_utils +from official.nlp.xlnet import data_utils, preprocess_utils SPIECE_UNDERLINE = u"▁" diff --git a/official/nlp/xlnet/training_utils.py b/official/nlp/xlnet/training_utils.py index be6476fd8..ab465c0e6 100755 --- a/official/nlp/xlnet/training_utils.py +++ b/official/nlp/xlnet/training_utils.py @@ -16,13 +16,12 @@ import os import re - -from absl import logging +from typing import Any, Callable, Dict, Optional, Text # pytype: disable=attribute-error # pylint: disable=g-bare-generic,unused-import import tensorflow as tf -from typing import Any, Callable, Dict, Text, Optional +from absl import logging from official.nlp.bert import model_training_utils from official.nlp.xlnet import data_utils diff --git a/official/pip_package/setup.py b/official/pip_package/setup.py index 6d24d5ce2..d77f9c1d9 100755 --- a/official/pip_package/setup.py +++ b/official/pip_package/setup.py @@ -17,8 +17,7 @@ import os import sys -from setuptools import find_packages -from setuptools import setup +from setuptools import find_packages, setup version = '2.4.0' diff --git a/official/recommendation/create_ncf_data.py b/official/recommendation/create_ncf_data.py index 27c2edbb9..af54f5329 100755 --- a/official/recommendation/create_ncf_data.py +++ b/official/recommendation/create_ncf_data.py @@ -16,15 +16,15 @@ import json +import tensorflow as tf # pylint: disable=g-bad-import-order # Import libraries -from absl import app -from absl import flags -import tensorflow as tf +from absl import app, flags + +from official.recommendation import data_preprocessing, movielens + # pylint: enable=g-bad-import-order -from official.recommendation import movielens -from official.recommendation import data_preprocessing flags.DEFINE_string( "data_dir", None, diff --git a/official/recommendation/data_pipeline.py b/official/recommendation/data_pipeline.py index 9cb0bf9e2..32fa61ea7 100755 --- a/official/recommendation/data_pipeline.py +++ b/official/recommendation/data_pipeline.py @@ -14,9 +14,7 @@ # ============================================================================== """Asynchronous data producer for the NCF pipeline.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import atexit import functools @@ -31,15 +29,13 @@ import numpy as np import six -from six.moves import queue import tensorflow as tf from absl import logging +from six.moves import queue +from tensorflow.python.tpu.datasets import StreamingFilesDataset from official.recommendation import constants as rconst -from official.recommendation import movielens -from official.recommendation import popen_helper -from official.recommendation import stat_utils -from tensorflow.python.tpu.datasets import StreamingFilesDataset +from official.recommendation import movielens, popen_helper, stat_utils SUMMARY_TEMPLATE = """General: {spacer}Num users: {num_users} diff --git a/official/recommendation/data_preprocessing.py b/official/recommendation/data_preprocessing.py index 4fc510ba2..184f07257 100755 --- a/official/recommendation/data_preprocessing.py +++ b/official/recommendation/data_preprocessing.py @@ -14,29 +14,28 @@ # ============================================================================== """Preprocess dataset and construct any necessary artifacts.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os import pickle import time import timeit +import typing +from typing import Dict, Text, Tuple -# pylint: disable=wrong-import-order - -from absl import logging import numpy as np import pandas as pd import tensorflow as tf -import typing -from typing import Dict, Text, Tuple -# pylint: enable=wrong-import-order +from absl import logging from official.recommendation import constants as rconst -from official.recommendation import data_pipeline -from official.recommendation import movielens +from official.recommendation import data_pipeline, movielens + +# pylint: disable=wrong-import-order + +# pylint: enable=wrong-import-order + _EXPECTED_CACHE_KEYS = (rconst.TRAIN_USER_KEY, rconst.TRAIN_ITEM_KEY, rconst.EVAL_USER_KEY, rconst.EVAL_ITEM_KEY, diff --git a/official/recommendation/data_test.py b/official/recommendation/data_test.py index 603e12732..c868992a1 100755 --- a/official/recommendation/data_test.py +++ b/official/recommendation/data_test.py @@ -14,24 +14,19 @@ # ============================================================================== """Test NCF data pipeline.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from collections import defaultdict import hashlib import os - -import mock +from collections import defaultdict import numpy as np import scipy.stats import tensorflow as tf +import mock from official.recommendation import constants as rconst -from official.recommendation import data_preprocessing -from official.recommendation import movielens -from official.recommendation import popen_helper +from official.recommendation import data_preprocessing, movielens, popen_helper DATASET = "ml-test" NUM_USERS = 1000 diff --git a/official/recommendation/movielens.py b/official/recommendation/movielens.py index f14fc6c6a..7f63fa519 100755 --- a/official/recommendation/movielens.py +++ b/official/recommendation/movielens.py @@ -17,9 +17,7 @@ Download the dataset, and perform basic preprocessing. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os import sys @@ -31,15 +29,15 @@ import numpy as np import pandas as pd import six -from six.moves import urllib # pylint: disable=redefined-builtin -from absl import app -from absl import flags -from absl import logging import tensorflow as tf -# pylint: enable=g-bad-import-order +from absl import app, flags, logging +from six.moves import urllib # pylint: disable=redefined-builtin from official.utils.flags import core as flags_core +# pylint: enable=g-bad-import-order + + ML_1M = "ml-1m" ML_20M = "ml-20m" diff --git a/official/recommendation/ncf_common.py b/official/recommendation/ncf_common.py index bb9406330..747ab3d02 100755 --- a/official/recommendation/ncf_common.py +++ b/official/recommendation/ncf_common.py @@ -14,23 +14,19 @@ # ============================================================================== """Common functionalities used by both Keras and Estimator implementations.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import json import os -from absl import flags -from absl import logging import numpy as np import tensorflow as tf +from absl import flags, logging from official.common import distribute_utils from official.recommendation import constants as rconst -from official.recommendation import data_pipeline -from official.recommendation import data_preprocessing -from official.recommendation import movielens +from official.recommendation import (data_pipeline, data_preprocessing, + movielens) from official.utils.flags import core as flags_core from official.utils.misc import keras_utils diff --git a/official/recommendation/ncf_input_pipeline.py b/official/recommendation/ncf_input_pipeline.py index 5d092f0c7..ab57aa58a 100755 --- a/official/recommendation/ncf_input_pipeline.py +++ b/official/recommendation/ncf_input_pipeline.py @@ -18,11 +18,12 @@ # pylint: disable=g-bad-import-order import tensorflow as tf -# pylint: enable=g-bad-import-order from official.recommendation import constants as rconst -from official.recommendation import data_pipeline -from official.recommendation import movielens +from official.recommendation import data_pipeline, movielens + +# pylint: enable=g-bad-import-order + def create_dataset_from_tf_record_files(input_file_pattern, diff --git a/official/recommendation/ncf_keras_main.py b/official/recommendation/ncf_keras_main.py index 808082bcd..390d8432c 100755 --- a/official/recommendation/ncf_keras_main.py +++ b/official/recommendation/ncf_keras_main.py @@ -21,23 +21,20 @@ import json import os -# pylint: disable=g-bad-import-order - -from absl import app -from absl import flags -from absl import logging import tensorflow as tf -# pylint: enable=g-bad-import-order +from absl import app, flags, logging from official.common import distribute_utils from official.recommendation import constants as rconst -from official.recommendation import movielens -from official.recommendation import ncf_common -from official.recommendation import ncf_input_pipeline -from official.recommendation import neumf_model +from official.recommendation import ( + movielens, ncf_common, ncf_input_pipeline, neumf_model) from official.utils.flags import core as flags_core -from official.utils.misc import keras_utils -from official.utils.misc import model_helpers +from official.utils.misc import keras_utils, model_helpers + +# pylint: disable=g-bad-import-order + +# pylint: enable=g-bad-import-order + FLAGS = flags.FLAGS diff --git a/official/recommendation/ncf_test.py b/official/recommendation/ncf_test.py index 90e92bd41..ed8e7b171 100755 --- a/official/recommendation/ncf_test.py +++ b/official/recommendation/ncf_test.py @@ -14,17 +14,16 @@ # ============================================================================== """Tests NCF.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import unittest import tensorflow as tf -from tensorflow.python.eager import context # pylint: disable=ungrouped-imports +from tensorflow.python.eager import \ + context # pylint: disable=ungrouped-imports + from official.recommendation import constants as rconst -from official.recommendation import ncf_common -from official.recommendation import ncf_keras_main +from official.recommendation import ncf_common, ncf_keras_main from official.utils.testing import integration NUM_TRAIN_NEG = 4 diff --git a/official/recommendation/neumf_model.py b/official/recommendation/neumf_model.py index 546c46907..1bc88401a 100755 --- a/official/recommendation/neumf_model.py +++ b/official/recommendation/neumf_model.py @@ -29,21 +29,17 @@ In NeuMF model, it allows GMF and MLP to learn separate embeddings, and combine the two models by concatenating their last hidden layer. """ -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import sys +from typing import Any, Dict, Text -from six.moves import xrange # pylint: disable=redefined-builtin import tensorflow as tf -from typing import Any, Dict, Text +from six.moves import xrange # pylint: disable=redefined-builtin from official.recommendation import constants as rconst -from official.recommendation import movielens -from official.recommendation import ncf_common -from official.recommendation import stat_utils +from official.recommendation import movielens, ncf_common, stat_utils def sparse_to_dense_grads(grads_and_vars): diff --git a/official/recommendation/stat_utils.py b/official/recommendation/stat_utils.py index 526db0fbb..b51744f49 100755 --- a/official/recommendation/stat_utils.py +++ b/official/recommendation/stat_utils.py @@ -14,9 +14,7 @@ # ============================================================================== """Statistics utility functions of NCF.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os diff --git a/official/staging/training/grad_utils.py b/official/staging/training/grad_utils.py index 004ee275d..17c57b9a3 100755 --- a/official/staging/training/grad_utils.py +++ b/official/staging/training/grad_utils.py @@ -14,9 +14,8 @@ # ============================================================================== """Some gradient util functions to help users writing custom training loop.""" -from absl import logging - import tensorflow as tf +from absl import logging def _filter_grads(grads_and_vars): diff --git a/official/utils/docs/build_docs.py b/official/utils/docs/build_docs.py index 904052b26..f1e9c710f 100755 --- a/official/utils/docs/build_docs.py +++ b/official/utils/docs/build_docs.py @@ -26,16 +26,12 @@ import os -from absl import app -from absl import flags -from absl import logging - import tensorflow as tf -from tensorflow_docs.api_generator import doc_controls -from tensorflow_docs.api_generator import generate_lib -from tensorflow_docs.api_generator import public_api +from absl import app, flags, logging from official.nlp import modeling as tfnlp +from tensorflow_docs.api_generator import (doc_controls, generate_lib, + public_api) FLAGS = flags.FLAGS diff --git a/official/utils/flags/_base.py b/official/utils/flags/_base.py index cbe7c1ec2..73959550d 100755 --- a/official/utils/flags/_base.py +++ b/official/utils/flags/_base.py @@ -14,12 +14,11 @@ # ============================================================================== """Flags which will be nearly universal across models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl import flags import tensorflow as tf +from absl import flags + from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/_benchmark.py b/official/utils/flags/_benchmark.py index acaec19a8..b8a545c85 100755 --- a/official/utils/flags/_benchmark.py +++ b/official/utils/flags/_benchmark.py @@ -14,9 +14,7 @@ # ============================================================================== """Flags for benchmarking models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function from absl import flags diff --git a/official/utils/flags/_conventions.py b/official/utils/flags/_conventions.py index b6f248b44..db271264a 100755 --- a/official/utils/flags/_conventions.py +++ b/official/utils/flags/_conventions.py @@ -14,13 +14,11 @@ # ============================================================================== """Central location for shared argparse convention definitions.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -import sys import codecs import functools +import sys from absl import app as absl_app from absl import flags diff --git a/official/utils/flags/_device.py b/official/utils/flags/_device.py index 2ac2c859e..5ac6d6819 100755 --- a/official/utils/flags/_device.py +++ b/official/utils/flags/_device.py @@ -14,12 +14,9 @@ # ============================================================================== """Flags for managing compute devices. Currently only contains TPU flags.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl import flags -from absl import logging +from absl import flags, logging from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/_distribution.py b/official/utils/flags/_distribution.py index 04edecb48..3a6510ce5 100755 --- a/official/utils/flags/_distribution.py +++ b/official/utils/flags/_distribution.py @@ -14,12 +14,10 @@ # ============================================================================== """Flags related to distributed execution.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl import flags import tensorflow as tf +from absl import flags from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/_misc.py b/official/utils/flags/_misc.py index b8b88f873..a426d09af 100755 --- a/official/utils/flags/_misc.py +++ b/official/utils/flags/_misc.py @@ -14,9 +14,7 @@ # ============================================================================== """Misc flags.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function from absl import flags diff --git a/official/utils/flags/_performance.py b/official/utils/flags/_performance.py index 99b0b572b..4b0dfdd19 100755 --- a/official/utils/flags/_performance.py +++ b/official/utils/flags/_performance.py @@ -14,14 +14,12 @@ # ============================================================================== """Register flags for optimizing performance.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import multiprocessing -from absl import flags # pylint: disable=g-bad-import-order import tensorflow as tf # pylint: disable=g-bad-import-order +from absl import flags # pylint: disable=g-bad-import-order from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/core.py b/official/utils/flags/core.py index d6eebbd76..46608d15f 100755 --- a/official/utils/flags/core.py +++ b/official/utils/flags/core.py @@ -17,24 +17,16 @@ See _example.py for detailed instructions on defining flags. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import sys -from six.moves import shlex_quote - from absl import app as absl_app from absl import flags +from six.moves import shlex_quote -from official.utils.flags import _base -from official.utils.flags import _benchmark -from official.utils.flags import _conventions -from official.utils.flags import _device -from official.utils.flags import _distribution -from official.utils.flags import _misc -from official.utils.flags import _performance +from official.utils.flags import (_base, _benchmark, _conventions, _device, + _distribution, _misc, _performance) def set_defaults(**kwargs): diff --git a/official/utils/flags/flags_test.py b/official/utils/flags/flags_test.py index 64fc2f9eb..ef0766022 100755 --- a/official/utils/flags/flags_test.py +++ b/official/utils/flags/flags_test.py @@ -15,8 +15,8 @@ import unittest -from absl import flags import tensorflow as tf +from absl import flags from official.utils.flags import core as flags_core # pylint: disable=g-bad-import-order diff --git a/official/utils/hyperparams_flags.py b/official/utils/hyperparams_flags.py index 4b8150677..3c5a0d76b 100755 --- a/official/utils/hyperparams_flags.py +++ b/official/utils/hyperparams_flags.py @@ -14,12 +14,11 @@ # ============================================================================== """Common flags for importing hyperparameters.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function from absl import flags + from official.utils.flags import core as flags_core FLAGS = flags.FLAGS diff --git a/official/utils/misc/distribution_utils.py b/official/utils/misc/distribution_utils.py index 92e540c18..77b9152ce 100755 --- a/official/utils/misc/distribution_utils.py +++ b/official/utils/misc/distribution_utils.py @@ -13,5 +13,4 @@ # limitations under the License. # ============================================================================== """Helper functions for running models in a distributed setting.""" -# pylint: disable=wildcard-import from official.common.distribute_utils import * diff --git a/official/utils/misc/keras_utils.py b/official/utils/misc/keras_utils.py index 6a4227486..087ca4536 100755 --- a/official/utils/misc/keras_utils.py +++ b/official/utils/misc/keras_utils.py @@ -18,9 +18,8 @@ import os import time -from absl import logging import tensorflow as tf - +from absl import logging from tensorflow.python.eager import monitoring global_batch_size_gauge = monitoring.IntGauge( diff --git a/official/utils/misc/model_helpers.py b/official/utils/misc/model_helpers.py index ae5ab4bb3..6eaed3098 100755 --- a/official/utils/misc/model_helpers.py +++ b/official/utils/misc/model_helpers.py @@ -14,16 +14,14 @@ # ============================================================================== """Miscellaneous functions that can be called by models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import numbers -from absl import logging import tensorflow as tf - +from absl import logging from tensorflow.python.util import nest + # pylint:disable=logging-format-interpolation diff --git a/official/utils/misc/model_helpers_test.py b/official/utils/misc/model_helpers_test.py index 388243301..dc2f54c0e 100755 --- a/official/utils/misc/model_helpers_test.py +++ b/official/utils/misc/model_helpers_test.py @@ -14,9 +14,7 @@ # ============================================================================== """Tests for Model Helper functions.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf # pylint: disable=g-bad-import-order diff --git a/official/utils/testing/integration.py b/official/utils/testing/integration.py index fde2a3332..b70cc4a49 100755 --- a/official/utils/testing/integration.py +++ b/official/utils/testing/integration.py @@ -14,9 +14,7 @@ # ============================================================================== """Helper code to run complete models from within python.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os import shutil diff --git a/official/utils/testing/mock_task.py b/official/utils/testing/mock_task.py index 17bf16043..0400cedf4 100755 --- a/official/utils/testing/mock_task.py +++ b/official/utils/testing/mock_task.py @@ -16,13 +16,13 @@ """Mock task for testing.""" import dataclasses + import numpy as np import tensorflow as tf from official.core import base_task from official.core import config_definitions as cfg -from official.core import exp_factory -from official.core import task_factory +from official.core import exp_factory, task_factory class MockModel(tf.keras.Model): diff --git a/official/vision/beta/__init__.py b/official/vision/beta/__init__.py index 146a44e28..f371adaf2 100755 --- a/official/vision/beta/__init__.py +++ b/official/vision/beta/__init__.py @@ -15,5 +15,4 @@ """Vision package definition.""" # Lint as: python3 # pylint: disable=unused-import -from official.vision.beta import configs -from official.vision.beta import tasks +from official.vision.beta import configs, tasks diff --git a/official/vision/beta/configs/__init__.py b/official/vision/beta/configs/__init__.py index 091beea62..b579f181a 100755 --- a/official/vision/beta/configs/__init__.py +++ b/official/vision/beta/configs/__init__.py @@ -15,8 +15,6 @@ # ============================================================================== """Configs package definition.""" -from official.vision.beta.configs import image_classification -from official.vision.beta.configs import maskrcnn -from official.vision.beta.configs import retinanet -from official.vision.beta.configs import semantic_segmentation -from official.vision.beta.configs import video_classification +from official.vision.beta.configs import (image_classification, maskrcnn, + retinanet, semantic_segmentation, + video_classification) diff --git a/official/vision/beta/configs/backbones.py b/official/vision/beta/configs/backbones.py index 93740818d..70b3a2e64 100755 --- a/official/vision/beta/configs/backbones.py +++ b/official/vision/beta/configs/backbones.py @@ -14,10 +14,9 @@ # limitations under the License. # ============================================================================== """Backbones configurations.""" -from typing import Optional, List - # Import libraries import dataclasses +from typing import List, Optional from official.modeling import hyperparams diff --git a/official/vision/beta/configs/backbones_3d.py b/official/vision/beta/configs/backbones_3d.py index 37d01d4b7..f41dd6f45 100755 --- a/official/vision/beta/configs/backbones_3d.py +++ b/official/vision/beta/configs/backbones_3d.py @@ -14,10 +14,9 @@ # limitations under the License. # ============================================================================== """3D Backbones configurations.""" -from typing import Optional, Tuple - # Import libraries import dataclasses +from typing import Optional, Tuple from official.modeling import hyperparams diff --git a/official/vision/beta/configs/decoders.py b/official/vision/beta/configs/decoders.py index ec974f48e..08fb36bf6 100755 --- a/official/vision/beta/configs/decoders.py +++ b/official/vision/beta/configs/decoders.py @@ -14,10 +14,9 @@ # limitations under the License. # ============================================================================== """Decoders configurations.""" -from typing import Optional, List - # Import libraries import dataclasses +from typing import List, Optional from official.modeling import hyperparams diff --git a/official/vision/beta/configs/image_classification.py b/official/vision/beta/configs/image_classification.py index baa456cc5..bfaab9a60 100755 --- a/official/vision/beta/configs/image_classification.py +++ b/official/vision/beta/configs/image_classification.py @@ -14,15 +14,14 @@ # limitations under the License. # ============================================================================== """Image classification configuration definition.""" +import dataclasses import os from typing import List, Optional -import dataclasses + from official.core import config_definitions as cfg from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization -from official.vision.beta.configs import backbones -from official.vision.beta.configs import common +from official.modeling import hyperparams, optimization +from official.vision.beta.configs import backbones, common @dataclasses.dataclass diff --git a/official/vision/beta/configs/image_classification_test.py b/official/vision/beta/configs/image_classification_test.py index 8ad55d124..c5bc236b7 100755 --- a/official/vision/beta/configs/image_classification_test.py +++ b/official/vision/beta/configs/image_classification_test.py @@ -14,9 +14,9 @@ # limitations under the License. # ============================================================================== """Tests for image_classification.""" +import tensorflow as tf # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/vision/beta/configs/maskrcnn.py b/official/vision/beta/configs/maskrcnn.py index a1ec46c1f..d70a9920c 100755 --- a/official/vision/beta/configs/maskrcnn.py +++ b/official/vision/beta/configs/maskrcnn.py @@ -15,16 +15,14 @@ # ============================================================================== """Mask R-CNN configuration definition.""" +import dataclasses import os from typing import List, Optional -import dataclasses + from official.core import config_definitions as cfg from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization -from official.vision.beta.configs import backbones -from official.vision.beta.configs import common -from official.vision.beta.configs import decoders +from official.modeling import hyperparams, optimization +from official.vision.beta.configs import backbones, common, decoders # pylint: disable=missing-class-docstring diff --git a/official/vision/beta/configs/retinanet.py b/official/vision/beta/configs/retinanet.py index df27b202b..e117d5ac7 100755 --- a/official/vision/beta/configs/retinanet.py +++ b/official/vision/beta/configs/retinanet.py @@ -15,16 +15,14 @@ # ============================================================================== """RetinaNet configuration definition.""" +import dataclasses import os from typing import List, Optional -import dataclasses + from official.core import config_definitions as cfg from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization -from official.vision.beta.configs import backbones -from official.vision.beta.configs import common -from official.vision.beta.configs import decoders +from official.modeling import hyperparams, optimization +from official.vision.beta.configs import backbones, common, decoders # pylint: disable=missing-class-docstring diff --git a/official/vision/beta/configs/semantic_segmentation.py b/official/vision/beta/configs/semantic_segmentation.py index 7e192e14c..2ea227b6b 100755 --- a/official/vision/beta/configs/semantic_segmentation.py +++ b/official/vision/beta/configs/semantic_segmentation.py @@ -14,19 +14,16 @@ # limitations under the License. # ============================================================================== """Semantic segmentation configuration definition.""" +import dataclasses import os from typing import List, Optional, Union -import dataclasses import numpy as np from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization +from official.modeling import hyperparams, optimization from official.modeling.hyperparams import config_definitions as cfg -from official.vision.beta.configs import backbones -from official.vision.beta.configs import common -from official.vision.beta.configs import decoders +from official.vision.beta.configs import backbones, common, decoders @dataclasses.dataclass diff --git a/official/vision/beta/configs/semantic_segmentation_test.py b/official/vision/beta/configs/semantic_segmentation_test.py index 0cb5a7c81..fe4f7386a 100755 --- a/official/vision/beta/configs/semantic_segmentation_test.py +++ b/official/vision/beta/configs/semantic_segmentation_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for semantic_segmentation.""" +import tensorflow as tf # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf from official.core import exp_factory from official.modeling.hyperparams import config_definitions as cfg diff --git a/official/vision/beta/configs/video_classification.py b/official/vision/beta/configs/video_classification.py index 06897d2a1..ad40781a8 100755 --- a/official/vision/beta/configs/video_classification.py +++ b/official/vision/beta/configs/video_classification.py @@ -14,14 +14,13 @@ # limitations under the License. # ============================================================================== """Video classification configuration definition.""" -from typing import Optional, Tuple import dataclasses +from typing import Optional, Tuple + from official.core import config_definitions as cfg from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization -from official.vision.beta.configs import backbones_3d -from official.vision.beta.configs import common +from official.modeling import hyperparams, optimization +from official.vision.beta.configs import backbones_3d, common @dataclasses.dataclass diff --git a/official/vision/beta/configs/video_classification_test.py b/official/vision/beta/configs/video_classification_test.py index bb65acacf..b387fb69a 100755 --- a/official/vision/beta/configs/video_classification_test.py +++ b/official/vision/beta/configs/video_classification_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for video_classification.""" +import tensorflow as tf # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/vision/beta/data/create_coco_tf_record.py b/official/vision/beta/data/create_coco_tf_record.py index 64317cc72..12d3f4b83 100755 --- a/official/vision/beta/data/create_coco_tf_record.py +++ b/official/vision/beta/data/create_coco_tf_record.py @@ -30,19 +30,17 @@ import collections import json import logging +import multiprocessing as mp import os +import numpy as np +import tensorflow as tf from absl import app # pylint:disable=unused-import from absl import flags -import numpy as np - from pycocotools import mask -import tensorflow as tf -import multiprocessing as mp from official.vision.beta.data import tfrecord_lib - flags.DEFINE_boolean( 'include_masks', False, 'Whether to include instance segmentations masks ' '(PNG encoded) in the result. default: False.') diff --git a/official/vision/beta/data/tfrecord_lib.py b/official/vision/beta/data/tfrecord_lib.py index bef18eb3b..c9bdc9370 100755 --- a/official/vision/beta/data/tfrecord_lib.py +++ b/official/vision/beta/data/tfrecord_lib.py @@ -17,13 +17,12 @@ import hashlib import io import itertools +import multiprocessing as mp -from absl import logging import numpy as np -from PIL import Image import tensorflow as tf - -import multiprocessing as mp +from absl import logging +from PIL import Image def convert_to_feature(value, value_type=None): @@ -172,4 +171,3 @@ def check_and_make_dir(directory): """Creates the directory if it doesn't exist.""" if not tf.io.gfile.isdir(directory): tf.io.gfile.makedirs(directory) - diff --git a/official/vision/beta/data/tfrecord_lib_test.py b/official/vision/beta/data/tfrecord_lib_test.py index 23d4b9173..66f8b0fc8 100755 --- a/official/vision/beta/data/tfrecord_lib_test.py +++ b/official/vision/beta/data/tfrecord_lib_test.py @@ -16,13 +16,12 @@ import os +import tensorflow as tf from absl import flags from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.data import tfrecord_lib - FLAGS = flags.FLAGS diff --git a/official/vision/beta/dataloaders/classification_input.py b/official/vision/beta/dataloaders/classification_input.py index 5d9acbd6f..42c084d2c 100755 --- a/official/vision/beta/dataloaders/classification_input.py +++ b/official/vision/beta/dataloaders/classification_input.py @@ -14,13 +14,12 @@ # ============================================================================== """Classification decoder and parser.""" from typing import List, Optional + # Import libraries import tensorflow as tf -from official.vision.beta.dataloaders import decoder -from official.vision.beta.dataloaders import parser -from official.vision.beta.ops import augment -from official.vision.beta.ops import preprocess_ops +from official.vision.beta.dataloaders import decoder, parser +from official.vision.beta.ops import augment, preprocess_ops MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) STDDEV_RGB = (0.229 * 255, 0.224 * 255, 0.225 * 255) diff --git a/official/vision/beta/dataloaders/maskrcnn_input.py b/official/vision/beta/dataloaders/maskrcnn_input.py index 8b789c4ed..923e0a52e 100755 --- a/official/vision/beta/dataloaders/maskrcnn_input.py +++ b/official/vision/beta/dataloaders/maskrcnn_input.py @@ -18,11 +18,8 @@ import tensorflow as tf -from official.vision.beta.dataloaders import parser -from official.vision.beta.dataloaders import utils -from official.vision.beta.ops import anchor -from official.vision.beta.ops import box_ops -from official.vision.beta.ops import preprocess_ops +from official.vision.beta.dataloaders import parser, utils +from official.vision.beta.ops import anchor, box_ops, preprocess_ops class Parser(parser.Parser): diff --git a/official/vision/beta/dataloaders/retinanet_input.py b/official/vision/beta/dataloaders/retinanet_input.py index 235376a89..770cb546f 100755 --- a/official/vision/beta/dataloaders/retinanet_input.py +++ b/official/vision/beta/dataloaders/retinanet_input.py @@ -21,11 +21,8 @@ # Import libraries import tensorflow as tf -from official.vision.beta.dataloaders import parser -from official.vision.beta.dataloaders import utils -from official.vision.beta.ops import anchor -from official.vision.beta.ops import box_ops -from official.vision.beta.ops import preprocess_ops +from official.vision.beta.dataloaders import parser, utils +from official.vision.beta.ops import anchor, box_ops, preprocess_ops class Parser(parser.Parser): diff --git a/official/vision/beta/dataloaders/segmentation_input.py b/official/vision/beta/dataloaders/segmentation_input.py index 394c63416..ceb12260d 100755 --- a/official/vision/beta/dataloaders/segmentation_input.py +++ b/official/vision/beta/dataloaders/segmentation_input.py @@ -15,8 +15,8 @@ """Data parser and processing for segmentation datasets.""" import tensorflow as tf -from official.vision.beta.dataloaders import decoder -from official.vision.beta.dataloaders import parser + +from official.vision.beta.dataloaders import decoder, parser from official.vision.beta.ops import preprocess_ops diff --git a/official/vision/beta/dataloaders/tf_example_decoder_test.py b/official/vision/beta/dataloaders/tf_example_decoder_test.py index 91bcb6857..8c18f9201 100755 --- a/official/vision/beta/dataloaders/tf_example_decoder_test.py +++ b/official/vision/beta/dataloaders/tf_example_decoder_test.py @@ -15,15 +15,15 @@ """Tests for tf_example_decoder.py.""" import io + +import numpy as np +import tensorflow as tf # Import libraries from absl.testing import parameterized -import numpy as np from PIL import Image -import tensorflow as tf from official.vision.beta.dataloaders import tf_example_decoder - DUMP_SOURCE_ID = b'123' diff --git a/official/vision/beta/dataloaders/tf_example_label_map_decoder.py b/official/vision/beta/dataloaders/tf_example_label_map_decoder.py index e9d7fa416..4c7dc4e91 100755 --- a/official/vision/beta/dataloaders/tf_example_label_map_decoder.py +++ b/official/vision/beta/dataloaders/tf_example_label_map_decoder.py @@ -18,6 +18,7 @@ protos for object detection. """ import csv + # Import libraries import tensorflow as tf diff --git a/official/vision/beta/dataloaders/tf_example_label_map_decoder_test.py b/official/vision/beta/dataloaders/tf_example_label_map_decoder_test.py index 8dedabc28..88c9aa4da 100755 --- a/official/vision/beta/dataloaders/tf_example_label_map_decoder_test.py +++ b/official/vision/beta/dataloaders/tf_example_label_map_decoder_test.py @@ -16,15 +16,15 @@ import io import os + +import numpy as np +import tensorflow as tf # Import libraries from absl.testing import parameterized -import numpy as np from PIL import Image -import tensorflow as tf from official.vision.beta.dataloaders import tf_example_label_map_decoder - DUMP_SOURCE_ID = b'123' LABEL_MAP_CSV_CONTENT = '0,class_0\n1,class_1\n2,class_2' diff --git a/official/vision/beta/dataloaders/tfds_classification_decoders.py b/official/vision/beta/dataloaders/tfds_classification_decoders.py index 0a6f1cf5b..223c0bb02 100755 --- a/official/vision/beta/dataloaders/tfds_classification_decoders.py +++ b/official/vision/beta/dataloaders/tfds_classification_decoders.py @@ -15,6 +15,7 @@ """TFDS Classification decoders.""" import tensorflow as tf + from official.vision.beta.dataloaders import decoder diff --git a/official/vision/beta/dataloaders/tfds_detection_decoders.py b/official/vision/beta/dataloaders/tfds_detection_decoders.py index 6b8e9deab..d0c7ccc8f 100755 --- a/official/vision/beta/dataloaders/tfds_detection_decoders.py +++ b/official/vision/beta/dataloaders/tfds_detection_decoders.py @@ -15,6 +15,7 @@ """TFDS detection decoders.""" import tensorflow as tf + from official.vision.beta.dataloaders import decoder diff --git a/official/vision/beta/dataloaders/tfds_segmentation_decoders.py b/official/vision/beta/dataloaders/tfds_segmentation_decoders.py index 8ee9962d1..6c960bcdc 100755 --- a/official/vision/beta/dataloaders/tfds_segmentation_decoders.py +++ b/official/vision/beta/dataloaders/tfds_segmentation_decoders.py @@ -15,6 +15,7 @@ """TFDS Semantic Segmentation decoders.""" import tensorflow as tf + from official.vision.beta.dataloaders import decoder diff --git a/official/vision/beta/dataloaders/video_input.py b/official/vision/beta/dataloaders/video_input.py index 3045591ef..bf7abfdf8 100755 --- a/official/vision/beta/dataloaders/video_input.py +++ b/official/vision/beta/dataloaders/video_input.py @@ -17,12 +17,11 @@ from typing import Dict, Optional, Tuple, Union -from absl import logging import tensorflow as tf +from absl import logging from official.vision.beta.configs import video_classification as exp_cfg -from official.vision.beta.dataloaders import decoder -from official.vision.beta.dataloaders import parser +from official.vision.beta.dataloaders import decoder, parser from official.vision.beta.ops import preprocess_ops_3d IMAGE_KEY = 'image/encoded' diff --git a/official/vision/beta/dataloaders/video_input_test.py b/official/vision/beta/dataloaders/video_input_test.py index ddaba79a4..a19a3f965 100755 --- a/official/vision/beta/dataloaders/video_input_test.py +++ b/official/vision/beta/dataloaders/video_input_test.py @@ -18,13 +18,12 @@ # Import libraries import numpy as np -from PIL import Image import tensorflow as tf +from PIL import Image from official.vision.beta.configs import video_classification as exp_cfg from official.vision.beta.dataloaders import video_input - AUDIO_KEY = 'features/audio' diff --git a/official/vision/beta/evaluation/coco_evaluator.py b/official/vision/beta/evaluation/coco_evaluator.py index 84ec57b6f..2376be6f1 100755 --- a/official/vision/beta/evaluation/coco_evaluator.py +++ b/official/vision/beta/evaluation/coco_evaluator.py @@ -28,12 +28,13 @@ import atexit import tempfile -# Import libraries -from absl import logging + import numpy as np -from pycocotools import cocoeval import six import tensorflow as tf +# Import libraries +from absl import logging +from pycocotools import cocoeval from official.vision.beta.evaluation import coco_utils diff --git a/official/vision/beta/evaluation/coco_utils.py b/official/vision/beta/evaluation/coco_utils.py index 3bbecf0d6..c8c6ed2a4 100755 --- a/official/vision/beta/evaluation/coco_utils.py +++ b/official/vision/beta/evaluation/coco_utils.py @@ -17,18 +17,17 @@ import copy import json +import numpy as np +import six +import tensorflow as tf # Import libraries from absl import logging -import numpy as np from PIL import Image from pycocotools import coco from pycocotools import mask as mask_api -import six -import tensorflow as tf from official.vision.beta.dataloaders import tf_example_decoder -from official.vision.beta.ops import box_ops -from official.vision.beta.ops import mask_ops +from official.vision.beta.ops import box_ops, mask_ops class COCOWrapper(coco.COCO): diff --git a/official/vision/beta/losses/maskrcnn_losses.py b/official/vision/beta/losses/maskrcnn_losses.py index 3b0aeffef..cf9f25b65 100755 --- a/official/vision/beta/losses/maskrcnn_losses.py +++ b/official/vision/beta/losses/maskrcnn_losses.py @@ -299,4 +299,3 @@ def __call__(self, mask_outputs, mask_targets, select_class_targets): # The loss is normalized by the number of 1's in weights and # + 0.01 is used to avoid division by zero. return mask_loss / (tf.reduce_sum(weights) + 0.01) - diff --git a/official/vision/beta/modeling/backbones/__init__.py b/official/vision/beta/modeling/backbones/__init__.py index 49a0f595a..351996af4 100755 --- a/official/vision/beta/modeling/backbones/__init__.py +++ b/official/vision/beta/modeling/backbones/__init__.py @@ -19,6 +19,7 @@ from official.vision.beta.modeling.backbones.mobilenet import MobileNet from official.vision.beta.modeling.backbones.resnet import ResNet from official.vision.beta.modeling.backbones.resnet_3d import ResNet3D -from official.vision.beta.modeling.backbones.resnet_deeplab import DilatedResNet +from official.vision.beta.modeling.backbones.resnet_deeplab import \ + DilatedResNet from official.vision.beta.modeling.backbones.revnet import RevNet from official.vision.beta.modeling.backbones.spinenet import SpineNet diff --git a/official/vision/beta/modeling/backbones/efficientnet.py b/official/vision/beta/modeling/backbones/efficientnet.py index d39a698ce..6219af823 100755 --- a/official/vision/beta/modeling/backbones/efficientnet.py +++ b/official/vision/beta/modeling/backbones/efficientnet.py @@ -15,12 +15,13 @@ """Contains definitions of EfficientNet Networks.""" import math + # Import libraries import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers layers = tf.keras.layers diff --git a/official/vision/beta/modeling/backbones/efficientnet_test.py b/official/vision/beta/modeling/backbones/efficientnet_test.py index 5869a301d..0c3a7f314 100755 --- a/official/vision/beta/modeling/backbones/efficientnet_test.py +++ b/official/vision/beta/modeling/backbones/efficientnet_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for EfficientNet.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import efficientnet diff --git a/official/vision/beta/modeling/backbones/factory.py b/official/vision/beta/modeling/backbones/factory.py index 174e6f05e..c467d7415 100755 --- a/official/vision/beta/modeling/backbones/factory.py +++ b/official/vision/beta/modeling/backbones/factory.py @@ -47,7 +47,6 @@ def build_my_backbone(): from official.core import registry - _REGISTERED_BACKBONE_CLS = {} diff --git a/official/vision/beta/modeling/backbones/factory_test.py b/official/vision/beta/modeling/backbones/factory_test.py index 5914ddeaf..8df4d13e5 100755 --- a/official/vision/beta/modeling/backbones/factory_test.py +++ b/official/vision/beta/modeling/backbones/factory_test.py @@ -14,11 +14,11 @@ # limitations under the License. # ============================================================================== """Tests for factory functions.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf - from tensorflow.python.distribute import combinations + from official.vision.beta.configs import backbones as backbones_cfg from official.vision.beta.configs import backbones_3d as backbones_3d_cfg from official.vision.beta.configs import common as common_cfg diff --git a/official/vision/beta/modeling/backbones/mobilenet.py b/official/vision/beta/modeling/backbones/mobilenet.py index 2ad8c4e22..1b7284d64 100755 --- a/official/vision/beta/modeling/backbones/mobilenet.py +++ b/official/vision/beta/modeling/backbones/mobilenet.py @@ -14,16 +14,15 @@ # ============================================================================== """Contains definitions of Mobilenet Networks.""" -from typing import Text, Optional, Dict, Any, Tuple - # Import libraries import dataclasses +from typing import Any, Dict, Optional, Text, Tuple + import tensorflow as tf -from official.modeling import hyperparams -from official.modeling import tf_utils + +from official.modeling import hyperparams, tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers layers = tf.keras.layers regularizers = tf.keras.regularizers diff --git a/official/vision/beta/modeling/backbones/mobilenet_test.py b/official/vision/beta/modeling/backbones/mobilenet_test.py index 79296f335..469c70430 100755 --- a/official/vision/beta/modeling/backbones/mobilenet_test.py +++ b/official/vision/beta/modeling/backbones/mobilenet_test.py @@ -16,13 +16,16 @@ """Tests for MobileNet.""" import itertools -# Import libraries -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from official.vision.beta.modeling.backbones import mobilenet +# Import libraries + + + class MobileNetTest(parameterized.TestCase, tf.test.TestCase): diff --git a/official/vision/beta/modeling/backbones/resnet.py b/official/vision/beta/modeling/backbones/resnet.py index 48eb6f973..1c4d4f193 100755 --- a/official/vision/beta/modeling/backbones/resnet.py +++ b/official/vision/beta/modeling/backbones/resnet.py @@ -21,10 +21,10 @@ # Import libraries import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers layers = tf.keras.layers diff --git a/official/vision/beta/modeling/backbones/resnet_3d.py b/official/vision/beta/modeling/backbones/resnet_3d.py index 77db96bbc..de5139dfb 100755 --- a/official/vision/beta/modeling/backbones/resnet_3d.py +++ b/official/vision/beta/modeling/backbones/resnet_3d.py @@ -17,6 +17,7 @@ # Import libraries import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory from official.vision.beta.modeling.layers import nn_blocks_3d diff --git a/official/vision/beta/modeling/backbones/resnet_3d_test.py b/official/vision/beta/modeling/backbones/resnet_3d_test.py index d7adf94a0..974be4854 100755 --- a/official/vision/beta/modeling/backbones/resnet_3d_test.py +++ b/official/vision/beta/modeling/backbones/resnet_3d_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for resnet.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import resnet_3d diff --git a/official/vision/beta/modeling/backbones/resnet_deeplab.py b/official/vision/beta/modeling/backbones/resnet_deeplab.py index 2d7b64c16..436c381df 100755 --- a/official/vision/beta/modeling/backbones/resnet_deeplab.py +++ b/official/vision/beta/modeling/backbones/resnet_deeplab.py @@ -16,10 +16,10 @@ import numpy as np import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers layers = tf.keras.layers diff --git a/official/vision/beta/modeling/backbones/resnet_deeplab_test.py b/official/vision/beta/modeling/backbones/resnet_deeplab_test.py index de9a23e83..9abb2b73c 100755 --- a/official/vision/beta/modeling/backbones/resnet_deeplab_test.py +++ b/official/vision/beta/modeling/backbones/resnet_deeplab_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for resnet_deeplab models.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.vision.beta.modeling.backbones import resnet_deeplab diff --git a/official/vision/beta/modeling/backbones/resnet_test.py b/official/vision/beta/modeling/backbones/resnet_test.py index e4635bd68..3eab4d8d4 100755 --- a/official/vision/beta/modeling/backbones/resnet_test.py +++ b/official/vision/beta/modeling/backbones/resnet_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for resnet.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.vision.beta.modeling.backbones import resnet diff --git a/official/vision/beta/modeling/backbones/revnet.py b/official/vision/beta/modeling/backbones/revnet.py index 276639910..f4b5c0ef7 100755 --- a/official/vision/beta/modeling/backbones/revnet.py +++ b/official/vision/beta/modeling/backbones/revnet.py @@ -21,13 +21,14 @@ """ from typing import Any, Callable, Dict, Optional + # Import libraries import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory from official.vision.beta.modeling.layers import nn_blocks - # Specifications for different RevNet variants. # Each entry specifies block configurations of the particular RevNet variant. # Each element in the block configuration is in the following format: diff --git a/official/vision/beta/modeling/backbones/revnet_test.py b/official/vision/beta/modeling/backbones/revnet_test.py index 1e9d4525c..4a957b8ed 100755 --- a/official/vision/beta/modeling/backbones/revnet_test.py +++ b/official/vision/beta/modeling/backbones/revnet_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for RevNet.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import revnet diff --git a/official/vision/beta/modeling/backbones/spinenet.py b/official/vision/beta/modeling/backbones/spinenet.py index 85f2eb6b9..2f1d88737 100755 --- a/official/vision/beta/modeling/backbones/spinenet.py +++ b/official/vision/beta/modeling/backbones/spinenet.py @@ -21,13 +21,13 @@ """ import math +import tensorflow as tf # Import libraries from absl import logging -import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers from official.vision.beta.ops import spatial_transform_ops layers = tf.keras.layers diff --git a/official/vision/beta/modeling/backbones/spinenet_test.py b/official/vision/beta/modeling/backbones/spinenet_test.py index b062095d0..cac31a50c 100755 --- a/official/vision/beta/modeling/backbones/spinenet_test.py +++ b/official/vision/beta/modeling/backbones/spinenet_test.py @@ -14,9 +14,9 @@ # limitations under the License. # ============================================================================== """Tests for SpineNet.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import spinenet diff --git a/official/vision/beta/modeling/classification_model_test.py b/official/vision/beta/modeling/classification_model_test.py index ea3d1bcc3..be3fc0152 100755 --- a/official/vision/beta/modeling/classification_model_test.py +++ b/official/vision/beta/modeling/classification_model_test.py @@ -15,15 +15,13 @@ # ============================================================================== """Tests for classification network.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations -from official.vision.beta.modeling import backbones -from official.vision.beta.modeling import classification_model +from official.vision.beta.modeling import backbones, classification_model class ClassificationNetworkTest(parameterized.TestCase, tf.test.TestCase): diff --git a/official/vision/beta/modeling/decoders/aspp_test.py b/official/vision/beta/modeling/decoders/aspp_test.py index 145df33be..9c5800c26 100755 --- a/official/vision/beta/modeling/decoders/aspp_test.py +++ b/official/vision/beta/modeling/decoders/aspp_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for aspp.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import resnet from official.vision.beta.modeling.decoders import aspp diff --git a/official/vision/beta/modeling/decoders/fpn_test.py b/official/vision/beta/modeling/decoders/fpn_test.py index c4e09e7a8..1f494c01b 100755 --- a/official/vision/beta/modeling/decoders/fpn_test.py +++ b/official/vision/beta/modeling/decoders/fpn_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for FPN.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import resnet from official.vision.beta.modeling.decoders import fpn diff --git a/official/vision/beta/modeling/decoders/nasfpn.py b/official/vision/beta/modeling/decoders/nasfpn.py index 735257741..67224b288 100755 --- a/official/vision/beta/modeling/decoders/nasfpn.py +++ b/official/vision/beta/modeling/decoders/nasfpn.py @@ -19,13 +19,12 @@ https://arxiv.org/abs/1904.07392. CVPR 2019. """ +import tensorflow as tf # Import libraries from absl import logging -import tensorflow as tf from official.vision.beta.ops import spatial_transform_ops - # The fixed NAS-FPN architecture discovered by NAS. # Each element represents a specification of a building block: # (block_level, combine_fn, (input_offset0, input_offset1), is_output). diff --git a/official/vision/beta/modeling/decoders/nasfpn_test.py b/official/vision/beta/modeling/decoders/nasfpn_test.py index 4cebc2b55..ef4025af6 100755 --- a/official/vision/beta/modeling/decoders/nasfpn_test.py +++ b/official/vision/beta/modeling/decoders/nasfpn_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for NAS-FPN.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.backbones import resnet from official.vision.beta.modeling.decoders import nasfpn diff --git a/official/vision/beta/modeling/factory.py b/official/vision/beta/modeling/factory.py index 6877dcab8..40ef93f7a 100755 --- a/official/vision/beta/modeling/factory.py +++ b/official/vision/beta/modeling/factory.py @@ -18,24 +18,22 @@ import tensorflow as tf -from official.vision.beta.configs import image_classification as classification_cfg +from official.vision.beta.configs import \ + image_classification as classification_cfg from official.vision.beta.configs import maskrcnn as maskrcnn_cfg from official.vision.beta.configs import retinanet as retinanet_cfg -from official.vision.beta.configs import semantic_segmentation as segmentation_cfg -from official.vision.beta.modeling import backbones -from official.vision.beta.modeling import classification_model -from official.vision.beta.modeling import maskrcnn_model -from official.vision.beta.modeling import retinanet_model -from official.vision.beta.modeling import segmentation_model +from official.vision.beta.configs import \ + semantic_segmentation as segmentation_cfg +from official.vision.beta.modeling import (backbones, classification_model, + maskrcnn_model, retinanet_model, + segmentation_model) from official.vision.beta.modeling.decoders import factory as decoder_factory -from official.vision.beta.modeling.heads import dense_prediction_heads -from official.vision.beta.modeling.heads import instance_heads -from official.vision.beta.modeling.heads import segmentation_heads -from official.vision.beta.modeling.layers import detection_generator -from official.vision.beta.modeling.layers import mask_sampler -from official.vision.beta.modeling.layers import roi_aligner -from official.vision.beta.modeling.layers import roi_generator -from official.vision.beta.modeling.layers import roi_sampler +from official.vision.beta.modeling.heads import (dense_prediction_heads, + instance_heads, + segmentation_heads) +from official.vision.beta.modeling.layers import (detection_generator, + mask_sampler, roi_aligner, + roi_generator, roi_sampler) def build_classification_model( diff --git a/official/vision/beta/modeling/factory_3d.py b/official/vision/beta/modeling/factory_3d.py index fd5253803..527362834 100755 --- a/official/vision/beta/modeling/factory_3d.py +++ b/official/vision/beta/modeling/factory_3d.py @@ -18,9 +18,9 @@ import tensorflow as tf from official.core import registry -from official.vision.beta.configs import video_classification as video_classification_cfg -from official.vision.beta.modeling import video_classification_model -from official.vision.beta.modeling import backbones +from official.vision.beta.configs import \ + video_classification as video_classification_cfg +from official.vision.beta.modeling import backbones, video_classification_model _REGISTERED_MODEL_CLS = {} diff --git a/official/vision/beta/modeling/factory_test.py b/official/vision/beta/modeling/factory_test.py index 7aa240fd3..7047e0025 100755 --- a/official/vision/beta/modeling/factory_test.py +++ b/official/vision/beta/modeling/factory_test.py @@ -15,18 +15,18 @@ # ============================================================================== """Tests for factory.py.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf -from official.vision.beta.configs import backbones -from official.vision.beta.configs import backbones_3d -from official.vision.beta.configs import image_classification as classification_cfg +from official.vision.beta.configs import backbones, backbones_3d +from official.vision.beta.configs import \ + image_classification as classification_cfg from official.vision.beta.configs import maskrcnn as maskrcnn_cfg from official.vision.beta.configs import retinanet as retinanet_cfg -from official.vision.beta.configs import video_classification as video_classification_cfg -from official.vision.beta.modeling import factory -from official.vision.beta.modeling import factory_3d +from official.vision.beta.configs import \ + video_classification as video_classification_cfg +from official.vision.beta.modeling import factory, factory_3d class ClassificationModelBuilderTest(parameterized.TestCase, tf.test.TestCase): diff --git a/official/vision/beta/modeling/heads/dense_prediction_heads_test.py b/official/vision/beta/modeling/heads/dense_prediction_heads_test.py index b701dbe6c..c474e3eaa 100755 --- a/official/vision/beta/modeling/heads/dense_prediction_heads_test.py +++ b/official/vision/beta/modeling/heads/dense_prediction_heads_test.py @@ -15,10 +15,10 @@ # ============================================================================== """Tests for dense_prediction_heads.py.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized from official.vision.beta.modeling.heads import dense_prediction_heads diff --git a/official/vision/beta/modeling/heads/instance_heads_test.py b/official/vision/beta/modeling/heads/instance_heads_test.py index 6939875d4..71d3fb2b4 100755 --- a/official/vision/beta/modeling/heads/instance_heads_test.py +++ b/official/vision/beta/modeling/heads/instance_heads_test.py @@ -15,10 +15,10 @@ # ============================================================================== """Tests for instance_heads.py.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized from official.vision.beta.modeling.heads import instance_heads diff --git a/official/vision/beta/modeling/heads/segmentation_heads_test.py b/official/vision/beta/modeling/heads/segmentation_heads_test.py index 18894bfde..b27bd183c 100755 --- a/official/vision/beta/modeling/heads/segmentation_heads_test.py +++ b/official/vision/beta/modeling/heads/segmentation_heads_test.py @@ -15,10 +15,10 @@ # ============================================================================== """Tests for segmentation_heads.py.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized from official.vision.beta.modeling.heads import segmentation_heads diff --git a/official/vision/beta/modeling/layers/detection_generator.py b/official/vision/beta/modeling/layers/detection_generator.py index 4e0eff2a1..919ee384d 100755 --- a/official/vision/beta/modeling/layers/detection_generator.py +++ b/official/vision/beta/modeling/layers/detection_generator.py @@ -18,8 +18,7 @@ import tensorflow as tf -from official.vision.beta.ops import box_ops -from official.vision.beta.ops import nms +from official.vision.beta.ops import box_ops, nms def _generate_detections_v1(boxes, diff --git a/official/vision/beta/modeling/layers/detection_generator_test.py b/official/vision/beta/modeling/layers/detection_generator_test.py index ccf1058b9..c2d7204fe 100755 --- a/official/vision/beta/modeling/layers/detection_generator_test.py +++ b/official/vision/beta/modeling/layers/detection_generator_test.py @@ -15,9 +15,9 @@ """Tests for detection_generator.py.""" # Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.vision.beta.modeling.layers import detection_generator from official.vision.beta.ops import anchor diff --git a/official/vision/beta/modeling/layers/nn_blocks.py b/official/vision/beta/modeling/layers/nn_blocks.py index 673cde8d4..9ad55699f 100755 --- a/official/vision/beta/modeling/layers/nn_blocks.py +++ b/official/vision/beta/modeling/layers/nn_blocks.py @@ -14,11 +14,11 @@ # ============================================================================== """Contains common building blocks for neural networks.""" -from typing import Any, Callable, Dict, List, Optional, Tuple, Union, Text +from typing import Any, Callable, Dict, List, Optional, Text, Tuple, Union +import tensorflow as tf # Import libraries from absl import logging -import tensorflow as tf from official.modeling import tf_utils from official.vision.beta.modeling.layers import nn_layers diff --git a/official/vision/beta/modeling/layers/nn_blocks_3d_test.py b/official/vision/beta/modeling/layers/nn_blocks_3d_test.py index 80a5caa37..edfd0c27e 100755 --- a/official/vision/beta/modeling/layers/nn_blocks_3d_test.py +++ b/official/vision/beta/modeling/layers/nn_blocks_3d_test.py @@ -15,9 +15,9 @@ # ============================================================================== """Tests for resnet.""" +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf from official.vision.beta.modeling.layers import nn_blocks_3d diff --git a/official/vision/beta/modeling/layers/nn_blocks_test.py b/official/vision/beta/modeling/layers/nn_blocks_test.py index 15228e29b..697acc9c2 100755 --- a/official/vision/beta/modeling/layers/nn_blocks_test.py +++ b/official/vision/beta/modeling/layers/nn_blocks_test.py @@ -16,12 +16,12 @@ """Tests for nn_blocks.""" from typing import Any, Iterable, Tuple + +import tensorflow as tf # Import libraries from absl.testing import parameterized -import tensorflow as tf +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.vision.beta.modeling.layers import nn_blocks diff --git a/official/vision/beta/modeling/layers/nn_layers.py b/official/vision/beta/modeling/layers/nn_layers.py index 4f8f65974..548c6690d 100755 --- a/official/vision/beta/modeling/layers/nn_layers.py +++ b/official/vision/beta/modeling/layers/nn_layers.py @@ -16,13 +16,15 @@ from typing import Optional -# Import libraries - -from absl import logging import tensorflow as tf +from absl import logging from official.modeling import tf_utils +# Import libraries + + + def make_divisible(value: float, divisor: int, diff --git a/official/vision/beta/modeling/layers/roi_generator.py b/official/vision/beta/modeling/layers/roi_generator.py index e122f3880..6f7518de1 100755 --- a/official/vision/beta/modeling/layers/roi_generator.py +++ b/official/vision/beta/modeling/layers/roi_generator.py @@ -17,8 +17,7 @@ # Import libraries import tensorflow as tf -from official.vision.beta.ops import box_ops -from official.vision.beta.ops import nms +from official.vision.beta.ops import box_ops, nms def _multilevel_propose_rois(raw_boxes, diff --git a/official/vision/beta/modeling/maskrcnn_model_test.py b/official/vision/beta/modeling/maskrcnn_model_test.py index 9723941a5..e08c31f16 100755 --- a/official/vision/beta/modeling/maskrcnn_model_test.py +++ b/official/vision/beta/modeling/maskrcnn_model_test.py @@ -15,21 +15,19 @@ # ============================================================================== """Tests for maskrcnn_model.py.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized from official.vision.beta.modeling import maskrcnn_model from official.vision.beta.modeling.backbones import resnet from official.vision.beta.modeling.decoders import fpn -from official.vision.beta.modeling.heads import dense_prediction_heads -from official.vision.beta.modeling.heads import instance_heads -from official.vision.beta.modeling.layers import detection_generator -from official.vision.beta.modeling.layers import mask_sampler -from official.vision.beta.modeling.layers import roi_aligner -from official.vision.beta.modeling.layers import roi_generator -from official.vision.beta.modeling.layers import roi_sampler +from official.vision.beta.modeling.heads import (dense_prediction_heads, + instance_heads) +from official.vision.beta.modeling.layers import (detection_generator, + mask_sampler, roi_aligner, + roi_generator, roi_sampler) from official.vision.beta.ops import anchor diff --git a/official/vision/beta/modeling/retinanet_model_test.py b/official/vision/beta/modeling/retinanet_model_test.py index 28c8555c3..645a1620b 100755 --- a/official/vision/beta/modeling/retinanet_model_test.py +++ b/official/vision/beta/modeling/retinanet_model_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for RetinaNet models.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.vision.beta.modeling import retinanet_model from official.vision.beta.modeling.backbones import resnet from official.vision.beta.modeling.decoders import fpn @@ -220,4 +219,3 @@ def test_serialize_deserialize(self): if __name__ == '__main__': tf.test.main() - diff --git a/official/vision/beta/modeling/segmentation_model_test.py b/official/vision/beta/modeling/segmentation_model_test.py index 41eb41dfb..d5406cc6a 100755 --- a/official/vision/beta/modeling/segmentation_model_test.py +++ b/official/vision/beta/modeling/segmentation_model_test.py @@ -15,12 +15,11 @@ # ============================================================================== """Tests for segmentation network.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized -from official.vision.beta.modeling import backbones -from official.vision.beta.modeling import segmentation_model +from official.vision.beta.modeling import backbones, segmentation_model from official.vision.beta.modeling.decoders import fpn from official.vision.beta.modeling.heads import segmentation_heads diff --git a/official/vision/beta/modeling/video_classification_model.py b/official/vision/beta/modeling/video_classification_model.py index 16935e681..6bfb0f4ab 100755 --- a/official/vision/beta/modeling/video_classification_model.py +++ b/official/vision/beta/modeling/video_classification_model.py @@ -14,6 +14,7 @@ # ============================================================================== """Build video classification models.""" from typing import Mapping + import tensorflow as tf layers = tf.keras.layers diff --git a/official/vision/beta/modeling/video_classification_model_test.py b/official/vision/beta/modeling/video_classification_model_test.py index 92e75db13..510092fe7 100755 --- a/official/vision/beta/modeling/video_classification_model_test.py +++ b/official/vision/beta/modeling/video_classification_model_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for video classification network.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized -from official.vision.beta.modeling import backbones -from official.vision.beta.modeling import video_classification_model +from official.vision.beta.modeling import backbones, video_classification_model class VideoClassificationNetworkTest(parameterized.TestCase, tf.test.TestCase): diff --git a/official/vision/beta/ops/anchor.py b/official/vision/beta/ops/anchor.py index a69f9ac94..88234355f 100755 --- a/official/vision/beta/ops/anchor.py +++ b/official/vision/beta/ops/anchor.py @@ -15,12 +15,13 @@ """Anchor box and labeler definition.""" import collections + # Import libraries import tensorflow as tf + from official.vision import keras_cv -from official.vision.detection.utils.object_detection import balanced_positive_negative_sampler -from official.vision.detection.utils.object_detection import box_list -from official.vision.detection.utils.object_detection import faster_rcnn_box_coder +from official.vision.detection.utils.object_detection import ( + balanced_positive_negative_sampler, box_list, faster_rcnn_box_coder) class Anchor(object): diff --git a/official/vision/beta/ops/anchor_test.py b/official/vision/beta/ops/anchor_test.py index 7c60dde21..0dfdce55d 100755 --- a/official/vision/beta/ops/anchor_test.py +++ b/official/vision/beta/ops/anchor_test.py @@ -14,10 +14,11 @@ # ============================================================================== """Tests for anchor.py.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized + from official.vision.beta.ops import anchor diff --git a/official/vision/beta/ops/augment.py b/official/vision/beta/ops/augment.py index 0c3d976d0..24bce4e4e 100755 --- a/official/vision/beta/ops/augment.py +++ b/official/vision/beta/ops/augment.py @@ -18,13 +18,12 @@ RandAugment Reference: https://arxiv.org/abs/1909.13719 """ import math -from typing import Any, List, Optional, Text, Tuple, Iterable +from typing import Any, Iterable, List, Optional, Text, Tuple import numpy as np import tensorflow as tf - -from tensorflow.python.keras.layers.preprocessing import image_preprocessing as image_ops - +from tensorflow.python.keras.layers.preprocessing import \ + image_preprocessing as image_ops # This signifies the max integer that the controller RNN could predict for the # augmentation scheme. diff --git a/official/vision/beta/ops/augment_test.py b/official/vision/beta/ops/augment_test.py index 670845ae2..01c9b5ac6 100755 --- a/official/vision/beta/ops/augment_test.py +++ b/official/vision/beta/ops/augment_test.py @@ -14,15 +14,13 @@ # ============================================================================== """Tests for autoaugment.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import random -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from official.vision.beta.ops import augment diff --git a/official/vision/beta/ops/box_ops.py b/official/vision/beta/ops/box_ops.py index 4fe7600cb..28b0a7c5c 100755 --- a/official/vision/beta/ops/box_ops.py +++ b/official/vision/beta/ops/box_ops.py @@ -18,7 +18,6 @@ import numpy as np import tensorflow as tf - EPSILON = 1e-8 BBOX_XFORM_CLIP = np.log(1000. / 16.) diff --git a/official/vision/beta/ops/mask_ops.py b/official/vision/beta/ops/mask_ops.py index bc25b1514..3f95c5d0c 100755 --- a/official/vision/beta/ops/mask_ops.py +++ b/official/vision/beta/ops/mask_ops.py @@ -15,6 +15,7 @@ """Utility functions for segmentations.""" import math + # Import libraries import cv2 import numpy as np @@ -187,4 +188,3 @@ def paste_instance_masks_v2(masks, segms = np.array(segms) return segms - diff --git a/official/vision/beta/ops/mask_ops_test.py b/official/vision/beta/ops/mask_ops_test.py index d07335036..5f6332b89 100755 --- a/official/vision/beta/ops/mask_ops_test.py +++ b/official/vision/beta/ops/mask_ops_test.py @@ -18,6 +18,7 @@ # Import libraries import numpy as np import tensorflow as tf + from official.vision.beta.ops import mask_ops diff --git a/official/vision/beta/ops/nms.py b/official/vision/beta/ops/nms.py index 645e2a4bc..ad01969db 100755 --- a/official/vision/beta/ops/nms.py +++ b/official/vision/beta/ops/nms.py @@ -19,7 +19,6 @@ from official.vision.beta.ops import box_ops - NMS_TILE_SIZE = 512 diff --git a/official/vision/beta/ops/preprocess_ops.py b/official/vision/beta/ops/preprocess_ops.py index 0d47ce601..f7aff0b77 100755 --- a/official/vision/beta/ops/preprocess_ops.py +++ b/official/vision/beta/ops/preprocess_ops.py @@ -15,12 +15,12 @@ """Preprocessing ops.""" import math -from six.moves import range + import tensorflow as tf +from six.moves import range from official.vision.beta.ops import box_ops - CENTER_CROP_FRACTION = 0.875 diff --git a/official/vision/beta/ops/preprocess_ops_3d.py b/official/vision/beta/ops/preprocess_ops_3d.py index fabe1f711..411d5ad8a 100755 --- a/official/vision/beta/ops/preprocess_ops_3d.py +++ b/official/vision/beta/ops/preprocess_ops_3d.py @@ -16,6 +16,7 @@ """Utils for processing video dataset features.""" from typing import Optional, Tuple + import tensorflow as tf diff --git a/official/vision/beta/ops/preprocess_ops_3d_test.py b/official/vision/beta/ops/preprocess_ops_3d_test.py index 9f5f0359e..5c27f0886 100755 --- a/official/vision/beta/ops/preprocess_ops_3d_test.py +++ b/official/vision/beta/ops/preprocess_ops_3d_test.py @@ -16,9 +16,10 @@ import io import itertools + import numpy as np -from PIL import Image import tensorflow as tf +from PIL import Image from official.vision.beta.ops import preprocess_ops_3d diff --git a/official/vision/beta/ops/preprocess_ops_test.py b/official/vision/beta/ops/preprocess_ops_test.py index 280f0f387..ed708927a 100755 --- a/official/vision/beta/ops/preprocess_ops_test.py +++ b/official/vision/beta/ops/preprocess_ops_test.py @@ -16,11 +16,12 @@ """Tests for preprocess_ops.py.""" import io + +import numpy as np +import tensorflow as tf # Import libraries from absl.testing import parameterized -import numpy as np from PIL import Image -import tensorflow as tf from official.vision.beta.ops import preprocess_ops diff --git a/official/vision/beta/projects/yolo/configs/backbones.py b/official/vision/beta/projects/yolo/configs/backbones.py index 31444687c..4693432ad 100755 --- a/official/vision/beta/projects/yolo/configs/backbones.py +++ b/official/vision/beta/projects/yolo/configs/backbones.py @@ -19,7 +19,6 @@ import dataclasses from official.modeling import hyperparams - from official.vision.beta.configs import backbones diff --git a/official/vision/beta/projects/yolo/configs/darknet_classification.py b/official/vision/beta/projects/yolo/configs/darknet_classification.py index f3061df5c..b709adaa9 100755 --- a/official/vision/beta/projects/yolo/configs/darknet_classification.py +++ b/official/vision/beta/projects/yolo/configs/darknet_classification.py @@ -15,9 +15,8 @@ # ============================================================================== """Image classification with darknet configs.""" -from typing import List, Optional - import dataclasses +from typing import List, Optional from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/vision/beta/projects/yolo/dataloaders/classification_tfds_decoder.py b/official/vision/beta/projects/yolo/dataloaders/classification_tfds_decoder.py index e0549aac9..123ca70a2 100755 --- a/official/vision/beta/projects/yolo/dataloaders/classification_tfds_decoder.py +++ b/official/vision/beta/projects/yolo/dataloaders/classification_tfds_decoder.py @@ -32,5 +32,3 @@ def decode(self, serialized_example): 'image/class/label': serialized_example['label'], } return sample_dict - - diff --git a/official/vision/beta/projects/yolo/modeling/backbones/darknet_test.py b/official/vision/beta/projects/yolo/modeling/backbones/darknet_test.py index ad63aeaca..3ca806ae7 100755 --- a/official/vision/beta/projects/yolo/modeling/backbones/darknet_test.py +++ b/official/vision/beta/projects/yolo/modeling/backbones/darknet_test.py @@ -15,12 +15,11 @@ # ============================================================================== """Tests for resnet.""" -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.vision.beta.projects.yolo.modeling.backbones import darknet diff --git a/official/vision/beta/projects/yolo/modeling/layers/nn_blocks.py b/official/vision/beta/projects/yolo/modeling/layers/nn_blocks.py index 3cdf16086..373b8392b 100755 --- a/official/vision/beta/projects/yolo/modeling/layers/nn_blocks.py +++ b/official/vision/beta/projects/yolo/modeling/layers/nn_blocks.py @@ -17,7 +17,9 @@ """Contains common building blocks for yolo neural networks.""" from typing import Callable, List + import tensorflow as tf + from official.modeling import tf_utils diff --git a/official/vision/beta/projects/yolo/modeling/layers/nn_blocks_test.py b/official/vision/beta/projects/yolo/modeling/layers/nn_blocks_test.py index 3d5ec2b97..99bb30ba6 100755 --- a/official/vision/beta/projects/yolo/modeling/layers/nn_blocks_test.py +++ b/official/vision/beta/projects/yolo/modeling/layers/nn_blocks_test.py @@ -14,9 +14,9 @@ # limitations under the License. # ============================================================================== -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized from official.vision.beta.projects.yolo.modeling.layers import nn_blocks diff --git a/official/vision/beta/projects/yolo/tasks/image_classification.py b/official/vision/beta/projects/yolo/tasks/image_classification.py index 75abc2959..cba0afdb3 100755 --- a/official/vision/beta/projects/yolo/tasks/image_classification.py +++ b/official/vision/beta/projects/yolo/tasks/image_classification.py @@ -16,11 +16,12 @@ """Image classification task definition.""" import tensorflow as tf -from official.core import input_reader -from official.core import task_factory +from official.core import input_reader, task_factory from official.vision.beta.dataloaders import classification_input -from official.vision.beta.projects.yolo.configs import darknet_classification as exp_cfg -from official.vision.beta.projects.yolo.dataloaders import classification_tfds_decoder as cli +from official.vision.beta.projects.yolo.configs import \ + darknet_classification as exp_cfg +from official.vision.beta.projects.yolo.dataloaders import \ + classification_tfds_decoder as cli from official.vision.beta.tasks import image_classification @@ -112,5 +113,3 @@ def train_step(self, inputs, model, optimizer, metrics=None): self.process_compiled_metrics(model.compiled_metrics, labels, outputs) logs.update({m.name: m.result() for m in model.metrics}) return logs - - diff --git a/official/vision/beta/projects/yolo/train.py b/official/vision/beta/projects/yolo/train.py index ba59837fb..33eab8e0e 100755 --- a/official/vision/beta/projects/yolo/train.py +++ b/official/vision/beta/projects/yolo/train.py @@ -15,17 +15,15 @@ # ============================================================================== """TensorFlow Model Garden Vision training driver.""" -from absl import app -from absl import flags import gin +from absl import app, flags from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.core import task_factory, train_lib, train_utils from official.modeling import performance -from official.vision.beta.projects.yolo.common import registry_imports # pylint: disable=unused-import +from official.vision.beta.projects.yolo.common import \ + registry_imports # pylint: disable=unused-import FLAGS = flags.FLAGS diff --git a/official/vision/beta/serving/detection.py b/official/vision/beta/serving/detection.py index 7612ae775..afd29d770 100755 --- a/official/vision/beta/serving/detection.py +++ b/official/vision/beta/serving/detection.py @@ -19,11 +19,9 @@ from official.vision.beta import configs from official.vision.beta.modeling import factory -from official.vision.beta.ops import anchor -from official.vision.beta.ops import preprocess_ops +from official.vision.beta.ops import anchor, preprocess_ops from official.vision.beta.serving import export_base - MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) STDDEV_RGB = (0.229 * 255, 0.224 * 255, 0.225 * 255) diff --git a/official/vision/beta/serving/detection_test.py b/official/vision/beta/serving/detection_test.py index a970a6ab2..787c7f9c4 100755 --- a/official/vision/beta/serving/detection_test.py +++ b/official/vision/beta/serving/detection_test.py @@ -18,10 +18,10 @@ import io import os -from absl.testing import parameterized import numpy as np -from PIL import Image import tensorflow as tf +from absl.testing import parameterized +from PIL import Image from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/vision/beta/serving/export_base.py b/official/vision/beta/serving/export_base.py index 85ce938be..edad0b617 100755 --- a/official/vision/beta/serving/export_base.py +++ b/official/vision/beta/serving/export_base.py @@ -16,6 +16,7 @@ """Base class for model export.""" import abc + import tensorflow as tf diff --git a/official/vision/beta/serving/export_saved_model.py b/official/vision/beta/serving/export_saved_model.py index 7f9dadaee..ee461bd2f 100755 --- a/official/vision/beta/serving/export_saved_model.py +++ b/official/vision/beta/serving/export_saved_model.py @@ -36,8 +36,7 @@ output = model_fn(input_images) """ -from absl import app -from absl import flags +from absl import app, flags from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/vision/beta/serving/export_saved_model_lib.py b/official/vision/beta/serving/export_saved_model_lib.py index a3e3f553d..c0103aa4e 100755 --- a/official/vision/beta/serving/export_saved_model_lib.py +++ b/official/vision/beta/serving/export_saved_model_lib.py @@ -21,9 +21,8 @@ from official.core import train_utils from official.vision.beta import configs -from official.vision.beta.serving import detection -from official.vision.beta.serving import image_classification -from official.vision.beta.serving import semantic_segmentation +from official.vision.beta.serving import (detection, image_classification, + semantic_segmentation) def export_inference_graph(input_type, batch_size, input_image_size, params, diff --git a/official/vision/beta/serving/export_tfhub.py b/official/vision/beta/serving/export_tfhub.py index 241e02a05..f1f15e183 100755 --- a/official/vision/beta/serving/export_tfhub.py +++ b/official/vision/beta/serving/export_tfhub.py @@ -15,18 +15,15 @@ # ============================================================================== """A script to export the image classification as a TF-Hub SavedModel.""" -# Import libraries -from absl import app -from absl import flags - import tensorflow as tf +# Import libraries +from absl import app, flags from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory from official.modeling import hyperparams from official.vision.beta.serving import image_classification - FLAGS = flags.FLAGS flags.DEFINE_string( diff --git a/official/vision/beta/serving/image_classification.py b/official/vision/beta/serving/image_classification.py index d7c6f4ad1..314dfa193 100755 --- a/official/vision/beta/serving/image_classification.py +++ b/official/vision/beta/serving/image_classification.py @@ -21,7 +21,6 @@ from official.vision.beta.ops import preprocess_ops from official.vision.beta.serving import export_base - MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) STDDEV_RGB = (0.229 * 255, 0.224 * 255, 0.225 * 255) diff --git a/official/vision/beta/serving/image_classification_test.py b/official/vision/beta/serving/image_classification_test.py index d9b7be7a5..79ed6d69a 100755 --- a/official/vision/beta/serving/image_classification_test.py +++ b/official/vision/beta/serving/image_classification_test.py @@ -18,10 +18,10 @@ import io import os -from absl.testing import parameterized import numpy as np -from PIL import Image import tensorflow as tf +from absl.testing import parameterized +from PIL import Image from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/vision/beta/serving/semantic_segmentation.py b/official/vision/beta/serving/semantic_segmentation.py index 14d8a45b2..520e5d699 100755 --- a/official/vision/beta/serving/semantic_segmentation.py +++ b/official/vision/beta/serving/semantic_segmentation.py @@ -21,7 +21,6 @@ from official.vision.beta.ops import preprocess_ops from official.vision.beta.serving import export_base - MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) STDDEV_RGB = (0.229 * 255, 0.224 * 255, 0.225 * 255) diff --git a/official/vision/beta/serving/semantic_segmentation_test.py b/official/vision/beta/serving/semantic_segmentation_test.py index f9c86515b..eebc3ef2d 100755 --- a/official/vision/beta/serving/semantic_segmentation_test.py +++ b/official/vision/beta/serving/semantic_segmentation_test.py @@ -18,10 +18,10 @@ import io import os -from absl.testing import parameterized import numpy as np -from PIL import Image import tensorflow as tf +from absl.testing import parameterized +from PIL import Image from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/vision/beta/tasks/__init__.py b/official/vision/beta/tasks/__init__.py index 90a83d37d..dc544132f 100755 --- a/official/vision/beta/tasks/__init__.py +++ b/official/vision/beta/tasks/__init__.py @@ -15,8 +15,6 @@ # ============================================================================== """Tasks package definition.""" -from official.vision.beta.tasks import image_classification -from official.vision.beta.tasks import maskrcnn -from official.vision.beta.tasks import retinanet -from official.vision.beta.tasks import semantic_segmentation -from official.vision.beta.tasks import video_classification +from official.vision.beta.tasks import (image_classification, maskrcnn, + retinanet, semantic_segmentation, + video_classification) diff --git a/official/vision/beta/tasks/image_classification.py b/official/vision/beta/tasks/image_classification.py index afe62927d..cdb2c9ddf 100755 --- a/official/vision/beta/tasks/image_classification.py +++ b/official/vision/beta/tasks/image_classification.py @@ -14,16 +14,15 @@ # limitations under the License. # ============================================================================== """Image classification task definition.""" -from absl import logging import tensorflow as tf +from absl import logging + from official.common import dataset_fn -from official.core import base_task -from official.core import input_reader -from official.core import task_factory +from official.core import base_task, input_reader, task_factory from official.modeling import tf_utils from official.vision.beta.configs import image_classification as exp_cfg -from official.vision.beta.dataloaders import classification_input -from official.vision.beta.dataloaders import tfds_classification_decoders +from official.vision.beta.dataloaders import (classification_input, + tfds_classification_decoders) from official.vision.beta.modeling import factory diff --git a/official/vision/beta/tasks/maskrcnn.py b/official/vision/beta/tasks/maskrcnn.py index a48612fca..356496b17 100755 --- a/official/vision/beta/tasks/maskrcnn.py +++ b/official/vision/beta/tasks/maskrcnn.py @@ -15,16 +15,15 @@ # ============================================================================== """RetinaNet task definition.""" -from absl import logging import tensorflow as tf +from absl import logging + from official.common import dataset_fn -from official.core import base_task -from official.core import input_reader -from official.core import task_factory +from official.core import base_task, input_reader, task_factory from official.vision.beta.configs import maskrcnn as exp_cfg -from official.vision.beta.dataloaders import maskrcnn_input -from official.vision.beta.dataloaders import tf_example_decoder -from official.vision.beta.dataloaders import tf_example_label_map_decoder +from official.vision.beta.dataloaders import (maskrcnn_input, + tf_example_decoder, + tf_example_label_map_decoder) from official.vision.beta.evaluation import coco_evaluator from official.vision.beta.losses import maskrcnn_losses from official.vision.beta.modeling import factory diff --git a/official/vision/beta/tasks/retinanet.py b/official/vision/beta/tasks/retinanet.py index 4e323a2e7..f06dea1df 100755 --- a/official/vision/beta/tasks/retinanet.py +++ b/official/vision/beta/tasks/retinanet.py @@ -15,18 +15,17 @@ # ============================================================================== """RetinaNet task definition.""" -from absl import logging import tensorflow as tf +from absl import logging + from official.common import dataset_fn -from official.core import base_task -from official.core import input_reader -from official.core import task_factory +from official.core import base_task, input_reader, task_factory from official.vision import keras_cv from official.vision.beta.configs import retinanet as exp_cfg -from official.vision.beta.dataloaders import retinanet_input -from official.vision.beta.dataloaders import tf_example_decoder -from official.vision.beta.dataloaders import tfds_detection_decoders -from official.vision.beta.dataloaders import tf_example_label_map_decoder +from official.vision.beta.dataloaders import (retinanet_input, + tf_example_decoder, + tf_example_label_map_decoder, + tfds_detection_decoders) from official.vision.beta.evaluation import coco_evaluator from official.vision.beta.modeling import factory diff --git a/official/vision/beta/tasks/semantic_segmentation.py b/official/vision/beta/tasks/semantic_segmentation.py index b4b7e64f2..62fb787b4 100755 --- a/official/vision/beta/tasks/semantic_segmentation.py +++ b/official/vision/beta/tasks/semantic_segmentation.py @@ -15,15 +15,14 @@ # ============================================================================== """Image segmentation task definition.""" -from absl import logging import tensorflow as tf +from absl import logging + from official.common import dataset_fn -from official.core import base_task -from official.core import input_reader -from official.core import task_factory +from official.core import base_task, input_reader, task_factory from official.vision.beta.configs import semantic_segmentation as exp_cfg -from official.vision.beta.dataloaders import segmentation_input -from official.vision.beta.dataloaders import tfds_segmentation_decoders +from official.vision.beta.dataloaders import (segmentation_input, + tfds_segmentation_decoders) from official.vision.beta.evaluation import segmentation_metrics from official.vision.beta.losses import segmentation_losses from official.vision.beta.modeling import factory diff --git a/official/vision/beta/tasks/video_classification.py b/official/vision/beta/tasks/video_classification.py index 33c6601e2..3fca0596b 100755 --- a/official/vision/beta/tasks/video_classification.py +++ b/official/vision/beta/tasks/video_classification.py @@ -14,11 +14,10 @@ # limitations under the License. # ============================================================================== """Video classification task definition.""" -from absl import logging import tensorflow as tf -from official.core import base_task -from official.core import input_reader -from official.core import task_factory +from absl import logging + +from official.core import base_task, input_reader, task_factory from official.modeling import tf_utils from official.vision.beta.configs import video_classification as exp_cfg from official.vision.beta.dataloaders import video_input diff --git a/official/vision/beta/train.py b/official/vision/beta/train.py index 0b4b617d8..31aa26cc8 100755 --- a/official/vision/beta/train.py +++ b/official/vision/beta/train.py @@ -15,18 +15,15 @@ # ============================================================================== """TensorFlow Model Garden Vision training driver.""" -from absl import app -from absl import flags import gin +from absl import app, flags -# pylint: disable=unused-import -from official.common import registry_imports # pylint: enable=unused-import +# pylint: disable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.common import registry_imports +from official.core import task_factory, train_lib, train_utils from official.modeling import performance FLAGS = flags.FLAGS diff --git a/official/vision/beta/train_spatial_partitioning.py b/official/vision/beta/train_spatial_partitioning.py index 4f0e19d52..b9491b872 100755 --- a/official/vision/beta/train_spatial_partitioning.py +++ b/official/vision/beta/train_spatial_partitioning.py @@ -15,21 +15,17 @@ # ============================================================================== """TensorFlow Model Garden Vision training driver with spatial partitioning.""" -from absl import app -from absl import flags import gin import numpy as np import tensorflow as tf +from absl import app, flags from official.common import registry_imports # pylint: disable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.core import train_utils +from official.core import task_factory, train_lib, train_utils from official.modeling import performance - FLAGS = flags.FLAGS diff --git a/official/vision/detection/configs/factory.py b/official/vision/detection/configs/factory.py index 2bd48fec4..61b3421f5 100755 --- a/official/vision/detection/configs/factory.py +++ b/official/vision/detection/configs/factory.py @@ -15,10 +15,8 @@ """Factory to provide model configs.""" from official.modeling.hyperparams import params_dict -from official.vision.detection.configs import maskrcnn_config -from official.vision.detection.configs import olnmask_config -from official.vision.detection.configs import retinanet_config -from official.vision.detection.configs import shapemask_config +from official.vision.detection.configs import ( + maskrcnn_config, olnmask_config, retinanet_config, shapemask_config) def config_generator(model): diff --git a/official/vision/detection/configs/maskrcnn_config.py b/official/vision/detection/configs/maskrcnn_config.py index c62756274..bf8d052e6 100755 --- a/official/vision/detection/configs/maskrcnn_config.py +++ b/official/vision/detection/configs/maskrcnn_config.py @@ -17,7 +17,6 @@ from official.modeling.hyperparams import params_dict from official.vision.detection.configs import base_config - # pylint: disable=line-too-long MASKRCNN_CFG = params_dict.ParamsDict(base_config.BASE_CFG) MASKRCNN_CFG.override({ diff --git a/official/vision/detection/configs/olnmask_config.py b/official/vision/detection/configs/olnmask_config.py index d1fd24f20..db49e1973 100755 --- a/official/vision/detection/configs/olnmask_config.py +++ b/official/vision/detection/configs/olnmask_config.py @@ -17,7 +17,6 @@ from official.modeling.hyperparams import params_dict from official.vision.detection.configs import base_config - # pylint: disable=line-too-long OLNMASK_CFG = params_dict.ParamsDict(base_config.BASE_CFG) OLNMASK_CFG.override({ diff --git a/official/vision/detection/configs/retinanet_config.py b/official/vision/detection/configs/retinanet_config.py index 7e89163b4..e229e6243 100755 --- a/official/vision/detection/configs/retinanet_config.py +++ b/official/vision/detection/configs/retinanet_config.py @@ -17,7 +17,6 @@ from official.modeling.hyperparams import params_dict from official.vision.detection.configs import base_config - # pylint: disable=line-too-long RETINANET_CFG = params_dict.ParamsDict(base_config.BASE_CFG) RETINANET_CFG.override({ diff --git a/official/vision/detection/dataloader/anchor.py b/official/vision/detection/dataloader/anchor.py index 8ef9f4bd1..f790dd304 100755 --- a/official/vision/detection/dataloader/anchor.py +++ b/official/vision/detection/dataloader/anchor.py @@ -14,20 +14,17 @@ # ============================================================================== """Anchor box and labeler definition.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import collections import tensorflow as tf + from official.vision import keras_cv from official.vision.detection.utils import box_utils -from official.vision.detection.utils.object_detection import argmax_matcher -from official.vision.detection.utils.object_detection import balanced_positive_negative_sampler -from official.vision.detection.utils.object_detection import box_list -from official.vision.detection.utils.object_detection import faster_rcnn_box_coder -from official.vision.detection.utils.object_detection import target_assigner +from official.vision.detection.utils.object_detection import ( + argmax_matcher, balanced_positive_negative_sampler, box_list, + faster_rcnn_box_coder, target_assigner) class Anchor(object): diff --git a/official/vision/detection/dataloader/factory.py b/official/vision/detection/dataloader/factory.py index 414b5b964..76f0c18ae 100755 --- a/official/vision/detection/dataloader/factory.py +++ b/official/vision/detection/dataloader/factory.py @@ -14,14 +14,12 @@ # ============================================================================== """Model architecture factory.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from official.vision.detection.dataloader import maskrcnn_parser -from official.vision.detection.dataloader import olnmask_parser -from official.vision.detection.dataloader import retinanet_parser -from official.vision.detection.dataloader import shapemask_parser +from official.vision.detection.dataloader import (maskrcnn_parser, + olnmask_parser, + retinanet_parser, + shapemask_parser) def parser_generator(params, mode): diff --git a/official/vision/detection/dataloader/input_reader.py b/official/vision/detection/dataloader/input_reader.py index 2e405cf0e..53c88c6dd 100755 --- a/official/vision/detection/dataloader/input_reader.py +++ b/official/vision/detection/dataloader/input_reader.py @@ -14,14 +14,13 @@ # ============================================================================== """Data loader and input processing.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function + +from typing import Optional, Text import tensorflow as tf -from typing import Text, Optional from official.modeling.hyperparams import params_dict from official.vision.detection.dataloader import factory from official.vision.detection.dataloader import mode_keys as ModeKeys diff --git a/official/vision/detection/dataloader/maskrcnn_parser.py b/official/vision/detection/dataloader/maskrcnn_parser.py index 35db6f147..54f4926ff 100755 --- a/official/vision/detection/dataloader/maskrcnn_parser.py +++ b/official/vision/detection/dataloader/maskrcnn_parser.py @@ -19,9 +19,8 @@ from official.vision.detection.dataloader import anchor from official.vision.detection.dataloader import mode_keys as ModeKeys from official.vision.detection.dataloader import tf_example_decoder -from official.vision.detection.utils import box_utils -from official.vision.detection.utils import dataloader_utils -from official.vision.detection.utils import input_utils +from official.vision.detection.utils import (box_utils, dataloader_utils, + input_utils) class Parser(object): diff --git a/official/vision/detection/dataloader/mode_keys.py b/official/vision/detection/dataloader/mode_keys.py index 020382b24..eb725075d 100755 --- a/official/vision/detection/dataloader/mode_keys.py +++ b/official/vision/detection/dataloader/mode_keys.py @@ -22,10 +22,7 @@ * `PREDICT_WITH_GT`: prediction mode with groundtruths in returned variables. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - +from __future__ import absolute_import, division, print_function TRAIN = 'train' EVAL = 'eval' diff --git a/official/vision/detection/dataloader/olnmask_parser.py b/official/vision/detection/dataloader/olnmask_parser.py index cd1236a1a..58290dad6 100755 --- a/official/vision/detection/dataloader/olnmask_parser.py +++ b/official/vision/detection/dataloader/olnmask_parser.py @@ -17,10 +17,9 @@ import tensorflow as tf from official.vision.detection.dataloader import anchor -from official.vision.detection.dataloader.maskrcnn_parser import Parser as MaskrcnnParser -from official.vision.detection.utils import box_utils -from official.vision.detection.utils import class_utils -from official.vision.detection.utils import input_utils +from official.vision.detection.dataloader.maskrcnn_parser import \ + Parser as MaskrcnnParser +from official.vision.detection.utils import box_utils, class_utils, input_utils class Parser(MaskrcnnParser): diff --git a/official/vision/detection/dataloader/retinanet_parser.py b/official/vision/detection/dataloader/retinanet_parser.py index f4badbde6..62d92a74c 100755 --- a/official/vision/detection/dataloader/retinanet_parser.py +++ b/official/vision/detection/dataloader/retinanet_parser.py @@ -26,8 +26,7 @@ from official.vision.detection.dataloader import anchor from official.vision.detection.dataloader import mode_keys as ModeKeys from official.vision.detection.dataloader import tf_example_decoder -from official.vision.detection.utils import box_utils -from official.vision.detection.utils import input_utils +from official.vision.detection.utils import box_utils, input_utils def process_source_id(source_id): diff --git a/official/vision/detection/dataloader/shapemask_parser.py b/official/vision/detection/dataloader/shapemask_parser.py index 3fd50dbd8..9df030a86 100755 --- a/official/vision/detection/dataloader/shapemask_parser.py +++ b/official/vision/detection/dataloader/shapemask_parser.py @@ -26,10 +26,8 @@ from official.vision.detection.dataloader import anchor from official.vision.detection.dataloader import mode_keys as ModeKeys from official.vision.detection.dataloader import tf_example_decoder -from official.vision.detection.utils import box_utils -from official.vision.detection.utils import class_utils -from official.vision.detection.utils import dataloader_utils -from official.vision.detection.utils import input_utils +from official.vision.detection.utils import (box_utils, class_utils, + dataloader_utils, input_utils) def pad_to_size(input_tensor, size): diff --git a/official/vision/detection/evaluation/coco_evaluator.py b/official/vision/detection/evaluation/coco_evaluator.py index fdc5bbef2..9b89c4c94 100755 --- a/official/vision/detection/evaluation/coco_evaluator.py +++ b/official/vision/detection/evaluation/coco_evaluator.py @@ -26,19 +26,17 @@ See also: https://github.com/cocodataset/cocoapi/ """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import atexit import copy import tempfile -from absl import logging import numpy as np -from pycocotools import cocoeval import six import tensorflow as tf +from absl import logging +from pycocotools import cocoeval from official.vision.detection.evaluation import coco_utils from official.vision.detection.utils import class_utils diff --git a/official/vision/detection/evaluation/coco_utils.py b/official/vision/detection/evaluation/coco_utils.py index a4f366850..532621565 100755 --- a/official/vision/detection/evaluation/coco_utils.py +++ b/official/vision/detection/evaluation/coco_utils.py @@ -14,24 +14,21 @@ # ============================================================================== """Util functions related to pycocotools and COCO eval.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import copy import json -from absl import logging import numpy as np +import six +import tensorflow as tf +from absl import logging from PIL import Image from pycocotools import coco from pycocotools import mask as mask_api -import six -import tensorflow as tf from official.vision.detection.dataloader import tf_example_decoder -from official.vision.detection.utils import box_utils -from official.vision.detection.utils import mask_utils +from official.vision.detection.utils import box_utils, mask_utils class COCOWrapper(coco.COCO): diff --git a/official/vision/detection/evaluation/factory.py b/official/vision/detection/evaluation/factory.py index b24f48454..00b70fcbd 100755 --- a/official/vision/detection/evaluation/factory.py +++ b/official/vision/detection/evaluation/factory.py @@ -14,9 +14,7 @@ # ============================================================================== """Evaluator factory.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function from official.vision.detection.evaluation import coco_evaluator diff --git a/official/vision/detection/executor/detection_executor.py b/official/vision/detection/executor/detection_executor.py index 0e76d7d16..6ffe7274f 100755 --- a/official/vision/detection/executor/detection_executor.py +++ b/official/vision/detection/executor/detection_executor.py @@ -14,16 +14,15 @@ # ============================================================================== """An executor class for running model on TensorFlow 2.0.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function +import tensorflow as tf from absl import logging -import tensorflow as tf from official.vision.detection.executor import distributed_executor as executor -from official.vision.detection.utils.object_detection import visualization_utils +from official.vision.detection.utils.object_detection import \ + visualization_utils class DetectionDistributedExecutor(executor.DistributedExecutor): diff --git a/official/vision/detection/executor/distributed_executor.py b/official/vision/detection/executor/distributed_executor.py index 75a214865..38902e06e 100755 --- a/official/vision/detection/executor/distributed_executor.py +++ b/official/vision/detection/executor/distributed_executor.py @@ -14,24 +14,20 @@ # ============================================================================== """Custom training loop for running TensorFlow 2.0 models.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os - -from absl import flags -from absl import logging +# pylint: disable=unused-import,g-import-not-at-top,redefined-outer-name,reimported +from typing import Any, Callable, Dict, Iterator, List, Optional, Text, Union import numpy as np import tensorflow as tf +from absl import flags, logging -# pylint: disable=unused-import,g-import-not-at-top,redefined-outer-name,reimported -from typing import Optional, Dict, List, Text, Callable, Union, Iterator, Any +from official.common import distribute_utils from official.modeling.hyperparams import params_dict from official.utils import hyperparams_flags -from official.common import distribute_utils from official.utils.misc import keras_utils FLAGS = flags.FLAGS diff --git a/official/vision/detection/main.py b/official/vision/detection/main.py index 4f28658f4..6cc283ab1 100755 --- a/official/vision/detection/main.py +++ b/official/vision/detection/main.py @@ -17,10 +17,8 @@ import functools import pprint -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +from absl import app, flags, logging from official.common import distribute_utils from official.modeling.hyperparams import params_dict @@ -31,7 +29,8 @@ from official.vision.detection.dataloader import input_reader from official.vision.detection.dataloader import mode_keys as ModeKeys from official.vision.detection.executor import distributed_executor as executor -from official.vision.detection.executor.detection_executor import DetectionDistributedExecutor +from official.vision.detection.executor.detection_executor import \ + DetectionDistributedExecutor from official.vision.detection.modeling import factory as model_factory hyperparams_flags.initialize_common_flags() diff --git a/official/vision/detection/modeling/architecture/factory.py b/official/vision/detection/modeling/architecture/factory.py index 8d7cf7ad6..3f48392bc 100755 --- a/official/vision/detection/modeling/architecture/factory.py +++ b/official/vision/detection/modeling/architecture/factory.py @@ -14,16 +14,11 @@ # ============================================================================== """Model architecture factory.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from official.vision.detection.modeling.architecture import fpn -from official.vision.detection.modeling.architecture import heads -from official.vision.detection.modeling.architecture import identity -from official.vision.detection.modeling.architecture import nn_ops -from official.vision.detection.modeling.architecture import resnet -from official.vision.detection.modeling.architecture import spinenet +from __future__ import absolute_import, division, print_function + +from official.vision.detection.modeling.architecture import (fpn, heads, + identity, nn_ops, + resnet, spinenet) def norm_activation_generator(params): diff --git a/official/vision/detection/modeling/architecture/fpn.py b/official/vision/detection/modeling/architecture/fpn.py index f531b49e3..9526846b9 100755 --- a/official/vision/detection/modeling/architecture/fpn.py +++ b/official/vision/detection/modeling/architecture/fpn.py @@ -20,16 +20,13 @@ Feature Pyramid Networks for Object Detection. CVPR 2017. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools import tensorflow as tf -from official.vision.detection.modeling.architecture import keras_utils -from official.vision.detection.modeling.architecture import nn_ops +from official.vision.detection.modeling.architecture import keras_utils, nn_ops from official.vision.detection.ops import spatial_transform_ops diff --git a/official/vision/detection/modeling/architecture/heads.py b/official/vision/detection/modeling/architecture/heads.py index c6084bd97..2e97fe6e3 100755 --- a/official/vision/detection/modeling/architecture/heads.py +++ b/official/vision/detection/modeling/architecture/heads.py @@ -14,17 +14,14 @@ # ============================================================================== """Classes to build various prediction heads in all supported models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools import numpy as np import tensorflow as tf -from official.vision.detection.modeling.architecture import keras_utils -from official.vision.detection.modeling.architecture import nn_ops +from official.vision.detection.modeling.architecture import keras_utils, nn_ops from official.vision.detection.ops import spatial_transform_ops diff --git a/official/vision/detection/modeling/architecture/identity.py b/official/vision/detection/modeling/architecture/identity.py index acc90c4d5..181f57003 100755 --- a/official/vision/detection/modeling/architecture/identity.py +++ b/official/vision/detection/modeling/architecture/identity.py @@ -14,9 +14,7 @@ # ============================================================================== """Identity Fn that forwards the input features.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function class Identity(object): @@ -25,4 +23,3 @@ class Identity(object): def __call__(self, features, is_training=False): """Only forwards the input features.""" return features - diff --git a/official/vision/detection/modeling/architecture/keras_utils.py b/official/vision/detection/modeling/architecture/keras_utils.py index 530f8f1e2..5fb4d6ee7 100755 --- a/official/vision/detection/modeling/architecture/keras_utils.py +++ b/official/vision/detection/modeling/architecture/keras_utils.py @@ -14,10 +14,7 @@ # ============================================================================== """Util functions to integrate with Keras internals.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - +from __future__ import absolute_import, division, print_function from tensorflow.python.keras import backend diff --git a/official/vision/detection/modeling/architecture/nn_blocks.py b/official/vision/detection/modeling/architecture/nn_blocks.py index c94a079f9..f9b548ddb 100755 --- a/official/vision/detection/modeling/architecture/nn_blocks.py +++ b/official/vision/detection/modeling/architecture/nn_blocks.py @@ -14,9 +14,7 @@ # ============================================================================== """Contains common building blocks for neural networks.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf diff --git a/official/vision/detection/modeling/architecture/nn_ops.py b/official/vision/detection/modeling/architecture/nn_ops.py index 4ce14e8ff..4c6038a9f 100755 --- a/official/vision/detection/modeling/architecture/nn_ops.py +++ b/official/vision/detection/modeling/architecture/nn_ops.py @@ -14,9 +14,7 @@ # ============================================================================== """Neural network operations commonly shared by the architectures.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools diff --git a/official/vision/detection/modeling/architecture/resnet.py b/official/vision/detection/modeling/architecture/resnet.py index bdcec6961..57fc6d411 100755 --- a/official/vision/detection/modeling/architecture/resnet.py +++ b/official/vision/detection/modeling/architecture/resnet.py @@ -19,14 +19,12 @@ Deep Residual Learning for Image Recognition. arXiv:1512.03385 """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl import logging import tensorflow as tf -from official.vision.detection.modeling.architecture import keras_utils -from official.vision.detection.modeling.architecture import nn_ops +from absl import logging + +from official.vision.detection.modeling.architecture import keras_utils, nn_ops # TODO(b/140112644): Refactor the code with Keras style, i.e. build and call. diff --git a/official/vision/detection/modeling/architecture/spinenet.py b/official/vision/detection/modeling/architecture/spinenet.py index 9c1094cc7..740f89b8f 100755 --- a/official/vision/detection/modeling/architecture/spinenet.py +++ b/official/vision/detection/modeling/architecture/spinenet.py @@ -21,12 +21,12 @@ """ import math -from absl import logging import tensorflow as tf +from absl import logging from official.modeling import tf_utils -from official.vision.detection.modeling.architecture import keras_utils -from official.vision.detection.modeling.architecture import nn_blocks +from official.vision.detection.modeling.architecture import (keras_utils, + nn_blocks) layers = tf.keras.layers diff --git a/official/vision/detection/modeling/base_model.py b/official/vision/detection/modeling/base_model.py index e9dd5c6d1..bb5c7cff0 100755 --- a/official/vision/detection/modeling/base_model.py +++ b/official/vision/detection/modeling/base_model.py @@ -14,18 +14,16 @@ # ============================================================================== """Base Model definition.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import abc import functools import re import tensorflow as tf -from official.vision.detection.modeling import checkpoint_utils -from official.vision.detection.modeling import learning_rates -from official.vision.detection.modeling import optimizers + +from official.vision.detection.modeling import (checkpoint_utils, + learning_rates, optimizers) def _make_filter_trainable_variables_fn(frozen_variable_prefix): diff --git a/official/vision/detection/modeling/checkpoint_utils.py b/official/vision/detection/modeling/checkpoint_utils.py index 73760e832..c4d39beb5 100755 --- a/official/vision/detection/modeling/checkpoint_utils.py +++ b/official/vision/detection/modeling/checkpoint_utils.py @@ -18,15 +18,12 @@ checkpoint to Tensorflow 2.x (keras) model. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import re -from absl import logging - import tensorflow as tf +from absl import logging def _build_assignment_map(keras_model, diff --git a/official/vision/detection/modeling/factory.py b/official/vision/detection/modeling/factory.py index 1c25ec97b..e90f6d10d 100755 --- a/official/vision/detection/modeling/factory.py +++ b/official/vision/detection/modeling/factory.py @@ -15,10 +15,9 @@ """Factory to build detection model.""" -from official.vision.detection.modeling import maskrcnn_model -from official.vision.detection.modeling import olnmask_model -from official.vision.detection.modeling import retinanet_model -from official.vision.detection.modeling import shapemask_model +from official.vision.detection.modeling import (maskrcnn_model, olnmask_model, + retinanet_model, + shapemask_model) def model_generator(params): diff --git a/official/vision/detection/modeling/learning_rates.py b/official/vision/detection/modeling/learning_rates.py index 6756ce5ba..8243df64c 100755 --- a/official/vision/detection/modeling/learning_rates.py +++ b/official/vision/detection/modeling/learning_rates.py @@ -14,14 +14,13 @@ # ============================================================================== """Learning rate schedule.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools import numpy as np import tensorflow as tf + from official.modeling.hyperparams import params_dict diff --git a/official/vision/detection/modeling/losses.py b/official/vision/detection/modeling/losses.py index 2cfe11d2b..bdde7e1bf 100755 --- a/official/vision/detection/modeling/losses.py +++ b/official/vision/detection/modeling/losses.py @@ -14,12 +14,10 @@ # ============================================================================== """Losses used for detection models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from absl import logging import tensorflow as tf +from absl import logging def focal_loss(logits, targets, alpha, gamma, normalizer): diff --git a/official/vision/detection/modeling/maskrcnn_model.py b/official/vision/detection/modeling/maskrcnn_model.py index aa347ffb4..2233f465d 100755 --- a/official/vision/detection/modeling/maskrcnn_model.py +++ b/official/vision/detection/modeling/maskrcnn_model.py @@ -14,23 +14,17 @@ # ============================================================================== """Model defination for the Mask R-CNN Model.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf -from official.vision.detection.dataloader import anchor -from official.vision.detection.dataloader import mode_keys +from official.vision.detection.dataloader import anchor, mode_keys from official.vision.detection.evaluation import factory as eval_factory -from official.vision.detection.modeling import base_model -from official.vision.detection.modeling import losses -from official.vision.detection.modeling.architecture import factory -from official.vision.detection.modeling.architecture import keras_utils -from official.vision.detection.ops import postprocess_ops -from official.vision.detection.ops import roi_ops -from official.vision.detection.ops import spatial_transform_ops -from official.vision.detection.ops import target_ops +from official.vision.detection.modeling import base_model, losses +from official.vision.detection.modeling.architecture import (factory, + keras_utils) +from official.vision.detection.ops import (postprocess_ops, roi_ops, + spatial_transform_ops, target_ops) from official.vision.detection.utils import box_utils diff --git a/official/vision/detection/modeling/olnmask_model.py b/official/vision/detection/modeling/olnmask_model.py index b405c41cf..63a6ad4ba 100755 --- a/official/vision/detection/modeling/olnmask_model.py +++ b/official/vision/detection/modeling/olnmask_model.py @@ -14,22 +14,17 @@ # ============================================================================== """Model defination for the Object Localization Network (OLN) Model.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf -from official.vision.detection.dataloader import anchor -from official.vision.detection.dataloader import mode_keys +from official.vision.detection.dataloader import anchor, mode_keys from official.vision.detection.modeling import losses -from official.vision.detection.modeling.architecture import factory -from official.vision.detection.modeling.architecture import keras_utils +from official.vision.detection.modeling.architecture import (factory, + keras_utils) from official.vision.detection.modeling.maskrcnn_model import MaskrcnnModel -from official.vision.detection.ops import postprocess_ops -from official.vision.detection.ops import roi_ops -from official.vision.detection.ops import spatial_transform_ops -from official.vision.detection.ops import target_ops +from official.vision.detection.ops import (postprocess_ops, roi_ops, + spatial_transform_ops, target_ops) from official.vision.detection.utils import box_utils diff --git a/official/vision/detection/modeling/optimizers.py b/official/vision/detection/modeling/optimizers.py index fd51bb59f..1a573a935 100755 --- a/official/vision/detection/modeling/optimizers.py +++ b/official/vision/detection/modeling/optimizers.py @@ -14,9 +14,7 @@ # ============================================================================== """Optimizers.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools diff --git a/official/vision/detection/modeling/retinanet_model.py b/official/vision/detection/modeling/retinanet_model.py index 0714d9784..6f7fc23c3 100755 --- a/official/vision/detection/modeling/retinanet_model.py +++ b/official/vision/detection/modeling/retinanet_model.py @@ -14,18 +14,15 @@ # ============================================================================== """Model defination for the RetinaNet Model.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf from official.vision.detection.dataloader import mode_keys from official.vision.detection.evaluation import factory as eval_factory -from official.vision.detection.modeling import base_model -from official.vision.detection.modeling import losses -from official.vision.detection.modeling.architecture import factory -from official.vision.detection.modeling.architecture import keras_utils +from official.vision.detection.modeling import base_model, losses +from official.vision.detection.modeling.architecture import (factory, + keras_utils) from official.vision.detection.ops import postprocess_ops diff --git a/official/vision/detection/modeling/shapemask_model.py b/official/vision/detection/modeling/shapemask_model.py index 8e3085422..d1af48505 100755 --- a/official/vision/detection/modeling/shapemask_model.py +++ b/official/vision/detection/modeling/shapemask_model.py @@ -14,19 +14,15 @@ # ============================================================================== """Model definition for the ShapeMask Model.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf -from official.vision.detection.dataloader import anchor -from official.vision.detection.dataloader import mode_keys +from official.vision.detection.dataloader import anchor, mode_keys from official.vision.detection.evaluation import factory as eval_factory -from official.vision.detection.modeling import base_model -from official.vision.detection.modeling import losses -from official.vision.detection.modeling.architecture import factory -from official.vision.detection.modeling.architecture import keras_utils +from official.vision.detection.modeling import base_model, losses +from official.vision.detection.modeling.architecture import (factory, + keras_utils) from official.vision.detection.ops import postprocess_ops from official.vision.detection.utils import box_utils diff --git a/official/vision/detection/ops/nms.py b/official/vision/detection/ops/nms.py index 7f4468992..ec9cd2f16 100755 --- a/official/vision/detection/ops/nms.py +++ b/official/vision/detection/ops/nms.py @@ -14,9 +14,7 @@ # ============================================================================== """Tensorflow implementation of non max suppression.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf diff --git a/official/vision/detection/ops/postprocess_ops.py b/official/vision/detection/ops/postprocess_ops.py index 802f9072e..397e86704 100755 --- a/official/vision/detection/ops/postprocess_ops.py +++ b/official/vision/detection/ops/postprocess_ops.py @@ -14,9 +14,7 @@ # ============================================================================== """Post-processing model outputs to generate detection.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools diff --git a/official/vision/detection/ops/roi_ops.py b/official/vision/detection/ops/roi_ops.py index ee67bb0ad..86f98eee6 100755 --- a/official/vision/detection/ops/roi_ops.py +++ b/official/vision/detection/ops/roi_ops.py @@ -14,9 +14,7 @@ # ============================================================================== """ROI-related ops.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf diff --git a/official/vision/detection/ops/spatial_transform_ops.py b/official/vision/detection/ops/spatial_transform_ops.py index c80677646..b4677c5eb 100755 --- a/official/vision/detection/ops/spatial_transform_ops.py +++ b/official/vision/detection/ops/spatial_transform_ops.py @@ -14,9 +14,7 @@ # ============================================================================== """Functions to performa spatial transformation for Tensor.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf diff --git a/official/vision/detection/ops/target_ops.py b/official/vision/detection/ops/target_ops.py index a2b54b207..3099be47c 100755 --- a/official/vision/detection/ops/target_ops.py +++ b/official/vision/detection/ops/target_ops.py @@ -14,15 +14,14 @@ # ============================================================================== """Target and sampling related ops.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf from official.vision.detection.ops import spatial_transform_ops from official.vision.detection.utils import box_utils -from official.vision.detection.utils.object_detection import balanced_positive_negative_sampler +from official.vision.detection.utils.object_detection import \ + balanced_positive_negative_sampler def box_matching(boxes, gt_boxes, gt_classes): diff --git a/official/vision/detection/utils/box_utils.py b/official/vision/detection/utils/box_utils.py index d8ad9f13d..a53da30fe 100755 --- a/official/vision/detection/utils/box_utils.py +++ b/official/vision/detection/utils/box_utils.py @@ -14,10 +14,8 @@ # ============================================================================== """Utility functions for bounding box processing.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import numpy as np import tensorflow as tf diff --git a/official/vision/detection/utils/mask_utils.py b/official/vision/detection/utils/mask_utils.py index 773aced60..c37782fc4 100755 --- a/official/vision/detection/utils/mask_utils.py +++ b/official/vision/detection/utils/mask_utils.py @@ -13,14 +13,12 @@ # limitations under the License. # ============================================================================== """Utility functions for segmentations.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import math -import numpy as np import cv2 +import numpy as np def paste_instance_masks(masks, detected_boxes, image_height, image_width): diff --git a/official/vision/detection/utils/object_detection/argmax_matcher.py b/official/vision/detection/utils/object_detection/argmax_matcher.py index 3f8b051bf..58c8a860d 100755 --- a/official/vision/detection/utils/object_detection/argmax_matcher.py +++ b/official/vision/detection/utils/object_detection/argmax_matcher.py @@ -28,8 +28,8 @@ """ import tensorflow as tf -from official.vision.detection.utils.object_detection import matcher -from official.vision.detection.utils.object_detection import shape_utils +from official.vision.detection.utils.object_detection import (matcher, + shape_utils) class ArgMaxMatcher(matcher.Matcher): diff --git a/official/vision/detection/utils/object_detection/balanced_positive_negative_sampler.py b/official/vision/detection/utils/object_detection/balanced_positive_negative_sampler.py index 66b4b1a66..8d3a9278d 100755 --- a/official/vision/detection/utils/object_detection/balanced_positive_negative_sampler.py +++ b/official/vision/detection/utils/object_detection/balanced_positive_negative_sampler.py @@ -33,8 +33,8 @@ import tensorflow as tf -from official.vision.detection.utils.object_detection import minibatch_sampler -from official.vision.detection.utils.object_detection import ops +from official.vision.detection.utils.object_detection import ( + minibatch_sampler, ops) class BalancedPositiveNegativeSampler(minibatch_sampler.MinibatchSampler): diff --git a/official/vision/detection/utils/object_detection/box_coder.py b/official/vision/detection/utils/object_detection/box_coder.py index 1ccb347f1..b1aeefe1f 100755 --- a/official/vision/detection/utils/object_detection/box_coder.py +++ b/official/vision/detection/utils/object_detection/box_coder.py @@ -25,9 +25,7 @@ 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 +from abc import ABCMeta, abstractmethod, abstractproperty import tensorflow as tf diff --git a/official/vision/detection/utils/object_detection/box_list_ops.py b/official/vision/detection/utils/object_detection/box_list_ops.py index 0420d8aa3..6aad38585 100755 --- a/official/vision/detection/utils/object_detection/box_list_ops.py +++ b/official/vision/detection/utils/object_detection/box_list_ops.py @@ -22,15 +22,12 @@ Whenever box_list_ops functions output a BoxList, the fields of the incoming BoxList are retained unless documented otherwise. """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from six.moves import range import tensorflow as tf +from six.moves import range -from official.vision.detection.utils.object_detection import box_list -from official.vision.detection.utils.object_detection import ops +from official.vision.detection.utils.object_detection import box_list, ops class SortOrder(object): diff --git a/official/vision/detection/utils/object_detection/faster_rcnn_box_coder.py b/official/vision/detection/utils/object_detection/faster_rcnn_box_coder.py index 11bd50c38..6e7aacf19 100755 --- a/official/vision/detection/utils/object_detection/faster_rcnn_box_coder.py +++ b/official/vision/detection/utils/object_detection/faster_rcnn_box_coder.py @@ -29,8 +29,8 @@ import tensorflow as tf -from official.vision.detection.utils.object_detection import box_coder -from official.vision.detection.utils.object_detection import box_list +from official.vision.detection.utils.object_detection import (box_coder, + box_list) EPSILON = 1e-8 diff --git a/official/vision/detection/utils/object_detection/matcher.py b/official/vision/detection/utils/object_detection/matcher.py index 1ae806f57..0b48dbd1e 100755 --- a/official/vision/detection/utils/object_detection/matcher.py +++ b/official/vision/detection/utils/object_detection/matcher.py @@ -30,8 +30,7 @@ The Match class is used to store the match results and it provides simple apis to query the results. """ -from abc import ABCMeta -from abc import abstractmethod +from abc import ABCMeta, abstractmethod import tensorflow as tf diff --git a/official/vision/detection/utils/object_detection/minibatch_sampler.py b/official/vision/detection/utils/object_detection/minibatch_sampler.py index 81acb4f2d..3b937952e 100755 --- a/official/vision/detection/utils/object_detection/minibatch_sampler.py +++ b/official/vision/detection/utils/object_detection/minibatch_sampler.py @@ -29,8 +29,7 @@ This is originally implemented in TensorFlow Object Detection API. """ -from abc import ABCMeta -from abc import abstractmethod +from abc import ABCMeta, abstractmethod import tensorflow as tf diff --git a/official/vision/detection/utils/object_detection/preprocessor.py b/official/vision/detection/utils/object_detection/preprocessor.py index 8a9da9004..40a533b41 100755 --- a/official/vision/detection/utils/object_detection/preprocessor.py +++ b/official/vision/detection/utils/object_detection/preprocessor.py @@ -39,9 +39,8 @@ back to rank 4. """ -import tensorflow as tf - import numpy as np +import tensorflow as tf from official.vision.detection.utils.object_detection import box_list diff --git a/official/vision/detection/utils/object_detection/region_similarity_calculator.py b/official/vision/detection/utils/object_detection/region_similarity_calculator.py index e7ae375e6..b66a3336b 100755 --- a/official/vision/detection/utils/object_detection/region_similarity_calculator.py +++ b/official/vision/detection/utils/object_detection/region_similarity_calculator.py @@ -17,8 +17,7 @@ Region Similarity Calculators compare a pairwise measure of similarity between the boxes in two BoxLists. """ -from abc import ABCMeta -from abc import abstractmethod +from abc import ABCMeta, abstractmethod import tensorflow as tf diff --git a/official/vision/detection/utils/object_detection/target_assigner.py b/official/vision/detection/utils/object_detection/target_assigner.py index 828097cf4..a5dffa2fa 100755 --- a/official/vision/detection/utils/object_detection/target_assigner.py +++ b/official/vision/detection/utils/object_detection/target_assigner.py @@ -33,8 +33,8 @@ import tensorflow as tf -from official.vision.detection.utils.object_detection import box_list -from official.vision.detection.utils.object_detection import shape_utils +from official.vision.detection.utils.object_detection import (box_list, + shape_utils) KEYPOINTS_FIELD_NAME = 'keypoints' diff --git a/official/vision/detection/utils/object_detection/visualization_utils.py b/official/vision/detection/utils/object_detection/visualization_utils.py index ada70af18..53f6fbc58 100755 --- a/official/vision/detection/utils/object_detection/visualization_utils.py +++ b/official/vision/detection/utils/object_detection/visualization_utils.py @@ -21,10 +21,8 @@ import collections import functools -from absl import logging # Set headless-friendly backend. import matplotlib -matplotlib.use('Agg') # pylint: disable=multiple-statements import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top import numpy as np import PIL.Image as Image @@ -33,10 +31,14 @@ import PIL.ImageFont as ImageFont import six import tensorflow as tf +from absl import logging from official.vision.detection.utils import box_utils from official.vision.detection.utils.object_detection import shape_utils +matplotlib.use('Agg') # pylint: disable=multiple-statements + + _TITLE_LEFT_MARGIN = 10 _TITLE_TOP_MARGIN = 10 STANDARD_COLORS = [ diff --git a/official/vision/image_classification/augment.py b/official/vision/image_classification/augment.py index 3a96a648d..88fcc2291 100755 --- a/official/vision/image_classification/augment.py +++ b/official/vision/image_classification/augment.py @@ -18,17 +18,15 @@ RandAugment Reference: https://arxiv.org/abs/1909.13719 """ -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import math - -import tensorflow as tf from typing import Any, Dict, List, Optional, Text, Tuple -from tensorflow.python.keras.layers.preprocessing import image_preprocessing as image_ops +import tensorflow as tf +from tensorflow.python.keras.layers.preprocessing import \ + image_preprocessing as image_ops # This signifies the max integer that the controller RNN could predict for the # augmentation scheme. diff --git a/official/vision/image_classification/augment_test.py b/official/vision/image_classification/augment_test.py index 27db5eb51..27a138e29 100755 --- a/official/vision/image_classification/augment_test.py +++ b/official/vision/image_classification/augment_test.py @@ -14,14 +14,11 @@ # ============================================================================== """Tests for autoaugment.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function - -from absl.testing import parameterized +from __future__ import absolute_import, division, print_function import tensorflow as tf +from absl.testing import parameterized from official.vision.image_classification import augment diff --git a/official/vision/image_classification/callbacks.py b/official/vision/image_classification/callbacks.py index 3d07f1e2a..6b4ec1abb 100755 --- a/official/vision/image_classification/callbacks.py +++ b/official/vision/image_classification/callbacks.py @@ -14,16 +14,14 @@ # limitations under the License. # ============================================================================== """Common modules for callbacks.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os from typing import Any, List, MutableMapping, Text -from absl import logging import tensorflow as tf +from absl import logging from official.modeling import optimization from official.utils.misc import keras_utils diff --git a/official/vision/image_classification/classifier_trainer.py b/official/vision/image_classification/classifier_trainer.py index 415225243..a651bd16a 100755 --- a/official/vision/image_classification/classifier_trainer.py +++ b/official/vision/image_classification/classifier_trainer.py @@ -17,25 +17,22 @@ import os import pprint -from typing import Any, Tuple, Text, Optional, Mapping +from typing import Any, Mapping, Optional, Text, Tuple -from absl import app -from absl import flags -from absl import logging import tensorflow as tf +from absl import app, flags, logging + from official.common import distribute_utils -from official.modeling import hyperparams -from official.modeling import performance +from official.modeling import hyperparams, performance from official.utils import hyperparams_flags from official.utils.misc import keras_utils from official.vision.image_classification import callbacks as custom_callbacks -from official.vision.image_classification import dataset_factory -from official.vision.image_classification import optimizer_factory -from official.vision.image_classification.configs import base_configs -from official.vision.image_classification.configs import configs -from official.vision.image_classification.efficientnet import efficientnet_model -from official.vision.image_classification.resnet import common -from official.vision.image_classification.resnet import resnet_model +from official.vision.image_classification import (dataset_factory, + optimizer_factory) +from official.vision.image_classification.configs import base_configs, configs +from official.vision.image_classification.efficientnet import \ + efficientnet_model +from official.vision.image_classification.resnet import common, resnet_model def get_models() -> Mapping[str, tf.keras.Model]: diff --git a/official/vision/image_classification/classifier_trainer_test.py b/official/vision/image_classification/classifier_trainer_test.py index cc61bb84c..fa8135719 100755 --- a/official/vision/image_classification/classifier_trainer_test.py +++ b/official/vision/image_classification/classifier_trainer_test.py @@ -15,29 +15,23 @@ # ============================================================================== """Unit tests for the classifier trainer models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools import json - import os import sys +from typing import ( + Any, Callable, Iterable, Mapping, MutableMapping, Optional, Tuple) -from typing import Any, Callable, Iterable, Mapping, MutableMapping, Optional, Tuple - -from absl import flags -from absl.testing import flagsaver -from absl.testing import parameterized import tensorflow as tf +from absl import flags +from absl.testing import flagsaver, parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.utils.flags import core as flags_core from official.vision.image_classification import classifier_trainer - classifier_trainer.define_classifier_flags() diff --git a/official/vision/image_classification/classifier_trainer_util_test.py b/official/vision/image_classification/classifier_trainer_util_test.py index bbb7dfb66..cc50239cf 100755 --- a/official/vision/image_classification/classifier_trainer_util_test.py +++ b/official/vision/image_classification/classifier_trainer_util_test.py @@ -15,19 +15,16 @@ # ============================================================================== """Unit tests for the classifier trainer models.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import copy import os -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized -from official.vision.image_classification import classifier_trainer -from official.vision.image_classification import dataset_factory -from official.vision.image_classification import test_utils +from official.vision.image_classification import (classifier_trainer, + dataset_factory, test_utils) from official.vision.image_classification.configs import base_configs diff --git a/official/vision/image_classification/configs/base_configs.py b/official/vision/image_classification/configs/base_configs.py index 316e8f2c4..8408f5614 100755 --- a/official/vision/image_classification/configs/base_configs.py +++ b/official/vision/image_classification/configs/base_configs.py @@ -14,9 +14,8 @@ # limitations under the License. # ============================================================================== """Definitions for high level configuration groups..""" -from typing import Any, List, Mapping, Optional - import dataclasses +from typing import Any, List, Mapping, Optional from official.core import config_definitions from official.modeling import hyperparams diff --git a/official/vision/image_classification/configs/configs.py b/official/vision/image_classification/configs/configs.py index 20b332143..a81d6e4fa 100755 --- a/official/vision/image_classification/configs/configs.py +++ b/official/vision/image_classification/configs/configs.py @@ -14,15 +14,14 @@ # limitations under the License. # ============================================================================== """Configuration utils for image classification experiments.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import dataclasses from official.vision.image_classification import dataset_factory from official.vision.image_classification.configs import base_configs -from official.vision.image_classification.efficientnet import efficientnet_config +from official.vision.image_classification.efficientnet import \ + efficientnet_config from official.vision.image_classification.resnet import resnet_config diff --git a/official/vision/image_classification/dataset_factory.py b/official/vision/image_classification/dataset_factory.py index d452f22bf..c93d9b2b3 100755 --- a/official/vision/image_classification/dataset_factory.py +++ b/official/vision/image_classification/dataset_factory.py @@ -14,22 +14,19 @@ # limitations under the License. # ============================================================================== """Dataset utilities for vision tasks using TFDS and tf.data.Dataset.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -from typing import Any, List, Optional, Tuple, Mapping, Union - -from absl import logging from dataclasses import dataclass +from typing import Any, List, Mapping, Optional, Tuple, Union + import tensorflow as tf import tensorflow_datasets as tfds +from absl import logging from official.modeling.hyperparams import base_config -from official.vision.image_classification import augment -from official.vision.image_classification import preprocessing +from official.vision.image_classification import augment, preprocessing AUGMENTERS = { 'autoaugment': augment.AutoAugment, diff --git a/official/vision/image_classification/efficientnet/common_modules.py b/official/vision/image_classification/efficientnet/common_modules.py index f656dc6d0..36a582104 100755 --- a/official/vision/image_classification/efficientnet/common_modules.py +++ b/official/vision/image_classification/efficientnet/common_modules.py @@ -13,16 +13,14 @@ # limitations under the License. # ============================================================================== """Common modeling utilities.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function + +from typing import Optional, Text import numpy as np import tensorflow as tf import tensorflow.compat.v1 as tf1 -from typing import Text, Optional - from tensorflow.python.tpu import tpu_function diff --git a/official/vision/image_classification/efficientnet/efficientnet_config.py b/official/vision/image_classification/efficientnet/efficientnet_config.py index a758cc63c..9705ae46d 100755 --- a/official/vision/image_classification/efficientnet/efficientnet_config.py +++ b/official/vision/image_classification/efficientnet/efficientnet_config.py @@ -14,13 +14,10 @@ # limitations under the License. # ============================================================================== """Configuration definitions for EfficientNet losses, learning rates, and optimizers.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function - -from typing import Any, Mapping +from __future__ import absolute_import, division, print_function import dataclasses +from typing import Any, Mapping from official.modeling.hyperparams import base_config from official.vision.image_classification.configs import base_configs diff --git a/official/vision/image_classification/efficientnet/efficientnet_model.py b/official/vision/image_classification/efficientnet/efficientnet_model.py index 01c0bc091..fa6157604 100755 --- a/official/vision/image_classification/efficientnet/efficientnet_model.py +++ b/official/vision/image_classification/efficientnet/efficientnet_model.py @@ -20,17 +20,15 @@ ICML'19, https://arxiv.org/abs/1905.11946 """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import math import os +from dataclasses import dataclass from typing import Any, Dict, Optional, Text, Tuple -from absl import logging -from dataclasses import dataclass import tensorflow as tf +from absl import logging from official.modeling import tf_utils from official.modeling.hyperparams import base_config diff --git a/official/vision/image_classification/efficientnet/tfhub_export.py b/official/vision/image_classification/efficientnet/tfhub_export.py index 71589920f..f171b6b46 100755 --- a/official/vision/image_classification/efficientnet/tfhub_export.py +++ b/official/vision/image_classification/efficientnet/tfhub_export.py @@ -14,19 +14,16 @@ # ============================================================================== """A script to export TF-Hub SavedModel.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -from absl import app -from absl import flags - import tensorflow as tf +from absl import app, flags -from official.vision.image_classification.efficientnet import efficientnet_model +from official.vision.image_classification.efficientnet import \ + efficientnet_model FLAGS = flags.FLAGS diff --git a/official/vision/image_classification/learning_rate.py b/official/vision/image_classification/learning_rate.py index becb118d7..3d5fa19f4 100755 --- a/official/vision/image_classification/learning_rate.py +++ b/official/vision/image_classification/learning_rate.py @@ -14,9 +14,7 @@ # limitations under the License. # ============================================================================== """Learning rate utilities for vision tasks.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function from typing import Any, Mapping, Optional diff --git a/official/vision/image_classification/learning_rate_test.py b/official/vision/image_classification/learning_rate_test.py index 52809abd1..ecfa8d2ad 100755 --- a/official/vision/image_classification/learning_rate_test.py +++ b/official/vision/image_classification/learning_rate_test.py @@ -14,9 +14,7 @@ # ============================================================================== """Tests for learning_rate.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf diff --git a/official/vision/image_classification/mnist_main.py b/official/vision/image_classification/mnist_main.py index 0d85853c3..9fd6174a4 100755 --- a/official/vision/image_classification/mnist_main.py +++ b/official/vision/image_classification/mnist_main.py @@ -13,18 +13,15 @@ # limitations under the License. # ============================================================================== """Runs a simple model on the MNIST dataset.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -# Import libraries -from absl import app -from absl import flags -from absl import logging import tensorflow as tf import tensorflow_datasets as tfds +# Import libraries +from absl import app, flags, logging + from official.common import distribute_utils from official.utils.flags import core as flags_core from official.utils.misc import model_helpers diff --git a/official/vision/image_classification/mnist_test.py b/official/vision/image_classification/mnist_test.py index fb97fb945..b0120d622 100755 --- a/official/vision/image_classification/mnist_test.py +++ b/official/vision/image_classification/mnist_test.py @@ -14,21 +14,17 @@ # ============================================================================== """Test the Keras MNIST model on GPU.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import functools -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from official.utils.testing import integration from official.vision.image_classification import mnist_main - mnist_main.define_mnist_flags() diff --git a/official/vision/image_classification/optimizer_factory.py b/official/vision/image_classification/optimizer_factory.py index 4e138d617..8dc492c3f 100755 --- a/official/vision/image_classification/optimizer_factory.py +++ b/official/vision/image_classification/optimizer_factory.py @@ -13,16 +13,14 @@ # limitations under the License. # ============================================================================== """Optimizer factory for vision tasks.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function from typing import Any, Dict, Text -from absl import logging import tensorflow as tf import tensorflow_addons as tfa +from absl import logging from official.modeling import optimization from official.vision.image_classification import learning_rate diff --git a/official/vision/image_classification/optimizer_factory_test.py b/official/vision/image_classification/optimizer_factory_test.py index 538605574..9b160302c 100755 --- a/official/vision/image_classification/optimizer_factory_test.py +++ b/official/vision/image_classification/optimizer_factory_test.py @@ -14,14 +14,12 @@ # ============================================================================== """Tests for optimizer_factory.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function +import tensorflow as tf from absl.testing import parameterized -import tensorflow as tf from official.vision.image_classification import optimizer_factory from official.vision.image_classification.configs import base_configs diff --git a/official/vision/image_classification/preprocessing.py b/official/vision/image_classification/preprocessing.py index 87ddeffdb..23548eef1 100755 --- a/official/vision/image_classification/preprocessing.py +++ b/official/vision/image_classification/preprocessing.py @@ -14,16 +14,14 @@ # ============================================================================== """Preprocessing functions for images.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function -import tensorflow as tf from typing import List, Optional, Text, Tuple -from official.vision.image_classification import augment +import tensorflow as tf +from official.vision.image_classification import augment # Calculated from the ImageNet training set MEAN_RGB = (0.485 * 255, 0.456 * 255, 0.406 * 255) diff --git a/official/vision/image_classification/resnet/common.py b/official/vision/image_classification/resnet/common.py index b9ea044cf..fe5a408ec 100755 --- a/official/vision/image_classification/resnet/common.py +++ b/official/vision/image_classification/resnet/common.py @@ -13,16 +13,15 @@ # limitations under the License. # ============================================================================== """Common util functions and classes used by both keras cifar and imagenet.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -from absl import flags import tensorflow as tf +from absl import flags +from tensorflow.python.keras.optimizer_v2 import \ + gradient_descent as gradient_descent_v2 -from tensorflow.python.keras.optimizer_v2 import gradient_descent as gradient_descent_v2 import tensorflow_model_optimization as tfmot from official.utils.flags import core as flags_core from official.utils.misc import keras_utils diff --git a/official/vision/image_classification/resnet/imagenet_preprocessing.py b/official/vision/image_classification/resnet/imagenet_preprocessing.py index 9f88471a8..d2f560ebf 100755 --- a/official/vision/image_classification/resnet/imagenet_preprocessing.py +++ b/official/vision/image_classification/resnet/imagenet_preprocessing.py @@ -31,14 +31,12 @@ """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -from absl import logging import tensorflow as tf +from absl import logging DEFAULT_IMAGE_SIZE = 224 NUM_CHANNELS = 3 diff --git a/official/vision/image_classification/resnet/resnet_config.py b/official/vision/image_classification/resnet/resnet_config.py index 787c8fd9f..8e09129d3 100755 --- a/official/vision/image_classification/resnet/resnet_config.py +++ b/official/vision/image_classification/resnet/resnet_config.py @@ -14,9 +14,7 @@ # limitations under the License. # ============================================================================== """Configuration definitions for ResNet losses, learning rates, and optimizers.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import dataclasses diff --git a/official/vision/image_classification/resnet/resnet_ctl_imagenet_main.py b/official/vision/image_classification/resnet/resnet_ctl_imagenet_main.py index 400c2ac0c..0868b86fa 100755 --- a/official/vision/image_classification/resnet/resnet_ctl_imagenet_main.py +++ b/official/vision/image_classification/resnet/resnet_ctl_imagenet_main.py @@ -17,20 +17,17 @@ import math import os +import tensorflow as tf # Import libraries -from absl import app -from absl import flags -from absl import logging +from absl import app, flags, logging + import orbit -import tensorflow as tf from official.common import distribute_utils from official.modeling import performance from official.utils.flags import core as flags_core -from official.utils.misc import keras_utils -from official.utils.misc import model_helpers -from official.vision.image_classification.resnet import common -from official.vision.image_classification.resnet import imagenet_preprocessing -from official.vision.image_classification.resnet import resnet_runnable +from official.utils.misc import keras_utils, model_helpers +from official.vision.image_classification.resnet import ( + common, imagenet_preprocessing, resnet_runnable) flags.DEFINE_boolean(name='use_tf_function', default=True, help='Wrap the train and test step inside a ' diff --git a/official/vision/image_classification/resnet/resnet_model.py b/official/vision/image_classification/resnet/resnet_model.py index 10f123335..2cdd184b9 100755 --- a/official/vision/image_classification/resnet/resnet_model.py +++ b/official/vision/image_classification/resnet/resnet_model.py @@ -23,16 +23,11 @@ - http://torch.ch/blog/2016/02/04/resnets.html """ -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function import tensorflow as tf +from tensorflow.python.keras import backend, initializers, models, regularizers -from tensorflow.python.keras import backend -from tensorflow.python.keras import initializers -from tensorflow.python.keras import models -from tensorflow.python.keras import regularizers from official.vision.image_classification.resnet import imagenet_preprocessing layers = tf.keras.layers diff --git a/official/vision/image_classification/resnet/resnet_runnable.py b/official/vision/image_classification/resnet/resnet_runnable.py index cd63f1f86..ba06d4f3f 100755 --- a/official/vision/image_classification/resnet/resnet_runnable.py +++ b/official/vision/image_classification/resnet/resnet_runnable.py @@ -14,15 +14,14 @@ # ============================================================================== """Runs a ResNet model on the ImageNet dataset using custom training loops.""" -import orbit import tensorflow as tf +import orbit from official.modeling import performance from official.staging.training import grad_utils from official.utils.flags import core as flags_core -from official.vision.image_classification.resnet import common -from official.vision.image_classification.resnet import imagenet_preprocessing -from official.vision.image_classification.resnet import resnet_model +from official.vision.image_classification.resnet import ( + common, imagenet_preprocessing, resnet_model) class ResnetRunnable(orbit.StandardTrainer, orbit.StandardEvaluator): diff --git a/official/vision/image_classification/resnet/tfhub_export.py b/official/vision/image_classification/resnet/tfhub_export.py index 2f49f5523..838b7d25b 100755 --- a/official/vision/image_classification/resnet/tfhub_export.py +++ b/official/vision/image_classification/resnet/tfhub_export.py @@ -14,21 +14,17 @@ # ============================================================================== """A script to export TF-Hub SavedModel.""" -from __future__ import absolute_import -from __future__ import division # from __future__ import google_type_annotations -from __future__ import print_function +from __future__ import absolute_import, division, print_function import os -# Import libraries -from absl import app -from absl import flags - import tensorflow as tf +# Import libraries +from absl import app, flags -from official.vision.image_classification.resnet import imagenet_preprocessing -from official.vision.image_classification.resnet import resnet_model +from official.vision.image_classification.resnet import ( + imagenet_preprocessing, resnet_model) FLAGS = flags.FLAGS diff --git a/official/vision/image_classification/test_utils.py b/official/vision/image_classification/test_utils.py index a6dc91dc7..98bf69ce6 100755 --- a/official/vision/image_classification/test_utils.py +++ b/official/vision/image_classification/test_utils.py @@ -14,13 +14,9 @@ # ============================================================================== """Test utilities for image classification tasks.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from tensorflow.python.keras import backend -from tensorflow.python.keras import layers -from tensorflow.python.keras import models +from tensorflow.python.keras import backend, layers, models def trivial_model(num_classes): diff --git a/official/vision/keras_cv/__init__.py b/official/vision/keras_cv/__init__.py index d0f087e73..b99c3af42 100755 --- a/official/vision/keras_cv/__init__.py +++ b/official/vision/keras_cv/__init__.py @@ -14,7 +14,4 @@ # ============================================================================== """Keras-CV package definition.""" # pylint: disable=wildcard-import -from official.vision.keras_cv import layers -from official.vision.keras_cv import losses -from official.vision.keras_cv import metrics -from official.vision.keras_cv import ops +from official.vision.keras_cv import layers, losses, metrics, ops diff --git a/official/vision/keras_cv/layers/deeplab_test.py b/official/vision/keras_cv/layers/deeplab_test.py index 7f5a750c5..80b0f5bf7 100755 --- a/official/vision/keras_cv/layers/deeplab_test.py +++ b/official/vision/keras_cv/layers/deeplab_test.py @@ -15,8 +15,8 @@ """Tests for ASPP.""" import tensorflow as tf - from tensorflow.python.keras import keras_parameterized + from official.vision.keras_cv.layers import deeplab diff --git a/official/vision/keras_cv/ops/anchor_generator_test.py b/official/vision/keras_cv/ops/anchor_generator_test.py index 7b95d4032..a3050f691 100755 --- a/official/vision/keras_cv/ops/anchor_generator_test.py +++ b/official/vision/keras_cv/ops/anchor_generator_test.py @@ -14,8 +14,9 @@ # ============================================================================== """Tests for anchor_generator.py.""" -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized + from official.vision.keras_cv.ops import anchor_generator diff --git a/official/vision/keras_cv/setup.py b/official/vision/keras_cv/setup.py index e9e8ca233..1c14b8dd5 100755 --- a/official/vision/keras_cv/setup.py +++ b/official/vision/keras_cv/setup.py @@ -16,8 +16,7 @@ import os -from setuptools import find_packages -from setuptools import setup +from setuptools import find_packages, setup version = '0.0.1' diff --git a/orbit/__init__.py b/orbit/__init__.py index a97bb719d..cdd006c33 100755 --- a/orbit/__init__.py +++ b/orbit/__init__.py @@ -15,13 +15,8 @@ """Defines exported symbols for the `orbit` package.""" from orbit import utils - from orbit.controller import Controller - -from orbit.runner import AbstractEvaluator -from orbit.runner import AbstractTrainer - -from orbit.standard_runner import StandardEvaluator -from orbit.standard_runner import StandardEvaluatorOptions -from orbit.standard_runner import StandardTrainer -from orbit.standard_runner import StandardTrainerOptions +from orbit.runner import AbstractEvaluator, AbstractTrainer +from orbit.standard_runner import ( + StandardEvaluator, StandardEvaluatorOptions, StandardTrainer, + StandardTrainerOptions) diff --git a/orbit/controller.py b/orbit/controller.py index 9ecb2c544..bed2af34d 100755 --- a/orbit/controller.py +++ b/orbit/controller.py @@ -16,15 +16,12 @@ import pprint import time - from typing import Callable, Optional, Union +import tensorflow as tf from absl import logging -from orbit import runner -from orbit import utils - -import tensorflow as tf +from orbit import runner, utils def _log(message: str): @@ -240,7 +237,6 @@ def evaluate(self, steps: int = -1) -> Optional[runner.Output]: ValueError: If `steps` is not a positive value or -1. """ self._require("evaluator", for_method="evaluate") - if steps > 0: steps_msg = f"running {steps} steps of evaluation..." elif steps == -1: diff --git a/orbit/controller_test.py b/orbit/controller_test.py index b4620b83b..35f71bbab 100755 --- a/orbit/controller_test.py +++ b/orbit/controller_test.py @@ -16,16 +16,12 @@ import os +import numpy as np +import tensorflow as tf from absl import logging from absl.testing import parameterized -import numpy as np - -from orbit import controller -from orbit import runner -from orbit import standard_runner - -import tensorflow as tf +from orbit import controller, runner, standard_runner def create_model(): diff --git a/orbit/runner.py b/orbit/runner.py index b0377c521..fbaed04d6 100755 --- a/orbit/runner.py +++ b/orbit/runner.py @@ -15,13 +15,11 @@ """Provides AbstractTrainer/Evaluator base classes, defining train/eval APIs.""" import abc - from typing import Dict, Optional, Union import numpy as np import tensorflow as tf - Output = Dict[str, Union[tf.Tensor, float, np.number, np.ndarray, 'Output']] # pytype: disable=not-supported-yet diff --git a/orbit/standard_runner.py b/orbit/standard_runner.py index a89e3ed2c..b26dff4bd 100755 --- a/orbit/standard_runner.py +++ b/orbit/standard_runner.py @@ -34,16 +34,14 @@ """ import abc - +import dataclasses from typing import Any, Optional -import dataclasses +import tensorflow as tf from orbit import runner from orbit.utils import loop_fns -import tensorflow as tf - @dataclasses.dataclass(frozen=True) class StandardTrainerOptions: @@ -299,7 +297,7 @@ def evaluate(self, num_steps: tf.Tensor) -> Optional[runner.Output]: "`options.use_tf_while_loop` is `True`") outputs = self.eval_begin() # pylint: disable=assignment-from-no-return - + has_state = outputs is not None if self._eval_loop_fn is None: self._eval_loop_fn = _create_eval_loop_fn( @@ -311,7 +309,6 @@ def evaluate(self, num_steps: tf.Tensor) -> Optional[runner.Output]: else: outputs = self._eval_loop_fn( eval_iter, num_steps, state=outputs, reduce_fn=self.eval_reduce) - if outputs is None: return self.eval_end() else: diff --git a/orbit/standard_runner_test.py b/orbit/standard_runner_test.py index e84ecb38e..20972d325 100755 --- a/orbit/standard_runner_test.py +++ b/orbit/standard_runner_test.py @@ -14,12 +14,10 @@ """Tests for orbit.standard_runner.""" +import tensorflow as tf from absl.testing import parameterized -from orbit import standard_runner -from orbit import utils - -import tensorflow as tf +from orbit import standard_runner, utils def dataset_fn(input_context=None): diff --git a/orbit/utils/__init__.py b/orbit/utils/__init__.py index 3eeb67c4a..197575cdb 100755 --- a/orbit/utils/__init__.py +++ b/orbit/utils/__init__.py @@ -14,16 +14,10 @@ """Defines exported symbols for the `orbit.utils` package.""" -from orbit.utils.common import create_global_step -from orbit.utils.common import get_value -from orbit.utils.common import make_distributed_dataset - +from orbit.utils.common import (create_global_step, get_value, + make_distributed_dataset) from orbit.utils.epoch_helper import EpochHelper - -from orbit.utils.loop_fns import create_loop_fn -from orbit.utils.loop_fns import create_tf_while_loop_fn -from orbit.utils.loop_fns import LoopFnWithSummaries - +from orbit.utils.loop_fns import (LoopFnWithSummaries, create_loop_fn, + create_tf_while_loop_fn) from orbit.utils.summary_manager import SummaryManager - from orbit.utils.tpu_summaries import OptionalSummariesFunction diff --git a/orbit/utils/common_test.py b/orbit/utils/common_test.py index 1a68e7c66..570d76b4c 100755 --- a/orbit/utils/common_test.py +++ b/orbit/utils/common_test.py @@ -14,10 +14,10 @@ """Tests for orbit.utils.common.""" -from orbit.utils import common - import tensorflow as tf +from orbit.utils import common + class UtilsTest(tf.test.TestCase): diff --git a/orbit/utils/loop_fns.py b/orbit/utils/loop_fns.py index 6e3262469..559485f37 100755 --- a/orbit/utils/loop_fns.py +++ b/orbit/utils/loop_fns.py @@ -14,10 +14,10 @@ """Utilities for creating loop functions.""" -from orbit.utils import tpu_summaries - import tensorflow as tf +from orbit.utils import tpu_summaries + def create_loop_fn(step_fn): """Creates a loop function driven by a Python `while` loop. diff --git a/orbit/utils/tpu_summaries_test.py b/orbit/utils/tpu_summaries_test.py index 4aa0d0820..43b352257 100755 --- a/orbit/utils/tpu_summaries_test.py +++ b/orbit/utils/tpu_summaries_test.py @@ -17,11 +17,10 @@ import functools import os -from orbit.utils import common -from orbit.utils import tpu_summaries - import tensorflow as tf +from orbit.utils import common, tpu_summaries + class TrainFunctionWithSummaries(tpu_summaries.OptionalSummariesFunction): """Implements a two-program approach for summaries on TPU.""" diff --git a/panoptic/data/create_cityscaped_tf_record.py b/panoptic/data/create_cityscaped_tf_record.py index 593f3557c..212cc5943 100755 --- a/panoptic/data/create_cityscaped_tf_record.py +++ b/panoptic/data/create_cityscaped_tf_record.py @@ -1,9 +1,11 @@ -import tensorflow as tf +import json import os + import cv2 -import json -from PIL import Image, ImageDraw import numpy as np +import pycocotools.mask as mask_utils +import tensorflow as tf +from PIL import Image, ImageDraw dataset_folder = "/media/vbanna/DATA_SHARE/CityScapes_raw" @@ -54,7 +56,6 @@ def _get_file_generator(image_folder, split): samples.append(get_file_lists(folder, file)) return samples -import pycocotools.mask as mask_utils def draw_polygons(): # mask_utils. return @@ -96,4 +97,4 @@ def get_instance_list(json_file): # print(polygon["label"]) # instance = load_instance(polygon["polygon"], json_polygons["imgWidth"], json_polygons["imgHeight"]) # plt.imshow(image_) -# plt.show() \ No newline at end of file +# plt.show() diff --git a/panoptic/dataloaders/decoders/coco_panoptic.py b/panoptic/dataloaders/decoders/coco_panoptic.py index d6d3b8599..15aec5eed 100755 --- a/panoptic/dataloaders/decoders/coco_panoptic.py +++ b/panoptic/dataloaders/decoders/coco_panoptic.py @@ -1,8 +1,8 @@ -import tensorflow_datasets as tfds -import tensorflow as tf import matplotlib.pyplot as plt -import utils.demos.utils as utils +import tensorflow as tf +import tensorflow_datasets as tfds +import utils.demos.utils as utils from panoptic.dataloaders.decoders import tfds_panoptic_coco_decoder path = "/media/vbanna/DATA_SHARE/tfds" @@ -30,4 +30,4 @@ plt.tight_layout() plt.show() if i > (lim + 1): - break \ No newline at end of file + break diff --git a/panoptic/dataloaders/decoders/tfds_panoptic_coco_decoder.py b/panoptic/dataloaders/decoders/tfds_panoptic_coco_decoder.py index dc9bf0ec9..2ad23d9dd 100755 --- a/panoptic/dataloaders/decoders/tfds_panoptic_coco_decoder.py +++ b/panoptic/dataloaders/decoders/tfds_panoptic_coco_decoder.py @@ -3,11 +3,13 @@ protos for object detection. """ import csv + # Import libraries import tensorflow as tf from official.vision.beta.dataloaders import decoder + def _generate_source_id(image_bytes): return tf.strings.as_string( tf.strings.to_hash_bucket_fast(image_bytes, 2**63 - 1)) diff --git a/panoptic/dataloaders/encoders/coco.py b/panoptic/dataloaders/encoders/coco.py index 87ae840f2..657b3d4b9 100755 --- a/panoptic/dataloaders/encoders/coco.py +++ b/panoptic/dataloaders/encoders/coco.py @@ -19,10 +19,9 @@ import json import os -from absl import logging import tensorflow.compat.v2 as tf - import tensorflow_datasets.public_api as tfds +from absl import logging _CITATION = """\ @article{DBLP:journals/corr/LinMBHPRDZ14, @@ -476,4 +475,4 @@ def get_annotations(self, img_id): AnnotationType.NONE: CocoAnnotation, AnnotationType.BBOXES: CocoAnnotationBBoxes, AnnotationType.PANOPTIC: CocoAnnotationPanoptic, -} \ No newline at end of file +} diff --git a/panoptic/dataloaders/encoders/coco_record_writer.py b/panoptic/dataloaders/encoders/coco_record_writer.py index 37dac3524..c0fb6fe66 100755 --- a/panoptic/dataloaders/encoders/coco_record_writer.py +++ b/panoptic/dataloaders/encoders/coco_record_writer.py @@ -4,13 +4,12 @@ import json import os -from absl import logging +import matplotlib.pyplot as plt +import numpy as np +import pycocotools.mask as mask_utils import tensorflow.compat.v2 as tf import tensorflow_datasets as tfds -import pycocotools.mask as mask_utils -import json -import matplotlib.pyplot as plt -import numpy as np +from absl import logging def reformat_dictionary(things_file, stuff_file, panoptic_file): diff --git a/panoptic/dataloaders/specs/tfds_load.py b/panoptic/dataloaders/specs/tfds_load.py index 539b1a2e3..02d47335c 100755 --- a/panoptic/dataloaders/specs/tfds_load.py +++ b/panoptic/dataloaders/specs/tfds_load.py @@ -4,4 +4,4 @@ dataset = "coco/2017_panoptic" train = tfds.load(name = dataset, download = True, data_dir = path, shuffle_files = True, split = "train") -print(train) \ No newline at end of file +print(train) diff --git a/panoptic/dataloaders/visual_test.py b/panoptic/dataloaders/visual_test.py index 636e5dc26..d2bc4282b 100755 --- a/panoptic/dataloaders/visual_test.py +++ b/panoptic/dataloaders/visual_test.py @@ -1,7 +1,9 @@ -import tensorflow_datasets as tfds import matplotlib.pyplot as plt +import tensorflow_datasets as tfds + from utils.demos import utils + """{image: (None, None, 3), image/filename: (), image/id: (), @@ -82,8 +84,3 @@ def __call__(self, sample): draw(sample) if i > 10: break - - - - - diff --git a/panoptic/train.py b/panoptic/train.py index b00fc5986..111646212 100755 --- a/panoptic/train.py +++ b/panoptic/train.py @@ -14,25 +14,24 @@ # limitations under the License. # ============================================================================== """TensorFlow Model Garden Vision training driver.""" +import gin +from absl import app, flags + +# pylint: enable=unused-import +from official.common import distribute_utils +from official.common import flags as tfm_flags +from official.core import task_factory, train_lib, train_utils +from official.modeling import performance +# pylint: disable=unused-import +from yolo.common import registry_imports from yolo.utils.run_utils import prep_gpu + try: prep_gpu() except BaseException: print('GPUs ready') -from absl import app -from absl import flags -import gin -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports -# pylint: enable=unused-import -from official.common import distribute_utils -from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib -from official.modeling import performance FLAGS = flags.FLAGS """ diff --git a/pylint.sh b/pylint.sh new file mode 100644 index 000000000..bab33732a --- /dev/null +++ b/pylint.sh @@ -0,0 +1,171 @@ +#!/bin/bash +# Copyright 2016 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +# +# Pylint wrapper extracted from main TensorFlow, sharing same exceptions. +# As this is meant for smaller repos, drops "modified files" checking in favor +# of full-repo checking. + +set -euo pipefail + +# Download latest configs from main TensorFlow repo. +wget -q -O /tmp/pylintrc https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/tools/ci_build/pylintrc +wget -q -O /tmp/pylint_allowlist https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/tools/ci_build/pylint_allowlist + +SCRIPT_DIR=/tmp + +num_cpus() { + # Get the number of CPUs + if [[ -f /proc/cpuinfo ]]; then + N_CPUS=$(grep -c ^processor /proc/cpuinfo) + else + # Fallback method + N_CPUS=`getconf _NPROCESSORS_ONLN` + fi + if [[ -z ${N_CPUS} ]]; then + die "ERROR: Unable to determine the number of CPUs" + fi + + echo ${N_CPUS} +} + +get_py_files_to_check() { + find . -name '*.py' +} + +do_pylint() { + # Get all Python files, regardless of mode. + PYTHON_SRC_FILES=$(get_py_files_to_check) + + # Something happened. TF no longer has Python code if this branch is taken + if [[ -z ${PYTHON_SRC_FILES} ]]; then + echo "do_pylint found no Python files to check. Returning." + return 0 + fi + + # Now that we know we have to do work, check if `pylint` is installed + # PYLINT_BIN="python3.8 -m pylint" + PYLINT_BIN="python3 -m pylint" + + echo "" + echo "check whether pylint is available or not." + echo "" + ${PYLINT_BIN} --version + if [[ $? -eq 0 ]] + then + echo "" + echo "pylint available, proceeding with pylint sanity check." + echo "" + else + echo "" + echo "pylint not available." + echo "" + return 1 + fi + + # Configure pylint using the following file + PYLINTRC_FILE="${SCRIPT_DIR}/pylintrc" + + if [[ ! -f "${PYLINTRC_FILE}" ]]; then + die "ERROR: Cannot find pylint rc file at ${PYLINTRC_FILE}" + fi + + # Run pylint in parallel, after some disk setup + NUM_SRC_FILES=$(echo ${PYTHON_SRC_FILES} | wc -w) + NUM_CPUS=$(num_cpus) + + echo "Running pylint on ${NUM_SRC_FILES} files with ${NUM_CPUS} "\ +"parallel jobs..." + echo "" + + PYLINT_START_TIME=$(date +'%s') + OUTPUT_FILE="$(mktemp)_pylint_output.log" + ERRORS_FILE="$(mktemp)_pylint_errors.log" + PERMIT_FILE="$(mktemp)_pylint_permit.log" + FORBID_FILE="$(mktemp)_pylint_forbid.log" + + rm -rf ${OUTPUT_FILE} + rm -rf ${ERRORS_FILE} + rm -rf ${PERMIT_FILE} + rm -rf ${FORBID_FILE} + + set +e + # When running, filter to only contain the error code lines. Removes module + # header, removes lines of context that show up from some lines. + # Also, don't redirect stderr as this would hide pylint fatal errors. + ${PYLINT_BIN} --rcfile="${PYLINTRC_FILE}" --output-format=parseable \ + --jobs=${NUM_CPUS} ${PYTHON_SRC_FILES} | grep '\[[CEFW]' > ${OUTPUT_FILE} + PYLINT_END_TIME=$(date +'%s') + + echo "" + echo "pylint took $((PYLINT_END_TIME - PYLINT_START_TIME)) s" + echo "" + + # Report only what we care about + # Ref https://pylint.readthedocs.io/en/latest/technical_reference/features.html + # E: all errors + # W0311 bad-indentation + # W0312 mixed-indentation + # C0330 bad-continuation + # C0301 line-too-long + # C0326 bad-whitespace + # W0611 unused-import + # W0622 redefined-builtin + grep -E '(\[E|\[W0311|\[W0312|\[C0330|\[C0301|\[C0326|\[W0611|\[W0622)' ${OUTPUT_FILE} > ${ERRORS_FILE} + + # Split the pylint reported errors into permitted ones and those we want to + # block submit on until fixed. + # We use `${ALLOW_LIST_FILE}` to record the errors we temporarily accept. Goal + # is to make that file only contain errors caused by difference between + # internal and external versions. + ALLOW_LIST_FILE="${SCRIPT_DIR}/pylint_allowlist" + + if [[ ! -f "${ALLOW_LIST_FILE}" ]]; then + die "ERROR: Cannot find pylint allowlist file at ${ALLOW_LIST_FILE}" + fi + + # We can split with just 2 grep invocations + grep -f ${ALLOW_LIST_FILE} ${ERRORS_FILE} > ${PERMIT_FILE} + grep -v -f ${ALLOW_LIST_FILE} ${ERRORS_FILE} > ${FORBID_FILE} + + # Determine counts of errors + N_PERMIT_ERRORS=$(wc -l ${PERMIT_FILE} | cut -d' ' -f1) + N_FORBID_ERRORS=$(wc -l ${FORBID_FILE} | cut -d' ' -f1) + set -e + + # First print all allowed errors + echo "" + if [[ ${N_PERMIT_ERRORS} != 0 ]]; then + echo "Found ${N_PERMIT_ERRORS} allowlisted pylint errors:" + cat ${PERMIT_FILE} + fi + + # Now, print the errors we should fix + echo "" + if [[ ${N_FORBID_ERRORS} != 0 ]]; then + echo "Found ${N_FORBID_ERRORS} non-allowlisted pylint errors:" + cat ${FORBID_FILE} + fi + + echo "" + if [[ ${N_FORBID_ERRORS} != 0 ]]; then + echo "FAIL: Found ${N_FORBID_ERRORS} non-allowlisted errors and ${N_PERMIT_ERRORS} allowlisted errors" + return 1 + else + echo "PASS: Found only ${N_PERMIT_ERRORS} allowlisted errors" + fi +} + +do_pylint \ No newline at end of file diff --git a/pylintrc b/pylintrc index 88750048c..5e643542f 100755 --- a/pylintrc +++ b/pylintrc @@ -1,3 +1,12 @@ +# NOTE: this pylintrc file is a combination of 3 pylint files. The source +# files are denoted in the comments as the following: +# { From [1] } : TensorFlow +# https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/tools/ci_build/pylintrc +# { From [2] } : TensorFlow Model Garden +# https://raw.githubusercontent.com/tensorflow/models/master/official/utils/testing/pylint.rcfile +# { From [3] } : Google Style Guide +# https://google.github.io/styleguide/pylintrc + # This Pylint rcfile contains a best-effort configuration to uphold the # best-practices and style described in the Google Python style guide: # https://google.github.io/styleguide/pyguide.html @@ -7,20 +16,24 @@ [MASTER] -# Add files or directories to the blacklist. They should be base names, not -# paths. +# Files or directories to be skipped. They should be base names, not paths. +# { From [1] } +# ignore=CVS ignore=third_party -# Add files or directories matching the regex patterns to the blacklist. The -# regex matches against base names, not paths. +# Files or directories matching the regex patterns are skipped. The regex +# matches against base names, not paths. ignore-patterns= # Pickle collected data for later comparisons. -persistent=no +persistent=yes # { From [1] } +# persistent=no # List of plugins (as comma separated values of python modules names) to load, # usually to register additional checkers. -load-plugins= +# { From [1] } +load-plugins=pylint.extensions.docparams +accept-no-param-doc=no # Use multiple processes to speed up Pylint. jobs=4 @@ -29,10 +42,8 @@ jobs=4 # active Python interpreter and may run arbitrary code. unsafe-load-any-extension=no -# A comma-separated list of package or module names from where C extensions may -# be loaded. Extensions are loading into the active Python interpreter and may -# run arbitrary code -extension-pkg-whitelist= +# Profiled execution. { From [1] } +profile=no [MESSAGES CONTROL] @@ -45,7 +56,8 @@ confidence= # either give multiple identifier separated by comma (,) or put this option # multiple time (only on the command line, not in the configuration file where # it should appear only once). See also the "--disable" option for examples. -#enable= +# { From [1] } +enable=indexing-exception,old-raise-syntax # Disable the message, report, category or checker with the given id(s). You # can either give multiple identifiers separated by comma (,) or put this @@ -56,103 +68,113 @@ confidence= # --enable=similarities". If you want to run only the classes checker, but have # no Warning level messages displayed, use"--disable=all --enable=classes # --disable=W" -disable=abstract-method, - apply-builtin, - arguments-differ, - attribute-defined-outside-init, - backtick, - bad-option-value, - basestring-builtin, - buffer-builtin, - c-extension-no-member, - consider-using-enumerate, - cmp-builtin, - cmp-method, - coerce-builtin, - coerce-method, - delslice-method, - div-method, - duplicate-code, - eq-without-hash, - execfile-builtin, - file-builtin, - filter-builtin-not-iterating, - fixme, - getslice-method, - global-statement, - hex-method, - idiv-method, - implicit-str-concat-in-sequence, - import-error, - import-self, - import-star-module-level, - inconsistent-return-statements, - input-builtin, - intern-builtin, - invalid-str-codec, - locally-disabled, - long-builtin, - long-suffix, - map-builtin-not-iterating, - misplaced-comparison-constant, - missing-function-docstring, - metaclass-assignment, - next-method-called, - next-method-defined, - no-absolute-import, - no-else-break, - no-else-continue, - no-else-raise, - no-else-return, - no-init, # added - no-member, - no-name-in-module, - no-self-use, - nonzero-method, - oct-method, - old-division, - old-ne-operator, - old-octal-literal, - old-raise-syntax, - parameter-unpacking, - print-statement, - raising-string, - range-builtin-not-iterating, - raw_input-builtin, - rdiv-method, - reduce-builtin, - relative-import, - reload-builtin, - round-builtin, - setslice-method, - signature-differs, - standarderror-builtin, - suppressed-message, - sys-max-int, - too-few-public-methods, - too-many-ancestors, - too-many-arguments, - too-many-boolean-expressions, - too-many-branches, - too-many-instance-attributes, - too-many-locals, - too-many-nested-blocks, - too-many-public-methods, - too-many-return-statements, - too-many-statements, - trailing-newlines, - unichr-builtin, - unicode-builtin, - unnecessary-pass, - unpacking-in-except, - useless-else-on-loop, - useless-object-inheritance, - useless-suppression, - using-cmp-argument, - wrong-import-order, - xrange-builtin, - zip-builtin-not-iterating, +# { From [1] } +disable=design,similarities,no-self-use,attribute-defined-outside-init,locally-disabled,star-args,pointless-except,bad-option-value,global-statement,fixme,suppressed-message,useless-suppression,locally-enabled,no-member,no-name-in-module,import-error,unsubscriptable-object,unbalanced-tuple-unpacking,undefined-variable,not-context-manager,invalid-sequence-index +# { From [2] } +#disable=R,W,bad-option-value,trailing-newlines,no-name-in-module + +# { From [3] } +#disable=abstract-method, +# apply-builtin, +# arguments-differ, +# attribute-defined-outside-init, +# backtick, +# bad-option-value, +# basestring-builtin, +# buffer-builtin, +# c-extension-no-member, +# consider-using-enumerate, +# cmp-builtin, +# cmp-method, +# coerce-builtin, +# coerce-method, +# delslice-method, +# div-method, +# duplicate-code, +# eq-without-hash, +# execfile-builtin, +# file-builtin, +# filter-builtin-not-iterating, +# fixme, +# getslice-method, +# global-statement, +# hex-method, +# idiv-method, +# implicit-str-concat-in-sequence, +# import-error, +# import-self, +# import-star-module-level, +# inconsistent-return-statements, +# input-builtin, +# intern-builtin, +# invalid-str-codec, +# locally-disabled, +# long-builtin, +# long-suffix, +# map-builtin-not-iterating, +# misplaced-comparison-constant, +# missing-function-docstring, +# metaclass-assignment, +# next-method-called, +# next-method-defined, +# no-absolute-import, +# no-else-break, +# no-else-continue, +# no-else-raise, +# no-else-return, +# no-init, # added +# no-member, +# no-name-in-module, +# no-self-use, +# nonzero-method, +# oct-method, +# old-division, +# old-ne-operator, +# old-octal-literal, +# old-raise-syntax, +# parameter-unpacking, +# print-statement, +# raising-string, +# range-builtin-not-iterating, +# raw_input-builtin, +# rdiv-method, +# reduce-builtin, +# relative-import, +# reload-builtin, +# round-builtin, +# setslice-method, +# signature-differs, +# standarderror-builtin, +# suppressed-message, +# sys-max-int, +# too-few-public-methods, +# too-many-ancestors, +# too-many-arguments, +# too-many-boolean-expressions, +# too-many-branches, +# too-many-instance-attributes, +# too-many-locals, +# too-many-nested-blocks, +# too-many-public-methods, +# too-many-return-statements, +# too-many-statements, +# trailing-newlines, +# unichr-builtin, +# unicode-builtin, +# unnecessary-pass, +# unpacking-in-except, +# useless-else-on-loop, +# useless-object-inheritance, +# useless-suppression, +# using-cmp-argument, +# wrong-import-order, +# xrange-builtin, +# zip-builtin-not-iterating, + +# Set the cache size for astng objects. +# { From [1] } +cache-size=500 [REPORTS] @@ -177,13 +199,29 @@ reports=no # (RP0004). evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) +# Add a comment according to your evaluation note. This is used by the global +# evaluation report (RP0004). +# { From [1] } +comment=no + # Template used to display messages. This is a python new-style format string # used to format the message information. See doc for all details #msg-template= +# Activate the evaluation score. +score=no + [BASIC] +# List of builtins function names that should not be used, separated by a comma { Frpm tensorflow/master/tensorflow/tools } +bad-functions=apply,input,reduce + +# Disable the report(s) with the given id(s). +# All non-Google reports are disabled by default. +# { From [1] } +disable-report=R0001,R0002,R0003,R0004,R0101,R0102,R0201,R0202,R0220,R0401,R0402,R0701,R0801,R0901,R0902,R0903,R0904,R0911,R0912,R0913,R0914,R0915,R0921,R0922,R0923 + # Good variable names which should always be accepted, separated by a comma good-names=main,_ @@ -202,7 +240,12 @@ include-naming-hint=no property-classes=abc.abstractproperty,cached_property.cached_property,cached_property.threaded_cached_property,cached_property.cached_property_with_ttl,cached_property.threaded_cached_property_with_ttl # Regular expression matching correct function names -function-rgx=^(?:(?PsetUp|tearDown|setUpModule|tearDownModule)|(?P_?[A-Z][a-zA-Z0-9]*)|(?P_?[a-z][a-z0-9_]*))$ +# { From [1] } +# function-rgx=^(?:(?P_?[A-Z][a-zA-Z0-9]*)|(?P_?[a-z][a-z0-9_]*))$ +# { From [2] } +function-rgx=^(?:(?P_?[A-Z][a-zA-Z0-9]*)|(?P_?[a-z][a-z0-9_]*))$ +# { From [3] } +#function-rgx=^(?:(?PsetUp|tearDown|setUpModule|tearDownModule)|(?P_?[A-Z][a-zA-Z0-9]*)|(?P_?[a-z][a-z0-9_]*))$ # Regular expression matching correct variable names variable-rgx=^[a-z][a-z0-9_]*$ @@ -226,19 +269,37 @@ inlinevar-rgx=^[a-z][a-z0-9_]*$ class-rgx=^_?[A-Z][a-zA-Z0-9]*$ # Regular expression matching correct module names -module-rgx=^(_?[a-z][a-z0-9_]*|__init__)$ +# { From [1] } +# module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ +# { From [2] } +module-rgx=^(_?[a-z][a-z0-9_]*)|__init__|PRESUBMIT|PRESUBMIT_unittest$ +# { From [3] } +#module-rgx=^(_?[a-z][a-z0-9_]*|__init__)$ # Regular expression matching correct method names -method-rgx=(?x)^(?:(?P_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P_{0,2}[a-z][a-z0-9_]*))$ +# { From [1] } +# method-rgx=^(?:(?P__[a-z0-9_]+__|next)|(?P_{0,2}[A-Z][a-zA-Z0-9]*)|(?P_{0,2}[a-z][a-z0-9_]*))$ +# { From [2] } +method-rgx=^(?:(?P__[a-z0-9_]+__|next)|(?P_{0,2}[A-Z][a-zA-Z0-9]*)|(?P_{0,2}[a-z][a-z0-9_]*)|(setUp|tearDown))$ +# { From [3] } +#method-rgx=(?x)^(?:(?P_[a-z0-9_]+__|runTest|setUp|tearDown|setUpTestCase|tearDownTestCase|setupSelf|tearDownClass|setUpClass|(test|assert)_*[A-Z0-9][a-zA-Z0-9_]*|next)|(?P_{0,2}[A-Z][a-zA-Z0-9_]*)|(?P_{0,2}[a-z][a-z0-9_]*))$ # Regular expression which should only match function or class names that do # not require a docstring. -no-docstring-rgx=(__.*__|main|test.*|.*test|.*Test)$ +# { From [1] } +# no-docstring-rgx=(__.*__|main) +# { From [2] } +no-docstring-rgx=(__.*__|main|.*ArgParser) +# { From [3] } +#no-docstring-rgx=(__.*__|main|test.*|.*test|.*Test)$ # Minimum line length for functions/classes that require docstrings, shorter # ones are exempt. docstring-min-length=10 +# Naming hint for variable names { From tensorflow/models/master/official } +variable-name-hint=[a-z_][a-z0-9_]{2,30}$ + [TYPECHECK] @@ -255,17 +316,28 @@ ignore-mixin-members=yes # (useful for modules/projects where namespaces are manipulated during runtime # and thus existing member attributes cannot be deduced by static analysis. It # supports qualified module names, as well as Unix pattern matching. -ignored-modules= + +# { From [2] } +ignored-modules=absl, absl.*, official, official.*, tensorflow, tensorflow.*, LazyLoader, google, google.cloud.* # List of class names for which member attributes should not be checked (useful # for classes with dynamically set attributes). This supports the use of # qualified names. -ignored-classes=optparse.Values,thread._local,_thread._local +# { From [1] } +# ignored-classes=SQLObject +# { From [3] } +ignored-classes=optparse.Values,thread._local,_thread._local, SQLObject + +# When zope mode is activated, add a predefined set of Zope acquired attributes +# to generated-members. +# { From [1] } +zope=no # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E1101 when accessed. Python regular -# expressions are accepted. -generated-members= +# expressions are accepted. +# { From [1] } +generated-members=REQUEST,acl_users,aq_parent [FORMAT] @@ -277,9 +349,26 @@ max-line-length=80 # lines made too long by directives to pytype. # Regexp for a line that is allowed to be longer than the limit. -ignore-long-lines=(?x)( - ^\s*(\#\ )??$| - ^\s*(from\s+\S+\s+)?import\s+.+$) +# { From [2] } +# ignore-long-lines=^\s*(?:(# )??$|# type:) + +# { From [1] } +ignore-long-lines=(?x) + (^\s*(import|from)\s + |\$Id:\s\/\/depot\/.+#\d+\s\$ + |^[a-zA-Z_][a-zA-Z0-9_]*\s*=\s*("[^"]\S+"|'[^']\S+') + |^\s*\#\ LINT\.ThenChange + |^[^#]*\#\ type:\ [a-zA-Z_][a-zA-Z0-9_.,[\] ]*$ + |pylint + |""" + |\# + |lambda + |(https?|ftp):) + +# { From [3] } +#ignore-long-lines=(?x)( +# ^\s*(\#\ )??$| +# ^\s*(from\s+\S+\s+)?import\s+.+$) # Allow the body of an if to be on the same line as the test if there is no # else. @@ -416,6 +505,10 @@ analyse-fallback-blocks=no [CLASSES] +# List of interface methods to ignore, separated by a comma. This is used for +# instance to not check methods defines in Zope's Interface base class. +# { From [1] } +ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods=__init__, @@ -437,6 +530,39 @@ valid-classmethod-first-arg=cls, # List of valid names for the first argument in a metaclass class method. valid-metaclass-classmethod-first-arg=mcs +[DESIGN] +# { From [2] } --> entire section + +# Argument names that match this expression will be ignored. Default to name +# with leading underscore +ignored-argument-names=_.* + +# Maximum number of arguments for function / method +max-args=5 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Maximum number of branch for function / method body +max-branches=12 + +# Maximum number of locals for function / method body +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body +max-returns=6 + +# Maximum number of statements in function / method body +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 [EXCEPTIONS] @@ -445,3 +571,32 @@ valid-metaclass-classmethod-first-arg=mcs overgeneral-exceptions=StandardError, Exception, BaseException + + + +[AST] +# { From [1] } --> entire section + +# Maximum line length for lambdas +short-func-length=1 + +# List of module members that should be marked as deprecated. +# All of the string functions are listed in 4.1.4 Deprecated string functions +# in the Python 2.4 docs. +deprecated-members=string.atof,string.atoi,string.atol,string.capitalize,string.expandtabs,string.find,string.rfind,string.index,string.rindex,string.count,string.lower,string.split,string.rsplit,string.splitfields,string.join,string.joinfields,string.lstrip,string.rstrip,string.strip,string.swapcase,string.translate,string.upper,string.ljust,string.rjust,string.center,string.zfill,string.replace,sys.exitfunc + + +[DOCSTRING] +# { From [1] } --> entire section +default-docstring-type=google +# List of exceptions that do not need to be mentioned in the Raises section of +# a docstring. +ignore-exceptions=AssertionError,NotImplementedError,StopIteration,TypeError + + + +[GOOGLE LINES] +# { From [1] } --> entire section + +# Regexp for a proper copyright notice. +copyright=Copyright \d{4} The TensorFlow Authors\. +All [Rr]ights [Rr]eserved\. \ No newline at end of file diff --git a/test_folder_linter/test_file.py b/test_folder_linter/test_file.py index ecae67987..9c15b3a62 100755 --- a/test_folder_linter/test_file.py +++ b/test_folder_linter/test_file.py @@ -1,13 +1,12 @@ +import numpy as np +import pandas as pd +from sklearn import preprocessing from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score -from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split -from sklearn import preprocessing -import numpy as np -import pandas as pd +from sklearn.preprocessing import StandardScaler -from NFold_GridSearch import NFold -from NFold_GridSearch import GridSearch +from NFold_GridSearch import GridSearch, NFold np.set_printoptions(threshold=np.inf) diff --git a/utils/demos/coco.py b/utils/demos/coco.py index 0a541be77..e3be9428e 100755 --- a/utils/demos/coco.py +++ b/utils/demos/coco.py @@ -1,7 +1,7 @@ -import cv2 import colorsys -import numpy as np +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras.backend as K diff --git a/utils/demos/coco_dataset_converter.py b/utils/demos/coco_dataset_converter.py index f0f780505..a25fff57d 100755 --- a/utils/demos/coco_dataset_converter.py +++ b/utils/demos/coco_dataset_converter.py @@ -1,9 +1,10 @@ +import io +import json +import os + import tensorflow as tf from PIL import Image from tqdm import tqdm -import io -import os -import json def encode_image(image, fmt='JPEG'): diff --git a/utils/demos/utils.py b/utils/demos/utils.py index ee46ec100..f08fc6cdd 100755 --- a/utils/demos/utils.py +++ b/utils/demos/utils.py @@ -1,14 +1,15 @@ -import tensorflow as tf -import tensorflow.keras.backend as K +import colorsys +import multiprocessing as mp +import os import socket import struct +from contextlib import closing from typing import Callable -import numpy as np -import colorsys + import cv2 -from contextlib import closing -import multiprocessing as mp -import os +import numpy as np +import tensorflow as tf +import tensorflow.keras.backend as K def get_device(policy): diff --git a/utils/downloads/__init__.py b/utils/downloads/__init__.py index 8b1378917..e69de29bb 100755 --- a/utils/downloads/__init__.py +++ b/utils/downloads/__init__.py @@ -1 +0,0 @@ - diff --git a/utils/downloads/file_manager.py b/utils/downloads/file_manager.py index 492644194..aee14cc51 100755 --- a/utils/downloads/file_manager.py +++ b/utils/downloads/file_manager.py @@ -6,7 +6,6 @@ import io import os - from typing import Union # define PathABC type diff --git a/utils/export/get_cfg_yaml.py b/utils/export/get_cfg_yaml.py index bd09487c6..ccb9cf409 100755 --- a/utils/export/get_cfg_yaml.py +++ b/utils/export/get_cfg_yaml.py @@ -1,6 +1,7 @@ -from yolo.configs import yolo as exp_cfg import yaml +from yolo.configs import yolo as exp_cfg + config = exp_cfg.yolo_v4_coco() e = yaml.dump(config.as_dict(), default_flow_style=False) diff --git a/utils/export/tensor_rt.py b/utils/export/tensor_rt.py index 29980cdbe..0f710190d 100755 --- a/utils/export/tensor_rt.py +++ b/utils/export/tensor_rt.py @@ -1,10 +1,12 @@ import tensorflow as tf -# import tensorflow.experimental.tensorrt as trt - from tensorflow.python.compiler.tensorrt import trt_convert as trt from utils.run_utils import prep_gpu +# import tensorflow.experimental.tensorrt as trt + + + class TensorRT(object): diff --git a/utils/register.py b/utils/register.py new file mode 100644 index 000000000..80eb98e97 --- /dev/null +++ b/utils/register.py @@ -0,0 +1,165 @@ +import dataclasses +import functools +import inspect +import string +import warnings +from typing import ClassVar, Union + +from official.core import exp_factory, registry, task_factory +from official.modeling import hyperparams +from official.vision.beta.configs import backbones, backbones_3d +from official.vision.beta.modeling import factory_3d as models_3d_factory +from official.vision.beta.modeling.backbones import \ + factory as backbones_factory + + +def _deduce_type(fn, config_param=1): + if inspect.isclass(fn): + fn = fn_or_cls.__init__ + if isinstance(config_param, int): + sig = list(inspect.signature(fn).parameters.items())[ + config_param][1] + return sig.annotation, sig.default + elif isinstance(config_param, str): + sig = inspect.signature(fn).parameters[config_param] + return sig.annotation, sig.default + else: + return None, inspect.Signature.empty + +def _snake_case(class_name: str): + words = [] + + for c in class_name: + if c in string.ascii_uppercase: + words.append('_' + c.lower()) + else: + words.append(c) + + return ''.join(words).strip('_') + +def _inject_dataclass(dcls, name, cls, value): + del dcls.__init__, dcls.__repr__, dcls.__eq__ + dcls.__annotations__[name] = cls + setattr(dcls, name, value) + dataclasses.dataclass(dcls) + +def _make_registry_shim(dataclass, register, config_param=1): + def shim(name: str = None, config_class: type = None, + default = inspect.Signature.empty): + nonlocal dataclass, register + + def decorator(builder): + nonlocal dataclass, register, name, config_class, default + + if config_class is None: + config_class, deduced_default = _deduce_type(builder, config_param) + else: + deduced_default = inspect.Signature.empty + + if name is None: + assert config_class is not None, 'Either the name or the class must ' \ + 'be specified' + name = _snake_case(config_class.__name__) + + if default is inspect.Signature.empty: + if deduced_default is not inspect.Signature.empty: + default = deduced_default + elif config_class is not None: + default = config_class() + + if config_class is not None: + _inject_dataclass(dataclass, name, config_class, default) + else: + warnings.warn(f'Config class for {name} was not specified', + stacklevel=2) + return register(name)(builder) + + if callable(name): + return decorator(name) + return decorator + + return shim + +backbone = _make_registry_shim(backbones.Backbone, + backbones_factory.register_backbone_builder, None) +backbone_3d = _make_registry_shim(backbones_3d.Backbone3D, + backbones_factory.register_backbone_builder, None) + +task = task_factory.register_task_cls +experiment = exp_factory.register_config_factory + + +class Registry(dict): + + def register(self, key): + return registry.register(self, key) + + def _lookup(self, key): + return registry.lookup(self, key) + + +class RegistryOneOfConfigMetaclass(type): + + def __new__(cls, name, bases, dct): + dct['_REGISTRY'] = Registry() + if '__annotations__' not in dct: + dct['__annotations__'] = {'_REGISTRY': ClassVar[dict]} + else: + dct['__annotations__']['_REGISTRY'] = ClassVar[dict] + + _CONFIG_PARAM = dct.get('_CONFIG_PARAM', 1) + obj = super().__new__(cls, name, bases, dct) + obj.register = _make_registry_shim(obj, obj._old_register, + config_param=_CONFIG_PARAM) + return obj + + +@dataclasses.dataclass +class RegistryOneOfConfig( + hyperparams.OneOfConfig, metaclass=RegistryOneOfConfigMetaclass): + _CONFIG_PARAM: ClassVar[Union[str, int]] = None + + @classmethod + def _old_register(cls, key): + return registry.register(cls._REGISTRY, key) + + @classmethod + def _lookup(cls, key): + return registry.lookup(cls._REGISTRY, key) + +if __name__ == '__main__': + from official.vision.beta.configs import backbones + import tensorflow as tf + + @dataclasses.dataclass + class Backbone(backbones.Backbone, RegistryOneOfConfig): + # _CONFIG_PARAM = 1 + pass + + @dataclasses.dataclass + class DarkNet(hyperparams.Config): + """DarkNet config.""" + model_id: str = 'darknet53' + + mobilenet = Backbone({'type': 'mobilenet'}) + print(mobilenet) + print(mobilenet.mobilenet) + + print(Backbone._REGISTRY) + + @Backbone.register('darknet') + # @factory.register_backbone_builder("darknet") + def build_darknet( + input_specs: tf.keras.layers.InputSpec, + model_config: DarkNet, + l2_regularizer: tf.keras.regularizers.Regularizer = None + ) -> tf.keras.Model: + pass + + print(build_darknet) + + darknet = Backbone({'type': 'darknet'}) + print(darknet) + print(mobilenet) + print(Backbone._REGISTRY) + print(Backbone._lookup('darknet')) diff --git a/utils/training/keras_task_trainer.py b/utils/training/keras_task_trainer.py index 376386697..ca54edc42 100755 --- a/utils/training/keras_task_trainer.py +++ b/utils/training/keras_task_trainer.py @@ -1,9 +1,10 @@ import tensorflow as tf +from tensorflow.keras.mixed_precision import experimental as mixed_precision + import official.core.base_task as bt from official.core import input_reader from yolo.dataloaders import yolo_input from yolo.dataloaders.decoders import tfds_coco_decoder -from tensorflow.keras.mixed_precision import experimental as mixed_precision class Trainer(tf.keras.Model): diff --git a/yolo/common/registry_imports.py b/yolo/common/registry_imports.py index 41bf498f5..0c16d420a 100755 --- a/yolo/common/registry_imports.py +++ b/yolo/common/registry_imports.py @@ -14,18 +14,14 @@ # ============================================================================== """All necessary imports for registration.""" +import yolo # pylint: disable=unused-import from official.common import registry_imports - -import yolo +from yolo.configs import darknet_classification, yolo +from yolo.configs.darknet_classification import (ImageClassificationTask, + image_classification) +from yolo.configs.yolo import YoloTask, yolo_custom from yolo.modeling.backbones import darknet -from yolo.configs import darknet_classification -from yolo.configs import yolo -from yolo.configs.yolo import yolo_custom -from yolo.configs.darknet_classification import image_classification -from yolo.configs.darknet_classification import ImageClassificationTask -from yolo.configs.yolo import YoloTask - from yolo.tasks.image_classification import ImageClassificationTask from yolo.tasks.yolo import YoloTask from yolo.tasks.yolo_subdiv import YoloSubDivTask diff --git a/yolo/common/train_lib.py b/yolo/common/train_lib.py index 46820ee85..8201df046 100755 --- a/yolo/common/train_lib.py +++ b/yolo/common/train_lib.py @@ -16,14 +16,12 @@ import os from typing import Any, Mapping, Tuple +import tensorflow as tf # Import libraries from absl import logging -import orbit -import tensorflow as tf -from official.core import base_task -from official.core import config_definitions -from official.core import train_utils +import orbit +from official.core import base_task, config_definitions, train_utils BestCheckpointExporter = train_utils.BestCheckpointExporter diff --git a/yolo/configs/backbones.py b/yolo/configs/backbones.py index 194547993..698cde27e 100755 --- a/yolo/configs/backbones.py +++ b/yolo/configs/backbones.py @@ -2,6 +2,7 @@ # Import libraries import dataclasses from typing import Optional + from official.modeling import hyperparams from official.vision.beta.configs import backbones diff --git a/yolo/configs/darknet_classification.py b/yolo/configs/darknet_classification.py index a76a76ba2..f686383c5 100755 --- a/yolo/configs/darknet_classification.py +++ b/yolo/configs/darknet_classification.py @@ -1,12 +1,11 @@ +import dataclasses import os from typing import List, Optional, Tuple -import dataclasses + from official.core import config_definitions as cfg from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization +from official.modeling import hyperparams, optimization from official.vision.beta.configs import common - from yolo.configs import backbones diff --git a/yolo/configs/yolo.py b/yolo/configs/yolo.py index 886218529..befc41544 100755 --- a/yolo/configs/yolo.py +++ b/yolo/configs/yolo.py @@ -14,17 +14,16 @@ # limitations under the License. # ============================================================================== """YOLO configuration definition.""" -import tensorflow as tf -from typing import ClassVar, Dict, List, Optional, Tuple, Union import dataclasses import os +from typing import ClassVar, Dict, List, Optional, Tuple, Union + +import tensorflow as tf from official.core import exp_factory -from official.modeling import hyperparams -from official.modeling import optimization +from official.modeling import hyperparams, optimization from official.modeling.hyperparams import config_definitions as cfg from official.vision.beta.configs import common - from yolo.configs import backbones COCO_INPUT_PATH_BASE = 'coco' diff --git a/yolo/dataloaders/classification_input.py b/yolo/dataloaders/classification_input.py index e19585478..51c9d6ff2 100755 --- a/yolo/dataloaders/classification_input.py +++ b/yolo/dataloaders/classification_input.py @@ -2,8 +2,8 @@ # Import libraries import tensorflow as tf -import tensorflow_datasets as tfds import tensorflow_addons as tfa +import tensorflow_datasets as tfds from official.vision.beta.dataloaders import parser from official.vision.beta.ops import preprocess_ops diff --git a/yolo/dataloaders/classification_vision.py b/yolo/dataloaders/classification_vision.py index f443dc1d2..e17f17f2c 100755 --- a/yolo/dataloaders/classification_vision.py +++ b/yolo/dataloaders/classification_vision.py @@ -2,12 +2,11 @@ # Import libraries import tensorflow as tf -import tensorflow_datasets as tfds import tensorflow_addons as tfa +import tensorflow_datasets as tfds from official.vision.beta.dataloaders import parser -from official.vision.beta.ops import preprocess_ops -from official.vision.beta.ops import augment +from official.vision.beta.ops import augment, preprocess_ops class Parser(parser.Parser): diff --git a/yolo/dataloaders/decoders/classification_tfds_decoder.py b/yolo/dataloaders/decoders/classification_tfds_decoder.py index fabb6abe4..411831cb2 100755 --- a/yolo/dataloaders/decoders/classification_tfds_decoder.py +++ b/yolo/dataloaders/decoders/classification_tfds_decoder.py @@ -16,8 +16,7 @@ # Import libraries import tensorflow as tf -from official.vision.beta.dataloaders import decoder -from official.vision.beta.dataloaders import parser +from official.vision.beta.dataloaders import decoder, parser from official.vision.beta.ops import preprocess_ops diff --git a/yolo/dataloaders/decoders/tfds_coco_decoder.py b/yolo/dataloaders/decoders/tfds_coco_decoder.py index 67aa4a345..26b9a025b 100755 --- a/yolo/dataloaders/decoders/tfds_coco_decoder.py +++ b/yolo/dataloaders/decoders/tfds_coco_decoder.py @@ -3,6 +3,7 @@ protos for object detection. """ import csv + # Import libraries import tensorflow as tf diff --git a/yolo/dataloaders/priming_input.py b/yolo/dataloaders/priming_input.py index 77ac54b63..cecdf96db 100755 --- a/yolo/dataloaders/priming_input.py +++ b/yolo/dataloaders/priming_input.py @@ -2,8 +2,8 @@ # Import libraries import tensorflow as tf -import tensorflow_datasets as tfds import tensorflow_addons as tfa +import tensorflow_datasets as tfds from official.vision.beta.dataloaders import parser diff --git a/yolo/dataloaders/yolo_input.py b/yolo/dataloaders/yolo_input.py index bc55d6557..965d5678c 100755 --- a/yolo/dataloaders/yolo_input.py +++ b/yolo/dataloaders/yolo_input.py @@ -7,11 +7,11 @@ import tensorflow as tf import tensorflow_addons as tfa -from yolo.ops import preprocessing_ops -from yolo.ops import box_ops as box_utils -from official.vision.beta.ops import box_ops, preprocess_ops from official.vision.beta.dataloaders import parser, utils +from official.vision.beta.ops import box_ops, preprocess_ops +from yolo.ops import box_ops as box_utils from yolo.ops import loss_utils as loss_ops +from yolo.ops import preprocessing_ops def pad_max_instances(value, instances, pad_value=0, pad_axis=0): diff --git a/yolo/dataloaders/yolo_input_test.py b/yolo/dataloaders/yolo_input_test.py index ae4f6c471..2b69ff296 100755 --- a/yolo/dataloaders/yolo_input_test.py +++ b/yolo/dataloaders/yolo_input_test.py @@ -1,18 +1,21 @@ -from yolo.tasks import image_classification as imc -from yolo.utils.demos import utils, coco -from yolo.tasks import yolo -from yolo.configs import yolo as yolocfg -from yolo.configs import darknet_classification as dcfg +import dataclasses +import time + +import matplotlib.pyplot as plt +import tensorflow as tf + +from official.core import config_definitions as cfg from official.core import input_reader -from yolo.dataloaders import yolo_input as YOLO_Detection_Input +from official.modeling import hyperparams +from yolo.configs import darknet_classification as dcfg +from yolo.configs import yolo as yolocfg from yolo.dataloaders import classification_input +from yolo.dataloaders import yolo_input as YOLO_Detection_Input from yolo.dataloaders.decoders import tfds_coco_decoder from yolo.ops import box_ops -import matplotlib.pyplot as plt -import dataclasses -from official.modeling import hyperparams -from official.core import config_definitions as cfg -import tensorflow as tf +from yolo.tasks import image_classification as imc +from yolo.tasks import yolo +from yolo.utils.demos import coco, utils def test_yolo_input_task(): @@ -63,7 +66,6 @@ def test_classification_pipeline(): return -import time def test_pipeline(): diff --git a/yolo/demos/demo_lib/readers.py b/yolo/demos/demo_lib/readers.py index b365f9cbc..9bb2f4cfb 100755 --- a/yolo/demos/demo_lib/readers.py +++ b/yolo/demos/demo_lib/readers.py @@ -1,8 +1,9 @@ +import abc import threading as t -from queue import Queue import time +from queue import Queue + import cv2 -import abc class Reader(object): diff --git a/yolo/demos/demo_lib/video_detect_gpu.py b/yolo/demos/demo_lib/video_detect_gpu.py index f1669e5f7..ff9f981fb 100755 --- a/yolo/demos/demo_lib/video_detect_gpu.py +++ b/yolo/demos/demo_lib/video_detect_gpu.py @@ -1,27 +1,22 @@ -import cv2 -import datetime import colorsys -import numpy as np -import time - +import datetime import threading as t +import time from queue import Queue +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras as ks import tensorflow.keras.backend as K -from yolo.utils.run_utils import support_windows -from yolo.utils.demos.coco import draw_box -from yolo.utils.demos.coco import get_draw_fn -from yolo.utils.demos.coco import gen_colors -from yolo.utils.demos.coco import get_coco_names -from yolo.utils.demos.coco import int_scale_boxes -from yolo.utils.demos import utils -# from utils.demos import utils -from yolo.utils.run_utils import prep_gpu from yolo.configs import yolo as exp_cfg from yolo.tasks.yolo import YoloTask +from yolo.utils.demos import utils +from yolo.utils.demos.coco import (draw_box, gen_colors, get_coco_names, + get_draw_fn, int_scale_boxes) +# from utils.demos import utils +from yolo.utils.run_utils import prep_gpu, support_windows class FastVideo(object): diff --git a/yolo/demos/demo_lib/writer.py b/yolo/demos/demo_lib/writer.py index 95cd9ffd3..9ec911c43 100755 --- a/yolo/demos/demo_lib/writer.py +++ b/yolo/demos/demo_lib/writer.py @@ -1,8 +1,9 @@ +import abc import threading as t -from queue import Queue import time +from queue import Queue + import cv2 -import abc class Writer(object): diff --git a/yolo/demos/examples/server/app.py b/yolo/demos/examples/server/app.py index abc2a372c..48eb36e0b 100755 --- a/yolo/demos/examples/server/app.py +++ b/yolo/demos/examples/server/app.py @@ -1,24 +1,26 @@ +import base64 +import sys +import urllib.request +from queue import Queue + +import cv2 +import numpy as np +import tensorflow as tf + +from flask import Flask, jsonify, request +from yolo.configs import yolo as exp_cfg +from yolo.demos.three_servers import model_server as ms +from yolo.tasks.yolo import YoloTask +from yolo.utils.demos import coco, utils from yolo.utils.run_utils import prep_gpu + try: prep_gpu() except BaseException: print("GPU's already prepped") -from flask import Flask, request, jsonify -import numpy as np -import base64 -import cv2 -import sys -import tensorflow as tf -from yolo.demos.three_servers import model_server as ms -from yolo.configs import yolo as exp_cfg -from yolo.tasks.yolo import YoloTask -from yolo.utils.demos import utils -from yolo.utils.demos import coco -from queue import Queue -import urllib.request app = Flask(__name__) diff --git a/yolo/demos/model_val.py b/yolo/demos/model_val.py index c77dc434f..4ee1c18cc 100755 --- a/yolo/demos/model_val.py +++ b/yolo/demos/model_val.py @@ -1,8 +1,8 @@ import tensorflow as tf -from yolo.utils.run_utils import prep_gpu from yolo.configs import yolo as exp_cfg from yolo.tasks.yolo import YoloTask +from yolo.utils.run_utils import prep_gpu if __name__ == "__main__": # initialize YOLOv4 model diff --git a/yolo/demos/routed_webcam.py b/yolo/demos/routed_webcam.py index 74cbe0fa2..c826dfb69 100755 --- a/yolo/demos/routed_webcam.py +++ b/yolo/demos/routed_webcam.py @@ -1,25 +1,19 @@ -import cv2 -import datetime import colorsys -import numpy as np -import time - +import datetime import threading as t +import time from queue import Queue +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras as ks import tensorflow.keras.backend as K -from yolo.utils.run_utils import support_windows -from yolo.utils.run_utils import prep_gpu -from yolo.utils.demos.coco import draw_box -from yolo.utils.demos.coco import get_draw_fn -from yolo.utils.demos.coco import gen_colors -from yolo.utils.demos.coco import get_coco_names -from yolo.utils.demos.coco import int_scale_boxes - import pyfakewebcam +from yolo.utils.demos.coco import (draw_box, gen_colors, get_coco_names, + get_draw_fn, int_scale_boxes) +from yolo.utils.run_utils import prep_gpu, support_windows class FastVideo(object): diff --git a/yolo/demos/three_servers/model_server.py b/yolo/demos/three_servers/model_server.py index d22a1544a..c660aa083 100755 --- a/yolo/demos/three_servers/model_server.py +++ b/yolo/demos/three_servers/model_server.py @@ -1,23 +1,20 @@ -import yolo.demos.three_servers.video_server as video_t -import struct -import cv2 -import datetime import colorsys -import numpy as np -import time - +import datetime +import struct import threading as t +import time +import traceback from queue import Queue +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras as ks import tensorflow.keras.backend as K -from yolo.utils.run_utils import support_windows -from yolo.utils.run_utils import prep_gpu -from yolo.utils.demos import utils -from yolo.utils.demos import coco -import traceback +import yolo.demos.three_servers.video_server as video_t +from yolo.utils.demos import coco, utils +from yolo.utils.run_utils import prep_gpu, support_windows class ModelServer(object): diff --git a/yolo/demos/three_servers/udp_server.py b/yolo/demos/three_servers/udp_server.py index 92975f9b9..0cfc89f91 100755 --- a/yolo/demos/three_servers/udp_server.py +++ b/yolo/demos/three_servers/udp_server.py @@ -1,9 +1,11 @@ import socket -from yolo.utils.demos import utils -from queue import Queue +import struct import threading as t +from queue import Queue + import numpy as np -import struct + +from yolo.utils.demos import utils class UDPServer(object): diff --git a/yolo/demos/three_servers/video_server.py b/yolo/demos/three_servers/video_server.py index 3cfd8246e..5d34cbf8e 100755 --- a/yolo/demos/three_servers/video_server.py +++ b/yolo/demos/three_servers/video_server.py @@ -1,8 +1,9 @@ -import cv2 import threading as t -from queue import Queue -import traceback import time +import traceback +from queue import Queue + +import cv2 from yolo.demos.three_servers.frame_que import FrameQue from yolo.utils.demos import utils diff --git a/yolo/demos/video_detect_cpu.py b/yolo/demos/video_detect_cpu.py index 2f78191b0..e2ff5a4ea 100755 --- a/yolo/demos/video_detect_cpu.py +++ b/yolo/demos/video_detect_cpu.py @@ -1,9 +1,9 @@ #### ARGUMENT PARSER #### -from yolo.utils.demos import utils -from yolo.utils.demos import coco -from yolo.demos.three_servers import video_server as vs -import tensorflow as tf import cv2 +import tensorflow as tf + +from yolo.demos.three_servers import video_server as vs +from yolo.utils.demos import coco, utils def print_opt(latency, fps): diff --git a/yolo/demos/video_detect_gpu.py b/yolo/demos/video_detect_gpu.py index 28f82995f..b35130561 100755 --- a/yolo/demos/video_detect_gpu.py +++ b/yolo/demos/video_detect_gpu.py @@ -1,28 +1,23 @@ -import cv2 -import datetime import colorsys -import numpy as np -import time - +import datetime import threading as t +import time from queue import Queue +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras as ks import tensorflow.keras.backend as K -from yolo.utils.run_utils import support_windows -from yolo.utils.demos.coco import draw_box -from yolo.utils.demos.coco import get_draw_fn -from yolo.utils.demos.coco import gen_colors -from yolo.utils.demos.coco import get_coco_names -from yolo.utils.demos.coco import int_scale_boxes -from yolo.utils.demos import utils -# from utils.demos import utils -from yolo.utils.run_utils import prep_gpu +import yolo.demos.three_servers.video_server as video_t from yolo.configs import yolo as exp_cfg from yolo.tasks.yolo import YoloTask -import yolo.demos.three_servers.video_server as video_t +from yolo.utils.demos import utils +from yolo.utils.demos.coco import (draw_box, gen_colors, get_coco_names, + get_draw_fn, int_scale_boxes) +# from utils.demos import utils +from yolo.utils.run_utils import prep_gpu, support_windows class FastVideo(object): diff --git a/yolo/losses/gradient_aggregator.py b/yolo/losses/gradient_aggregator.py index 2b38f0214..ca7e718a9 100755 --- a/yolo/losses/gradient_aggregator.py +++ b/yolo/losses/gradient_aggregator.py @@ -1,5 +1,7 @@ import tensorflow as tf +from yolo import run + # TODO: run sub dividied training. take the gradients and added them together in the update # once you, when they ask for the result jsut return it, and reset the state # i think you need to zip and then add them together. @@ -79,7 +81,6 @@ def result(self): return self._zeros, self._count -from yolo import run if __name__ == '__main__': task, model, params = run.load_model( diff --git a/yolo/losses/yolo_loss.py b/yolo/losses/yolo_loss.py index d3ef33f61..d065da746 100755 --- a/yolo/losses/yolo_loss.py +++ b/yolo/losses/yolo_loss.py @@ -1,11 +1,11 @@ +import numpy as np import tensorflow as tf import tensorflow.keras as ks from tensorflow.keras import backend as K +from yolo.ops import box_ops, math_ops from yolo.ops.loss_utils import GridGenerator -from yolo.ops import box_ops -from yolo.ops import math_ops -import numpy as np + @tf.custom_gradient def gradient_trap(y): diff --git a/yolo/modeling/Yolo.py b/yolo/modeling/Yolo.py index c349cfbd3..23c39d85c 100755 --- a/yolo/modeling/Yolo.py +++ b/yolo/modeling/Yolo.py @@ -1,12 +1,12 @@ -from yolo.configs import yolo -from official.core import registry -from official.vision.beta.modeling.backbones import factory -from yolo.modeling.backbones.darknet import build_darknet +from typing import * + import tensorflow as tf import tensorflow.keras as ks -from typing import * -from yolo.modeling.backbones.darknet import Darknet +from official.core import registry +from official.vision.beta.modeling.backbones import factory +from yolo.configs import yolo +from yolo.modeling.backbones.darknet import Darknet, build_darknet from yolo.modeling.decoders.yolo_decoder import YoloDecoder from yolo.modeling.heads.yolo_head import YoloHead from yolo.modeling.layers.detection_generator import YoloLayer diff --git a/yolo/modeling/backbones/darknet.py b/yolo/modeling/backbones/darknet.py index 37e2674b5..16007924a 100755 --- a/yolo/modeling/backbones/darknet.py +++ b/yolo/modeling/backbones/darknet.py @@ -14,6 +14,7 @@ """ import collections + import tensorflow as tf import tensorflow.keras as ks diff --git a/yolo/modeling/backbones/darknet_test.py b/yolo/modeling/backbones/darknet_test.py index c362ab71a..1c2c730b1 100755 --- a/yolo/modeling/backbones/darknet_test.py +++ b/yolo/modeling/backbones/darknet_test.py @@ -1,10 +1,9 @@ # Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations from yolo.modeling.backbones import darknet diff --git a/yolo/modeling/backbones/spinenet.py b/yolo/modeling/backbones/spinenet.py index 5381bf0aa..7158d1480 100755 --- a/yolo/modeling/backbones/spinenet.py +++ b/yolo/modeling/backbones/spinenet.py @@ -21,13 +21,13 @@ """ import math +import tensorflow as tf # Import libraries from absl import logging -import tensorflow as tf + from official.modeling import tf_utils from official.vision.beta.modeling.backbones import factory -from official.vision.beta.modeling.layers import nn_blocks -from official.vision.beta.modeling.layers import nn_layers +from official.vision.beta.modeling.layers import nn_blocks, nn_layers from official.vision.beta.ops import spatial_transform_ops layers = tf.keras.layers diff --git a/yolo/modeling/classification_model.py b/yolo/modeling/classification_model.py index 8d4e85765..c4ca48d15 100755 --- a/yolo/modeling/classification_model.py +++ b/yolo/modeling/classification_model.py @@ -16,6 +16,7 @@ # Import libraries import tensorflow as tf + from yolo.modeling.layers import nn_blocks layers = tf.keras.layers diff --git a/yolo/modeling/decoders/yolo_decoder.py b/yolo/modeling/decoders/yolo_decoder.py index 1cf67ff0b..f66ab21b4 100755 --- a/yolo/modeling/decoders/yolo_decoder.py +++ b/yolo/modeling/decoders/yolo_decoder.py @@ -16,6 +16,7 @@ """Feature Pyramid Network and Path Aggregation variants used in YOLO""" import tensorflow as tf + from yolo.modeling.layers import nn_blocks diff --git a/yolo/modeling/decoders/yolo_decoder_.py b/yolo/modeling/decoders/yolo_decoder_.py index 47c2a4d3b..72f1bb6cc 100755 --- a/yolo/modeling/decoders/yolo_decoder_.py +++ b/yolo/modeling/decoders/yolo_decoder_.py @@ -16,6 +16,7 @@ """Feature Pyramid Network and Path Aggregation variants used in YOLO""" import tensorflow as tf + from yolo.modeling.layers import nn_blocks diff --git a/yolo/modeling/decoders/yolo_decoder_test.py b/yolo/modeling/decoders/yolo_decoder_test.py index 8097323a3..57f2337b3 100755 --- a/yolo/modeling/decoders/yolo_decoder_test.py +++ b/yolo/modeling/decoders/yolo_decoder_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for resnet.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations # from yolo.modeling.backbones import darknet from yolo.modeling.decoders import yolo_decoder as decoders diff --git a/yolo/modeling/heads/yolo_head.py b/yolo/modeling/heads/yolo_head.py index 88ad67d45..451acae0a 100755 --- a/yolo/modeling/heads/yolo_head.py +++ b/yolo/modeling/heads/yolo_head.py @@ -1,4 +1,5 @@ import tensorflow as tf + from yolo.modeling.layers import nn_blocks diff --git a/yolo/modeling/heads/yolo_head_test.py b/yolo/modeling/heads/yolo_head_test.py index 19c335e75..bab951b67 100755 --- a/yolo/modeling/heads/yolo_head_test.py +++ b/yolo/modeling/heads/yolo_head_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for resnet.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations # from yolo.modeling.backbones import darknet from yolo.modeling.heads import yolo_head as heads diff --git a/yolo/modeling/layers/detection_generator.py b/yolo/modeling/layers/detection_generator.py index ff710d3f8..44d69d7a3 100755 --- a/yolo/modeling/layers/detection_generator.py +++ b/yolo/modeling/layers/detection_generator.py @@ -3,10 +3,9 @@ import tensorflow.keras as ks import tensorflow.keras.backend as K -from yolo.ops import loss_utils -from yolo.ops import box_ops as box_utils from yolo.losses.yolo_loss import Yolo_Loss -from yolo.ops import nms_ops +from yolo.ops import box_ops as box_utils +from yolo.ops import loss_utils, nms_ops @ks.utils.register_keras_serializable(package='yolo') diff --git a/yolo/modeling/layers/detection_generator_test.py b/yolo/modeling/layers/detection_generator_test.py index 70f22f3be..158304357 100755 --- a/yolo/modeling/layers/detection_generator_test.py +++ b/yolo/modeling/layers/detection_generator_test.py @@ -15,13 +15,12 @@ # ============================================================================== """Tests for resnet.""" -# Import libraries -from absl.testing import parameterized import numpy as np import tensorflow as tf +# Import libraries +from absl.testing import parameterized +from tensorflow.python.distribute import combinations, strategy_combinations -from tensorflow.python.distribute import combinations -from tensorflow.python.distribute import strategy_combinations # from yolo.modeling.backbones import darknet from yolo.modeling.layers import detection_generator as dg diff --git a/yolo/modeling/layers/nn_blocks.py b/yolo/modeling/layers/nn_blocks.py index 3fd9995cb..2f00c5724 100755 --- a/yolo/modeling/layers/nn_blocks.py +++ b/yolo/modeling/layers/nn_blocks.py @@ -1,9 +1,11 @@ """Contains common building blocks for yolo neural networks.""" from typing import Callable + import tensorflow as tf -from yolo.modeling.layers import subnormalization + from official.modeling import tf_utils from official.vision.beta.ops import spatial_transform_ops +from yolo.modeling.layers import subnormalization TPU_BASE = True @@ -1564,4 +1566,4 @@ def call(self, inputs): x_prev = x x = layer(x) output_prev = output - return x_prev, x \ No newline at end of file + return x_prev, x diff --git a/yolo/modeling/layers/nn_blocks_test.py b/yolo/modeling/layers/nn_blocks_test.py index f730d57ee..8b1f2948f 100755 --- a/yolo/modeling/layers/nn_blocks_test.py +++ b/yolo/modeling/layers/nn_blocks_test.py @@ -1,6 +1,6 @@ +import numpy as np import tensorflow as tf import tensorflow.keras as ks -import numpy as np from absl.testing import parameterized from yolo.modeling.layers import nn_blocks diff --git a/yolo/modeling/layers/subnormalization.py b/yolo/modeling/layers/subnormalization.py index d6b8cf0f4..dd0aca3ae 100755 --- a/yolo/modeling/layers/subnormalization.py +++ b/yolo/modeling/layers/subnormalization.py @@ -13,35 +13,22 @@ # limitations under the License. # ============================================================================== """Normalization layers.""" -from __future__ import absolute_import -from __future__ import division -from __future__ import print_function +from __future__ import absolute_import, division, print_function -from tensorflow.python.distribute import distribution_strategy_context +import tensorflow as tf from tensorflow.python.distribute import distribution_strategy_context as ds -from tensorflow.python.framework import constant_op -from tensorflow.python.framework import dtypes -from tensorflow.python.framework import ops -from tensorflow.python.framework import tensor_shape +from tensorflow.python.distribute import reduce_util +from tensorflow.python.framework import constant_op, dtypes, ops, tensor_shape from tensorflow.python.keras import backend as K -from tensorflow.python.keras import constraints -from tensorflow.python.keras import initializers -from tensorflow.python.keras import regularizers +from tensorflow.python.keras import constraints, initializers, regularizers from tensorflow.python.keras.engine.base_layer import Layer from tensorflow.python.keras.engine.input_spec import InputSpec +from tensorflow.python.keras.layers import normalization from tensorflow.python.keras.utils import control_flow_util -from tensorflow.python.ops import array_ops -from tensorflow.python.ops import control_flow_ops -from tensorflow.python.ops import init_ops -from tensorflow.python.ops import math_ops -from tensorflow.python.ops import nn -from tensorflow.python.ops import state_ops +from tensorflow.python.ops import (array_ops, control_flow_ops, init_ops, + math_ops, nn, state_ops) from tensorflow.python.ops import variables as tf_variables from tensorflow.python.platform import tf_logging as logging -from tensorflow.python.distribute import reduce_util -from tensorflow.python.keras.layers import normalization - -import tensorflow as tf class SubDivBatchNormalization(normalization.BatchNormalizationBase): diff --git a/yolo/modeling/optimizers/AdamAccumulated.py b/yolo/modeling/optimizers/AdamAccumulated.py index 6719a8f3a..0591ddaf0 100755 --- a/yolo/modeling/optimizers/AdamAccumulated.py +++ b/yolo/modeling/optimizers/AdamAccumulated.py @@ -1,7 +1,7 @@ import tensorflow as tf -from tensorflow.python.keras.optimizer_v2.optimizer_v2 import OptimizerV2 -from tensorflow.python import ops, math_ops, state_ops, control_flow_ops +from tensorflow.python import control_flow_ops, math_ops, ops, state_ops from tensorflow.python.keras import backend_config +from tensorflow.python.keras.optimizer_v2.optimizer_v2 import OptimizerV2 __all__ = ['AdamAccumulated'] diff --git a/yolo/modeling/optimizers/SGDAccumulated.py b/yolo/modeling/optimizers/SGDAccumulated.py index 515587ca0..cd828b65a 100755 --- a/yolo/modeling/optimizers/SGDAccumulated.py +++ b/yolo/modeling/optimizers/SGDAccumulated.py @@ -1,6 +1,8 @@ import tensorflow as tf from tensorflow.python.keras.optimizer_v2.optimizer_v2 import OptimizerV2 -from tensorflow.python.ops import math_ops, state_ops, control_flow_ops, array_ops +from tensorflow.python.ops import (array_ops, control_flow_ops, math_ops, + state_ops) + # from tensorflow.python import ops # from tensorflow.python.keras import backend_config diff --git a/yolo/ops/box_ops.py b/yolo/ops/box_ops.py index adb913df6..eb4b79f68 100755 --- a/yolo/ops/box_ops.py +++ b/yolo/ops/box_ops.py @@ -1,10 +1,12 @@ """ bounding box utils file """ +import math +from typing import Tuple, Union + # import libraries import tensorflow as tf import tensorflow.keras.backend as K -from typing import Tuple, Union -import math + from yolo.ops import math_ops diff --git a/yolo/ops/kmeans_anchors.py b/yolo/ops/kmeans_anchors.py index 8427a539a..9004ace70 100755 --- a/yolo/ops/kmeans_anchors.py +++ b/yolo/ops/kmeans_anchors.py @@ -1,9 +1,8 @@ -import tensorflow as tf import numpy as np +import tensorflow as tf -from yolo.ops.box_ops import compute_iou -from yolo.ops.box_ops import yxyx_to_xcycwh from official.core import input_reader +from yolo.ops.box_ops import compute_iou, yxyx_to_xcycwh class AnchorKMeans: diff --git a/yolo/ops/math_ops.py b/yolo/ops/math_ops.py index 23aebf089..82db5558b 100755 --- a/yolo/ops/math_ops.py +++ b/yolo/ops/math_ops.py @@ -1,6 +1,7 @@ import tensorflow as tf import tensorflow.keras.backend as K + def rm_nan_inf(x, val=0.0): cond = tf.math.logical_or(tf.math.is_nan(x), tf.math.is_inf(x)) val = tf.cast(val, dtype=x.dtype) @@ -20,4 +21,4 @@ def divide_no_nan(a, b): return tf.where(b == zero, zero, a / b) def mul_no_nan(x, y): - return tf.where(x == 0, tf.cast(0, x.dtype), x * y) \ No newline at end of file + return tf.where(x == 0, tf.cast(0, x.dtype), x * y) diff --git a/yolo/ops/preprocessing_ops.py b/yolo/ops/preprocessing_ops.py index ca730a050..7065ad745 100755 --- a/yolo/ops/preprocessing_ops.py +++ b/yolo/ops/preprocessing_ops.py @@ -1,9 +1,10 @@ import tensorflow as tf -import tensorflow_addons as tfa import tensorflow.keras.backend as K -from yolo.ops import box_ops -from official.vision.beta.ops import preprocess_ops +import tensorflow_addons as tfa + from official.vision.beta.ops import box_ops as bbox_ops +from official.vision.beta.ops import preprocess_ops +from yolo.ops import box_ops def rand_uniform_strong(minval, maxval, dtype=tf.float32): @@ -455,34 +456,46 @@ def filter_boxes_and_classes(boxes, classes, image_info, keep_thresh=0.01): return boxes, classes -def letter_box(image, boxes, target_dim=None): +def letter_box(image, boxes, xs = 0.5, ys = 0.5, target_dim=None): height, width = get_image_shape(image) clipper = tf.math.maximum(width, height) if target_dim is None: target_dim = clipper - pad_width = clipper - width - pad_height = clipper - height - image = tf.image.pad_to_bounding_box(image, pad_height // 2, pad_width // 2, + xs = tf.convert_to_tensor(xs) + ys = tf.convert_to_tensor(ys) + pad_width_p = clipper - width + pad_height_p = clipper - height + pad_height = tf.cast(tf.cast(pad_height_p, ys.dtype) * ys, tf.int32) + pad_width = tf.cast(tf.cast(pad_width_p, xs.dtype) * xs, tf.int32) + image = tf.image.pad_to_bounding_box(image, pad_height, pad_width, clipper, clipper) boxes = box_ops.yxyx_to_xcycwh(boxes) x, y, w, h = tf.split(boxes, 4, axis=-1) - y *= tf.cast(height / clipper, tf.float32) - x *= tf.cast(width / clipper, tf.float32) + y *= tf.cast(height / clipper, y.dtype) + x *= tf.cast(width / clipper, x.dtype) - y += tf.cast((pad_height / clipper) / 2, tf.float32) - x += tf.cast((pad_width / clipper) / 2, tf.float32) + y += tf.cast((pad_height / clipper), y.dtype) + x += tf.cast((pad_width / clipper), x.dtype) - h *= tf.cast(height / clipper, tf.float32) - w *= tf.cast(width / clipper, tf.float32) + h *= tf.cast(height / clipper, h.dtype) + w *= tf.cast(width / clipper, w.dtype) boxes = tf.concat([x, y, w, h], axis=-1) boxes = box_ops.xcycwh_to_yxyx(boxes) + boxes = tf.where(h == 0, tf.zeros_like(boxes), boxes) + image = tf.image.resize(image, (target_dim, target_dim)) - return image, boxes + + scale = target_dim/clipper + pt_width = tf.cast(tf.cast(pad_width, scale.dtype) * scale, tf.int32) + pt_height = tf.cast(tf.cast(pad_height, scale.dtype) * scale, tf.int32) + pt_width_p = tf.cast(tf.cast(pad_width_p, scale.dtype) * scale, tf.int32) + pt_height_p = tf.cast(tf.cast(pad_height_p, scale.dtype) * scale, tf.int32) + return image, boxes, [pt_height, pt_width, target_dim - pt_height_p, target_dim - pt_width_p] def patch_four_images(images): diff --git a/yolo/run.py b/yolo/run.py index 35532d083..cc94a8fb3 100755 --- a/yolo/run.py +++ b/yolo/run.py @@ -1,29 +1,29 @@ +import os +import sys +from typing import List, Tuple + +import gin +import tensorflow as tf +from absl import app, flags + +# pylint: enable=unused-import +from official.common import flags as tfm_flags +from official.core import task_factory, train_utils +from official.modeling import performance +# pylint: disable=unused-import +from yolo.common import registry_imports +from yolo.demos import video_detect_cpu as vcu +from yolo.demos import video_detect_gpu as vgu from yolo.utils.run_utils import prep_gpu + # try: # # except BaseException: # print("GPUs ready") -from absl import app -from absl import flags -import gin -import sys -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports -# pylint: enable=unused-import -from official.common import flags as tfm_flags -from typing import Tuple, List -from official.core import train_utils -from official.modeling import performance -from official.core import task_factory -import os -from yolo.demos import video_detect_gpu as vgu -from yolo.demos import video_detect_cpu as vcu -import tensorflow as tf """ export GOOGLE_APPLICATION_CREDENTIALS=.json python3.8 -m yolo.run --experiment=yolo_custom --out_resolution 416 --config_file=yolo/configs/experiments/yolov4-eval.yaml --video ../videos/nyc.mp4 --max_batch 5 diff --git a/yolo/run_image.py b/yolo/run_image.py index 5b7accc15..874ba3991 100755 --- a/yolo/run_image.py +++ b/yolo/run_image.py @@ -1,28 +1,24 @@ -from absl import app -from absl import flags -import gin +import os import sys +from typing import List, Tuple + +import cv2 +import gin +import numpy as np +import tensorflow as tf +from absl import app, flags -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports # pylint: enable=unused-import from official.common import flags as tfm_flags - -from typing import Tuple, List -from official.core import train_utils +from official.core import task_factory, train_utils from official.modeling import performance -from official.core import task_factory -import os -import tensorflow as tf - +from skimage import io +# pylint: disable=unused-import +from yolo.common import registry_imports from yolo.run import load_model from yolo.utils.demos import utils -import cv2 -import numpy as np -from skimage import io - from yolo.utils.run_utils import prep_gpu + try: prep_gpu() except BaseException: diff --git a/yolo/tasks/backbone_test.py b/yolo/tasks/backbone_test.py index 630d9b823..78d9ebb47 100755 --- a/yolo/tasks/backbone_test.py +++ b/yolo/tasks/backbone_test.py @@ -1,10 +1,10 @@ -from yolo.configs import darknet_classification as dcfg -from yolo.tasks import image_classification as imc -from yolo.modeling.backbones import darknet +import matplotlib.pyplot as plt import tensorflow as tf +from yolo.configs import darknet_classification as dcfg +from yolo.modeling.backbones import darknet +from yolo.tasks import image_classification as imc from yolo.utils.run_utils import prep_gpu -import matplotlib.pyplot as plt def test_classification_input(): diff --git a/yolo/tasks/image_classification.py b/yolo/tasks/image_classification.py index c72d43272..280f38bf8 100755 --- a/yolo/tasks/image_classification.py +++ b/yolo/tasks/image_classification.py @@ -14,17 +14,17 @@ # limitations under the License. # ============================================================================== """Image classification task definition.""" +import logging + import tensorflow as tf -from official.core import input_reader -from official.core import task_factory + +from official.core import input_reader, task_factory +from official.modeling import tf_utils +from official.vision.beta.tasks import image_classification from yolo.configs import darknet_classification as exp_cfg +from yolo.dataloaders import classification_input, classification_vision from yolo.dataloaders.decoders import classification_tfds_decoder as cli -from yolo.dataloaders import classification_input -from yolo.dataloaders import classification_vision -from official.vision.beta.tasks import image_classification from yolo.losses import cross_entropy_loss -from official.modeling import tf_utils -import logging @task_factory.register_task_cls(exp_cfg.ImageClassificationTask) diff --git a/yolo/tasks/yolo.py b/yolo/tasks/yolo.py index 37b26bf50..50de5b6ae 100755 --- a/yolo/tasks/yolo.py +++ b/yolo/tasks/yolo.py @@ -1,22 +1,18 @@ import tensorflow as tf -from tensorflow.keras.mixed_precision import experimental as mixed_precision - from absl import logging -from official.core import base_task -from official.core import input_reader -from official.core import task_factory -from yolo.configs import yolo as exp_cfg +from tensorflow.keras.mixed_precision import experimental as mixed_precision +from official.core import base_task, input_reader, task_factory +from official.vision.beta.dataloaders import (tf_example_decoder, + tf_example_label_map_decoder, + tfds_detection_decoders) from official.vision.beta.evaluation import coco_evaluator -from official.vision.beta.dataloaders import tf_example_decoder -from official.vision.beta.dataloaders import tfds_detection_decoders -from official.vision.beta.dataloaders import tf_example_label_map_decoder - +from official.vision.beta.ops import box_ops, preprocess_ops +from yolo.configs import yolo as exp_cfg from yolo.dataloaders import yolo_input -from yolo.ops.kmeans_anchors import BoxGenInputReader from yolo.ops.box_ops import xcycwh_to_yxyx +from yolo.ops.kmeans_anchors import BoxGenInputReader -from official.vision.beta.ops import box_ops, preprocess_ops # from yolo.modeling.layers.detection_generator import YoloGTFilter diff --git a/yolo/tasks/yolo_subdiv.py b/yolo/tasks/yolo_subdiv.py index 0751edde4..4a80bc915 100755 --- a/yolo/tasks/yolo_subdiv.py +++ b/yolo/tasks/yolo_subdiv.py @@ -1,23 +1,18 @@ import tensorflow as tf -from tensorflow.keras.mixed_precision import experimental as mixed_precision - from absl import logging -from official.core import base_task -from official.core import input_reader -from official.core import task_factory -from yolo.configs import yolo as exp_cfg +from tensorflow.keras.mixed_precision import experimental as mixed_precision +from official.core import base_task, input_reader, task_factory from official.vision.beta.evaluation import coco_evaluator - +from official.vision.beta.ops import box_ops, preprocess_ops +from yolo.configs import yolo as exp_cfg from yolo.dataloaders import yolo_input from yolo.dataloaders.decoders import tfds_coco_decoder -from yolo.ops.kmeans_anchors import BoxGenInputReader +from yolo.losses import gradient_aggregator from yolo.ops.box_ops import xcycwh_to_yxyx - -from official.vision.beta.ops import box_ops, preprocess_ops +from yolo.ops.kmeans_anchors import BoxGenInputReader # from yolo.modeling.layers.detection_generator import YoloGTFilter from yolo.tasks import yolo -from yolo.losses import gradient_aggregator @task_factory.register_task_cls(exp_cfg.YoloSubDivTask) diff --git a/yolo/tasks/yolo_test.py b/yolo/tasks/yolo_test.py index 4f272e691..46c7ccdc8 100755 --- a/yolo/tasks/yolo_test.py +++ b/yolo/tasks/yolo_test.py @@ -1,11 +1,12 @@ -from yolo.tasks import yolo +import tensorflow as tf +from absl.testing import parameterized + import orbit from official.core import exp_factory from official.modeling import optimization - -import tensorflow as tf -from absl.testing import parameterized +from yolo.tasks import yolo from yolo.utils.run_utils import prep_gpu + # try: # prep_gpu() # except BaseException: diff --git a/yolo/test.py b/yolo/test.py index 855b4b3f5..c87a654cb 100755 --- a/yolo/test.py +++ b/yolo/test.py @@ -1,4 +1,4 @@ -from yolo.utils.run_utils import prep_gpu, expand_gpu +from yolo.utils.run_utils import expand_gpu, prep_gpu expand_gpu() try: diff --git a/yolo/train.py b/yolo/train.py index c00a5e3d4..751f5f7d7 100755 --- a/yolo/train.py +++ b/yolo/train.py @@ -14,27 +14,27 @@ # limitations under the License. # ============================================================================== """TensorFlow Model Garden Vision training driver.""" -from yolo.utils.run_utils import prep_gpu -try: - prep_gpu() -except BaseException: - print('GPUs ready') +import pprint +import sys -from absl import app -from absl import flags import gin -import sys +from absl import app, flags -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports # pylint: enable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib +from official.core import task_factory, train_lib, train_utils from official.modeling import performance -import pprint +# pylint: disable=unused-import +from yolo.common import registry_imports +from yolo.utils.run_utils import prep_gpu + +try: + prep_gpu() +except BaseException: + print('GPUs ready') + + FLAGS = flags.FLAGS """ diff --git a/yolo/train_gilbreth.py b/yolo/train_gilbreth.py index ba9108a8c..9cb243afb 100755 --- a/yolo/train_gilbreth.py +++ b/yolo/train_gilbreth.py @@ -21,22 +21,19 @@ # except RuntimeError: # print("GPUs ready") -from absl import app -from absl import flags -import gin import sys -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports +import gin +from absl import app, flags +from tensorflow import distribute + # pylint: enable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib +from official.core import task_factory, train_lib, train_utils from official.modeling import performance - -from tensorflow import distribute +# pylint: disable=unused-import +from yolo.common import registry_imports FLAGS = flags.FLAGS """ diff --git a/yolo/train_vm.py b/yolo/train_vm.py index b99928385..a93a798be 100755 --- a/yolo/train_vm.py +++ b/yolo/train_vm.py @@ -14,23 +14,20 @@ # limitations under the License. # ============================================================================== """TensorFlow Model Garden Vision training driver.""" -from yolo.utils.run_utils import prep_gpu +import sys -from absl import app -from absl import flags import gin -import sys +import tensorflow as tf +from absl import app, flags -from official.core import train_utils -# pylint: disable=unused-import -from yolo.common import registry_imports # pylint: enable=unused-import from official.common import distribute_utils from official.common import flags as tfm_flags -from official.core import task_factory -from official.core import train_lib +from official.core import task_factory, train_lib, train_utils from official.modeling import performance -import tensorflow as tf +# pylint: disable=unused-import +from yolo.common import registry_imports +from yolo.utils.run_utils import prep_gpu FLAGS = flags.FLAGS """ diff --git a/yolo/utils/_darknet2tf/__init__.py b/yolo/utils/_darknet2tf/__init__.py index fb53d1f34..1768ee28b 100755 --- a/yolo/utils/_darknet2tf/__init__.py +++ b/yolo/utils/_darknet2tf/__init__.py @@ -1,11 +1,10 @@ import collections import collections.abc import io +from typing import Type, TypeVar, Union from yolo.utils.downloads.file_manager import PathABC -from typing import Union, Type, TypeVar - T = TypeVar('T', bound='DarkNetModel') diff --git a/yolo/utils/_darknet2tf/__main__.py b/yolo/utils/_darknet2tf/__main__.py index 013abc20f..5129be61f 100755 --- a/yolo/utils/_darknet2tf/__main__.py +++ b/yolo/utils/_darknet2tf/__main__.py @@ -1,11 +1,12 @@ # !/usr/bin/env python3 import argparse as _argparse -from absl.flags import argparse_flags as _argparse_flags -from absl import flags as _flags -from . import DarkNetConverter -from absl import app import sys -from . import main, _parser + +from absl import app +from absl import flags as _flags +from absl.flags import argparse_flags as _argparse_flags + +from . import DarkNetConverter, _parser, main "Convert a DarkNet config file and weights into a TensorFlow model" diff --git a/yolo/utils/_darknet2tf/config_classes.py b/yolo/utils/_darknet2tf/config_classes.py index 1b31f2738..f9d7207e3 100755 --- a/yolo/utils/_darknet2tf/config_classes.py +++ b/yolo/utils/_darknet2tf/config_classes.py @@ -10,9 +10,9 @@ from abc import ABC, abstractmethod from dataclasses import dataclass, field -import numpy as np +from typing import List, Tuple -from typing import Tuple, List +import numpy as np class Config(ABC): diff --git a/yolo/utils/_darknet2tf/dn2dicts.py b/yolo/utils/_darknet2tf/dn2dicts.py index 209eab066..95b3ad17b 100755 --- a/yolo/utils/_darknet2tf/dn2dicts.py +++ b/yolo/utils/_darknet2tf/dn2dicts.py @@ -4,7 +4,6 @@ import configparser import io import sys - from typing import Dict, List if sys.version_info < (3, 10): diff --git a/yolo/utils/_darknet2tf/dnnum.py b/yolo/utils/_darknet2tf/dnnum.py index 648fed07a..ed785d738 100755 --- a/yolo/utils/_darknet2tf/dnnum.py +++ b/yolo/utils/_darknet2tf/dnnum.py @@ -1,9 +1,10 @@ #!/usr/bin/env python3 "Number the blocks in a DarkNet config file" +import argparse + from absl import app from absl.flags import argparse_flags -import argparse from yolo.utils.downloads import file_manager diff --git a/yolo/utils/_darknet2tf/load_weights copy.py b/yolo/utils/_darknet2tf/load_weights copy.py index 6f7a617bd..d740f6cc0 100755 --- a/yolo/utils/_darknet2tf/load_weights copy.py +++ b/yolo/utils/_darknet2tf/load_weights copy.py @@ -3,8 +3,11 @@ format into TensorFlow layers """ import itertools + from tensorflow import keras as ks -from yolo.modeling.layers.nn_blocks import DarkConv # pylint: disable=unused-import + +from yolo.modeling.layers.nn_blocks import \ + DarkConv # pylint: disable=unused-import def split_converter(lst, i, j=None): diff --git a/yolo/utils/_darknet2tf/load_weights.py b/yolo/utils/_darknet2tf/load_weights.py index 14dc7e030..63afe5fc2 100755 --- a/yolo/utils/_darknet2tf/load_weights.py +++ b/yolo/utils/_darknet2tf/load_weights.py @@ -3,8 +3,11 @@ format into TensorFlow layers """ import itertools + from tensorflow import keras as ks + from yolo.modeling.layers.nn_blocks import ConvBN + from .config_classes import convCFG diff --git a/yolo/utils/_darknet2tf/load_weights2.py b/yolo/utils/_darknet2tf/load_weights2.py index 3916e96f2..207258c5d 100755 --- a/yolo/utils/_darknet2tf/load_weights2.py +++ b/yolo/utils/_darknet2tf/load_weights2.py @@ -1,6 +1,8 @@ +import numpy as np + from yolo.modeling.layers.nn_blocks import ConvBN + from .config_classes import convCFG, samCFG -import numpy as np def split_converter(lst, i, j=None): diff --git a/yolo/utils/_darknet2tf/read_weights.py b/yolo/utils/_darknet2tf/read_weights.py index 234ed09f6..9f0793ea4 100755 --- a/yolo/utils/_darknet2tf/read_weights.py +++ b/yolo/utils/_darknet2tf/read_weights.py @@ -2,9 +2,10 @@ This file contains the code to parse DarkNet weight files. """ +from yolo.utils.downloads.file_manager import get_size, open_if_not_open + from .config_classes import * # pylint: disable=wildcard-import, unused-wildcard-import from .dn2dicts import convertConfigFile -from yolo.utils.downloads.file_manager import get_size, open_if_not_open def build_layer(layer_dict, file, net): diff --git a/yolo/utils/demos/coco.py b/yolo/utils/demos/coco.py index 0a541be77..e3be9428e 100755 --- a/yolo/utils/demos/coco.py +++ b/yolo/utils/demos/coco.py @@ -1,7 +1,7 @@ -import cv2 import colorsys -import numpy as np +import cv2 +import numpy as np import tensorflow as tf import tensorflow.keras.backend as K diff --git a/yolo/utils/demos/coco_dataset_converter.py b/yolo/utils/demos/coco_dataset_converter.py index f0f780505..a25fff57d 100755 --- a/yolo/utils/demos/coco_dataset_converter.py +++ b/yolo/utils/demos/coco_dataset_converter.py @@ -1,9 +1,10 @@ +import io +import json +import os + import tensorflow as tf from PIL import Image from tqdm import tqdm -import io -import os -import json def encode_image(image, fmt='JPEG'): diff --git a/yolo/utils/demos/utils.py b/yolo/utils/demos/utils.py index 5ee359c20..7914342f2 100755 --- a/yolo/utils/demos/utils.py +++ b/yolo/utils/demos/utils.py @@ -1,14 +1,16 @@ -import tensorflow as tf -import tensorflow.keras.backend as K +import colorsys +import multiprocessing as mp +import os import socket import struct +from concurrent.futures import ThreadPoolExecutor as pooler from typing import Callable -import numpy as np -import colorsys + import cv2 -from concurrent.futures import ThreadPoolExecutor as pooler -import multiprocessing as mp -import os +import numpy as np +import tensorflow as tf +import tensorflow.keras.backend as K + # from concurrent.futures import ProcessPoolExecutor as pooler diff --git a/yolo/utils/downloads/__init__.py b/yolo/utils/downloads/__init__.py index 8b1378917..e69de29bb 100755 --- a/yolo/utils/downloads/__init__.py +++ b/yolo/utils/downloads/__init__.py @@ -1 +0,0 @@ - diff --git a/yolo/utils/downloads/file_manager.py b/yolo/utils/downloads/file_manager.py index 492644194..aee14cc51 100755 --- a/yolo/utils/downloads/file_manager.py +++ b/yolo/utils/downloads/file_manager.py @@ -6,7 +6,6 @@ import io import os - from typing import Union # define PathABC type diff --git a/yolo/utils/export/get_cfg_yaml.py b/yolo/utils/export/get_cfg_yaml.py index bd09487c6..ccb9cf409 100755 --- a/yolo/utils/export/get_cfg_yaml.py +++ b/yolo/utils/export/get_cfg_yaml.py @@ -1,6 +1,7 @@ -from yolo.configs import yolo as exp_cfg import yaml +from yolo.configs import yolo as exp_cfg + config = exp_cfg.yolo_v4_coco() e = yaml.dump(config.as_dict(), default_flow_style=False) diff --git a/yolo/utils/export/tensor_rt.py b/yolo/utils/export/tensor_rt.py index d3b033526..c4e81219a 100755 --- a/yolo/utils/export/tensor_rt.py +++ b/yolo/utils/export/tensor_rt.py @@ -1,10 +1,12 @@ import tensorflow as tf -# import tensorflow.experimental.tensorrt as trt - from tensorflow.python.compiler.tensorrt import trt_convert as trt from yolo.utils.run_utils import prep_gpu +# import tensorflow.experimental.tensorrt as trt + + + class TensorRT(object): diff --git a/yolo/utils/export/tflite_convert.py b/yolo/utils/export/tflite_convert.py index 075f860c1..3e510160d 100755 --- a/yolo/utils/export/tflite_convert.py +++ b/yolo/utils/export/tflite_convert.py @@ -1,10 +1,13 @@ import os + +import cv2 import tensorflow as tf -from yolo.utils.run_utils import prep_gpu + +from skimage import io from yolo.configs import yolo as exp_cfg from yolo.tasks.yolo import YoloTask -from skimage import io -import cv2 +from yolo.utils.run_utils import prep_gpu + prep_gpu() diff --git a/yolo/utils/export/tflite_convert_gpu.py b/yolo/utils/export/tflite_convert_gpu.py index 5f971024f..ece8c9511 100755 --- a/yolo/utils/export/tflite_convert_gpu.py +++ b/yolo/utils/export/tflite_convert_gpu.py @@ -1,9 +1,11 @@ +import cv2 import tensorflow as tf -from yolo.utils.run_utils import prep_gpu + +from skimage import io from yolo.configs import yolo as exp_cfg from yolo.tasks.yolo import YoloTask -from skimage import io -import cv2 +from yolo.utils.run_utils import prep_gpu + prep_gpu() diff --git a/yolo/utils/export/tflite_gpu_test.py b/yolo/utils/export/tflite_gpu_test.py index 4d1b16ac8..4c7bd442f 100755 --- a/yolo/utils/export/tflite_gpu_test.py +++ b/yolo/utils/export/tflite_gpu_test.py @@ -1,7 +1,8 @@ +import cv2 import numpy as np import tensorflow as tf + from skimage import io -import cv2 # from yolo.utils.run_utils import prep_gpu # prep_gpu() # from yolo.modeling.layers.detection_generator import YoloLayer as filters diff --git a/yolo/utils/export/tflite_inspect.py b/yolo/utils/export/tflite_inspect.py index 6b30df8f0..ff95b2c66 100755 --- a/yolo/utils/export/tflite_inspect.py +++ b/yolo/utils/export/tflite_inspect.py @@ -1,5 +1,7 @@ import tensorflow as tf + from skimage import io + # from yolo.utils.run_utils import prep_gpu # prep_gpu() # from yolo.modeling.layers.detection_generator import YoloLayer as filters diff --git a/yolo/utils/export/tflite_test.py b/yolo/utils/export/tflite_test.py index 12463c144..6dcad8904 100755 --- a/yolo/utils/export/tflite_test.py +++ b/yolo/utils/export/tflite_test.py @@ -1,7 +1,8 @@ +import cv2 import numpy as np import tensorflow as tf + from skimage import io -import cv2 # from yolo.utils.run_utils import prep_gpu # prep_gpu() # from yolo.modeling.layers.detection_generator import YoloLayer as filters diff --git a/yolo/utils/tests/test_darknet2tf.py b/yolo/utils/tests/test_darknet2tf.py index 301d5da97..482cadb4d 100755 --- a/yolo/utils/tests/test_darknet2tf.py +++ b/yolo/utils/tests/test_darknet2tf.py @@ -1,5 +1,5 @@ -from absl.testing import parameterized import tensorflow as tf +from absl.testing import parameterized from yolo import DarkNet53 diff --git a/yolo/utils/training/keras_task_trainer.py b/yolo/utils/training/keras_task_trainer.py index 376386697..ca54edc42 100755 --- a/yolo/utils/training/keras_task_trainer.py +++ b/yolo/utils/training/keras_task_trainer.py @@ -1,9 +1,10 @@ import tensorflow as tf +from tensorflow.keras.mixed_precision import experimental as mixed_precision + import official.core.base_task as bt from official.core import input_reader from yolo.dataloaders import yolo_input from yolo.dataloaders.decoders import tfds_coco_decoder -from tensorflow.keras.mixed_precision import experimental as mixed_precision class Trainer(tf.keras.Model):