From 64122751f9719a3bc8dbe0690b1b368c5b0e3879 Mon Sep 17 00:00:00 2001 From: Jiageng Zhang Date: Mon, 25 Sep 2023 13:45:34 -0700 Subject: [PATCH 01/42] Remove unnecessary comma. PiperOrigin-RevId: 568313920 --- official/nlp/data/wmt_dataloader_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/official/nlp/data/wmt_dataloader_test.py b/official/nlp/data/wmt_dataloader_test.py index f9963cac00e..523af7eb77e 100644 --- a/official/nlp/data/wmt_dataloader_test.py +++ b/official/nlp/data/wmt_dataloader_test.py @@ -41,7 +41,7 @@ def _generate_record_file(filepath, src_lines, tgt_lines, unique_id=False): } if unique_id: features['unique_id'] = tf.train.Feature( - int64_list=tf.train.Int64List(value=[i])), + int64_list=tf.train.Int64List(value=[i])) example = tf.train.Example( features=tf.train.Features( feature=features)) From 94583313e0d452e116405cc03e5867394dfcda92 Mon Sep 17 00:00:00 2001 From: Jinoo Baek Date: Mon, 25 Sep 2023 22:53:50 -0700 Subject: [PATCH 02/42] No public description PiperOrigin-RevId: 568424866 --- official/modeling/hyperparams/params_dict_test.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/official/modeling/hyperparams/params_dict_test.py b/official/modeling/hyperparams/params_dict_test.py index c4a81d3459b..d6859262c01 100644 --- a/official/modeling/hyperparams/params_dict_test.py +++ b/official/modeling/hyperparams/params_dict_test.py @@ -220,7 +220,7 @@ def test_save_params_dict_to_yaml(self): params_dict.save_params_dict_to_yaml(params, output_yaml_file) with tf.io.gfile.GFile(output_yaml_file, 'r') as f: - params_d = yaml.load(f) + params_d = yaml.load(f, Loader=yaml.Loader) self.assertEqual(params.a, params_d['a']) self.assertEqual(params.b, params_d['b']) self.assertEqual(params.c.c1, params_d['c']['c1']) @@ -364,7 +364,7 @@ def test_basic_csv_str_load(self): csv_str = 'a=1,b=2,c=3' expected_output = {'a': 1, 'b': 2, 'c': 3} converted_csv_str = params_dict.nested_csv_str_to_json_str(csv_str) - converted_dict = yaml.load(converted_csv_str) + converted_dict = yaml.load(converted_csv_str, Loader=yaml.Loader) self.assertDictEqual(converted_dict, expected_output) def test_basic_nested_csv_str_to_json_str(self): @@ -377,7 +377,7 @@ def test_basic_nested_csv_str_load(self): csv_str = 'a=1,b.b1=2,c.c1=3' expected_output = {'a': 1, 'b': {'b1': 2}, 'c': {'c1': 3}} converted_csv_str = params_dict.nested_csv_str_to_json_str(csv_str) - converted_dict = yaml.load(converted_csv_str) + converted_dict = yaml.load(converted_csv_str, Loader=yaml.Loader) self.assertDictEqual(converted_dict, expected_output) def test_complex_nested_csv_str_to_json_str(self): @@ -390,7 +390,7 @@ def test_complex_nested_csv_str_load(self): csv_str = 'a.aa.aaa.aaaaa.a=1,a.a=2' expected_output = {'a': {'aa': {'aaa': {'aaaaa': {'a': 1}}}, 'a': 2}} converted_csv_str = params_dict.nested_csv_str_to_json_str(csv_str) - converted_dict = yaml.load(converted_csv_str) + converted_dict = yaml.load(converted_csv_str, Loader=yaml.Loader) self.assertDictEqual(converted_dict, expected_output) def test_int_array_param_nested_csv_str_to_json_str(self): @@ -413,7 +413,7 @@ def test_incomplete_array_param_nested_csv_str_to_json_str(self): def test_csv_str_load_supported_datatypes(self): csv_str = 'a=1,b=2.,c=[1,2,3],d=\'hello, there\',e=\"Hi.\"' converted_csv_str = params_dict.nested_csv_str_to_json_str(csv_str) - converted_dict = yaml.load(converted_csv_str) + converted_dict = yaml.load(converted_csv_str, Loader=yaml.Loader) self.assertEqual(converted_dict['a'], 1) self.assertEqual(converted_dict['b'], 2.) self.assertEqual(converted_dict['c'], [1, 2, 3]) From 00443ed9568707e79daf53b0545865745c5df5ce Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 27 Sep 2023 10:25:10 -0700 Subject: [PATCH 03/42] Load any extra hyperparameters when default experiment config fails PiperOrigin-RevId: 568890612 --- .../yolo/serving/export_saved_model.py | 21 ++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/official/projects/yolo/serving/export_saved_model.py b/official/projects/yolo/serving/export_saved_model.py index bac858c2ff0..69e1a5c804c 100644 --- a/official/projects/yolo/serving/export_saved_model.py +++ b/official/projects/yolo/serving/export_saved_model.py @@ -81,12 +81,23 @@ def main(_): params = exp_factory.get_exp_config(FLAGS.experiment) for config_file in FLAGS.config_file or []: - params = hyperparams.override_params_dict( - params, config_file, is_strict=True) + try: + params = hyperparams.override_params_dict( + params, config_file, is_strict=True + ) + except KeyError: + params = hyperparams.override_params_dict( + params, config_file, is_strict=False + ) if FLAGS.params_override: - params = hyperparams.override_params_dict( - params, FLAGS.params_override, is_strict=True) - + try: + params = hyperparams.override_params_dict( + params, FLAGS.params_override, is_strict=True + ) + except KeyError: + params = hyperparams.override_params_dict( + params, FLAGS.params_override, is_strict=False + ) params.validate() params.lock() From b913abfd73dc3d59c3d4769d3ede2439e012b390 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 27 Sep 2023 18:22:07 -0700 Subject: [PATCH 04/42] No public description PiperOrigin-RevId: 569017854 --- .../download_and_unzip_models.py | 100 +++++++++++++++ .../two_model_inference/labels.py | 118 ++++++++++++++++++ 2 files changed, 218 insertions(+) create mode 100644 official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py create mode 100644 official/projects/waste_identification_ml/two_model_inference/labels.py diff --git a/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py b/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py new file mode 100644 index 00000000000..61fb1109ad9 --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py @@ -0,0 +1,100 @@ +# Copyright 2023 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. + +"""This module provides utilities for executing shell commands. + +It particularly downloads and extracts Mask RCNN models from the TensorFlow +model garden. It includes a function to execute shell commands and +a custom exception to handle errors that arise from command execution. + +Functions: + - execute_command(cmd: str) -> str: Executes a shell command and returns its + standard output. Raises + a CommandExecutionError if the command execution fails. + +Exceptions: + - CommandExecutionError: Custom exception that's raised when there's an + error executing a shell command. + +Usage: + The main purpose of this module is to download two specific Mask RCNN models + and unzip them. The module + performs these operations when imported. + +Note: + It's recommended to not perform actions like downloading files on module + import in production applications. + It's better to move such tasks inside a function or a main block to allow + for more controlled execution. +""" +import argparse +import os +import subprocess + + +class CommandExecutionError(Exception): + """Raised when there's an error executing a shell command.""" + + def __init__(self, cmd, returncode, stderr): + super().__init__(f"Error executing command: {cmd}. Error: {stderr}") + self.cmd = cmd + self.returncode = returncode + self.stderr = stderr + + +def execute_command(cmd: str) -> str: + """Executes a shell command and returns its output.""" + result = subprocess.run( + cmd, + shell=True, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + check=False, + ) + + if result.returncode != 0: + raise CommandExecutionError( + cmd, result.returncode, result.stderr.decode("utf-8") + ) + + return result.stdout.decode("utf-8") + + +def main(_) -> None: + # Download the provided files + execute_command(f"wget {args.url1}") + execute_command(f"wget {args.url2}") + + # Create directories + os.makedirs("material", exist_ok=True) + os.makedirs("material_form", exist_ok=True) + + # Unzip the provided files + zip_file1 = os.path.basename(args.url1) + zip_file2 = os.path.basename(args.url2) + execute_command(f"unzip {zip_file1} -d material/") + execute_command(f"unzip {zip_file2} -d material_form/") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Download and extract Mask RCNN models." + ) + parser.add_argument("material_url", help="repo url for material model") + parser.add_argument( + "material_form_url", help="repo url for material form model" + ) + + args = parser.parse_args() + main(args) diff --git a/official/projects/waste_identification_ml/two_model_inference/labels.py b/official/projects/waste_identification_ml/two_model_inference/labels.py new file mode 100644 index 00000000000..b69f23b2f94 --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/labels.py @@ -0,0 +1,118 @@ +# Copyright 2023 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. + +"""Load labels for model prediction. + +Given paths of CSV files, task is to import them and convert into a +form required for mapping with the model output. +""" +import csv +from typing import TypedDict + + +class ItemDict(TypedDict): + id: int + name: str + supercategory: str + + +def read_csv_to_list(file_path: str) -> list[str]: + """Reads a CSV file and returns its contents as a list. + + This function reads the given CSV file, skips the header, and assumes + there is only one column in the CSV. It returns the contents as a list of + strings. + + Args: + file_path: The path to the CSV file. + + Returns: + The contents of the CSV file as a list of strings. + """ + data_list = [] + with open(file_path, 'r') as csvfile: + reader = csv.reader(csvfile) + next(reader) # Skip the header row if present + for row in reader: + data_list.append(row[0]) # Assuming there is only one column in the CSV + return data_list + + +def categories_dictionary(objects: list[str]) -> dict[int, ItemDict]: + """This function takes a list of objects and returns a dictionaries. + + A dictionary of objects, where each object is represented by a dictionary + with the following keys: + - id: The ID of the object. + - name: The name of the object. + - supercategory: The supercategory of the object. + + Args: + objects: A list of strings, where each string is the name of an + object. + + Returns: + A tuple of two dictionaries, as described above. + """ + category_index = {} + + for num, obj_name in enumerate(objects, start=1): + obj_dict = {'id': num, 'name': obj_name, 'supercategory': 'objects'} + category_index[num] = obj_dict + + return category_index + + +def load_labels( + label_paths: dict[str, str] +) -> tuple[list[list[str]], dict[int, ItemDict]]: + """Loads labels, combines them, and formats them for prediction. + + This function reads labels for multiple models, combines the labels in + order to predict a single label output, and formats them into the desired + structure required for prediction. + + Args: + label_paths: Dictionary of label paths for different models. + + Returns: + - A list of lists containing individual category indices for each + model. + - A dictionary of combined category indices in the desired format for + prediction. + + Note: + - The function assumes there are exactly two models. + - Inserts a category 'Na' for both models in case there is no detection. + - The total number of predicted labels for a combined model is + predetermined. + """ + # loading labels for both models + category_indices = [read_csv_to_list(label) for label in label_paths.values()] + + # insert a cateory 'Na' for both models in case there is no detection + for i in [0, 1]: + category_indices[i].insert(0, 'Na') + + # combine the labels for both models in order to predict a single label output + combined_category_indices = [] + for i in category_indices[0]: + for j in category_indices[1]: + combined_category_indices.append(f'{i}_{j}') + combined_category_indices.sort() + + # convert the list of labels into a desired format required for prediction + category_index = categories_dictionary(combined_category_indices) + + return category_indices, category_index From 280039018b87fd733a7c81bc4d6fe98b4f8de37d Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 27 Sep 2023 18:24:35 -0700 Subject: [PATCH 05/42] No public description PiperOrigin-RevId: 569018411 --- .../two_model_inference/Inference.ipynb | 454 ++++++++++++++++++ 1 file changed, 454 insertions(+) create mode 100644 official/projects/waste_identification_ml/two_model_inference/Inference.ipynb diff --git a/official/projects/waste_identification_ml/two_model_inference/Inference.ipynb b/official/projects/waste_identification_ml/two_model_inference/Inference.ipynb new file mode 100644 index 00000000000..68319942e6c --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/Inference.ipynb @@ -0,0 +1,454 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "TtlIRiNXWlQ0" + }, + "source": [ + "# Waste identification with instance segmentation in TensorFlow" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ohoMgYgXWsIO" + }, + "source": [ + "Welcome to the Instance Segmentation Colab! This notebook will take you through the steps of running an \"out-of-the-box\" Mask RCNN Instance Segmentation model on images." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8PKG9z4VYPEs" + }, + "source": [ + "To finish this task, a proper path for the saved models and a single image needs to be provided. The path to the labels on which the models are trained is in the waste_identification_ml directory inside the Tensorflow Model Garden repository. The label files are inferred automatically for both models." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j7yl9CqgYWvS" + }, + "source": [ + "## Imports and Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ELUFMVDDAopS" + }, + "outputs": [], + "source": [ + "from six.moves.urllib.request import urlopen\n", + "from six import BytesIO\n", + "from PIL import Image\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import sys\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "import logging\n", + "import pandas as pd\n", + "from labels import load_labels\n", + "\n", + "logging.disable(logging.WARNING)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "imIpwZgv_3dE" + }, + "source": [ + "Run the following cell to import utility functions that will be needed for pre-processing, post-processing and color detection.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_77YK3a_BCg_" + }, + "source": [ + "To visualize the images with the proper detected boxes and segmentation masks, we will use the TensorFlow Object Detection API. To install it we will clone the repo.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oCC-WANYBD03", + "outputId": "f507a381-aa79-4a45-c722-4109e252ef71" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cloning into 'models'...\n", + "remote: Enumerating objects: 3985, done.\u001b[K\n", + "remote: Counting objects: 100% (3985/3985), done.\u001b[K\n", + "remote: Compressing objects: 100% (3093/3093), done.\u001b[K\n", + "remote: Total 3985 (delta 1151), reused 1942 (delta 835), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (3985/3985), 49.76 MiB | 33.28 MiB/s, done.\n", + "Resolving deltas: 100% (1151/1151), done.\n" + ] + } + ], + "source": [ + "# Clone the tensorflow models repository\n", + "!git clone --depth 1 https://github.com/tensorflow/models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "o1dYyG55BtWb" + }, + "outputs": [], + "source": [ + "sys.path.append('models/research/')\n", + "from object_detection.utils import visualization_utils as viz_utils\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nq2DNpXQ_0-n" + }, + "source": [ + "## Utilities" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GO488S78_2GJ" + }, + "outputs": [], + "source": [ + "def load_image_into_numpy_array(path):\n", + " \"\"\"Load an image from file into a numpy array.\n", + "\n", + " Puts image into numpy array to feed into tensorflow graph.\n", + " Note that by convention we put it into a numpy array with shape\n", + " (height, width, channels), where channels=3 for RGB.\n", + "\n", + " Args:\n", + " path: the file path to the image\n", + "\n", + " Returns:\n", + " uint8 numpy array with shape (1, h, w, 3)\n", + " \"\"\"\n", + " image = None\n", + " if(path.startswith('http')):\n", + " response = urlopen(path)\n", + " image_data = response.read()\n", + " image_data = BytesIO(image_data)\n", + " image = Image.open(image_data)\n", + " else:\n", + " image_data = tf.io.gfile.GFile(path, 'rb').read()\n", + " image = Image.open(BytesIO(image_data))\n", + "\n", + " (im_width, im_height) = image.size\n", + " return np.array(image.getdata()).reshape(\n", + " (1, im_height, im_width, 3)).astype(np.uint8)\n", + "\n", + "\n", + "def load_model(model_handle):\n", + " \"\"\"Loads a TensorFlow SavedModel and returns a function that can be used to make predictions.\n", + "\n", + " Args:\n", + " model_handle: A path to a TensorFlow SavedModel.\n", + "\n", + " Returns:\n", + " A function that can be used to make predictions.\n", + " \"\"\"\n", + " print('loading model...')\n", + " print(model_handle)\n", + " model = tf.saved_model.load(model_handle)\n", + " print('model loaded!')\n", + " detection_fn = model.signatures['serving_default']\n", + " return detection_fn\n", + "\n", + "\n", + "def perform_detection(model, image):\n", + " \"\"\"Performs Mask RCNN on an image using the specified model.\n", + "\n", + " Args:\n", + " model: A function that can be used to make predictions.\n", + " image_np: A NumPy array representing the image to be detected.\n", + "\n", + " Returns:\n", + " A list of detections.\n", + " \"\"\"\n", + " detection_fn = model(image)\n", + " detection_fn = {key: value.numpy() for key, value in detection_fn.items()}\n", + " return detection_fn" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "t7d00cJH-68Z" + }, + "outputs": [], + "source": [ + "# 'material_model' output is both material and its sub type e.g. Plastics_PET\n", + "# 'material_form_model' outputs the form of an object e.g. can, bottle, etc\n", + "MODEL_WEIGHTS = {\n", + "'material_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material/material_version_1.zip',\n", + "'material_form_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material_form/material_form_version_1.zip',\n", + "}\n", + "\n", + "ALL_MODELS = {\n", + "'material_model' : 'material/two_model_material_1_saved/saved_model/',\n", + "'material_form_model' : 'material_form/two_model_material_form_1_saved/saved_model/',\n", + "}\n", + "\n", + "LABELS = {\n", + "'material_model' : 'models/official/projects/waste_identification_ml/pre_processing/config/data/two_model_strategy_material.csv',\n", + "'material_form_model' : 'models/official/projects/waste_identification_ml/pre_processing/config/data/two_model_strategy_material_form.csv',\n", + "}\n", + "\n", + "# path to a sample image stored in the repo\n", + "IMAGES_FOR_TEST = {\n", + " 'Image1' : 'models/official/projects/waste_identification_ml/pre_processing/config/sample_images/image_2.png'\n", + "}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4XjfDEq--UlE" + }, + "source": [ + "## Import pre-trained models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "UUmc3aMXWjUO" + }, + "outputs": [], + "source": [ + "# download the model weights from the Google's repo\n", + "url1 = MODEL_WEIGHTS['material_url']\n", + "url2 = MODEL_WEIGHTS['material_form_url']\n", + "!python download_and_unzip_models.py --material_url $url1 material_form_url $url2" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W6mmyLsOJicF" + }, + "source": [ + "## Load label map data" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PM2A29OrJqaU" + }, + "source": [ + "Label maps correspond index numbers to category names, so that when our convolution network predicts 5, we know that this corresponds to airplane. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine.\n", + "\n", + "We are going, for simplicity, to load from the repository that we loaded the Object Detection API code" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5RUzrh0uegqt" + }, + "outputs": [], + "source": [ + "# the total number of predicted labels (category_indices) for a combined model = 741\n", + "category_indices, category_index = load_labels(LABELS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vBm2aQzfHhId", + "outputId": "37527599-2060-4167-f7dd-74649a07a58f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Na',\n", + " 'Fiber_Na',\n", + " 'Food_Na',\n", + " 'Glass_Na',\n", + " 'Inorganic-wastes_Na',\n", + " 'Metals_Na',\n", + " 'Plastics_HDPE',\n", + " 'Plastics_LDPE',\n", + " 'Plastics_Others-HIPC',\n", + " 'Plastics_Others-MLP',\n", + " 'Plastics_Others-Tetrapak',\n", + " 'Plastics_PET',\n", + " 'Plastics_PP',\n", + " 'Plastics_PS',\n", + " 'Plastics_PVC',\n", + " 'Rubber-\u0026-Leather_Na',\n", + " 'Textiles_Na',\n", + " 'Wood_Na',\n", + " 'Yard-trimming_Na']" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display labels only for 'material' model\n", + "# total number of labels for 'material' model = 19\n", + "category_indices[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Eh_Ey6lXHs8m", + "outputId": "b53520a4-e18c-4f40-d2a9-6b49348c251d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Na',\n", + " 'Bag',\n", + " 'Battery',\n", + " 'Blister-pack',\n", + " 'Book-\u0026-magazine',\n", + " 'Bottle',\n", + " 'Box',\n", + " 'Brush',\n", + " 'Bulb',\n", + " 'Can',\n", + " 'Cards',\n", + " 'Carton',\n", + " 'Cassette-\u0026-tape',\n", + " 'Clamshell',\n", + " 'Clothes',\n", + " 'Container',\n", + " 'Cosmetic',\n", + " 'Cup-\u0026-glass',\n", + " 'Cutlery',\n", + " 'Electronic-devices',\n", + " 'Flexibles',\n", + " 'Foil',\n", + " 'Foot-wear',\n", + " 'Hangers',\n", + " 'Jug-\u0026-Jar',\n", + " 'Lid',\n", + " 'Mirror',\n", + " 'Office-Stationary',\n", + " 'Paper-Products-Others',\n", + " 'Paper-Products-Others-Cardboard',\n", + " 'Paper-Products-Others-Newspaper',\n", + " 'Paper-Products-Others-Whitepaper',\n", + " 'Pipe',\n", + " 'Sachets-\u0026-Pouch',\n", + " 'Scissor',\n", + " 'Tangler',\n", + " 'Toys',\n", + " 'Tray',\n", + " 'Tube']" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display labels only for 'material_form' model\n", + "# total number of labels for 'material form' model = 39\n", + "category_indices[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PFczkMGBClZ4" + }, + "source": [ + "## Load pre-trained weights for both models." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5J6MgjOSC5JO", + "outputId": "3de66985-bdb1-428d-85e1-5be4317d6bcb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading model...\n", + "material/two_model_material_1_saved/saved_model/\n", + "model loaded!\n", + "loading model...\n", + "material_form/two_model_material_form_1_saved/saved_model/\n", + "model loaded!\n" + ] + } + ], + "source": [ + "# loading both models\n", + "detection_fns = [load_model(model_path) for model_path in ALL_MODELS.values()]" + ] + } + ], + "metadata": { + "colab": { + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From a2823c700a60e55ae687b23f3854a29ffbcc12e5 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 28 Sep 2023 14:22:54 -0700 Subject: [PATCH 06/42] No public description PiperOrigin-RevId: 569290058 --- official/vision/configs/maskrcnn.py | 7 ++++ official/vision/configs/retinanet.py | 1 + official/vision/serving/detection.py | 51 ++++++++++++++++++++++------ 3 files changed, 48 insertions(+), 11 deletions(-) diff --git a/official/vision/configs/maskrcnn.py b/official/vision/configs/maskrcnn.py index 9909e839443..706c28eab3e 100644 --- a/official/vision/configs/maskrcnn.py +++ b/official/vision/configs/maskrcnn.py @@ -46,6 +46,13 @@ class Parser(hyperparams.Config): rpn_batch_size_per_im: int = 256 rpn_fg_fraction: float = 0.5 mask_crop_size: int = 112 + pad: bool = True # Only support `pad = True`. + + def __post_init__(self, *args, **kwargs): + """Validates the configuration.""" + if not self.pad: + raise ValueError('`maskrcnn.Parser` only supports `pad = True`.') + super().__post_init__(*args, **kwargs) @dataclasses.dataclass diff --git a/official/vision/configs/retinanet.py b/official/vision/configs/retinanet.py index ae643b13779..7499b157a02 100644 --- a/official/vision/configs/retinanet.py +++ b/official/vision/configs/retinanet.py @@ -59,6 +59,7 @@ class Parser(hyperparams.Config): max_num_instances: int = 100 # Can choose AutoAugment and RandAugment. aug_type: Optional[common.Augmentation] = None + pad: bool = True # Keep for backward compatibility. Not used. aug_policy: Optional[str] = None diff --git a/official/vision/serving/detection.py b/official/vision/serving/detection.py index aa849152f77..673eef878bb 100644 --- a/official/vision/serving/detection.py +++ b/official/vision/serving/detection.py @@ -14,11 +14,13 @@ """Detection input and model functions for serving/inference.""" +import math from typing import Mapping, Tuple from absl import logging import tensorflow as tf +from official.core import config_definitions as cfg from official.vision import configs from official.vision.modeling import factory from official.vision.ops import anchor @@ -30,6 +32,34 @@ class DetectionModule(export_base.ExportModule): """Detection Module.""" + def __init__( + self, + params: cfg.ExperimentConfig, + *, + input_image_size: list[int], + **kwargs, + ): + """Initializes a detection module for export. + + Args: + params: Experiment params. + input_image_size: List or Tuple of size of the input image. For 2D image, + it is [height, width]. + **kwargs: All other kwargs are passed to `export_base.ExportModule`; see + the documentation on `export_base.ExportModule` for valid arguments. + """ + if params.task.train_data.parser.pad: + self._padded_size = preprocess_ops.compute_padded_size( + input_image_size, 2**params.task.model.max_level + ) + else: + self._padded_size = input_image_size + super().__init__( + params=params, + input_image_size=input_image_size, + **kwargs, + ) + def _build_model(self): nms_versions_supporting_dynamic_batch_size = {'batched', 'v2', 'v3'} @@ -40,8 +70,8 @@ def _build_model(self): 'does not support with dynamic batch size.', nms_version) self.params.task.model.detection_generator.nms_version = 'batched' - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + - self._input_image_size + [3]) + input_specs = tf.keras.layers.InputSpec(shape=[ + self._batch_size, *self._padded_size, 3]) if isinstance(self.params.task.model, configs.maskrcnn.MaskRCNN): model = factory.build_maskrcnn( @@ -64,12 +94,10 @@ def _build_anchor_boxes(self): num_scales=model_params.anchor.num_scales, aspect_ratios=model_params.anchor.aspect_ratios, anchor_size=model_params.anchor.anchor_size) - return input_anchor( - image_size=(self._input_image_size[0], self._input_image_size[1])) + return input_anchor(image_size=self._padded_size) def _build_inputs(self, image): """Builds detection model inputs for serving.""" - model_params = self.params.task.model # Normalizes image with mean and std pixel values. image = preprocess_ops.normalize_image( image, offset=preprocess_ops.MEAN_RGB, scale=preprocess_ops.STDDEV_RGB) @@ -77,10 +105,10 @@ def _build_inputs(self, image): image, image_info = preprocess_ops.resize_and_crop_image( image, self._input_image_size, - padded_size=preprocess_ops.compute_padded_size( - self._input_image_size, 2**model_params.max_level), + padded_size=self._padded_size, aug_scale_min=1.0, - aug_scale_max=1.0) + aug_scale_max=1.0, + ) anchor_boxes = self._build_anchor_boxes() return image, anchor_boxes, image_info @@ -128,7 +156,7 @@ def preprocess( images = tf.cast(images, dtype=tf.float32) # Tensor Specs for map_fn outputs (images, anchor_boxes, and image_info). - images_spec = tf.TensorSpec(shape=self._input_image_size + [3], + images_spec = tf.TensorSpec(shape=self._padded_size + [3], dtype=tf.float32) num_anchors = model_params.anchor.num_scales * len( @@ -137,8 +165,9 @@ def preprocess( for level in range(model_params.min_level, model_params.max_level + 1): anchor_level_spec = tf.TensorSpec( shape=[ - self._input_image_size[0] // 2**level, - self._input_image_size[1] // 2**level, num_anchors + math.ceil(self._padded_size[0] / 2**level), + math.ceil(self._padded_size[1] / 2**level), + num_anchors, ], dtype=tf.float32) anchor_shapes.append((str(level), anchor_level_spec)) From d49f8365d7c3b8b0f1f10c167c563fea4932f122 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 28 Sep 2023 15:58:01 -0700 Subject: [PATCH 07/42] Add Orbit beacon metric and retention policy. PiperOrigin-RevId: 569314229 --- orbit/controller.py | 11 +++++++++++ orbit/controller_test.py | 3 +++ 2 files changed, 14 insertions(+) diff --git a/orbit/controller.py b/orbit/controller.py index 47fb812672e..78728468a28 100644 --- a/orbit/controller.py +++ b/orbit/controller.py @@ -26,6 +26,14 @@ import tensorflow as tf +# pylint: disable=g-direct-tensorflow-import +from tensorflow.python.eager import monitoring +# pylint: enable=g-direct-tensorflow-import + +_orbit_api_gauge = monitoring.BoolGauge( + "/tensorflow/api/orbit", "orbit api usage" +) + def _log(message: str): """Logs `message` to the `info` log, and also prints to stdout.""" @@ -243,6 +251,9 @@ def __init__( if restored_path: _log(f"restored from checkpoint: {restored_path}") + # Set Orbit framework gauge to True value + _orbit_api_gauge.get_cell().set(True) + def train(self, steps: int, checkpoint_at_completion: bool = True): """Runs training until the specified global step count has been reached. diff --git a/orbit/controller_test.py b/orbit/controller_test.py index 8ffad830bd1..487e013aa9f 100644 --- a/orbit/controller_test.py +++ b/orbit/controller_test.py @@ -281,6 +281,7 @@ def test_no_checkpoint(self): test_controller.train_and_evaluate( train_steps=10, eval_steps=2, eval_interval=6) self.assertEqual(test_runner.global_step, 10) + self.assertTrue(controller._orbit_api_gauge.get_cell().value()) def test_no_checkpoint_and_summaries(self): test_runner = TestRunner() @@ -293,6 +294,7 @@ def test_no_checkpoint_and_summaries(self): test_controller.train_and_evaluate( train_steps=10, eval_steps=2, eval_interval=6) self.assertEqual(test_runner.global_step, 10) + self.assertTrue(controller._orbit_api_gauge.get_cell().value()) @parameterized.named_parameters( ("_sync_checkpoint_saving", False), @@ -317,6 +319,7 @@ def test_has_checkpoint_no_summaries(self, enable_async_checkpoint_saving): test_controller.train_and_evaluate( train_steps=10, eval_steps=2, eval_interval=6) self.assertEqual(test_runner.global_step, 10) + self.assertTrue(controller._orbit_api_gauge.get_cell().value()) # No summaries are saved. self.assertEmpty(tf.io.gfile.glob( From 1f3214cad55d37c52735dc2c32e668c394461477 Mon Sep 17 00:00:00 2001 From: Jinoo Baek Date: Thu, 28 Sep 2023 23:17:03 -0700 Subject: [PATCH 08/42] No public description PiperOrigin-RevId: 569394081 --- official/nlp/tasks/question_answering_test.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/official/nlp/tasks/question_answering_test.py b/official/nlp/tasks/question_answering_test.py index 3171e6fc5fa..2c903b1a9b3 100644 --- a/official/nlp/tasks/question_answering_test.py +++ b/official/nlp/tasks/question_answering_test.py @@ -101,7 +101,8 @@ def _run_task(self, config): logs = task.aggregate_logs(step_outputs=logs) metrics = task.reduce_aggregated_logs(logs) self.assertIn("final_f1", metrics) - model.save(os.path.join(self.get_temp_dir(), "saved_model")) + model.save(os.path.join(self.get_temp_dir(), "saved_model.keras"), + save_format="keras") @parameterized.parameters( itertools.product( @@ -109,6 +110,7 @@ def _run_task(self, config): ("WordPiece", "SentencePiece"), )) def test_task(self, version_2_with_negative, tokenization): + del tokenization # Saves a checkpoint. pretrain_cfg = bert.PretrainerConfig( encoder=self._encoder_config, From 1f336a6483580088d7bd223ad487b94a919bc784 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Fri, 29 Sep 2023 15:40:33 -0700 Subject: [PATCH 09/42] No public description PiperOrigin-RevId: 569605914 --- .../color_and_property_extractor.py | 190 ++++++++++++++++++ 1 file changed, 190 insertions(+) create mode 100644 official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py diff --git a/official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py b/official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py new file mode 100644 index 00000000000..f8793bbdea9 --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py @@ -0,0 +1,190 @@ +# Copyright 2023 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. + +"""Extract properties from each object mask and detect its color.""" +from typing import Optional, Union +import numpy as np +import pandas as pd +import skimage.measure +from sklearn.cluster import KMeans +import webcolors + +PROPERTIES = [ + 'area', + 'bbox', + 'convex_area', + 'bbox_area', + 'major_axis_length', + 'minor_axis_length', + 'eccentricity', + 'centroid', +] + + +def extract_properties_and_object_masks( + final_result: dict[str, np.ndarray], + height: int, + width: int, + original_image: np.ndarray, +) -> tuple[list[pd.DataFrame], list[np.ndarray]]: + """Extract specific properties from given detection masks. + + Properties that will be computed includes the area of the masks, bbox + coordinates, area of that bbox, convex length, major_axis_length, + minor_axis_length, eccentricity and centroid. + + Args: + final_result: A dictionary containing the num_detections, detection_classes, + detection_scores,detection_boxes,detection_classes_names, + detection_masks_reframed' + height: The height of the original image. + width: The width of the original image. + original_image: The actual image on which the objects were detected. + + Returns: + A tuple containing two lists: + 1. List of dataframes where each dataframe contains properties for a + detected object. + 2. List of ndarrays where each ndarray is a cropped portion of the + original image + corresponding to a detected object. + """ + list_of_df = [] + cropped_masks = [] + + for i, mask in enumerate(final_result['detection_masks_reframed']): + mask = np.where(mask, 1, 0) + df = pd.DataFrame( + skimage.measure.regionprops_table(mask, properties=PROPERTIES) + ) + list_of_df.append(df) + + bb = final_result['detection_boxes'][0][i] + ymin, xmin, ymax, xmax = ( + int(bb[0] * height), + int(bb[1] * width), + int(bb[2] * height), + int(bb[3] * width), + ) + mask = np.expand_dims(mask, axis=2) + cropped_object = np.where( + mask[ymin:ymax, xmin:xmax], original_image[ymin:ymax, xmin:xmax], 0 + ) + cropped_masks.append(cropped_object) + + return list_of_df, cropped_masks + + +def find_dominant_color( + image: np.ndarray, black_threshold: int = 50 +) -> tuple[Union[int, str], Union[int, str], Union[int, str]]: + """Determines the dominant color in a given image. + + The function performs the following steps: + Filters out black or near-black pixels based on a threshold. + Uses k-means clustering to identify the dominant color among the remaining + pixels. + + Args: + image: An array representation of the image. + black_threshold: pixel value of black color + + shape is (height, width, 3) for RGB channels. + black_threshold: The intensity threshold below which pixels + are considered 'black' or near-black. Default is 50. + + Returns: + The dominant RGB color in the format (R, G, B). If no non-black + pixels are found, returns ('Na', 'Na', 'Na'). + """ + pixels = image.reshape(-1, 3) + + # Filter out black pixels based on the threshold + non_black_pixels = pixels[(pixels > black_threshold).any(axis=1)] + + if non_black_pixels.size != 0: + kmeans = KMeans(n_clusters=1, n_init=10, random_state=0).fit( + non_black_pixels + ) + dominant_color = kmeans.cluster_centers_[0].astype(int) + + else: + dominant_color = ['Na', 'Na', 'Na'] + return tuple(dominant_color) + + +def color_difference(color1: int, color2: int) -> Union[float, int]: + """Computes the squared difference between two color components. + + Args: + color1: First color component. + color2: Second color component. + + Returns: + The squared difference between the two color components. + """ + return (color1 - color2) ** 2 + + +def est_color(requested_color: tuple[int, int, int]) -> str: + """Estimates the closest named color for a given RGB color. + + The function uses the Euclidean distance in the RGB space to find the closest + match among the CSS3 colors. + + Args: + requested_color: The RGB color value for which to find the closest named + color. Expected format is (R, G, B). + + Returns: + The name of the closest matching color from the CSS3 predefined colors. + + Example: est_color((255, 0, 0)) + 'red' + """ + min_colors = {} + for key, name in webcolors.CSS3_HEX_TO_NAMES.items(): + r_c, g_c, b_c = webcolors.hex_to_rgb(key) + rd = color_difference(r_c, requested_color[0]) + gd = color_difference(g_c, requested_color[1]) + bd = color_difference(b_c, requested_color[2]) + min_colors[(rd + gd + bd)] = name + return min_colors[min(min_colors.keys())] + + +def get_color_name(rgb_color: tuple[int, int, int]) -> Optional[str]: + """Retrieves the name of a given RGB color. + + If the RGB color exactly matches one of the CSS3 predefined colors, it returns + the exact color name. + Otherwise, it estimates the closest matching color name. + + Args: + rgb_color: The RGB color value for which to retrieve the name. + + Returns: + The name of the color if found, or None if the color is marked as 'Na' or + not found. + + Example: get_color_name((255, 0, 0)) + 'red' + """ + if 'Na' not in rgb_color: + try: + closest_color_name = webcolors.rgb_to_name(rgb_color) + except ValueError: + closest_color_name = est_color(rgb_color) + return closest_color_name + else: + return None From d620771a0bb78d05c93c2371c0ea8577b41694c9 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Sat, 30 Sep 2023 00:36:08 -0700 Subject: [PATCH 10/42] No public description PiperOrigin-RevId: 569683088 --- .../modeling/layers/detection_generator.py | 37 ++++- .../layers/detection_generator_test.py | 152 ++++++++++++++++++ .../projects/centernet/tasks/centernet.py | 5 +- 3 files changed, 186 insertions(+), 8 deletions(-) create mode 100644 official/projects/centernet/modeling/layers/detection_generator_test.py diff --git a/official/projects/centernet/modeling/layers/detection_generator.py b/official/projects/centernet/modeling/layers/detection_generator.py index 212f1d22069..775b8706d3a 100644 --- a/official/projects/centernet/modeling/layers/detection_generator.py +++ b/official/projects/centernet/modeling/layers/detection_generator.py @@ -34,7 +34,7 @@ class CenterNetDetectionGenerator(tf.keras.layers.Layer): """CenterNet Detection Generator.""" def __init__(self, - input_image_dims: int = 512, + input_image_dims: tuple[int, int] | int = 512, net_down_scale: int = 4, max_detections: int = 100, peak_error: float = 1e-6, @@ -47,7 +47,10 @@ def __init__(self, """Initialize CenterNet Detection Generator. Args: - input_image_dims: An `int` that specifies the input image size. + input_image_dims: The input image size. If it is a tuple of two `int`s, it + is the size (height, width) of the input images. If it is an `int`, the + input images are supposed to be squared images whose height and width + are equal. net_down_scale: An `int` that specifies stride of the output. max_detections: An `int` specifying the maximum number of bounding boxes generated. This is an upper bound, so the number of generated @@ -67,6 +70,9 @@ def __init__(self, """ super(CenterNetDetectionGenerator, self).__init__(**kwargs) + if isinstance(input_image_dims, int): + input_image_dims = (input_image_dims, input_image_dims) + # Object center selection parameters self._max_detections = max_detections self._peak_error = peak_error @@ -246,10 +252,28 @@ def get_boxes(self, return boxes, detection_classes def convert_strided_predictions_to_normalized_boxes(self, boxes: tf.Tensor): + """Converts strided predictions to normalized boxes. + + Args: + boxes: A tf.Tensor of shape [batch_size, num_predictions, 4], representing + the strided predictions of the detected objects. + + Returns: + A tf.Tensor of shape [batch_size, num_predictions, 4], representing + the normalized boxes of the detected objects. + """ 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 + + height = tf.cast(self._input_image_dims[0], boxes.dtype) + width = tf.cast(self._input_image_dims[1], boxes.dtype) + ymin = boxes[..., 0:1] / height + xmin = boxes[..., 1:2] / width + ymax = boxes[..., 2:3] / height + xmax = boxes[..., 3:4] / width + + normalized_boxes = tf.concat([ymin, xmin, ymax, xmax], axis=-1) + normalized_boxes = tf.clip_by_value(normalized_boxes, 0.0, 1.0) + return normalized_boxes def __call__(self, inputs): # Get heatmaps from decoded outputs via final hourglass stack output @@ -308,8 +332,7 @@ def __call__(self, inputs): nms_thresh=0.4) num_det = tf.reduce_sum(tf.cast(scores > 0, dtype=tf.int32), axis=1) - boxes = box_ops.denormalize_boxes( - boxes, [self._input_image_dims, self._input_image_dims]) + boxes = box_ops.denormalize_boxes(boxes, self._input_image_dims) return { 'boxes': boxes, diff --git a/official/projects/centernet/modeling/layers/detection_generator_test.py b/official/projects/centernet/modeling/layers/detection_generator_test.py new file mode 100644 index 00000000000..c5c827b3f53 --- /dev/null +++ b/official/projects/centernet/modeling/layers/detection_generator_test.py @@ -0,0 +1,152 @@ +# Copyright 2023 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Tests for Centernet detection_generator.""" + +from collections.abc import Mapping, Sequence + +from absl.testing import parameterized +import tensorflow as tf + +from official.projects.centernet.modeling.layers import detection_generator + + +def _build_input_example( + batch_size: int, height: int, width: int, num_classes: int, num_outputs: int +) -> Mapping[str, Sequence[tf.Tensor]]: + """Builds a random input example for CenterNetDetectionGenerator. + + Args: + batch_size: The batch size. + height: The height of the feature_map. + width: The width of the feature_map. + num_classes: The number of classes to detect. + num_outputs: The number of output heatmaps, which corresponds to the length + of CenterNetHead's input_levels. + + Returns: + A dictionary, mapping from feature names to sequences of tensors. + """ + return { + 'ct_heatmaps': [ + tf.random.normal([batch_size, height, width, num_classes]) + for _ in range(num_outputs) + ], + 'ct_size': [ + tf.random.normal([batch_size, height, width, 2]) + for _ in range(num_outputs) + ], + 'ct_offset': [ + tf.random.normal([batch_size, height, width, 2]) + for _ in range(num_outputs) + ], + } + + +class CenterNetDetectionGeneratorTest(parameterized.TestCase, tf.test.TestCase): + + @parameterized.parameters( + (1, 256), + (1, 512), + (2, 256), + (2, 512), + ) + def test_squered_image_forward(self, batch_size, input_image_dims): + max_detections = 128 + num_classes = 80 + generator = detection_generator.CenterNetDetectionGenerator( + input_image_dims=input_image_dims, max_detections=max_detections + ) + test_input = _build_input_example( + batch_size=batch_size, + height=input_image_dims, + width=input_image_dims, + num_classes=num_classes, + num_outputs=2, + ) + + output = generator(test_input) + + self.assert_detection_generator_output_shapes( + output, batch_size, max_detections + ) + + @parameterized.parameters( + (1, (256, 512)), + (1, (512, 256)), + (2, (256, 512)), + (2, (512, 256)), + ) + def test_rectangular_image_forward(self, batch_size, input_image_dims): + max_detections = 128 + num_classes = 80 + generator = detection_generator.CenterNetDetectionGenerator( + input_image_dims=input_image_dims, max_detections=max_detections + ) + test_input = _build_input_example( + batch_size=batch_size, + height=input_image_dims[0], + width=input_image_dims[1], + num_classes=num_classes, + num_outputs=2, + ) + + output = generator(test_input) + + self.assert_detection_generator_output_shapes( + output, batch_size, max_detections + ) + + def assert_detection_generator_output_shapes( + self, + output: Mapping[str, tf.Tensor], + batch_size: int, + max_detections: int, + ): + self.assertAllEqual(output['boxes'].shape, (batch_size, max_detections, 4)) + self.assertAllEqual(output['classes'].shape, (batch_size, max_detections)) + self.assertAllEqual( + output['confidence'].shape, (batch_size, max_detections) + ) + self.assertAllEqual(output['num_detections'].shape, (batch_size,)) + + @parameterized.parameters( + (256,), + (512,), + ((256, 512),), + ((512, 256),), + ) + def test_serialize_deserialize(self, input_image_dims): + kwargs = { + 'input_image_dims': input_image_dims, + 'net_down_scale': 4, + 'max_detections': 128, + 'peak_error': 1e-6, + 'peak_extract_kernel_size': 3, + 'class_offset': 1, + 'use_nms': False, + 'nms_pre_thresh': 0.1, + 'nms_thresh': 0.5, + } + + generator = detection_generator.CenterNetDetectionGenerator(**kwargs) + new_generator = detection_generator.CenterNetDetectionGenerator.from_config( + generator.get_config() + ) + + self.assertAllEqual(generator.get_config(), new_generator.get_config()) + + +if __name__ == '__main__': + tf.test.main() diff --git a/official/projects/centernet/tasks/centernet.py b/official/projects/centernet/tasks/centernet.py index 381dc621354..af272deaffc 100644 --- a/official/projects/centernet/tasks/centernet.py +++ b/official/projects/centernet/tasks/centernet.py @@ -130,7 +130,10 @@ def build_model(self): peak_extract_kernel_size=dg_config.peak_extract_kernel_size, class_offset=dg_config.class_offset, net_down_scale=self._net_down_scale, - input_image_dims=model_config.input_size[0], + input_image_dims=( + model_config.input_size[0], + model_config.input_size[1], + ), use_nms=dg_config.use_nms, nms_pre_thresh=dg_config.nms_pre_thresh, nms_thresh=dg_config.nms_thresh) From e2777344ede7583dbdb161170bd5030d8d00091b Mon Sep 17 00:00:00 2001 From: Jinoo Baek Date: Mon, 2 Oct 2023 02:56:18 -0700 Subject: [PATCH 11/42] No public description PiperOrigin-RevId: 570000839 --- official/nightly_requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/official/nightly_requirements.txt b/official/nightly_requirements.txt index 93781ecd364..e762d9a826e 100644 --- a/official/nightly_requirements.txt +++ b/official/nightly_requirements.txt @@ -26,5 +26,5 @@ sacrebleu # Projects/vit dependencies immutabledict # Fix CI -wrapt>=1.11.0,<1.15 +wrapt>=1.15 From 01248af1d4c1e2f6bdc3141a474a3641c1c340bc Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 2 Oct 2023 17:22:09 -0700 Subject: [PATCH 12/42] No public description PiperOrigin-RevId: 570225377 --- .../two_model_inference/preprocessing.py | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 official/projects/waste_identification_ml/two_model_inference/preprocessing.py diff --git a/official/projects/waste_identification_ml/two_model_inference/preprocessing.py b/official/projects/waste_identification_ml/two_model_inference/preprocessing.py new file mode 100644 index 00000000000..a69fe48ae6a --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/preprocessing.py @@ -0,0 +1,75 @@ +# Copyright 2023 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. + +"""This module provides utilities to normalize image tensors. +""" +from typing import Sequence +import tensorflow as tf + +MEAN_NORM = (0.485, 0.456, 0.406) +STDDEV_NORM = (0.229, 0.224, 0.225) + + +def normalize_image( + image: tf.Tensor, + offset: Sequence[float] = MEAN_NORM, + scale: Sequence[float] = STDDEV_NORM, +) -> tf.Tensor: + """Normalizes the image to zero mean and unit variance. + + If the input image dtype is float, it is expected to either have values in + [0, 1) and offset is MEAN_NORM, or have values in [0, 255] and offset is + MEAN_RGB. + + Args: + image: A tf.Tensor in either (1) float dtype with values in range [0, 1) or + [0, 255], or (2) int type with values in range [0, 255]. + offset: A tuple of mean values to be subtracted from the image. + scale: A tuple of normalization factors. + + Returns: + A normalized image tensor. + """ + image = tf.image.convert_image_dtype(image, dtype=tf.float32) + return normalize_scaled_float_image(image, offset, scale) + + +def normalize_scaled_float_image( + image: tf.Tensor, + offset: Sequence[float] = MEAN_NORM, + scale: Sequence[float] = STDDEV_NORM, +): + """Normalizes a scaled float image to zero mean and unit variance. + + It assumes the input image is float dtype with values in [0, 1) if offset is + MEAN_NORM, values in [0, 255] if offset is MEAN_RGB. + + Args: + image: A tf.Tensor in float32 dtype with values in range [0, 1) or [0, 255]. + offset: A tuple of mean values to be subtracted from the image. + scale: A tuple of normalization factors. + + Returns: + A normalized image tensor. + """ + offset = tf.constant(offset) + offset = tf.expand_dims(offset, axis=0) + offset = tf.expand_dims(offset, axis=0) + image -= offset + + scale = tf.constant(scale) + scale = tf.expand_dims(scale, axis=0) + scale = tf.expand_dims(scale, axis=0) + image /= scale + return image From b6818034d4669e769f19d4bf3642630a20c09e14 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Tue, 3 Oct 2023 14:00:55 -0700 Subject: [PATCH 13/42] No public description PiperOrigin-RevId: 570489626 --- official/vision/serving/detection.py | 32 ++++++---------------------- 1 file changed, 6 insertions(+), 26 deletions(-) diff --git a/official/vision/serving/detection.py b/official/vision/serving/detection.py index 673eef878bb..b15e294d60d 100644 --- a/official/vision/serving/detection.py +++ b/official/vision/serving/detection.py @@ -20,7 +20,6 @@ from absl import logging import tensorflow as tf -from official.core import config_definitions as cfg from official.vision import configs from official.vision.modeling import factory from official.vision.ops import anchor @@ -32,33 +31,14 @@ class DetectionModule(export_base.ExportModule): """Detection Module.""" - def __init__( - self, - params: cfg.ExperimentConfig, - *, - input_image_size: list[int], - **kwargs, - ): - """Initializes a detection module for export. - - Args: - params: Experiment params. - input_image_size: List or Tuple of size of the input image. For 2D image, - it is [height, width]. - **kwargs: All other kwargs are passed to `export_base.ExportModule`; see - the documentation on `export_base.ExportModule` for valid arguments. - """ - if params.task.train_data.parser.pad: - self._padded_size = preprocess_ops.compute_padded_size( - input_image_size, 2**params.task.model.max_level + @property + def _padded_size(self): + if self.params.task.train_data.parser.pad: + return preprocess_ops.compute_padded_size( + self._input_image_size, 2**self.params.task.model.max_level ) else: - self._padded_size = input_image_size - super().__init__( - params=params, - input_image_size=input_image_size, - **kwargs, - ) + return self._input_image_size def _build_model(self): From bea907c354311ebf586a1006be429da53aa189b5 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 4 Oct 2023 15:29:51 -0700 Subject: [PATCH 14/42] No public description PiperOrigin-RevId: 570828691 --- .../two_model_inference/postprocessing.py | 529 ++++++++++++++++++ 1 file changed, 529 insertions(+) create mode 100644 official/projects/waste_identification_ml/two_model_inference/postprocessing.py diff --git a/official/projects/waste_identification_ml/two_model_inference/postprocessing.py b/official/projects/waste_identification_ml/two_model_inference/postprocessing.py new file mode 100644 index 00000000000..6408cf61b70 --- /dev/null +++ b/official/projects/waste_identification_ml/two_model_inference/postprocessing.py @@ -0,0 +1,529 @@ +# Copyright 2023 The TensorFlow Authors. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Post process the results output from the ML model. + +Given the output from the 2 mask RCNN models. The 3 main tasks are done by three +functions mentioned below - +1. reframing_masks : Reframe the masks according to the size of an image and +their respective positions within an image. +2. find_similar_masks : Given masks from the output of 2 models. Find masks +which belong to the same object and combine all of their attributes like +confidence score, bounding boxes, label names, etc. The masks are mapped to each +other if their score is above a threshold limit. Two outputs are combined into +a single output. +3. filter_bounding_boxes : The combined output may have nested bounding boxes of +the same object. The parent bounding boxes are removed in this step so that any +object should not have more than a single bounding box. +""" +import copy +from typing import Any, Optional, TypedDict +import numpy as np +import tensorflow as tf + + +class DetectionResult(TypedDict): + num_detections: np.ndarray + detection_classes: np.ndarray + detection_scores: np.ndarray + detection_boxes: np.ndarray + detection_classes_names: np.ndarray + detection_masks_reframed: np.ndarray + + +class ItemDict(TypedDict): + id: int + name: str + supercategory: str + + +def reframe_image_corners_relative_to_boxes(boxes: tf.Tensor) -> tf.Tensor: + """Reframe the image corners ([0, 0, 1, 1]) to be relative to boxes. + + The local coordinate frame of each box is assumed to be relative to + its own for corners. + + Args: + boxes: A float tensor of [num_boxes, 4] of (ymin, xmin, ymax, xmax) + coordinates in relative coordinate space of each bounding box. + + Returns: + reframed_boxes: Reframes boxes with same shape as input. + """ + ymin, xmin, ymax, xmax = tf.unstack(boxes, axis=1) + + height = tf.maximum(ymax - ymin, 1e-4) + width = tf.maximum(xmax - xmin, 1e-4) + + ymin_out = (0 - ymin) / height + xmin_out = (0 - xmin) / width + ymax_out = (1 - ymin) / height + xmax_out = (1 - xmin) / width + return tf.stack([ymin_out, xmin_out, ymax_out, xmax_out], axis=1) + + +def reframe_box_masks_to_image_masks( + box_masks: tf.Tensor, + boxes: tf.Tensor, + image_height: int, + image_width: int, + resize_method: str = 'bilinear', +) -> tf.Tensor: + """Transforms the box masks back to full image masks. + + Embeds masks in bounding boxes of larger masks whose shapes correspond to + image shape. + + Args: + box_masks: A tensor of size [num_masks, mask_height, mask_width]. + boxes: A tf.float32 tensor of size [num_masks, 4] containing the box + corners. Row i contains [ymin, xmin, ymax, xmax] of the box corresponding + to mask i. Note that the box corners are in normalized coordinates. + image_height: Image height. The output mask will have the same height as the + image height. + image_width: Image width. The output mask will have the same width as the + image width. + resize_method: The resize method, either 'bilinear' or 'nearest'. Note that + 'bilinear' is only respected if box_masks is a float. + + Returns: + A tensor of size [num_masks, image_height, image_width] with the same dtype + as `box_masks`. + """ + resize_method = 'nearest' if box_masks.dtype == tf.uint8 else resize_method + + def reframe_box_masks_to_image_masks_default(): + """The default function when there are more than 0 box masks.""" + + num_boxes = tf.shape(box_masks)[0] + box_masks_expanded = tf.expand_dims(box_masks, axis=3) + + resized_crops = tf.image.crop_and_resize( + image=box_masks_expanded, + boxes=reframe_image_corners_relative_to_boxes(boxes), + box_indices=tf.range(num_boxes), + crop_size=[image_height, image_width], + method=resize_method, + extrapolation_value=0, + ) + return tf.cast(resized_crops, box_masks.dtype) + + image_masks = tf.cond( + tf.shape(box_masks)[0] > 0, + reframe_box_masks_to_image_masks_default, + lambda: tf.zeros([0, image_height, image_width, 1], box_masks.dtype), + ) + return tf.squeeze(image_masks, axis=3) + + +def reframing_masks( + results: dict[str, np.ndarray], height: int, width: int +) -> dict[str, np.ndarray]: + """Processes the output from Mask RCNN model to create a full size mask. + + Args: + results: list of dictionaries containing the output of Mask RCNN. + height: The height of the image. + width: The width of the image. + + Returns: + A processed list of dictionaries. + """ + result = copy.deepcopy(results) + result['detection_boxes'][0][:, [0, 2]] /= height + result['detection_boxes'][0][:, [1, 3]] /= width + + detection_masks = tf.convert_to_tensor(result['detection_masks'][0]) + detection_boxes = tf.convert_to_tensor(result['detection_boxes'][0]) + detection_masks_reframed = reframe_box_masks_to_image_masks( + detection_masks, detection_boxes, height, width + ) + detection_masks_reframed = tf.cast(detection_masks_reframed > 0.8, np.uint8) + result['detection_masks_reframed'] = detection_masks_reframed.numpy() + return result + + +def find_id_by_name( + dictionary: dict[int, ItemDict], name: str +) -> Optional[int]: + """Finds the id of a dictionary given its value. + + Args: + dictionary: The dictionary containing the data. + name: The value to find. + + Returns: + The id, or None if its not found. + """ + + # Iterate over the dictionary, and check if the name of the user + # matches the name that was passed in. + for value in dictionary.values(): + if value['name'] == name: + # If the name matches, return the id of the user. + return value['id'] + + return None + + +def combine_bounding_boxes( + box1: list[float], + box2: list[float], +) -> list[float]: + """Combines two bounding boxes. + + Args: + box1: A list of four numbers representing the coordinates of the first + bounding box. + box2: A list of four numbers representing the coordinates of the second + bounding box. + + Returns: + A list of four numbers representing the coordinates of the combined + bounding box. + """ + + ymin = min(box1[0], box2[0]) + xmin = min(box1[1], box2[1]) + ymax = max(box1[2], box2[2]) + xmax = max(box1[3], box2[3]) + + return [ymin, xmin, ymax, xmax] + + +def calculate_combined_scores_boxes_classes( + i: int, + j: int, + results_1: DetectionResult, + results_2: DetectionResult, + category_indices: list[list[Any]], + category_index_combined: dict[int, ItemDict], +) -> tuple[Any, list[float], Any, Optional[int]]: + """Calculate combined scores, boxes, and classes for matched masks. + + Args: + i: Index of the mask from the results_1. + j: Index of the mask from the results_2. + results_1: A dictionary which contains the results from the first model. + results_2: A dictionary which contains the results from the second model. + category_indices: list of sub lists which contains the labels of 1st and + 2nd ML model. + category_index_combined: Combined category index. + + Returns: + tuple: A tuple containing: + - avg_score: Average score of the matched masks. + - combined_box: Combined bounding box for the matched masks. + - combined_label: Combined label of the matched masks. + - result_id: ID associated with the combined label. + """ + score_1 = results_1['detection_scores'][0][i] + score_2 = results_2['detection_scores'][0][j] + avg_score = (score_1 + score_2) / 2 + + box_1 = results_1['detection_boxes'][0][i] + box_2 = results_2['detection_boxes'][0][j] + combined_box = combine_bounding_boxes(box_1, box_2) + + class_1 = results_1['detection_classes'][0][i] + class_2 = results_2['detection_classes'][0][j] + combined_label = ( + category_indices[0][class_1] + '_' + category_indices[1][class_2] + ) + result_id = find_id_by_name(category_index_combined, combined_label) + + return avg_score, combined_box, combined_label, result_id + + +def calculate_single_result( + index: int, + result: DetectionResult, + category_indices: list[list[Any]], + flag: Any | str, +) -> tuple[float, tuple[float, float, float, float], str]: + """Calculate scores, boxes, and classes for non-matched masks. + + Args: + index: Index of the mask in the results. + result: A dictionary containing detection results (either from results_1 + or results_2). + category_indices: list of category indices. + flag: To identify whose model did not detected an object. + + Returns: + score: Score of the mask. + box: Bounding box of the mask. + combined_label: Label of the mask with the added suffix. + """ + combined_label = 'Default Value' + score = result['detection_scores'][0][index] + box = result['detection_boxes'][0][index] + class_idx = result['detection_classes'][0][index] + if flag == 'after': + combined_label = category_indices[class_idx] + '_Na' + elif flag == 'before': + combined_label = 'Na_' + category_indices[class_idx] + return score, box, combined_label + + +def calculate_iou( + mask1: np.ndarray, mask2: np.ndarray +) -> tuple[float, np.ndarray]: + """Calculates the intersection over union (IoU) score for two masks. + + Args: + mask1: The first mask. + mask2: The second mask. + + Returns: + The IoU scorea and union of two masks. + """ + + # Check if the masks have the same dimensions. + if mask1.shape != mask2.shape: + raise ValueError('The masks must have the same dimensions.') + + intersection = np.logical_and(mask1, mask2) + union = np.logical_or(mask1, mask2) + iou_score = np.sum(intersection) / np.sum(union) + return iou_score, union + + +def find_similar_masks( + results_1: DetectionResult, + results_2: DetectionResult, + num_detections: int, + min_score_thresh: float, + category_indices: list[list[Any]], + category_index_combined: dict[int, ItemDict], + area_threshold: float, + iou_threshold: float = 0.8, +) -> dict[str, np.ndarray]: + """Aligns the masks of the detections in `results_1` and `results_2`. + + Args: + results_1: A dictionary which contains the results from the first model. + results_2: A dictionary which contains the results from the second model. + num_detections: The number of detections to consider. + min_score_thresh: The minimum score threshold for a detection + category_indices: list of sub lists which contains the labels of 1st and 2nd + ML model + category_index_combined: A dictionary with an object ID and nested + dictionary with name. e.g. {1: {'id': 1, 'name': 'Fiber_Na_Bag', + 'supercategory': 'objects'}} + area_threshold: Threshold for mask area consideration. + iou_threshold: IOU threshold to compare masks. + + Returns: + A dictionary containing the following keys: + - num_detections: The number of aligned detections. + - detection_classes: A NumPy array of shape (num_detections,) containing + the classes for the aligned detections. + - detection_scores: A NumPy array of shape (num_detections,) containing + the scores for the aligned detections. + - detection_boxes: A NumPy array of shape (num_detections, 4) containing + the bounding boxes for the aligned detections. + - detection_classes_names: A list of strings containing the names of the + classes for the aligned detections. + - detection_masks_reframed: A NumPy array of shape (num_detections, + height, width) containing the full masks for the aligned detections. + """ + detection_masks_reframed = [] + detection_scores = [] + detection_boxes = [] + detection_classes = [] + detection_classes_names = [] + + aligned_masks = 0 + masks_list1 = results_1['detection_masks_reframed'][:num_detections] + masks_list2 = results_2['detection_masks_reframed'][:num_detections] + scores_list1 = results_1['detection_scores'][0] + scores_list2 = results_2['detection_scores'][0] + matched_masks_list2 = [False] * len(masks_list2) + matched_masks_list1 = [False] * len(masks_list1) + + for i, mask1 in enumerate(masks_list1): + if (scores_list1[i] > min_score_thresh) and ( + np.sum(mask1) < area_threshold + ): + is_similar = False + + for j, mask2 in enumerate(masks_list2): + if scores_list2[j] > min_score_thresh and ( + np.sum(mask2) < area_threshold + ): + iou, union = calculate_iou(mask1, mask2) + + # masks which are present both in the 'detection_masks_reframed' + # key of 'results_1' & 'results_2' dictionary + if iou > iou_threshold: + aligned_masks += 1 + is_similar = True + matched_masks_list2[j] = True + matched_masks_list1[i] = True + + detection_masks_reframed.append(union) + + avg_score, combined_box, combined_label, result_id = ( + calculate_combined_scores_boxes_classes( + i, + j, + results_1, + results_2, + category_indices, + category_index_combined, + ) + ) + detection_scores.append(avg_score) + detection_boxes.append(combined_box) + detection_classes_names.append(combined_label) + detection_classes.append(result_id) + break + + # masks which are only present in the 'detection_masks_reframed' + # of 'results_1' dictionary + if not is_similar: + aligned_masks += 1 + detection_masks_reframed.append(mask1) + score, box, combined_label = calculate_single_result( + i, results_1, category_indices[0], 'after' + ) + detection_scores.append(score) + detection_boxes.append(box) + detection_classes_names.append(combined_label) + result_id = find_id_by_name(category_index_combined, combined_label) + detection_classes.append(result_id) + + # masks which are only present in the 'detection_masks_reframed' + # key of 'results_2' dictionary + for k, mask2 in enumerate(masks_list2): + if ( + (not matched_masks_list2[k]) + and (scores_list2[k] > min_score_thresh) + and (np.sum(mask2) < area_threshold) + ): + aligned_masks += 1 + detection_masks_reframed.append(mask2) + score, box, combined_label = calculate_single_result( + k, results_2, category_indices[1], 'before' + ) + detection_scores.append(score) + detection_boxes.append(box) + detection_classes_names.append(combined_label) + result_id = find_id_by_name(category_index_combined, combined_label) + detection_classes.append(result_id) + + final_result = { + 'num_detections': np.array([aligned_masks]), + 'detection_classes': np.array(detection_classes), + 'detection_scores': np.array([detection_scores]), + 'detection_boxes': np.array([detection_boxes]), + 'detection_classes_names': np.array(detection_classes_names), + 'detection_masks_reframed': np.array(detection_masks_reframed), + } + + return final_result + + +def filter_bounding_boxes( + bounding_boxes: list[tuple[int, int, int, int]], + iou_threshold: float = 0.5, + area_ratio_threshold: float = 0.8, +) -> tuple[list[tuple[int, int, int, int]], list[int]]: + """Filters overlapping bounding boxes based on IoU and area ratio criteria. + + This function filters out overlapping bounding boxes from a given list based + on Intersection over Union (IoU) and area ratio of the intersection to the + smaller bounding box's area. + + Args: + bounding_boxes: A list of bounding boxes, where each bounding box is + represented as a tuple of (xmin, ymin, xmax, ymax). + iou_threshold: Threshold for Intersection over Union. Bounding boxes with + IoU above this threshold will be considered overlapping. Defaults to + 0.5. + area_ratio_threshold: Threshold for the area ratio of the intersection to + the smaller bounding box's area. Defaults to 0.8. + + Returns: + tuple: A tuple containing: + - filtered_boxes: A list of bounding boxes that passed the filtering + criteria. + - eliminated_indices: Indices of the bounding boxes that didn't pass + the filtering criteria. + + Example: + >>> bounding_boxes = [(10, 10, 50, 50), (20, 20, 60, 60)] + >>> filter_bounding_boxes(bounding_boxes) + ([(10, 10, 50, 50)], [1]) + """ + filtered_boxes = [] + eliminated_indices = [] + + # Enumerate and sort the boxes based on their area in descending order + enumerated_boxes = list(enumerate(bounding_boxes)) + sorted_boxes = sorted( + enumerated_boxes, + key=lambda item: (item[1][2] - item[1][0]) * (item[1][3] - item[1][1]), + reverse=True, + ) + + for idx, bbox in sorted_boxes: + skip_box = False + + # Calculate areas of individual bounding boxes + area_bbox = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) + + for jdx, other_bbox in sorted_boxes: + if idx == jdx: + continue + + # Calculate intersection coordinates + xmin_inter = max(bbox[0], other_bbox[0]) + ymin_inter = max(bbox[1], other_bbox[1]) + xmax_inter = min(bbox[2], other_bbox[2]) + ymax_inter = min(bbox[3], other_bbox[3]) + + # Calculate intersection area + width_inter = max(0, xmax_inter - xmin_inter) + height_inter = max(0, ymax_inter - ymin_inter) + area_inter = width_inter * height_inter + + area_other_bbox = (other_bbox[2] - other_bbox[0]) * ( + other_bbox[3] - other_bbox[1] + ) + + # Calculate area ratio + area_ratio = area_inter / min(area_bbox, area_other_bbox) + + # Check for overlapping and area ratio thresholds + if area_ratio > area_ratio_threshold: + if area_bbox > area_other_bbox: + skip_box = True + eliminated_indices.append(idx) + break + elif ( + area_inter > 0 + and area_inter / (area_bbox + area_other_bbox - area_inter) + > iou_threshold + ): + if area_bbox > area_other_bbox: + skip_box = True + eliminated_indices.append(idx) + break + + if not skip_box: + filtered_boxes.append(bbox) + + return filtered_boxes, eliminated_indices From 87b2351c30bc56853b6deb82cd08e2be16f638d5 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 5 Oct 2023 13:29:56 -0700 Subject: [PATCH 15/42] No public description PiperOrigin-RevId: 571114273 --- .../two_model_inference/download_and_unzip_models.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py b/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py index 61fb1109ad9..3af5e3e0e86 100644 --- a/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py +++ b/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py @@ -73,16 +73,16 @@ def execute_command(cmd: str) -> str: def main(_) -> None: # Download the provided files - execute_command(f"wget {args.url1}") - execute_command(f"wget {args.url2}") + execute_command(f"wget {args.material_url}") + execute_command(f"wget {args.material_form_url}") # Create directories os.makedirs("material", exist_ok=True) os.makedirs("material_form", exist_ok=True) # Unzip the provided files - zip_file1 = os.path.basename(args.url1) - zip_file2 = os.path.basename(args.url2) + zip_file1 = os.path.basename(args.material_url) + zip_file2 = os.path.basename(args.material_form_url) execute_command(f"unzip {zip_file1} -d material/") execute_command(f"unzip {zip_file2} -d material_form/") From 302739ebfb895157c94ae9f8dfcfe8085594fbc8 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 5 Oct 2023 13:31:28 -0700 Subject: [PATCH 16/42] Apply class weights in maskrcnn loss PiperOrigin-RevId: 571114756 --- official/vision/configs/maskrcnn.py | 1 + official/vision/losses/maskrcnn_losses.py | 23 ++++++++++- .../vision/losses/maskrcnn_losses_test.py | 10 +++-- official/vision/tasks/maskrcnn.py | 38 ++++++++++++------- 4 files changed, 54 insertions(+), 18 deletions(-) diff --git a/official/vision/configs/maskrcnn.py b/official/vision/configs/maskrcnn.py index 706c28eab3e..d39625d5124 100644 --- a/official/vision/configs/maskrcnn.py +++ b/official/vision/configs/maskrcnn.py @@ -223,6 +223,7 @@ class Losses(hyperparams.Config): frcnn_class_weight: float = 1.0 frcnn_box_weight: float = 1.0 mask_weight: float = 1.0 + class_weights: Optional[List[float]] = None @dataclasses.dataclass diff --git a/official/vision/losses/maskrcnn_losses.py b/official/vision/losses/maskrcnn_losses.py index dd5f5571755..dec15971a75 100644 --- a/official/vision/losses/maskrcnn_losses.py +++ b/official/vision/losses/maskrcnn_losses.py @@ -167,26 +167,40 @@ def __init__(self, self._use_binary_cross_entropy = use_binary_cross_entropy self._top_k_percent = top_k_percent - def __call__(self, class_outputs, class_targets): + def __call__(self, class_outputs, class_targets, class_weights=None): """Computes the class loss (Fast-RCNN branch) of Mask-RCNN. This function implements the classification loss of the Fast-RCNN. The classification loss is categorical (or binary) cross entropy on all RoIs. - Reference: https://github.com/facebookresearch/Detectron/blob/master/detectron/modeling/fast_rcnn_heads.py # pylint: disable=line-too-long + Reference: + https://github.com/facebookresearch/Detectron/blob/master/detectron/modeling/fast_rcnn_heads.py + # pylint: disable=line-too-long Args: class_outputs: a float tensor representing the class prediction for each box with a shape of [batch_size, num_boxes, num_classes]. class_targets: a float tensor representing the class label for each box with a shape of [batch_size, num_boxes]. + class_weights: A float list containing the weight of each class. Returns: a scalar tensor representing total class loss. """ with tf.name_scope('fast_rcnn_loss'): + output_dtype = class_outputs.dtype num_classes = class_outputs.get_shape().as_list()[-1] + class_weights = ( + class_weights if class_weights is not None else [1.0] * num_classes + ) + if num_classes != len(class_weights): + raise ValueError( + 'Length of class_weights should be {}'.format(num_classes) + ) + + class_weights = tf.constant(class_weights, dtype=output_dtype) + class_targets_one_hot = tf.one_hot( tf.cast(class_targets, dtype=tf.int32), num_classes, @@ -195,10 +209,15 @@ def __call__(self, class_outputs, class_targets): # (batch_size, num_boxes, num_classes) cross_entropy_loss = tf.nn.sigmoid_cross_entropy_with_logits( labels=class_targets_one_hot, logits=class_outputs) + cross_entropy_loss *= class_weights else: # (batch_size, num_boxes) cross_entropy_loss = tf.nn.softmax_cross_entropy_with_logits( labels=class_targets_one_hot, logits=class_outputs) + class_weight_mask = tf.einsum( + '...y,y->...', class_targets_one_hot, class_weights + ) + cross_entropy_loss *= class_weight_mask if self._top_k_percent < 1.0: return self.aggregate_loss_top_k(cross_entropy_loss) diff --git a/official/vision/losses/maskrcnn_losses_test.py b/official/vision/losses/maskrcnn_losses_test.py index b203d81e808..1e65cc5e88e 100644 --- a/official/vision/losses/maskrcnn_losses_test.py +++ b/official/vision/losses/maskrcnn_losses_test.py @@ -77,7 +77,10 @@ def testFastrcnnClassLoss(self, use_binary_cross_entropy): maxval=num_classes + 1, dtype=tf.int32) loss_fn = maskrcnn_losses.FastrcnnClassLoss(use_binary_cross_entropy) - self.assertEqual(tf.rank(loss_fn(class_outputs, class_targets)), 0) + class_weights = [1.0] * num_classes + self.assertEqual( + tf.rank(loss_fn(class_outputs, class_targets, class_weights)), 0 + ) def testFastrcnnClassLossTopK(self): class_targets = tf.constant([[0, 0, 0, 2]]) @@ -87,16 +90,17 @@ def testFastrcnnClassLossTopK(self): [100.0, 0.0, 0.0], [0.0, 1.0, 0.0], ]]) + class_weights = [1.0, 1.0, 1.0] self.assertAllClose( maskrcnn_losses.FastrcnnClassLoss(top_k_percent=0.5)( - class_outputs, class_targets + class_outputs, class_targets, class_weights ), 0.775718, atol=1e-4, ) self.assertAllClose( maskrcnn_losses.FastrcnnClassLoss(top_k_percent=1.0)( - class_outputs, class_targets + class_outputs, class_targets, class_weights ), 0.387861, atol=1e-4, diff --git a/official/vision/tasks/maskrcnn.py b/official/vision/tasks/maskrcnn.py index a5a612e110a..9e0ee7bf37d 100644 --- a/official/vision/tasks/maskrcnn.py +++ b/official/vision/tasks/maskrcnn.py @@ -202,8 +202,10 @@ def _build_rpn_losses( return rpn_score_loss, rpn_box_loss def _build_frcnn_losses( - self, outputs: Mapping[str, Any], - labels: Mapping[str, Any]) -> Tuple[tf.Tensor, tf.Tensor]: + self, + outputs: Mapping[str, Any], + labels: Mapping[str, Any], + ) -> Tuple[tf.Tensor, tf.Tensor]: """Builds losses for Fast R-CNN.""" cascade_ious = self.task_config.model.roi_sampler.cascade_iou_thresholds @@ -222,10 +224,19 @@ def _build_frcnn_losses( for cas_num in range(num_det_heads): frcnn_cls_loss_i = tf.reduce_mean( frcnn_cls_loss_fn( - outputs['class_outputs_{}' - .format(cas_num) if cas_num else 'class_outputs'], - outputs['class_targets_{}' - .format(cas_num) if cas_num else 'class_targets'])) + outputs[ + 'class_outputs_{}'.format(cas_num) + if cas_num + else 'class_outputs' + ], + outputs[ + 'class_targets_{}'.format(cas_num) + if cas_num + else 'class_targets' + ], + self.task_config.losses.class_weights, + ) + ) frcnn_box_loss_i = tf.reduce_mean( frcnn_box_loss_fn( outputs['box_outputs_{}'.format(cas_num @@ -257,6 +268,7 @@ def build_losses(self, labels: Mapping[str, Any], aux_losses: Optional[Any] = None) -> Dict[str, tf.Tensor]: """Builds Mask R-CNN losses.""" + loss_params = self.task_config.losses rpn_score_loss, rpn_box_loss = self._build_rpn_losses(outputs, labels) frcnn_cls_loss, frcnn_box_loss = self._build_frcnn_losses(outputs, labels) if self.task_config.model.include_mask: @@ -264,20 +276,20 @@ def build_losses(self, else: mask_loss = tf.constant(0.0, dtype=tf.float32) - params = self.task_config model_loss = ( - params.losses.rpn_score_weight * rpn_score_loss + - params.losses.rpn_box_weight * rpn_box_loss + - params.losses.frcnn_class_weight * frcnn_cls_loss + - params.losses.frcnn_box_weight * frcnn_box_loss + - params.losses.mask_weight * mask_loss) + loss_params.rpn_score_weight * rpn_score_loss + + loss_params.rpn_box_weight * rpn_box_loss + + loss_params.frcnn_class_weight * frcnn_cls_loss + + loss_params.frcnn_box_weight * frcnn_box_loss + + loss_params.mask_weight * mask_loss + ) total_loss = model_loss if aux_losses: reg_loss = tf.reduce_sum(aux_losses) total_loss = model_loss + reg_loss - total_loss = params.losses.loss_weight * total_loss + total_loss = loss_params.loss_weight * total_loss losses = { 'total_loss': total_loss, 'rpn_score_loss': rpn_score_loss, From 019a58d0a4c6063281eea6bec0e8adfc467aeb06 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 5 Oct 2023 14:22:35 -0700 Subject: [PATCH 17/42] No public description PiperOrigin-RevId: 571129370 --- .../TFHub_saved_model_inference.ipynb | 0 .../saved_model_inference.ipynb | 0 .../tflite_model_inference.ipynb | 0 3 files changed, 0 insertions(+), 0 deletions(-) rename official/projects/waste_identification_ml/{model_inference => deprecated_model_inference}/TFHub_saved_model_inference.ipynb (100%) rename official/projects/waste_identification_ml/{model_inference => deprecated_model_inference}/saved_model_inference.ipynb (100%) rename official/projects/waste_identification_ml/{model_inference => deprecated_model_inference}/tflite_model_inference.ipynb (100%) diff --git a/official/projects/waste_identification_ml/model_inference/TFHub_saved_model_inference.ipynb b/official/projects/waste_identification_ml/deprecated_model_inference/TFHub_saved_model_inference.ipynb similarity index 100% rename from official/projects/waste_identification_ml/model_inference/TFHub_saved_model_inference.ipynb rename to official/projects/waste_identification_ml/deprecated_model_inference/TFHub_saved_model_inference.ipynb diff --git a/official/projects/waste_identification_ml/model_inference/saved_model_inference.ipynb b/official/projects/waste_identification_ml/deprecated_model_inference/saved_model_inference.ipynb similarity index 100% rename from official/projects/waste_identification_ml/model_inference/saved_model_inference.ipynb rename to official/projects/waste_identification_ml/deprecated_model_inference/saved_model_inference.ipynb diff --git a/official/projects/waste_identification_ml/model_inference/tflite_model_inference.ipynb b/official/projects/waste_identification_ml/deprecated_model_inference/tflite_model_inference.ipynb similarity index 100% rename from official/projects/waste_identification_ml/model_inference/tflite_model_inference.ipynb rename to official/projects/waste_identification_ml/deprecated_model_inference/tflite_model_inference.ipynb From a06edcbf9afd303056e931dc95cd43f5bd670026 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 5 Oct 2023 15:37:22 -0700 Subject: [PATCH 18/42] No public description PiperOrigin-RevId: 571149107 --- .../{two_model_inference => model_inference}/Inference.ipynb | 0 .../color_and_property_extractor.py | 0 .../download_and_unzip_models.py | 0 .../{two_model_inference => model_inference}/labels.py | 0 .../{two_model_inference => model_inference}/postprocessing.py | 0 .../{two_model_inference => model_inference}/preprocessing.py | 0 6 files changed, 0 insertions(+), 0 deletions(-) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/Inference.ipynb (100%) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/color_and_property_extractor.py (100%) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/download_and_unzip_models.py (100%) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/labels.py (100%) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/postprocessing.py (100%) rename official/projects/waste_identification_ml/{two_model_inference => model_inference}/preprocessing.py (100%) diff --git a/official/projects/waste_identification_ml/two_model_inference/Inference.ipynb b/official/projects/waste_identification_ml/model_inference/Inference.ipynb similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/Inference.ipynb rename to official/projects/waste_identification_ml/model_inference/Inference.ipynb diff --git a/official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py b/official/projects/waste_identification_ml/model_inference/color_and_property_extractor.py similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/color_and_property_extractor.py rename to official/projects/waste_identification_ml/model_inference/color_and_property_extractor.py diff --git a/official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py b/official/projects/waste_identification_ml/model_inference/download_and_unzip_models.py similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/download_and_unzip_models.py rename to official/projects/waste_identification_ml/model_inference/download_and_unzip_models.py diff --git a/official/projects/waste_identification_ml/two_model_inference/labels.py b/official/projects/waste_identification_ml/model_inference/labels.py similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/labels.py rename to official/projects/waste_identification_ml/model_inference/labels.py diff --git a/official/projects/waste_identification_ml/two_model_inference/postprocessing.py b/official/projects/waste_identification_ml/model_inference/postprocessing.py similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/postprocessing.py rename to official/projects/waste_identification_ml/model_inference/postprocessing.py diff --git a/official/projects/waste_identification_ml/two_model_inference/preprocessing.py b/official/projects/waste_identification_ml/model_inference/preprocessing.py similarity index 100% rename from official/projects/waste_identification_ml/two_model_inference/preprocessing.py rename to official/projects/waste_identification_ml/model_inference/preprocessing.py From 43c2ee0f5a6efa287097c0315fb6f4699a81c3e6 Mon Sep 17 00:00:00 2001 From: Fan Yang Date: Tue, 10 Oct 2023 14:38:28 -0700 Subject: [PATCH 19/42] No public description PiperOrigin-RevId: 572370412 --- .../vision/configs/semantic_segmentation.py | 1 + .../vision/tasks/semantic_segmentation.py | 39 ++++- .../object_detection/visualization_utils.py | 157 ++++++++++++++++++ 3 files changed, 192 insertions(+), 5 deletions(-) diff --git a/official/vision/configs/semantic_segmentation.py b/official/vision/configs/semantic_segmentation.py index b41392e40d0..c84fa11dde9 100644 --- a/official/vision/configs/semantic_segmentation.py +++ b/official/vision/configs/semantic_segmentation.py @@ -198,6 +198,7 @@ class SemanticSegmentationTask(cfg.TaskConfig): init_checkpoint_modules: Union[ str, List[str]] = 'all' # all, backbone, and/or decoder export_config: ExportConfig = dataclasses.field(default_factory=ExportConfig) + allow_image_summary: bool = True @exp_factory.register_config_factory('semantic_segmentation') diff --git a/official/vision/tasks/semantic_segmentation.py b/official/vision/tasks/semantic_segmentation.py index b77b32753ce..a2e6a978ba9 100644 --- a/official/vision/tasks/semantic_segmentation.py +++ b/official/vision/tasks/semantic_segmentation.py @@ -29,6 +29,7 @@ from official.vision.evaluation import segmentation_metrics from official.vision.losses import segmentation_losses from official.vision.modeling import factory +from official.vision.utils.object_detection import visualization_utils @task_factory.register_task_cls(exp_cfg.SemanticSegmentationTask) @@ -321,6 +322,14 @@ def validation_step(self, if metrics: self.process_metrics(metrics, labels, outputs) + if ( + hasattr(self.task_config, 'allow_image_summary') + and self.task_config.allow_image_summary + ): + logs.update( + {'visualization': (tf.cast(features, dtype=tf.float32), outputs)} + ) + return logs def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model): @@ -330,17 +339,37 @@ def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model): def aggregate_logs(self, state=None, step_outputs=None): if state is None and self.iou_metric is not None: self.iou_metric.reset_states() - state = self.iou_metric + + if 'visualization' in step_outputs: + # Update segmentation state for writing summary if there are artifacts for + # visualization. + if state is None: + state = {} + state.update(visualization_utils.update_segmentation_state(step_outputs)) + + if state is None: + # Create an arbitrary state to indicate it's not the first step in the + # following calls to this function. + state = True + return state def reduce_aggregated_logs(self, aggregated_logs, global_step=None): - result = {} + logs = {} if self.iou_metric is not None: ious = self.iou_metric.result() # TODO(arashwan): support loading class name from a label map file. if self.task_config.evaluation.report_per_class_iou: for i, value in enumerate(ious.numpy()): - result.update({'iou/{}'.format(i): value}) + logs.update({'iou/{}'.format(i): value}) # Computes mean IoU - result.update({'mean_iou': tf.reduce_mean(ious)}) - return result + logs.update({'mean_iou': tf.reduce_mean(ious)}) + + # Add visualization for summary. + if isinstance(aggregated_logs, dict) and 'image' in aggregated_logs: + validation_outputs = visualization_utils.visualize_segmentation_outputs( + logs=aggregated_logs, task_config=self.task_config + ) + logs.update(validation_outputs) + + return logs diff --git a/official/vision/utils/object_detection/visualization_utils.py b/official/vision/utils/object_detection/visualization_utils.py index 1407abaa541..c55b52bca6b 100644 --- a/official/vision/utils/object_detection/visualization_utils.py +++ b/official/vision/utils/object_detection/visualization_utils.py @@ -894,3 +894,160 @@ def update_detection_state(step_outputs=None) -> Dict[str, Any]: state['detection_masks'] = tf.concat(detection_masks, axis=0) return state + + +def update_segmentation_state(step_outputs=None) -> Dict[str, Any]: + """Updates segmentation state to optionally add input image and predictions.""" + state = {} + if step_outputs: + state['image'] = tf.concat(step_outputs['visualization'][0], axis=0) + state['logits'] = tf.concat( + step_outputs['visualization'][1]['logits'], axis=0 + ) + return state + + +def visualize_segmentation_outputs( + logs, + task_config, + original_image_spatial_shape=None, + true_image_shape=None, + image_mean: Optional[Union[float, List[float]]] = None, + image_std: Optional[Union[float, List[float]]] = None, + key: str = 'image/validation_outputs', +) -> Dict[str, Any]: + """Visualizes the detection outputs. + + It extracts images and predictions from logs and draws visualization on input + images. By default, it requires `detection_boxes`, `detection_classes` and + `detection_scores` in the prediction, and optionally accepts + `detection_keypoints` and `detection_masks`. + + Args: + logs: A dictionaty of log that contains images and predictions. + task_config: A task config. + original_image_spatial_shape: A [N, 2] tensor containing the spatial size of + the original image. + true_image_shape: A [N, 3] tensor containing the spatial size of unpadded + original_image. + image_mean: An optional float or list of floats used as the mean pixel value + to normalize images. + image_std: An optional float or list of floats used as the std to normalize + images. + key: A string specifying the key of the returned dictionary. + + Returns: + A dictionary of images with visualization drawn on it. Each key corresponds + to a 4D tensor with segments drawn on each image. + """ + images = logs['image'] + masks = np.argmax(logs['logits'], axis=-1) + num_classes = task_config.model.num_classes + + def _denormalize_images(images: tf.Tensor) -> tf.Tensor: + if image_mean is None and image_std is None: + images *= tf.constant( + preprocess_ops.STDDEV_RGB, shape=[1, 1, 3], dtype=images.dtype + ) + images += tf.constant( + preprocess_ops.MEAN_RGB, shape=[1, 1, 3], dtype=images.dtype + ) + elif image_mean is not None and image_std is not None: + if isinstance(image_mean, float) and isinstance(image_std, float): + images = images * image_std + image_mean + elif isinstance(image_mean, list) and isinstance(image_std, list): + images *= tf.constant(image_std, shape=[1, 1, 3], dtype=images.dtype) + images += tf.constant(image_mean, shape=[1, 1, 3], dtype=images.dtype) + else: + raise ValueError( + '`image_mean` and `image_std` should be the same type.' + ) + else: + raise ValueError( + 'Both `image_mean` and `image_std` should be set or None at the same ' + 'time.' + ) + return tf.cast(images, dtype=tf.uint8) + + images = tf.nest.map_structure( + tf.identity, + tf.map_fn( + _denormalize_images, + elems=images, + fn_output_signature=tf.TensorSpec( + shape=images.shape.as_list()[1:], dtype=tf.uint8 + ), + parallel_iterations=32, + ), + ) + + if images.shape[3] > 3: + images = images[:, :, :, 0:3] + elif images.shape[3] == 1: + images = tf.image.grayscale_to_rgb(images) + if true_image_shape is None: + true_shapes = tf.constant(-1, shape=[images.shape.as_list()[0], 3]) + else: + true_shapes = true_image_shape + if original_image_spatial_shape is None: + original_shapes = tf.constant(-1, shape=[images.shape.as_list()[0], 2]) + else: + original_shapes = original_image_spatial_shape + + visualize_fn = functools.partial(_visualize_masks, num_classes=num_classes) + elems = [true_shapes, original_shapes, images, masks] + + def draw_segments(image_and_segments): + """Draws boxes on image.""" + true_shape = image_and_segments[0] + original_shape = image_and_segments[1] + if true_image_shape is not None: + image = shape_utils.pad_or_clip_nd( + image_and_segments[2], [true_shape[0], true_shape[1], 3] + ) + if original_image_spatial_shape is not None: + image_and_segments[2] = _resize_original_image(image, original_shape) + + image_with_boxes = tf.compat.v1.py_func( + visualize_fn, image_and_segments[2:], tf.uint8 + ) + return image_with_boxes + + images_with_segments = tf.map_fn( + draw_segments, elems, dtype=tf.uint8, back_prop=False + ) + + outputs = {} + for i, image in enumerate(images_with_segments): + outputs[key + f'/{i}'] = image[None, ...] + + return outputs + + +def _visualize_masks(image, mask, num_classes, alpha=0.4): + """Visualizes semantic segmentation masks.""" + solid_color = np.repeat( + np.expand_dims(np.zeros_like(mask), axis=2), 3, axis=2 + ) + for i in range(num_classes): + color = STANDARD_COLORS[i % len(STANDARD_COLORS)] + rgb = ImageColor.getrgb(color) + one_class_mask = np.where(mask == i, 1, 0) + solid_color = solid_color + np.expand_dims( + one_class_mask, axis=2 + ) * np.reshape(list(rgb), [1, 1, 3]) + + pil_image = Image.fromarray(image) + pil_solid_color = ( + Image.fromarray(np.uint8(solid_color)) + .convert('RGBA') + .resize(pil_image.size) + ) + pil_mask = ( + Image.fromarray(np.uint8(255.0 * alpha * np.ones_like(mask))) + .convert('L') + .resize(pil_image.size) + ) + pil_image = Image.composite(pil_solid_color, pil_image, pil_mask) + np.copyto(image, np.array(pil_image.convert('RGB'))) + return image From 6cf041341fa4084c3ecc5b23cf3528c0e3139c73 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 11 Oct 2023 13:43:33 -0700 Subject: [PATCH 20/42] No public description PiperOrigin-RevId: 572674406 --- .../model_inference/Inference.ipynb | 499 ++++++++++++++++-- 1 file changed, 458 insertions(+), 41 deletions(-) diff --git a/official/projects/waste_identification_ml/model_inference/Inference.ipynb b/official/projects/waste_identification_ml/model_inference/Inference.ipynb index 68319942e6c..a1596b9a28f 100644 --- a/official/projects/waste_identification_ml/model_inference/Inference.ipynb +++ b/official/projects/waste_identification_ml/model_inference/Inference.ipynb @@ -54,9 +54,10 @@ "import matplotlib\n", "import logging\n", "import pandas as pd\n", - "from labels import load_labels\n", "\n", - "logging.disable(logging.WARNING)" + "logging.disable(logging.WARNING)\n", + "\n", + "%matplotlib inline" ] }, { @@ -83,30 +84,24 @@ "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "oCC-WANYBD03", - "outputId": "f507a381-aa79-4a45-c722-4109e252ef71" + "id": "qhk_NujKO0mb" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cloning into 'models'...\n", - "remote: Enumerating objects: 3985, done.\u001b[K\n", - "remote: Counting objects: 100% (3985/3985), done.\u001b[K\n", - "remote: Compressing objects: 100% (3093/3093), done.\u001b[K\n", - "remote: Total 3985 (delta 1151), reused 1942 (delta 835), pack-reused 0\u001b[K\n", - "Receiving objects: 100% (3985/3985), 49.76 MiB | 33.28 MiB/s, done.\n", - "Resolving deltas: 100% (1151/1151), done.\n" - ] - } - ], + "outputs": [], + "source": [ + "# Clone the tensorflow models repository.\n", + "!git clone --depth 1 https://github.com/tensorflow/models 2\u003e/dev/null" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "fBAdlmHKO3AV" + }, + "outputs": [], "source": [ - "# Clone the tensorflow models repository\n", - "!git clone --depth 1 https://github.com/tensorflow/models" + "# Download the script to pull instance segmentation model weights from the TF Model Garden repo.\n", + "!wget -q https://raw.githubusercontent.com/tensorflow/models/master/official/projects/waste_identification_ml/model_inference/download_and_unzip_models.py" ] }, { @@ -118,8 +113,22 @@ "outputs": [], "source": [ "sys.path.append('models/research/')\n", - "from object_detection.utils import visualization_utils as viz_utils\n", - "%matplotlib inline" + "from object_detection.utils import visualization_utils as viz_utils" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "cbcEDJHAB65J" + }, + "outputs": [], + "source": [ + "sys.path.append('models/official/projects/waste_identification_ml/model_inference/')\n", + "import preprocessing\n", + "import postprocessing\n", + "import color_and_property_extractor\n", + "import labels" ] }, { @@ -207,8 +216,8 @@ }, "outputs": [], "source": [ - "# 'material_model' output is both material and its sub type e.g. Plastics_PET\n", - "# 'material_form_model' outputs the form of an object e.g. can, bottle, etc\n", + "# 'material_model' output is both material and its sub type e.g. Plastics_PET.\n", + "# 'material_form_model' outputs the form of an object e.g. can, bottle, etc.\n", "MODEL_WEIGHTS = {\n", "'material_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material/material_version_1.zip',\n", "'material_form_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material_form/material_form_version_1.zip',\n", @@ -224,7 +233,7 @@ "'material_form_model' : 'models/official/projects/waste_identification_ml/pre_processing/config/data/two_model_strategy_material_form.csv',\n", "}\n", "\n", - "# path to a sample image stored in the repo\n", + "# Path to a sample image stored in the repo.\n", "IMAGES_FOR_TEST = {\n", " 'Image1' : 'models/official/projects/waste_identification_ml/pre_processing/config/sample_images/image_2.png'\n", "}" @@ -247,10 +256,10 @@ }, "outputs": [], "source": [ - "# download the model weights from the Google's repo\n", + "# Download the model weights from the Google's repo.\n", "url1 = MODEL_WEIGHTS['material_url']\n", "url2 = MODEL_WEIGHTS['material_form_url']\n", - "!python download_and_unzip_models.py --material_url $url1 material_form_url $url2" + "!python3 download_and_unzip_models.py $url1 $url2" ] }, { @@ -281,8 +290,8 @@ }, "outputs": [], "source": [ - "# the total number of predicted labels (category_indices) for a combined model = 741\n", - "category_indices, category_index = load_labels(LABELS)" + "# The total number of predicted labels (category_indices) for a combined model = 741.\n", + "category_indices, category_index = labels.load_labels(LABELS)" ] }, { @@ -293,7 +302,7 @@ "base_uri": "https://localhost:8080/" }, "id": "vBm2aQzfHhId", - "outputId": "37527599-2060-4167-f7dd-74649a07a58f" + "outputId": "e125b727-cae4-4b28-eb33-bf8b61438aef" }, "outputs": [ { @@ -326,8 +335,8 @@ } ], "source": [ - "# display labels only for 'material' model\n", - "# total number of labels for 'material' model = 19\n", + "# Display labels only for 'material' model.\n", + "# Total number of labels for 'material' model = 19.\n", "category_indices[0]" ] }, @@ -339,7 +348,7 @@ "base_uri": "https://localhost:8080/" }, "id": "Eh_Ey6lXHs8m", - "outputId": "b53520a4-e18c-4f40-d2a9-6b49348c251d" + "outputId": "79292fab-fe13-4b3e-cee9-7ae177092914" }, "outputs": [ { @@ -392,8 +401,8 @@ } ], "source": [ - "# display labels only for 'material_form' model\n", - "# total number of labels for 'material form' model = 39\n", + "# Display labels only for 'material_form' model.\n", + "# Total number of labels for 'material form' model = 39.\n", "category_indices[1]" ] }, @@ -414,7 +423,7 @@ "base_uri": "https://localhost:8080/" }, "id": "5J6MgjOSC5JO", - "outputId": "3de66985-bdb1-428d-85e1-5be4317d6bcb" + "outputId": "bf4d7498-3b00-4234-c6f8-1715088da8cc" }, "outputs": [ { @@ -431,9 +440,417 @@ } ], "source": [ - "# loading both models\n", + "# Loading both models.\n", "detection_fns = [load_model(model_path) for model_path in ALL_MODELS.values()]" ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VkdD8-QvGZ23" + }, + "source": [ + "## Loading an image" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BSXQF57FGba5" + }, + "source": [ + "Let's try the model on a simple image. Here are some simple things to try out if you are curious:\n", + "\n", + "\n", + "\n", + "* Try running inference on your own images, just upload them to colab and load the same way it's done in the cell below.\n", + "* Modify some of the input images and see if detection still works. Some simple things to try out here include flipping the image horizontally, or converting to grayscale (note that we still expect the input image to have 3 channels)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UVdlDwchGim_" + }, + "source": [ + "Be careful: when using images with an alpha channel, the model expect 3 channels images and the alpha will count as a 4th." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-7ZS7gHgGk9f", + "outputId": "f1694436-64fc-4e04-8bc2-b360c457de1d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "min: 0 max: 255\n" + ] + } + ], + "source": [ + "selected_image = 'Image1'\n", + "flip_image_horizontally = False #@param {type:\"boolean\"}\n", + "convert_image_to_grayscale = False #@param {type:\"boolean\"}\n", + "\n", + "image_path = IMAGES_FOR_TEST[selected_image]\n", + "image_np = load_image_into_numpy_array(image_path)\n", + "\n", + "# Flip horizontally\n", + "if (flip_image_horizontally):\n", + " image_np[0] = np.fliplr(image_np[0]).copy()\n", + "\n", + "# Convert image to grayscale\n", + "if (convert_image_to_grayscale):\n", + " image_np[0] = np.tile(\n", + " np.mean(image_np[0], 2, keepdims=True), (1, 1, 3)).astype(np.uint8)\n", + "\n", + "print('min:', np.min(image_np[0]), 'max:', np.max(image_np[0]))\n", + "plt.figure(figsize=(24,32))\n", + "plt.imshow(image_np[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ztNkdbIwGnoH" + }, + "source": [ + "## Pre-processing an image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dCAhYIyzGUNj", + "outputId": "4ab307b1-0bf5-4a96-8700-5e4de18157fe" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(512, 1024)\n" + ] + } + ], + "source": [ + "# Get an input size of images from one of the Instance Segmentation model.\n", + "height = detection_fns[0].structured_input_signature[1]['inputs'].shape[1]\n", + "width = detection_fns[0].structured_input_signature[1]['inputs'].shape[2]\n", + "input_size = (height, width)\n", + "print(input_size)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Uc_UWbRpGq1-", + "outputId": "cd3bd774-a279-40e4-d48b-dfd21f2550ca" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "TensorShape([1, 512, 1024, 3])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image_np_cp = tf.image.resize(image_np[0], input_size, method=tf.image.ResizeMethod.AREA)\n", + "image_np_cp = tf.cast(image_np_cp, tf.uint8)\n", + "image_np = preprocessing.normalize_image(image_np_cp)\n", + "image_np = tf.expand_dims(image_np, axis=0)\n", + "image_np.get_shape()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "wACzUTKWGxh4" + }, + "outputs": [], + "source": [ + "# Display pre-processed image.\n", + "plt.figure(figsize=(24,32))\n", + "plt.imshow(image_np[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "H3r73X-FGzz-" + }, + "source": [ + "## Doing the inference" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SqW1z96LGzmZ" + }, + "outputs": [], + "source": [ + "# Running inference with bith the models.\n", + "results = list(map(lambda model: perform_detection(model, image_np), detection_fns))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "332GbmRuG5A9" + }, + "source": [ + "## Merge results, extract properties and detect colors" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oxWFukUTG3d5" + }, + "outputs": [], + "source": [ + "SCORE_THRESH = 0.8\n", + "\n", + "no_detections_in_first = results[0]['num_detections'][0]\n", + "no_detections_in_second = results[1]['num_detections'][0]\n", + "\n", + "if no_detections_in_first !=0 and no_detections_in_second != 0:\n", + " # Reframe the masks from the output of the model to its original size.\n", + " results = [postprocessing.reframing_masks(detection, height, width) for detection in results]\n", + "\n", + " # Required to loop over the first max_detection values from both model outputs.\n", + " max_detection = max(no_detections_in_first, no_detections_in_second)\n", + "\n", + " # This threshold will be used to eliminate all the detected objects whose area\n", + " # is greater than the 'area_threshold'.\n", + " area_threshold = 0.3 * np.product(image_np_cp.shape[:2])\n", + "\n", + " # Align similar masks from both the model outputs and merge all the properties\n", + " # into a single mask. Function will only compare first 'max_detection' objects\n", + " # All the objects which have less than 'SCORE_THRESH' probability will be\n", + " # eliminated. All objects whose area is more than 'area_threshold' will be\n", + " # eliminated. 'category_dict' and 'category_index' are used to find the label\n", + " # from the combinations of labels from both individual models. The output\n", + " # should include masks appearing in either of the models if they qualify the\n", + " # criteria.\n", + " final_result = postprocessing.find_similar_masks(\n", + " results[0],\n", + " results[1],\n", + " max_detection,\n", + " SCORE_THRESH,\n", + " category_indices,\n", + " category_index,\n", + " area_threshold\n", + " )\n", + "\n", + " # Convert normalized bounding box cocrdinates to their original format.\n", + " transformed_boxes = []\n", + " for bb in final_result['detection_boxes'][0]:\n", + " YMIN = int(bb[0]*height)\n", + " XMIN = int(bb[1]*width)\n", + " YMAX = int(bb[2]*height)\n", + " XMAX = int(bb[3]*width)\n", + " transformed_boxes.append([YMIN, XMIN, YMAX, XMAX])\n", + "\n", + " # Filtering duplicate bounding boxes.\n", + " filtered_boxes, index_to_delete = (\n", + " postprocessing.filter_bounding_boxes(transformed_boxes))\n", + "\n", + " # Removing the corresponding values from all keys of a dictionary which\n", + " # corresponds to the duplicate bounding boxes.\n", + " final_result['num_detections'][0] -= len(index_to_delete)\n", + " final_result['detection_classes'] = np.delete(\n", + " final_result['detection_classes'], index_to_delete)\n", + " final_result['detection_scores'] = np.delete(\n", + " final_result['detection_scores'], index_to_delete, axis=1)\n", + " final_result['detection_boxes'] = np.delete(\n", + " final_result['detection_boxes'], index_to_delete, axis=1)\n", + " final_result['detection_classes_names'] = np.delete(\n", + " final_result['detection_classes_names'], index_to_delete)\n", + " final_result['detection_masks_reframed'] = np.delete(\n", + " final_result['detection_masks_reframed'], index_to_delete, axis=0)\n", + "\n", + " if final_result['num_detections'][0]:\n", + "\n", + " # Calculate properties of each object for object tracking purpose.\n", + " dfs, cropped_masks = (\n", + " color_and_property_extractor.extract_properties_and_object_masks(\n", + " final_result, height, width, image_np_cp))\n", + " features = pd.concat(dfs, ignore_index=True)\n", + " features['image_name'] = selected_image\n", + " features.rename(columns={\n", + " 'centroid-0':'y',\n", + " 'centroid-1':'x',\n", + " 'bbox-0':'bbox_0',\n", + " 'bbox-1':'bbox_1',\n", + " 'bbox-2':'bbox_2',\n", + " 'bbox-3':'bbox_3'\n", + " }, inplace=True)\n", + "\n", + " # Find color of each object.\n", + " dominant_colors = [*map(color_and_property_extractor.find_dominant_color, cropped_masks)]\n", + " color_names = [*map(color_and_property_extractor.get_color_name, dominant_colors)]\n", + " features['color'] = color_names" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7gAmUStY-Ch0", + "outputId": "1d031d1f-2c74-4642-95ab-b06eacb026d2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "area 6455\n", + "bbox_0 327\n", + "bbox_1 342\n", + "bbox_2 481\n", + "bbox_3 490\n", + "convex_area 6899\n", + "bbox_area 22792\n", + "major_axis_length 215.927556\n", + "minor_axis_length 39.32658\n", + "eccentricity 0.983275\n", + "y 402.730132\n", + "x 415.564833\n", + "image_name Image1\n", + "color saddlebrown\n", + "Name: 0, dtype: object" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Showing all properties of 1st object in an image\n", + "features.iloc[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bkN8UgZ0HcM-" + }, + "source": [ + "## Visualization of masks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 742 + }, + "id": "MErKSA5jHbEq", + "outputId": "e11034f1-5072-4d86-c40d-80d9682c3553" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "\u003cFigure size 2000x1000 with 1 Axes\u003e" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "image_new = image_np_cp.numpy().copy()\n", + "\n", + "if 'detection_masks_reframed' in final_result:\n", + " final_result['detection_masks_reframed'] = final_result['detection_masks_reframed'].astype(np.uint8)\n", + "\n", + "viz_utils.visualize_boxes_and_labels_on_image_array(\n", + " image_new,\n", + " final_result['detection_boxes'][0],\n", + " (final_result['detection_classes'] + 0).astype(int),\n", + " final_result['detection_scores'][0],\n", + " category_index=category_index,\n", + " use_normalized_coordinates=True,\n", + " max_boxes_to_draw=100,\n", + " min_score_thresh=0.6,\n", + " agnostic_mode=False,\n", + " instance_masks=final_result.get('detection_masks_reframed', None),\n", + " line_thickness=2)\n", + "\n", + "plt.figure(figsize=(20,10))\n", + "plt.imshow(image_new)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 742 + }, + "id": "1z44wBf3Hovc", + "outputId": "b8f5dc72-1bfe-425b-fd50-8ff8228ca062" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "\u003cFigure size 2000x1000 with 1 Axes\u003e" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize binary masks.\n", + "mask = np.zeros_like(final_result['detection_masks_reframed'][0])\n", + "for i in final_result['detection_masks_reframed']:\n", + " mask += i\n", + "\n", + "plt.figure(figsize=(20,10))\n", + "plt.imshow(mask)\n", + "plt.show()" + ] } ], "metadata": { From 9d12293bbc3cfecd6a655c3630ec6ed8cf6bad9a Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 12 Oct 2023 22:45:52 -0700 Subject: [PATCH 21/42] No public description PiperOrigin-RevId: 573108970 --- .../model_inference/Inference.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/official/projects/waste_identification_ml/model_inference/Inference.ipynb b/official/projects/waste_identification_ml/model_inference/Inference.ipynb index a1596b9a28f..b5d584e96dd 100644 --- a/official/projects/waste_identification_ml/model_inference/Inference.ipynb +++ b/official/projects/waste_identification_ml/model_inference/Inference.ipynb @@ -219,13 +219,13 @@ "# 'material_model' output is both material and its sub type e.g. Plastics_PET.\n", "# 'material_form_model' outputs the form of an object e.g. can, bottle, etc.\n", "MODEL_WEIGHTS = {\n", - "'material_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material/material_version_1.zip',\n", - "'material_form_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material_form/material_form_version_1.zip',\n", + "'material_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material/material_version_2.zip',\n", + "'material_form_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material_form/material_form_version_2.zip',\n", "}\n", "\n", "ALL_MODELS = {\n", - "'material_model' : 'material/two_model_material_1_saved/saved_model/',\n", - "'material_form_model' : 'material_form/two_model_material_form_1_saved/saved_model/',\n", + "'material_model' : 'material/saved_model/',\n", + "'material_form_model' : 'material_form/saved_model/',\n", "}\n", "\n", "LABELS = {\n", From 79f97184218314e7b4fca34315e1ab98ef73e62d Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 16 Oct 2023 07:24:08 -0700 Subject: [PATCH 22/42] Use ImageClassificationTask from yolo darknet_classification config. PiperOrigin-RevId: 573803409 --- .../projects/yolo/serving/export_module_factory.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/official/projects/yolo/serving/export_module_factory.py b/official/projects/yolo/serving/export_module_factory.py index 60207591cc0..a365937cbea 100644 --- a/official/projects/yolo/serving/export_module_factory.py +++ b/official/projects/yolo/serving/export_module_factory.py @@ -20,13 +20,13 @@ from official.core import config_definitions as cfg from official.core import export_base -from official.projects.yolo.configs.yolo import YoloTask -from official.projects.yolo.configs.yolov7 import YoloV7Task +from official.projects.yolo.configs import darknet_classification +from official.projects.yolo.configs import yolo +from official.projects.yolo.configs import yolov7 from official.projects.yolo.modeling import factory as yolo_factory from official.projects.yolo.modeling.backbones import darknet # pylint: disable=unused-import from official.projects.yolo.modeling.decoders import yolo_decoder # pylint: disable=unused-import from official.projects.yolo.serving import model_fn as yolo_model_fn -from official.vision import configs from official.vision.dataloaders import classification_input from official.vision.modeling import factory from official.vision.serving import export_utils @@ -164,12 +164,12 @@ def create_yolo_export_module( input_type, batch_size, input_image_size, num_channels, input_name) input_specs = tf.keras.layers.InputSpec(shape=[batch_size] + input_image_size + [num_channels]) - if isinstance(params.task, YoloTask): + if isinstance(params.task, yolo.YoloTask): model, _ = yolo_factory.build_yolo( input_specs=input_specs, model_config=params.task.model, l2_regularization=None) - elif isinstance(params.task, YoloV7Task): + elif isinstance(params.task, yolov7.YoloV7Task): model = yolo_factory.build_yolov7( input_specs=input_specs, model_config=params.task.model, @@ -248,13 +248,13 @@ def get_export_module(params: cfg.ExperimentConfig, input_name: Optional[str] = None) -> ExportModule: """Factory for export modules.""" if isinstance(params.task, - configs.image_classification.ImageClassificationTask): + darknet_classification.ImageClassificationTask): export_module = create_classification_export_module(params, input_type, batch_size, input_image_size, num_channels, input_name) - elif isinstance(params.task, (YoloTask, YoloV7Task)): + elif isinstance(params.task, (yolo.YoloTask, yolov7.YoloV7Task)): export_module = create_yolo_export_module(params, input_type, batch_size, input_image_size, num_channels, input_name) From b947596d8f186eae7cc878e39f28fc95ba6622bb Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 16 Oct 2023 11:28:41 -0700 Subject: [PATCH 23/42] No public description PiperOrigin-RevId: 573875313 --- official/vision/tasks/maskrcnn.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/official/vision/tasks/maskrcnn.py b/official/vision/tasks/maskrcnn.py index 9e0ee7bf37d..81f867b9666 100644 --- a/official/vision/tasks/maskrcnn.py +++ b/official/vision/tasks/maskrcnn.py @@ -575,6 +575,10 @@ def _reduce_instance_metrics( else: instance_metrics = self.instance_box_perclass_metrics prefix = '' + if instance_metrics is None: + raise ValueError( + 'No instance metrics defined when use_masks is %s' % use_masks + ) result = instance_metrics.result() iou_thresholds = instance_metrics.get_config()['iou_thresholds'] From 4a5f14343d201d5cce357d9bfd6a8fded80624de Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 16 Oct 2023 12:21:13 -0700 Subject: [PATCH 24/42] No public description PiperOrigin-RevId: 573892050 --- official/projects/pix2seq/configs/pix2seq.py | 1 + official/projects/pix2seq/modeling/pix2seq_model.py | 4 ++++ official/projects/pix2seq/tasks/pix2seq_task.py | 1 + 3 files changed, 6 insertions(+) diff --git a/official/projects/pix2seq/configs/pix2seq.py b/official/projects/pix2seq/configs/pix2seq.py index e4478d0f435..79f96857bba 100644 --- a/official/projects/pix2seq/configs/pix2seq.py +++ b/official/projects/pix2seq/configs/pix2seq.py @@ -129,6 +129,7 @@ class Pix2Seq(hyperparams.Config): drop_units: float = 0.1 drop_att: float = 0.0 norm_first: bool = True + temperature: float = 1.0 top_k: int = 0 top_p: float = 0.4 diff --git a/official/projects/pix2seq/modeling/pix2seq_model.py b/official/projects/pix2seq/modeling/pix2seq_model.py index b457f3bc7d6..4d1e29ce036 100644 --- a/official/projects/pix2seq/modeling/pix2seq_model.py +++ b/official/projects/pix2seq/modeling/pix2seq_model.py @@ -237,6 +237,7 @@ def __init__( drop_path=0.1, drop_units=0.1, drop_att=0.0, + temperature=1.0, top_k=0, top_p=0.4, **kwargs @@ -276,6 +277,7 @@ def __init__( drop_att=self._drop_att, num_heads=self._num_heads, ) + self._temperature = temperature self._top_k = top_k self._top_p = top_p @@ -299,6 +301,7 @@ def get_config(self): "drop_path": self._drop_path, "drop_units": self._drop_units, "drop_att": self._drop_att, + "temperature": self._temperature, "top_k": self._top_k, "top_p": self._top_p, "num_heads": self._num_heads, @@ -363,6 +366,7 @@ def call( else: tokens, logits = self._transformer.infer( inputs, + temperature=self._temperature, top_k=self._top_k, top_p=self._top_p, ) diff --git a/official/projects/pix2seq/tasks/pix2seq_task.py b/official/projects/pix2seq/tasks/pix2seq_task.py index 87072773408..fecba47e592 100644 --- a/official/projects/pix2seq/tasks/pix2seq_task.py +++ b/official/projects/pix2seq/tasks/pix2seq_task.py @@ -70,6 +70,7 @@ def build_model(self): drop_units=config.drop_units, drop_att=config.drop_att, num_heads=config.num_heads, + temperature=config.temperature, top_p=config.top_p, top_k=config.top_k, ) From 8a9fb86d3d7c009f44a17c68dc47aba3bfde5d8f Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 16 Oct 2023 13:55:37 -0700 Subject: [PATCH 25/42] No public description PiperOrigin-RevId: 573920646 --- official/vision/modeling/layers/detection_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/official/vision/modeling/layers/detection_generator.py b/official/vision/modeling/layers/detection_generator.py index 1b605a33929..7490abd9637 100644 --- a/official/vision/modeling/layers/detection_generator.py +++ b/official/vision/modeling/layers/detection_generator.py @@ -1128,7 +1128,7 @@ def __init__( nms_v3_refinements: Optional[int] = None, return_decoded: Optional[bool] = None, use_class_agnostic_nms: Optional[bool] = None, - box_coder_weights: list[float] | None = None, + box_coder_weights: Optional[list[float]] = None, **kwargs, ): """Initializes a multi-level detection generator. From cf251159fcb11a4877a189db783336465679feec Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Tue, 17 Oct 2023 11:24:44 -0700 Subject: [PATCH 26/42] No public description PiperOrigin-RevId: 574212326 --- official/vision/modeling/layers/detection_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/official/vision/modeling/layers/detection_generator.py b/official/vision/modeling/layers/detection_generator.py index 7490abd9637..3e0886432cc 100644 --- a/official/vision/modeling/layers/detection_generator.py +++ b/official/vision/modeling/layers/detection_generator.py @@ -1128,7 +1128,7 @@ def __init__( nms_v3_refinements: Optional[int] = None, return_decoded: Optional[bool] = None, use_class_agnostic_nms: Optional[bool] = None, - box_coder_weights: Optional[list[float]] = None, + box_coder_weights: Optional[List[float]] = None, **kwargs, ): """Initializes a multi-level detection generator. From 7be0a09a2fb1f2d594f5c9e6fe0881eeae29fbf4 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 18 Oct 2023 01:18:48 -0700 Subject: [PATCH 27/42] No public description PiperOrigin-RevId: 574397139 --- official/vision/tasks/retinanet.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/official/vision/tasks/retinanet.py b/official/vision/tasks/retinanet.py index 1a7b3d26cfa..58084dd598b 100644 --- a/official/vision/tasks/retinanet.py +++ b/official/vision/tasks/retinanet.py @@ -135,7 +135,9 @@ def build_inputs(self, aug_scale_min=params.parser.aug_scale_min, aug_scale_max=params.parser.aug_scale_max, skip_crowd_during_training=params.parser.skip_crowd_during_training, - max_num_instances=params.parser.max_num_instances) + max_num_instances=params.parser.max_num_instances, + pad=params.parser.pad, + ) reader = input_reader_factory.input_reader_generator( params, From 6718ed8e1dc94c4ea70f7999e777f8136e2a6f54 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 18 Oct 2023 10:57:09 -0700 Subject: [PATCH 28/42] No public description PiperOrigin-RevId: 574528346 --- .../model_inference/Inference.ipynb | 36 +++++++++++++++---- 1 file changed, 30 insertions(+), 6 deletions(-) diff --git a/official/projects/waste_identification_ml/model_inference/Inference.ipynb b/official/projects/waste_identification_ml/model_inference/Inference.ipynb index b5d584e96dd..d5673d130b8 100644 --- a/official/projects/waste_identification_ml/model_inference/Inference.ipynb +++ b/official/projects/waste_identification_ml/model_inference/Inference.ipynb @@ -101,7 +101,14 @@ "outputs": [], "source": [ "# Download the script to pull instance segmentation model weights from the TF Model Garden repo.\n", - "!wget -q https://raw.githubusercontent.com/tensorflow/models/master/official/projects/waste_identification_ml/model_inference/download_and_unzip_models.py" + "url = (\n", + " \"https://raw.githubusercontent.com/\"\n", + " \"tensorflow/models/master/\"\n", + " \"official/projects/waste_identification_ml/\"\n", + " \"model_inference/download_and_unzip_models.py\"\n", + ")\n", + "\n", + "!wget -q {url}" ] }, { @@ -219,8 +226,16 @@ "# 'material_model' output is both material and its sub type e.g. Plastics_PET.\n", "# 'material_form_model' outputs the form of an object e.g. can, bottle, etc.\n", "MODEL_WEIGHTS = {\n", - "'material_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material/material_version_2.zip',\n", - "'material_form_url' : 'https://storage.googleapis.com/tf_model_garden/vision/waste_identification_ml/two_model_strategy/material_form/material_form_version_2.zip',\n", + " 'material_url': (\n", + " 'https://storage.googleapis.com/tf_model_garden/vision/'\n", + " 'waste_identification_ml/two_model_strategy/material/'\n", + " 'material_version_2.zip'\n", + " ),\n", + " 'material_form_url': (\n", + " 'https://storage.googleapis.com/tf_model_garden/vision/'\n", + " 'waste_identification_ml/two_model_strategy/material_form/'\n", + " 'material_form_version_2.zip'\n", + " ),\n", "}\n", "\n", "ALL_MODELS = {\n", @@ -229,13 +244,22 @@ "}\n", "\n", "LABELS = {\n", - "'material_model' : 'models/official/projects/waste_identification_ml/pre_processing/config/data/two_model_strategy_material.csv',\n", - "'material_form_model' : 'models/official/projects/waste_identification_ml/pre_processing/config/data/two_model_strategy_material_form.csv',\n", + " 'material_model': (\n", + " 'models/official/projects/waste_identification_ml/pre_processing/'\n", + " 'config/data/two_model_strategy_material.csv'\n", + " ),\n", + " 'material_form_model': (\n", + " 'models/official/projects/waste_identification_ml/pre_processing/'\n", + " 'config/data/two_model_strategy_material_form.csv'\n", + " ),\n", "}\n", "\n", "# Path to a sample image stored in the repo.\n", "IMAGES_FOR_TEST = {\n", - " 'Image1' : 'models/official/projects/waste_identification_ml/pre_processing/config/sample_images/image_2.png'\n", + " 'Image1': (\n", + " 'models/official/projects/waste_identification_ml/pre_processing/'\n", + " 'config/sample_images/image_2.png'\n", + " )\n", "}" ] }, From 69c27445f5328154712b0a66d07dd44b6cb9423c Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 19 Oct 2023 10:31:06 -0700 Subject: [PATCH 29/42] No public description PiperOrigin-RevId: 574922875 --- .../yolo/configs/darknet_classification.py | 29 ++++++++++++++----- 1 file changed, 21 insertions(+), 8 deletions(-) diff --git a/official/projects/yolo/configs/darknet_classification.py b/official/projects/yolo/configs/darknet_classification.py index 80df61bacda..0331cca109b 100644 --- a/official/projects/yolo/configs/darknet_classification.py +++ b/official/projects/yolo/configs/darknet_classification.py @@ -31,10 +31,17 @@ class ImageClassificationModel(hyperparams.Config): """Image classification model config.""" num_classes: int = 0 input_size: List[int] = dataclasses.field(default_factory=lambda: [224, 224]) - backbone: backbones.Backbone = backbones.Backbone( - type='darknet', darknet=backbones.Darknet()) + backbone: backbones.Backbone = dataclasses.field( + # pylint: disable=g-long-lambda + default_factory=lambda: backbones.Backbone( + type='darknet', darknet=backbones.Darknet() + ) + # pylint: enable=g-long-lambda + ) dropout_rate: float = 0.0 - norm_activation: common.NormActivation = common.NormActivation() + norm_activation: common.NormActivation = dataclasses.field( + default_factory=common.NormActivation + ) # Adds a Batch Normalization layer pre-GlobalAveragePooling in classification. add_head_batch_norm: bool = False kernel_initializer: str = 'VarianceScaling' @@ -53,11 +60,17 @@ class Losses(hyperparams.Config): @dataclasses.dataclass class ImageClassificationTask(cfg.TaskConfig): """The model config.""" - model: ImageClassificationModel = ImageClassificationModel() - train_data: imc.DataConfig = imc.DataConfig(is_training=True) - validation_data: imc.DataConfig = imc.DataConfig(is_training=False) - evaluation: imc.Evaluation = imc.Evaluation() - losses: Losses = Losses() + model: ImageClassificationModel = dataclasses.field( + default_factory=ImageClassificationModel + ) + train_data: imc.DataConfig = dataclasses.field( + default_factory=lambda: imc.DataConfig(is_training=True) + ) + validation_data: imc.DataConfig = dataclasses.field( + default_factory=lambda: imc.DataConfig(is_training=False) + ) + evaluation: imc.Evaluation = dataclasses.field(default_factory=imc.Evaluation) + losses: Losses = dataclasses.field(default_factory=Losses) gradient_clip_norm: float = 0.0 logging_dir: Optional[str] = None freeze_backbone: bool = False From dc2db580a14e6d7cb9ff31f4159a348eb5f8a079 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 19 Oct 2023 14:29:57 -0700 Subject: [PATCH 30/42] No public description PiperOrigin-RevId: 575003416 --- official/projects/maxvit/modeling/layers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/official/projects/maxvit/modeling/layers.py b/official/projects/maxvit/modeling/layers.py index 76630143c96..8cb90a29808 100644 --- a/official/projects/maxvit/modeling/layers.py +++ b/official/projects/maxvit/modeling/layers.py @@ -300,7 +300,7 @@ def call( attn_probs = common_ops.float32_softmax(attn_logits, axis=-1) if self.dropatt: - attn_probs = tf.keras.layers.Dropout(self.dropatt, 'attn_prob_drop')( + attn_probs = tf.keras.layers.Dropout(self.dropatt, name='attn_prob_drop')( attn_probs, training=training ) From 1e2efbbbb7c127c04cbde06a5e21499149dd3e6f Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Fri, 20 Oct 2023 21:34:24 -0700 Subject: [PATCH 31/42] No public description PiperOrigin-RevId: 575386162 --- .../config/sample_images/image_4.png | Bin 0 -> 1959649 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 official/projects/waste_identification_ml/pre_processing/config/sample_images/image_4.png diff --git a/official/projects/waste_identification_ml/pre_processing/config/sample_images/image_4.png b/official/projects/waste_identification_ml/pre_processing/config/sample_images/image_4.png new file mode 100644 index 0000000000000000000000000000000000000000..07c67c126f4a6a7104523043e68f315ff4665360 GIT binary patch literal 1959649 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 z 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⪼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
  • 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

    %g{}5F7^V9t2@li7drc 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

    iHEr^?w6Mw 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 IN#TCM4`_rnC;8 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�BQH2IZq_{lyJor7xcg3{N!z?}WXK{CV?UENRZph`2d-T%Za2 z4s(-h&#NVeS9BLSJ)xK$E2dRd5BH(Ds09OX%nilz z7*bbd8gpWTS%&e0c;bWYVFr8uisZ}pj?);;fuMx!n)hmxCXa>{AFnzd*1UpHWO)b~ z*T!;U;V6|s(mir~{6cVpfEq)4f~vT0&KMpY?QKNw%=PUE9inKTvE?Bw4uBR@rsNZ< zMfEEug*n-;)mPD$tuTLWtU;uRAwAQjltd!aP~&l^2QX|r>3=LEZjHCl=l3H_gBRP% z=H~q_MhFsxW>|JLm}$5xZ{8{tTt8joY|a~+tfEJc%n#gJ6jtrJ|77rmFau z@k)LYt>QP&-?Hac^L?TL`vRGxm-Qe1UTD zM9GKiiri@$)*dEoq5|=b?ZA5`UcvkMpLKCi6&{!=85^=E(rElcYILVrvt|)b_3n+SM_X^mcOKlF0T}Tq zZhO)SW_7;W^xxr>^NdUr5M1B)*A0jV*bDdcB&Tk|3xC_q@`sC}|3uo+>6;$)rUuS* zerTNVw;J0(Ed3+V(^O4`$LrQ~hNMcNQ*tBc7!O9IT;YGQHM%9YtmGvgiix0=a#Zw~Y=yC))PVuVff7L{uWYm>tS8FT(LDXp}0CDDACYoIg2LlS??aJOkD zU44||cao{3+MXrV0sFrY=DB&~E2hTiY1xt@W?=^L!=tLIcH)eWKv*ld?NndQ2OxFn z{}xzfKd5GWN_+sRwp!ymotv#u_w|uQ&(wmFsDUT7_^QzX>vl(iZHOZWJ4o!sUzLV0 z&R)10{ZO_fju>>b5X}*C(dMiq(M1H_fIP7@d_DR@_?vueufdOEE-h*RQ7p%2+5rUs z_`@a`#(V$d+_3P(5$N6NJXs76DSfoo`q><9(Z0e4{E#3w3kwW1+UyuZ;_+>B)*xh; zo;x#l#)Dr}Hx#Oss=+dD%T;eK`tpl+{|4@WasNDrY39jpDf8TL>VK@8K=n04qKM z8EL&ifZ3W8Y=G#$hPc(3)%GrB48$s0TX!2nP+tt#lT8Lgdi+RcOBbEkRY0(aFs>0A=)O{-qNr|0LVgTUfD$!}VTGVcen>oi2 z2QFdDBY0>iG4*3(tZlVx^$FssKxdsQvF#@kE~3)FKnmDDGjFv(!`D53 zSdF*G;d)FeOn1feI<~K5|D6i&aci_4pcHy?fUSq@qQOQmPQ(ODWu=;RoOq)|@<1Z? za>;(AZO5uZ7h3zsq2{8N@Sk%u{XM=l5i=VvJQv6dPj!6ntM}bSkof+kw~OYE6Z?Ca zF^uv?fMsxJ~HyxM@8sg2S#T`?8 zqM)T{?c0T|joyKe-JP>9YLK^1iD!4%CGih!ty?I+>A!r=I%w@q`3HxFem{3O4*U2n z5P20nOXLaX5yU4Ezr8wl+})asfNCRQu8LKSosI%iTU9}%CT`r0`wwmvPN<+5;Ed`H zFtw_$e*6ZA5i-ceJ2V70O{`cM0Pq*b=N>qL<;|?*{)s1$5e;*41``>0L7{_I0 z#raJUy`N4q8;_N8>ca~_rF!e@@lWH|P7mOr&kGtH!i{vRcX-CoC!#61mn-)^9r3O6 z%Qol99np6v&uUApDhX^lZfK`ZG<|b8GdcFrr;t~hw2wYJv*qBi7WLggY;OtyD?{qIOsy3`dN=ngNqkbe4q^*ZvI6REgO#4Q5a|2nq&jZG^7}}mU|1; z@)&nz|3*ho0dS$4B#AA%A7>!$l+6vs?~rg0B~IE*yE1n$wHJK4pR(Zg#&@O(tZYc6 zj$XI~A{ZOJbA54m5I_a%_jW9nVa)NO`*}M5!v*jP9UAzI4B2`7eBxLvK{Z4N$A9mBvB#uoDl;v3YU5l-BRwSbs2k`_aeG_ z`FdnQx+{ z8f|3G!zz{93*7>6eoGh{%vl9UE^Z%lNQp}}>l+Q*Qo%Ndhpnpxu;Mj|$_SXIxG;T4 z%Yo#jYxfVN&i%-<`q2)7TJX-in!#K_?(^S#bnlbT2Cf&Uum6e*1a5Cx5>yRX-RNS^ zW%1WbFXzZ_EzM0(@LRL8=Pj-6CFAF%OBhLkYkWsCEj*tc>K1A&XYFrOoiWq~fyV?; zk}0}0;1MeuTn7B>ggKh6j77x`M@RW^oud^#R2GCB#u{H@hE0l;j;bx8Nh&lq`Q|l@ zb;n^Po+{YHE3CQP5EdHxt{Z)?nK$*(9X;VK?j{npE=ay{0qe;_k#y=(*@U!U`)?XN zJ^j6ye}TeC0v*sih9!iMmC(RChI;Em8TUK)L(>kIOqXe@>H)LNgxodcE6dz(8_V2{eeITm4yu0rPFw!Op9Pb#=dK-pNbg3tG9yzDU!nLs##ATM z*?64t^U)(J3gBw8*N$1=!b)z_ru2#}D&ze6H?**L!sAY!kBXVqX2cU@-bTDJ(pzO{ z&NtTODP|JKp0L5y=ipLCAKFJ*G2oOxO9P3HcxQAxR63u2c?ILkcJ$pa@g$8WxPNDtmY*@wx9=`zr^^gAB{iQR8Dq-Y3&|3EW zQys$lYG?e_I`G%%yTwEW5W4vhHj{XGcJQWUDBTR_zyt>!=X8bWDd0Q2#&*1NBJP?w zRlHOB*?9WNl18|wwinmc?-=WJm3cf%5MEpGAl)driM5e71eCyjHI`Q$*F2J?k4|+0 ziZyJpn!rmJpm78RaI5% z!3l`kiQk%+?TIZma`IjcZz~#wTzOGA%oejGG80WakMKi3!qjl&1|UlUK%%uC#V3Aw z2R82+7`PKz=6L>E1LV=ZPnPi)+S+Pk1)4rZaAo2ZKAo{qRl;q!ervG11YE0AQh&pX z+GEgfJdf6A>YNNr*jl&k!5lhu(mAj2yUiC!En-wB9QRsKaQJ1BTX@&+j1`=5*kS7c z1+j#3ebpw`+b>VZ5~t%#A}4N6@HytHhhE1n#$+`V&&mF21kI`!jzdgr2e_>y_Q7{Ov6J=QG?(YhGMjQ=i(zNK!>`j zJcZr2=T`3w366+J64j_M4{TQ^fX8Y`7()|pF| zJ=G9`ILgHd!G|=WNOFWbwf8%SOIBUgM92VhEw(lUBswX5z8hTbxvMx7H&=Xcv&b2* zPMPj96Qm>hHZNnnGY0#W?k#(52GI`1GPE>!ewbj!9i3a}8U|C~0EOJQTZ!#31@?>k zYcs6sl&RgF&oJV6tkAY)*39il)<2pLe6O6M@6Ymb zhA}d_PhLANa!*~}mq!>t7>xpUfqsVsX%S^nqmjOUd0yvyX~_E(Gr`)B-MdxXosSFV zXd!+MCPg=b0|KtT?7?Z2ALBn91w7v1+Zg)OX=|W;qi~r3gnOXw=RmPtxXj zLg(gNvz;~%ea6zrjlP?X z!U1nz66gLU(AAYAIktjJt(P27_ z9MXhT6iPEu7*;4GtA-9Dse}%wB&4Psrc`v4nowq?q9P(qg)~+)is&FpLelB`J*{v5 z|KD|e``UY7d#!CTz4N@!ec!+PcYs|6GK3M8w(};&E|n*EY}38&|Azc`QV~)8a2}nS z6ZHFIAwxA%Wc1`gMV0)y9yrcIpLgV?mOTh)nA=(^WJwG z#u#g^-S?iyQ=l1`_qcl9Lro7cf+0SS!&Z~7{k88X8#mMgI7VLNG^$P5Cin@vDdE^M z@Un21rA1`2KEy{;8)Ok56fehCbQid4B1%VT7bxuTljBy@z-1878)39tLJZki;eAK? zvPuyMl6<+Xo#eu96g@(cEyixm)AAS;q|~>GD!dy3tSg^9tnRPt8&alds^*%(uKN;CxgOc5toA#~nj1tmP2_MF(b=bD<3twia~6Um1ZAuFjpOC+erIE+MVSADSTDzz8h?pZ+!P0wSE}3VaO)lg= zzu!Sooemb05nSgl%dzp;2Q!tVq#7SEd9H85Hm`J`uJlMB$QS#A z0!DgBf>8Tzp~Fzk>);X0^0hDi%VRjUmEX{u#22KS9J|QBUB2=|lf_G7l}$$>S3W^c zI}lA@iwqob%T^Q0=QXxY=ziw^*2mXmq6SUvb;Jzctq`#kPM&YsdL?KVeWIJ%q&sDc zxugt&yG#6uR^b|hly|$)Mp9y{j=;6kvxwh8W9T;7(5yt-E_h&c4*8AKT( z{Q^(p%D!4c>qiZu9q{L^geOH;Mg;46d8XxucupjI@An6P@*gHv@=wf%d%&&<6bC{X z3ytL(va1ry&Vok;kf4EnfO~K2;oC$n95BeCSeCjFDr0+DzKX*Y&pZQPrj6Dx(Ig^y zlsil)bH3}X;xiU$DizAdH1=ld zs)77TWx|Z!W+fAi<&>MC+Skb=5cdH-k-+!<&g6Xsz|R;fY~mdi&eXrb90uC=E0P#h zk5)yuZ%$*ef9)yFN(*MHg2NZ4&*HP`akmd!Q}D8_3o=iD0CDz{7pJa?ixPg-8M#j1 z$ew8|e{!I?i<_~4`F0auu-FfA1Kc~gaTsQbJPB3OHDePNEzDWtuG&Fa>bxBaj`|}w z!Wc8(bo-gY5LMZScxG0tDDr(Ju zo`@mIZG^BP{+POg*BC-96k;Uj0?+TNk-os8+V$LF^%CE<4R)^H&`-<3c=-@~_~tSv zUgWo9Q=i2dzss1leKltXR|;S3VH=voYrtC`&!M8;Z4Xf|rGb;h(o{wG+hCmBYhrv! zeIZu!I?#cww@O3@szPclQo z3Eex*E2&NVhV+(r4P8BW|Mdl@oN=kKu}cnWsW=B7K^J~Ty83jUVQ+sz?akMnFb<4o z?ZNh%HrWooAu|;e&fTKF>_}w!+_58v-I^GDCZ_go-<`Yr@NF z1l)`kmweL)P#xB6XVpgiuwRm?cO=l<{dh)4d5%VMu+gmenK=M(98Dk-yvvB zKil$K422O)i!ya}yH@1bbJzTt1gB?0>jENkTVpMw)dV;7vgO#-Z`qRl7p$z0(~w&v zT9@`Egu5nwnys%QP2F_IY6Qn%?djTTAfNrSxodS>7yUwx5c|S^$mqZr16`4F4+CUG zZ3X%0SB6?C!Z;(_#hMU?@lQ+FK|urRF`*!ms5AJEvm4lXUT}t2fpgj}vPlrf%RW^| zL_iH^9XukCsyG*JKp&gY4tXx=@|rwpv&|xDwt+SvFS{K^t~yG+W~JcZB7YM!h<`1p46Mu~};JZFN3>a4OUyUv9BTET5)BxWb9V zIr7}_RI?41uQE`4UC7^tS2JU!Z+`(2keK00+5b)YU${LkaBPZmUVQUOej9DR=FLNN_1}OPy*|iFjrd>5fN!q zI_NOfV9zsTIly&#+1=Q6s?kUc-@(w1qYj}?Q{&0;EE02v1nLbAv!3+mI}Iha!LgYv zJV4~CN640**<-Ck+4Tl~B(ROr)!w+3rGfDi9L*H)#*OgyA#U$;_RUehPLG?VL1_20 z^NYLN`o9)54R@Rm{sT1T6Bv&pj%K|gW^i)Eo}_-+Pszc(o!m8#@vlQYG9k7E@*92u z|Fz!M>Mbk!KAJp^{Y0`LgPkK5DA(490J@x(Ma^;NewxGQdrCjG^K;d#c4EI^7r zonT^8@>;#NJJ#zJ5TFJtqiQTshg2B}Q&^rNwCE~m9S zoDn-j@|4Cxmt;_68iwKfB8=1y9yF9Mcb`FRV7MhMXbY&h0ufwsf(BEzw{YP5rP6y2 z`$%M(Y+pBm+_gfMEw1hLig)mk+Zz)Vm8LiEGG1Azih5sNN5muM^2lL(U~U zf9DK;zeM-}DKr z+UpnXX>Amq-G0aBWscb=NQqqFBO??ejODL`8gdg*F-QvTZY~;KSviXsfpDE`#!7tQ ziq7faz89_uy$xrOpWHZQ8+P3tlrWGx4GzF`_O1yd-R#)0+yB}kjRTWw?D`D1qQGiJarp%*ArX-1^C5PL>#4}HW z73+cO-2bh7(wyZ-WQYYNR_-S}h?l8be7G|Lh~RTnTvde!Z403oJYg|j<# zyKrXsao}%rL1sU8f9D>}X&)X^JUOXd2VZ=rEVxHBOn7oJp*iB2*YJXWtVBY+bTnTh zM)~$GgdV;SsvG7Dx8L#P>BY!=Vem!`6pyJ|V=(1u#5Zi7lp(?CSZrHIT-YKgbwvxQ z?d@4x^)x5V4B2oM>O5nq8CB06AZ97oU7sXh{u!K?w_mq$A0C?#emjTt@Lxy}VpPX2 zOwS2_A&T6__|)^b1;04y$`w)Xz2wZ~k-@h8!QDp@?+K5^lf;~Jy7_<=K({zV(C-%n zey>b*=sa?N3DW`2CzxRMxLscI>=2|Kt9x4@wN2^(5}Uzvw3Fi*b1v~0Lr@xR*+!oR zbCmHUS7r=$c*5(ligc!o#nZ4TYDVBnl=#F6C+Dc}5L4c2WZP@Dc5Z7rBn`z88>~@% zX8=(sDn4$^I@G`IvwWo%gK!(SplpJGBqGw-@hhcM64cGy2HPksY zk$MIgrVUmQ&;&xxQ*C{Ic3`K|P!pCm3eh|V$!mxF#ccevgM*DCw7T4*FuDP=;4y#- zymJP)x?Oz6H>aM*eA9A%Ed$i6;ZH}q(E$>@?w_v(K?4|9%wgr>xuoURf^^m~xT*P< z^d=%7ZhAv2Cvq}YjhStG{+pUHVcdlqr=!QNJluQKXH|4q7HBKrG(jU49$tbS+qYw@ z<0_nO!$6hhX1EA`e*Sy|v$H8C0t+J)2Lv6%UX`ce+Df|aMk{1^&?X~cK(ra`H85Gp zo}E1^wdLNxb0Sb7g%^a0y;io+=9vd{-5p#V9pr=24qQVL3^w7j8mm2#O!OgCt<02X zXCoCm`i9sbJydK+qB3C|5s;*Pu7x!RZ^4HyF#)uH&*N;pEUo^ji))ad|Fr`I@GYIR zvU^Rob@(lTSujE8L&OAGjl1J})gkRXKE@$sX1?nktLljBifD&0o{_EciO=8nYfK_T zF{ad|s$!WNsJbvZ^Jg?4oI9>*Jtv@AHbM&H5B zA$AZ(WJI}ewfej7_n#l#l%0a#6asawE?|0FIzOo8-Eo-MVyr;+(HO5{DZP1V*j!nU z1x1~s7BU&GoDwg8I6#vuv7y1~rAS7I&*VI7d_!Pv^O1MSkPj!1%o#2ok*h`3Zqoh0 z-!r_jzje-FOT=ZrOJ``B+uV!6jhMdkULgAC-u$0!EBXra>x3XM2avzf+xrxRsEye@ zaFQMQcr&Pn1VWZuUpha1pdVJMeI-4oVDwRa!dunZ6>nDLRLr?kUf;rT`#(jS+bT=i zyJ^oN04S&+Fn(*evtIh|6R_pIz5}aZ1g2o?4oYAEonZitQv&1#VNvzA=5gD3`TxJJjHT=Nn55H zq%?zlO@H3JE*Y5~+(Sw>(uv?K)_s4V%dGbN>=meyMlC4WNAA-$c$|yKmiz$HRpk~n zjt%Uz{MJhv4eSRl-D`Kx-Uvoo#F_xvx7zr%^10ozsB9&zHu#Os*xyvB=XN zB%O}xs|Q)seX%n6t20av~?<*N4REpljDZMq^F3NVwvwdyjed+$AskXx@$@4TM%ENJjXY z4#1gFQ11p)sLj@Smt)}`hY!A{K;lXIvK{Cd3=`7uE!De^xtuncHbcR(YMqX@P!wTd z9m~Hx<-r&;rpGzA_$0GJBnm+9d-`N31;KnkNuhk!1 zs#v><9XcLMWaq497)U|1M-pnPJyolA&s)uS90JFm=JzK-j}T%_H4p#=)cKO1U-$26 zMFy~WAex$YL;c153>YF=Kk`~C6dTq}Tk&lsE`0W?zm#?XIAuW$hBeynsqDLJ_#7$V4OXFPqRo3)vvHS?j@1wk^S3>uzi&EDhre4H zYSZ*6m?Gsf0bltE7M~`b7beeGDY%0=3BJ2@e-gBQ!9N#{+$6z{ihrHSQH&9==VDX_ z@NGUa$UQ0rn#|ql{tMIZnj%kO;u*x$r-P(cfvFZmr}3UNfaMIGICdI7D1XcF|p_i{Q_(c z_gTWuc>}L_zny*htZ>XUN_qdWyC#PCg9SUmhg`obOx8Vmbl$*_sv?Dq9J4);08Lv% zDKR(2OrXAe^Tz`Ra!!&2ixZFt3KEXcUX5sXxoe8}+9z-wOEs?|zlP#2`F$K$w%uv*E<^{@>NO8=Z6_^m1e{q(yCZ8iXMOo&or*q5d8Y8Tc?){7G` ziF(~v(XMwZ#jbZWR~vyy|GvLI%G7h!F@-YY0b03e%SD>*cSJcpcdTYxLTdC}`*I?H z*UPf7${|kd(MW2ZG?s@`1F%TrA2ELI*>P$zXjM+vrjSiKzkwsD5?!oR2+`O_TVTWB zF7X4%g;?`VXwHano&TOwcEDsv_#oQ}0o+)xSaAL^kuS$hZXAUcJWDvublhmM{v9`q zk_Ny@`Qkl*D!`CwVueIm4$0G~9r<%}5=t zwTD|#qE{%QTu*wobfkF>4xr>yY{WNtUiuR1=8C?DRSQdx_5J#K2`NHfT;O5<#QRFy zHb|@<4?(UHTsQ)!%E2z{ImG^>4b-c9_l}u;g>tnANomQ;q4n72scH>}TBYsA=Ozq| zXH#FGsy1PK+XgYuT|GoUn@%4X+U~JWMQA@BmhD7+Ob|A1_yVkzFav-N2h7X+9GoV} zN`j;y9$6kNwT~j%p-L@?@-q$fyLDbT@blyHF}m$bA;(7|`>0x?~7`aRWnBC*6z7 z%l?Z0?PEH5#~E~>^!Hd=q@`7J|K>sxHF*-vNwh$ygX+&YCB}qKSQQ#vnwoy~FUb9k3`G zuyC}zF8n9KPiSw$wO8fZi!@UzZpxz%OoccQPdp`7hH#gb1VyIRIjGDDx*T@lXhgTxx=;Bzs{VFzLLq-Y-u_|s3 z)7`q2CVn+ei;%hKRX{w5Ksn{|Q0+4J=(ZT^D6rxi+>N&;Umu#hkE=~JXEBI$@&o*W~)R}i*JNgD}@ zWr5fNWM=B3lY`B?DRpqh6L0fc^l!jk+y#&^i(ADGI)+mWj$KqP+$+l`dA{|6C-ufr zPp`D~$F5%ie@J4z_F6ZShx9vm>q8 z;W&M^%J6*FDzvBQsGgA|bYEN&5n(-eH?Ra{Fs2eh1z3(N^y$=^g0Q+=4Ve0Rp`Xf6 z$Y5wvGujd0q!f}%Lo;ToNI(8DrtW|(f;Jh<`el!S?GXr{*izJplyu}q6!0!99f9zbFDg4!^fY3A86#|w*CiC`oQ1-{ij-f4YhQ?1j`ZpcabmLtG!jLMfOu_v}u5@V9nbmab6_2X%`DR|)587;1lAaW=ajm??xs@t>cTB-<1 zW-3n>t-5sS60b2Zf7^w}y8tzsvY)yOurK=G7!67gb{tA3eqA*S9^own?PR{;`!2cp z)JK|O?86iEVFg%jj1JP>B2RRVv6hC!D+!KmC8Nvse6GB5+9lln@PT%B)o+ruKy zI7t(~Ye>ZPGt02T0huPrEPzwtyUb7@2pZ%e<6iS2+t0^q)K7B)^qSDNl;oQ)>>F54 zJlBwS45xOcG%syi4B`5U66vNh|Et5Hn^iyVzTxAsFBg3;E+>ZEjuW`!LC1b($<@4| z7BcGU&I>ZQ1tf_F>+lU8^O>ntW0XSb;BtcvG0XZApO@z$fcS7(+!t!bUhbEBv!V=R z=^>#Ab@iB!T{T8~65Mv<%s5{@`%fm2OdK)$Q707?1Ss0Tu9H;Dk02uh)t4ppT#-`z zB9ga&m7nQl?e}|CpI|m^`XgupWcjDpe54n6d^1ZaY&|@)JKQDR+Wz}$Iq0W%enCj?#~5|2V9=H}0wesUozdLG=s zTf0Pi1?Y_NzG`8>S_7&J>?gSq6n3`b4Kz8Jr_l+6kD}@lqTkV<1duw8Ha)B6hT!#OpyLYd&qNL4y;V|XDO6&?Gg<^RXIQj#rh1PJO z)+y-Ih5f;uj_@Z5?*DLR;X6F8L>Tmf)a7Iru-OKd*O->+eVfijkoBTp-8{F_Cah(> zw@W`oH_AI~t49Y{)ix!U7ELfB!%bj2!B%mS;v(M{9L_50-oGc(=n=ee?>DX4u5}s? znhnSYFMn9{z?x?V$u{TJiNsiLYw5#?y}iW8y^oK)R3t2oGA~+>+z;wVzXbD%*wa=g zf~x|P_OR(sZa3Zw*t8M;qe>gAJwL(H8cWLTp}#!lJGMxze95LXQ0$nqpyXPGg{{pq z1%$41zz+y9n;i1R;kqz9RirExqDik7Kxh1V=YSATXf)}FAr$Lxp6+^2Nup z6jGsQjvSV)HVnG<<5h)} zo}A&l%YehMhO)erXu>0?U%0b+g9+3}Qq3`Hpy5&Ui5q0qnSdx@&`^rpoBQ7$3L?;x zK6pG*JG=4c8(~tLa|ynRCzpM4g-;(_9X!*hBrG^Pf9(=aqr67-+kY=!l~7@uaK7b- z`jDDcr1CPo$Z7q{twQejNuF6v6^6Jx?QX5n42>fiUedmGhy(=#kJY!jx; znbGWf|1iQ4@ok%<1IW(SA6>OF{XT;)ljb}FZvf-dpFeZYD{u3FcKWEn#V%X})v}W? zoY3;PH8nvB>^t^C55E(z=6z zff5roeagd?JW#ou`EscW|JpZD8=&_tzqJf_?N=zc?wXo_M`kKtzP%Ho=O2Upy%D>n zZ*=qsp*?*RNe|MP^k${y7}7H2$JTLd5+MxBPDq%=?kZ{UY(I(3BNhnE)RSrc+{coo zt9x?e4DTZEJOUe=tq$OLh!6lLfi@-BLx2dkwxB-$;65aq=kKY_6N=<30jg-W79z~^ z#7ARK8-{^20PRQ>`x`LD;<0oHiVHUeUOVf9wxTsG-8dz9wZKh|+$C$FW_oCq7=|He zf^flvfS%^u%3^NOx9C6VqQj6S~Mt0TX%M$~`{J^SNY*n3KS`|`b`xVr=nzl8^-H!S&d z215W!BB3QY&tR?6=^*~W#CWAM0jh!6a)ZVapJ4>iLXto!iOwFNHoe|l{pI7wM<&$9 zw??+Ur$uzszC7%kDNv`RExvzrakS}q=&dSAq`L^kkllG8K@lta_BDjLfdvGI+f^if z^D_v*-csADpwjct4dgZLv8@(v-}t)#+Y4N1D7hiNUzQ};GOReyz>Nqst<|wb=0+DxawJ2L$b%_7tUL|<3np}YkzOs!kzcNId4Me;XPw) z*-jj>FMzgyDkD(BI0`$7L_o6leFlzgyEt@cc`Z{em!t#ZK8%!&igE$Jo!GAdO}mD4 zTM=EO-XV6f;#!32oF)^UB_vQfn7hqF>|xa!n+DuU_9~Xyz(+$wampqvz4I_g->MhM3N|Z0sK7AEqKz7|OCkEn$1{(w@n;1~vSHYfUbPhz|B-!-g(!lrv-yJ4< zWErzcAzPk}4jVj;+GO+6l9GSW6;iNG!gh{}_m74y6M{8DvDqiPmYWj$k)#Qge%CKW zGB(*EJ9vzmV)OKJNFns|qq;|@er~H7#naag5j~oFE%o_IvJal@E@&}c0j`7j(5aDj zyz6*1%xeGYe}8Ju@cWS;=1tg2l@9D5cD(oNjYlv)0++Y`r|i5;lhHb@5hfH9kE!@foT>zRGB*4lZI{orjMEB{A_ATN*oU~D7;-nE;;>-)^pWi|a=5XxG;|jz z+b~Yzdj;^Ng=fw5*az2}nNj2!`C)HL){fZVUA+0<93C>I+~CR;P+M$O&J;_t^JYkJ zc3g08Nn04w{JOmCSt)h38_4Qm^|N(P>0vu}w|xO5PrT_QUR!J$qFVCi_1<&3==#Qq z&u5az7!IW>wTsYpMv>Sv5eeFWl(u_V($}d){aa`nQqA=_a^$lYrtdi;EhB?J#882h zn-3BcqQm+;90p1TzIF$}p6A6h>duF*as$?z+QsN96&KYmW_sM&Cu@-c7AHs#lgASV z5Vg*l5HXQ7&S02={{a<8Iz&M8dyQw1d5WwKDt@f$lNS=&~=C3bHZ z^djF>r^i(rXaDJ6^+W-buczF8-j2Fg|jCd>UgXX0Ak3{O5DQ{kSTg z`$1bU+2m=2g*!HWM}9Q8Zd*k@zh=HL{MB3A zZ}=}|va1w>wsCC?nX}<~$rDcuBNn0AhjG)HYRTbL3ak@Z0&sxTh))e*Oq$hx{X5fU3-GM52$pg%rS^ z#>BlmN-Jx@Au5D!LQG85PbW|DCN9RG6t7R^7~2qgUEZw})=WsjF4{AhWI;yQE=ZyQ z8hcq~%Xmtx0kZnS8<_S1b3Eupd3R-flMI$>1%VTTg?31%Kqld8l--AB@b7Ut@HGSNd@Ao z;eYAi(q<7-!-6i!xp5#s8b{%chMhT7c;9g|BDwNt)4)5p^QtISiUyH(4B2g}(}2*a z*thdyaowFi-%g${MHYNX->?%kV=dBQ6C}T?mp0w=Ju+ABD!*_d^zQddN^Puxx5tEZ=?zcvp)C)PtlqD{ihhJy% zhOXI> zY*qv?L2*W*AP-YBMMpdW_0%q<=nF{QX*01t^FK9}`tl<(G!LP&uNF=Y;op|tH5r|@4R+yi9-q&z$;I>Q9Bco8I(Knwwk>Bv2e0P+Fn z`kREjr)fpVojlz6|F<~rc17{?uZ=7^K2wxA|^gru9mL<$!v8#rU#OpY@bGsfj4OTY|{&eae1nxJxv0s_( zFH1!Ia3{-LzW~H4u&-M72lXa&FCYFkx{LfXS2H(`tZEXR`tL)rG0#=iTA%zUi9aST zbPIU!pg6FkI7&NLa(H!UuMTf8^yzX~!{q=cTQa(ne>Am7e3AI(^F(I>R!CpXh4e`v zJQjw{lWfQ{Y~>CXA!Tp{G%1>eDyU|k^Wd0Cc>6HePlF3NQj#!`w}mMMdI`Nu9G1Q2#Q`NU@=xbc)z zpgBSv-6a8mx}ibkH0VC-hbx0OhQALU+%obR3h1FPZ}(%q4<2xA8U};Z@J5=lB(PXg z(|e3LADa@a>DNMgp!%em+tQ_^js6h$?}k?nu#nyLd35W7v^JO7_%q4^w-!#~FZ+M1 z@(IZNZ8Sr*z!{mMuuh5H8IC|-3QUa$*0aZj#3JJn`?t#771G4{cK|?oM{DaE(u2TQ zxA!1!OTeEf$`IQ}_sE}VwIHfr3pliN2MkyBl9VfqaI@G>6Vc_Cx(wgt|f)s#NEa z)C3iD8nYGXAp_p*WRvDRiku6@bfGd~6r)X? zeeDd6=atQSB;0(GzIX}Z8)rSC7=*3uJ9n-?w!?oj1#ImI?=;Fr*KONHBA=zx%z}qi zWl#SFasb-O#Kg<|M`SJ~Ug0Rt?dW??PUOM>SOiD9V~x#ac^=t?xhYwK=k}WT;k*j8 zj_oBO*2c27eYwzQfJLGu?zgVE5=fr(8UM*yPH7m#=#C88R~QNz!;&c>qw>C zWI4rv);BNx`MytJ`=TOxhHFBL3|hMisF#B^l4AOlH{E>;cQ)QT-1Fi5aQk^+rw7|= zBuyhjO?}S4LBz{+<5+VzvtiJ!$o)rx9vLc5*Z6IVeEk1r!HO6QNEA3FHEl96w^^d} zW`WnkXP2)WA5w&vpHMBITzPa=YqN=0hr$jiIvxm~sJ2D|y)zo_RZP5Ih~dJ8`mGAg zkK59?Tr=NKRg6j8>CEy21Bi zk9`NsO-*r6lW@Di50B5d3Fjf`3k>pLcpyPSLW(rF3C@Su0}1`L!(VC<9pCGOSook$ zG47aKD(1cX+AE#~e7OU@M-FDkeFviPg;gMHx9j$6U}`js`Y8Vg!Wi~`K4Sj&him2k;{p(sE#*)J zJCtz^H;l;%aL{5-MaPf!hAgesPj89#6u^TCS2frj=gbhmZ3ulAh&>prx#9(y^m8qT{rs?4$4(1;Sq%+M_odbQ zv>B#sL|&}Qj-a9wElIUwR?F|GLeyf{0uyL&vJguV4uPjjrjt4~di*CoJWksnYa#o> zA$zfd$2GcKi2ei7zZW?7fQ-N^tsNG|L=c7ry}iwC1&TBW)@k4%KgJpz$3nf{0fvhx z+_K-`{jNtiEO0$SZ`g*QZ|aBAZ9uhzF5$6nTZSkO7k4pmY~XZw-TDUZ!v_|aMA%eQ zX3Iu~{b*)F{;0c=!Pdw$l_IjJuwpl$YzHXoYrsE=Bt4l1_jQx$nj4?#=HMXxjYN#0 zSq>g{8u9u6PSob`!LGezdL&N4&q2y54yR61{3go=kb@ zg985G7-y~zhIdq88_fTjzkf$-anz(c)9uavDzuRurN10Y1CJb;Sp%4T0SS5{R0Aev9apQ<+KNT%h#i~)aM4dEHs?xYYC7 z4NBnRh@d+p$|nih`CIeWI%bGxzB;TvJ0cBk4*Xl19bF{e(Q=&-7b2X7UPV5Np?wD4 zh{43%{H8DRKu3m3`;uK+OCf+OCnSSkZ%g5y8T4&v&hnr^ohM-r+xg9F#)d;6vj^K!*o<0RqdT zMeEp*9&iPV^-JD#uLf8fLmO(C8Tg|X zoHokgn8Om2T&(I_p5K@c5ZWy_UD=0q;%r))NLiD~{ztrGpuxJu_{K(Dw^=ANz}!Tl zV%Kf35D;OB7L|&h7y^q}-Sdtf#S%GqYSk=|R(xS-55LBKD9wy)v6x$*yy9Fc=h!Vz2ebjyAwmGA$9~9^C)0NXRu1_y`+3X9s=WL>W3--W|Yw=4yEf)P9eBK8{vE2RCX-VY}}Kx2P4WHDiP!dbuAH%<} z8$*hUy%!bkjBPot1zcq#ugYb48Eym{X$>eTEbMn0`F);X`)~L76E6ME#^OF?#{F{< zYcT>k+9Su5o5A0=w3xJna?z@dw>cMNW|#_Cm{nnb!&05Wj?ibfzjD6tr!e$Z$}Jlp z7;Hw)t82_mn6$}!baz{EaN=v%u4^A(TRP|Q@+?s{A)By{BcRL#-ZoQS3` ztC-}50ww`;h2I>1<5oT>g^t!ZHI!WW$Q(Ak9!CH<1@y-*dtf&p@q%?n1ITc=i9t#x z`n;M5z8hqZmF*Of9Yzu}4diTH6{DbiV;*g9qPa1AUmzSCF6~vQM*Dz-_ zfB7;EJN9DpW4~_+v2I#co1b!rxAO<`Q zePiI&FoYT9QW5V{KGfhzR}$Ae8Vz-In`jZ5;dWzjj+V+b-0_P|dB0UqePK+6$0ChA zlL-T86aGCqRDi@&hBCcN%3{3rG4^Oh<%yTMa_#P#MvE_SFc-4lM1t>s)dkDnPIm#^ zK9S=00}wE*D4)E5tFCAr?;UwPmhCNEm7=u_oHdroeCBa_M;G@Wl|a`DPUOn=SG36! zLs-y@*DugC^vQ2%Eb^_Aus=tj>~bwd!g_~HS3vimD2p~vzZUUS!D99<)NPzzLzurm zl9nyg!d$@s9fhg+N`t{j$-{6+PqahojndBvsMDCtSHa_#IHxE2CsbEFBi%V0F;(X- zs*$S%dwB5T;Aw_G&PAs~d>g$3l@;-?R{~TaAzDDL$T9Rf%^S(0%GG!oQmBG!RB44Z^Ipn1pRrt=rg27V9 zFyECr(6>JD^QMspTSm$Ynt}$71T$^xUMiKrucwPtm-Qo6!I6XLnokni+CRG+Ci z9Qytwr{za~bAB7?gmanox#1ZgY(}n@$=6>FpCHZAz!8~xrfki?g<`l3m$%v zzlRL}u|q%2YHR0}{(ii0SlIMuAJr(2JH`J<5#l$E*sS}ZCuIzN)3D9@@7w-XMZc{N z8qKW+dETggGL$}EUl&#u@E}T4CaLTgu8`~kXcu>t&$(m--GY$NKp<%Y|6)mpS3!g4 zvv!zYnHKCvm!FV;R(35?P+vJfW@|uD>R3|I)R0Ap6MnZQ&rT}%|va2*);d! zaqP^7bu=ry;~=;utv%TU9sPw!bvVZEYV3M;JOFKo$kQmk0nwNmG9jGtl?1$c`_-NU z6eY<#cmabxXvk~F{#gziqs#o_>85ZLPHIaB3WjroZVa3pEKpEPX5hAn1~Q!M8m(-r z#P)Z}2=ti9pmu+l3IdK1Glzq#C?e7K3%0|S#P>&^1PFzsMeGHUv5bno6J@P=D31RE z^uUK?Y2b;SE)X~=+!8vd2bj=O@Moe_7Y;m!vWEDvrf;=8_Pr95w%N9e>B5V0Y(9Jx zN3j(AYWQMOB${YJ)$SdZ(HM-<<0M|I^TgxTHA%KPtlltl-|ugJU?30LHu*U&8m3f< zkbg06pI0`7bglpFa$RzW3a>^!&#iw~YN%Xu@W5+-0z(%`L}5b1Iabbi37)U=$?ZoW+qoWS-#7LgDvSj@ImE6XC4i`I2{1(g05|RtItR`dqu;{nl$ID@A`!&bVPiAHg!j83 zIy6;eX^r*tX$$nHkl2mh*crqZZvz79xqf*PkU}_+Aq4+vnKJ~I>F;kRlNVH_M7VB) zK9L#2mum(S-ncmM=!~%xG*#Ts+9~-{frK^&HvVg5J16jWCAy@%d38o%7T=)+C6b$k z!=I-^%MpE6;&q9STY30(>F`gez^;d2y3+Q>*6Pfe;uhnYUQaH9x}S;GujqFHVFe2m zvOq9o!rv!P81Xc>{_Hq*yMy(A7+&gH%?>pbY+(e>@&Oq1oyGH(iB>Bj@D-zFGNNrt zg!WpLOUi7pTBOx)qYFMqUK(^Mgvg<2GCQk$CE@6;#tIBr1gbO@D>H@S7=KtRg*{Pt zjY%fU#F=aHMiI=0^chnuSo8~`Twj=);+vmxKL^A#Za&K16dnVH2H0J4n#kA(p_P6fl z>jgr2I4z(_k&Uz~EfWD);Im&A$sp2>=CWJ65?o`HYJEb7s*H%nC?Rz#ck3c1gJmN^ zgC61u{<>C*D`@`Ukitxd+)D=XD?AUREhydqn^#b%B9X?67H5>3z-ODB|2Ce3`@?wI zvPy7U5k8|0cPmWP`JC~vV*26pXf3873#?)2e=MT18yLLC$14HPNMpA31|h{_mE@ysaDmU4z)G>zOSo~75(&_bfLtMaqm;wvtarJ4EQ`QQ=sfo8YQ z33kEOVisIdwqL>}bd3ByM1=ex_6do>XhHPF#q(w`(hq8>a{8kb;tXNRlFR}xWGLJb zSX<26@fZFI zbr)Ql2V*-}Lf9-i#2tG%Y83)52-^k69`|C%x{u?JoKC}T#KMr-RtSp#zMS_3vL&4; zYm_5@EDKQqe8re?Oz91<{*VTX1(+`gA{eDDM+sIDTQi38=JDmO&aXqrypb(f50GWu z1<4dNm2hXUm1QWw)32XhPDS0s<1RP2*Wa43r8X(38=JEilS<5OV^azTxTaT&>byG6+7I(5?{U?W8YN8ak<}= zHgN#@Ok;~?}zWi#9$j%O)GdLj8^IWN2+!kXl7cZ;khm(_59O#R!bEKn~ zkW{-pTed8f7}n}X1m|D>=Daze`H@>w_a?xVd9TTi_Cf+tzLa`r4zj>#aGMf^d*s*=*6DtFXQS;(z;MZbh8I&SL1~D*ag*R4eRf5>S zr!V1Vgexha5RMLH)$42pQ}NAr*(n*!MkGx@Qa+MHbzv3xNSbn(jN!_?gM=15w5@N(`f=;ntKmrGB zc7r;@t>7&>s28&=&ip(g=^JvdUmLl>lJ$9DxO!>nx9?R8n*a?hUp|JzdF>kncp;AO zv*}3@LgZ^y_;RBQ-)&2O?0BtMa_ePmj?iZOHL<&WYryO$65_Q(eh&9luYyk=-r3Zb z-o2JVFV2PR#TJH|IEVn(JOrM^>!lC2Fj%Qme>g?CT8ykEb$2dVu2ee9g`H!#^Y39~ zu%DbW*t}_>q#p^PhP6Gg^5Qv6?(#||6iD(QXzllY1eP}Bi00)>{T`gPfB50T!G}lg z*NCv%A@c(ohZf_Yfw#fEAg1~Iw0k%WydkBJNTh$iU+zzKr0xRl#fgW)z;@2~T>|KG0{Bm2DY1EO|R|RYG$=$FQ^_X^STF|XXG&1zplVdYE3BJC^Vl| zRw4SKYDBNj=`@*UNrrYyy)0?54znXsVJpH-3dM6zPgIbnW>IFmM`O>?jR?-s(Y2SQ z8KxC@f_g+h9Zsh>l-_0dNv!@G6%K&%c0GjH^P%8F;}2&CYTQLzB&ZqssJ4w^FflT9 zC7res{H4?Z$a)d(3bWc`$z}dEi`99T3yW3mPG(85UrMTTx zG{5B-LY|x8r0%<84~VOq@Q!gUU(H05VI+Qhh4-)JCXY3#T4lR6Twy$eaCR;a!_N)c z^S1);nHb;Ou%VdBJ)% z)YzS%#!;zg&ZlHMZiOmZXmaqLJt6%Ft?!Ckm+9#ZjJw~#rC-lc})YJ=QeU3 zUjF;G#MA5Dy@s16Jm{Oai!s{l*tyd@;Jb_J6LK!KDv2dY6X?{Dd}wqjcPxL;M#L|& z-ISr3GWL)KJI!%5`BHYgj*(H4Wxt%ik48h3B?CLoMPX>mb?{Yf_LyieZ8!Jx(`gpi zgbiTvU(XfpyqW1%>L4JlN!aV5lCdAEmdTnIuUD!FNP5D6CZanN;V%BTVVC9)1v!W| z0xb{kDkI2C8BSX@0Cj*3*0=~D9i|L57;)}!F$D{STjL|@RRt$Dlph9gf?j@n84a43 z9j|{P{Dk>}E=45(^(pip1#y;e?Pn5Gg^3}^jD^K4GIP41+F~#|v207l;0vk%umxmd zmJI*tOpkN$Si)=#EKAG^qTEyMIS}Fz~*<>q}MyzJ$$&dN&iMMh}{4s z4z9ADeLW64b#(GK+~PI&5NHxDF5x>>I&|ViCkyTz7`Zeg@%dO&WA`n?HRAsI(|OZ> z$EAE01l8j-vPdAFC0=e`uNkhHtnPu_PK>Jo2lK#_>Ii~ZBH;eJTPooi%z=`nAZ-PI zk4=VOWbdqkKai32L1ObDIVPC$a<)L?(ziG$o`pc~W7iG%McG(>y zqGf#sGt&(k4p^ia4faLf!DZtSi9|}eKVEZO*F?)g)3ngQ2Q)C7DczA(wfb8bKMO$O`K(_XNLa^j|%5yH@C~qut#qGIJV*d29~kBP{CIab7AbsRE1KzaZSs`&CZ zDTP@f1;rGJ#n4jhzP;~HiKutpM&uSN_M|Ti1PC(ptS5eE9W$%c; z*cUknQy|>lt^@~t_}oMBa}+t4T=Cel=f1e|FB##w7xm6iRGy~EQXmmr-w_?~jgY1@ zcNX;`C@Ziu8EC>&9Swh7H<(6qY+j?gbm6vPnGhT6``VX3we05bpAq6AklRU``VJUA z5u1A>TQ~_8Hx2(PNZ!74gvezGa{vp7#?oLK0XNB8N*zjHc#f~ViyO$`+HVg4*i8?E zV+b3$)yU}8Sb#5tTFkl@BcnA`-SX;eGD6y&C9$+3*+R%WY}Mx;HXktW5@8hZ}QcbT#Z;KDvg)N)2u zePoVIUiNRH`a*< z{e8z=opofMNb8}1Y(X2&^_FzkTk6fiBmc1M@iA}`{^T77oookyDF}PY!ec*v!$%fsizNw=UH$WRKE;M5%lME{{$Mhn z++iD-hOr;bYG1G-BLX7FM2!~e&Z3fT0VxouNL;LBs>f37r_?uM42(CiFK|7iu@9yy z!V+D{#bg(%>z%8yIg2}yGKVWhA*7ZDfD>PUZ)h0yydL!1i#90DTpZ%|;E^Ic8>kHi zOpNUCr!=v8DZ0CX(6TJ@80nW+TQgGlZQD4w&R9}B7t&+0pN+k>2ZU`7=84Rrr;(|< zWxKY|7>9&A49g{$m{S*yTY|Q1oVs^3pWEufwG-ChwStDF`>6jVbeG73j&Mj77tQMP zU6cuA3_2d2)=|S#u*mhYT6L+dZR>Z2>BluApd3Acs3GF&n0P~1$-WdjUx`)UJTSU&>bmvlY)|N zvh|#S3%@O(LNP3i4sSRhiSke`zdCU^99S|g_Fglw1I**_7cv%x(~S+x{@#1|qfBLN ztgv`e;w292jg-s=`3bO!LaoL}I=jY}D>d%ZhaW!%TdNbC247x!2Qgv9-J+r!LU7X&cppKid!%NUig|x!nv9PhnmQG z+#^nO=wjEd1AQCr2agQjB?XynL~@QvfovS;r#+~}e9Bp_ag=|r^`DO7~b98ZSRnUq|Nr51zPBS(6f?jrK% z;fFPu|7&15d|{Yn)4IYYQtXCxb+As+dEJ={N@BE3S{gE; z3I7q%nfC&FTS<}~790I5tqqx-8`r%^OS^&f2$4`1e;|a2QTNyhGeg!9)jFC1)B=z@ zc}f@g?yQs;IQt)R1gfb`1M3qc4@J5bexit7e{;K{!Y%|P{S9x^UbEOQjcZpQBwLVk z#SvGr_d4>fMuq-^|kNn*L%24eTaQ*OiHY= zF8%3P>O1gjA2VB6Gyo*$=kK06=NWK#>JIEpXu5ar9Z6dFOalLKOmULX5E6WWTn8@a zil=uss`)*is-JEQpPnIUsc~bbn^5bNq$Vg%IL!+|Y8R7XrX^Rghtk7r0|Ow|Vm^b| zT*i?AJBpi3V)rQ&{R&av-&_-wD=DDW0QpwtrVm&m6r>)fz z-T@buk=a52C4P8J8XqF)!%y&OLX)SjvTTk>Lt9rdmP%GU913PeKlsh*-Csc_oHO`E zm-LPpW}sRGOZKj5h>TWBw>=yjUc#M5`+*)~N&^M7$$|&-Wb)OXx)ygZAb=3n&d*sM zpV0wE#Q#Ipn}9>TxBufGOSDK)k0=U_N~cmrDiW12BBf4ciX@G!C0mkA9fcGcT85;> zQfW$Q$QC6@4H5=1RLV|CQP%(K?L6P#_582vS+3IwY4wu-ua_ndo(ezmf1ljej14BZVrz)HTJ%zwzgZ2gY* z(*mXS$DK0B-Ac%fMd#ir5am3e({(Bw=TDkK;;|!6wq=C2Lur&ba(+-%35O9tg9k%@pAZeH08@AWjm~~c`GSdd?g-?Fi zT=N#5H%=Ye=?l2EJI&QJ9SEFq5$qr~W5ezF)W%&3flWF3BBYSE`Y!+xx4!`agcnq_u4tia&g!V|xO#gkJeE9272ugu&_y6}bs(9LAkF@B>Dw_kND;S;`7dNhwlq~DSd4R1tX~G)5==Q!Iw1-~bg8L1 zr^w2QHRrK`fvqlVPE9kD#T+TH(2ts6u%B5o-T`N4Abl-IIb&GEW|9gyE-1>>Y1 z*=G77m;+oVhXmp^;9P^|8el6wR*724U9+lrwXjG>$V~U_z>Pq5caG>89E(9I8Xaym z3_6a}_2fw?xUd7T++K;~ru&YTh&LFpKFkSRO6Pz@2GVv&cQGFIaGr9qz+pcZ!9Eg6nz zKsd}U#^4~^xB^)o7nQR|zkCVC_<@rmM+tIkfcDun3J;%U!&dF)p54ujVy_{u(OKi9 zObT@r%qzSG-unroBsbR}cuf2GnU};)ym|GwYwF{>VUS<|{{L;-)^C9#&7mHLg+k$V zLwFCpzyJK>tSv+TpvMHS7kdlrCL%&do+Pv?ajC&)7M0#Z{qd!&z8d&D!I5!VW?VGM zF-?jAodWCV0)-*~efWI2O9UG6xY5X}zve;8y;BPe;`o)7+lf45eDBm&0SqVlTi~|< z0@sX$hY+jIprOp5A(&ji2mxRMg}S+6BhXI)Z;5?NPmzte=VT*R$GquAi)h=Vae~^b zIb58?FoHv6i4o)2E7+zyQpi+I2&5@R^~3A$c@m z#$zJKi9!&$4u@@gTMB@;y4fwYu(7*U>T}i>6CB*WxyP+56i)-E<=tu1-w79kTg@h` z%~^@Y%ap2J4TcGdm=RVFtIEm-pJ`1%Uu-z|yq=f}W(Pq|pkvA3siRiK6lFtWK?epE zn>@*c!F^XgA0q(U0n`ANPg;`|@RaNzPo%kFg4VH&2M@Blu8zb9CtQz5j%LldxH@dY zF!_8NE!{W5=kj(If@9uZ((aqnJ#_sGe5J9)gs|ro?5^qrRFn+lz2^xkLvd~`p2NWn zybQq^tndj9&{3c&9A~p7X$R4+0TIH)NRU2E z5@a2K{Q%UMQ>kn*6k<|e84^&6-jHzlpCOvmYbu3&0V=k2lyS3;E;3b(U;>J>`n827 zjcZeLRmq;Kxov8R^<*~Cedk!04V;yU4S9-Yvui`K^0sNR*|={y3*Ji_jiY7+5yC5+NcUPTvj&0FYSbHusRmz1rA#0Y+R`9&rJ7#wUeT9W($T z2-~V^x)kl}EfcgZv`vz;8S#Eo&>2(QFq6rQKQgjaTeayrqskRxX~ZSso!PmGIz1j! z&*R0O4;4Zfg>67!ueEv801jZdRZU#Ecj6QV^*i#ajV^O~d77sm!+$Gm^3eVsc{!gk z=_)sR^>Q6ft)e6LYwvtS$J-P@0(yF6vZ>p<;NS(3>Knj=G+#uwDnI;e_{Up-A8*L6 zXMY}`K5NHJ#hpRJ#X-Xfqm^Ufv)~J!Frya*`qpqr)0i#8=76%P<TS4z-#ElhCD<-$Z& z2I=Ey+T@M{@RPr=P7bB=P8g){<7L@VqrK-~MIDUppJ6+YT59xOre{l1Vv5y67haF8 zaaC+NMHV}$zuwtIbB#=lYo>-{&057Q1{Tuu3Wj1AA3?nrAPt$1c*YSwPXDAR?>7n- zoFaRc5ogIuI@l|iSc&}5h+`8L>UoXsbko8GHD8WeT^nRf&VuAA`T3u}IU zA~4XP^lCC}RN`zbEil*urtJKc9n&ZP6x-@At5Gsu$I@Pj#NJx0T)EwF8XE`0_8sfWtn4OUMQbPB2(~;g+rE z{f7m%eBfhj@My8)ka4LSYC1Mx#By=GYlmddaHJ#$Br3IPA5nK)E9L?DncOf8A#9*L zBEiIm;a6RFb*OuOmQ4e!e$bjgF5aEEGO+3J*-{56Cgz>^O{e;1_N_(IV$RT?KmJVv zThLXV8J#DQQW?}Q}~X0R(>RjkUcjeQ*Vx4Vw>2NuFc_y8V7vjApj0$u^Z0SGW9r0&45 zpz1jhRfFY)!-wu?8qM!ey^s0~NdY#QcurKEr{W0vu?FAZVBv6fe&MO{{lJ{!6>}!h#4IXx zB8Eb7CFW@J@?SIOIYLy zkL@BxW%lhujRLcCCh}>A5TNvJV0$!I4GIb_b&NL2)ElU6&oa1SxT$ZjG~?cVgNM{#w0Vryfpcc%WQrjObUFCAJ6`9ABTNuSL(izj*^nFoM?gI+lf|v!e2d}H##~H^m`Tj z(Y_&IS8MdM)@a$c6U}J%z`VjyB*6Y<<3{-lE8{Oc=tPZf!A46-!3G;+HsKFYGw)8Y z41Wo-VC-Ef3JJ{`Hy^!%aVkj?#aXlMK*YqAU?{1QridLnCN+oN$0FMgR~DzA2yTGz zzc$)vZHhViVz9~7^T%Wv!kUE4M6oWns_EqGfZhFl2oCF?KdT=&0Tlb!FArc5I_Vg$CysJau!-s5 z+QNydGxShMwP#$I&aE3ttM$kTY%)bG$dB7Y^T4O|RBrXxg^Mzu8AzZLpH?ApRwm9{ z6_F=@@(u^OUT^)o2|yLH^lp6%pbu4T_9Ggu1UtA_!eY%rzQmCl#~ZmW+EG(uL$^xY zz~Z?-5PLauO;D<10R*v<6J?g@`RP)~O#w#axPblc`ONtxU}{7TZq}>$p!kwwoqN~mD%n;}VoxDTd8(E=GI=UP2T>2} z<;`?huT1cV7;udicu(iZEV_`BesPiW_4!~}j-L<3aJ+jjxCU3^Q;DZ8zzm-IE8d_P zj-H9!yJB$qgO&?}ui3fR2!)cH^fS;`1Q=kMSX=6Vumhvo7~{vg+W~FiA)@J6W7kN9Nie8I zNWV7MZ1h3u4Ke$`@)apVHy+K;MvHKPcH#vZxErvgf6zy2H%q}%m-BSGf(vR2ZJnt# z%Vqtr0WvRu{=ZH}?Iw!S-!jximM{wrh(WstZ+EFw9C%Fn_r__AML4}Zc^hj;xYolck5WM;i%#NZ!10WZ7g$d z75FR;&$6>W7-lnL?v4_})Ni9gLTLS^s=%NKEhcGgUiJxMr!w609F|aIJFArh{$olf zso)8t0#^V$R$GLfKJD?2rROJ_=>9E_`US0&8DTNt9g}->*;fgqlW2~J+{qxJ6kos?}&RzS_r@w~?Sve`GIbpGM0 z%}4l)FPCwgw{in_5*w2U0hr3b>`_%HOzRmM1-OK<7pBABdGinkvIE)m6+RLSdh;p3 zALQ+1skX-~y-EvzE@0DaLY+`ZaVVop3q4D-=Vmoo$!)uY1CBkDzf(H1-aWr3=YhnJ zuCDWqc*Xo9Qmhinyx`MiNr&B+rt`fumT=!WGJqrP**?Z`?Bf7WDRBl(CgX-qK4u7;704j1L(Q0m6*e@7@5OR(MjN$4MJA2?4iVwRV~QE2E4gugg1 z2pU&ZRD>Yv?XKNtK}7T2SZ*R8>#2-gZ$}RpU;x28h&B(VtF2aJKdplL8?ELVo?L55 zHu6?M9ZBfp4hpyo#1MFc($TZ!nC;6QuB8?$dm877!C4)3cDjwZTHU~iZ=S)LHLw<^ z1@(^x^w_nMBg`Z7FLYFY(f9nqGmE_ipE>CfS{`iF|0;3A7|u_2#Rc>a^k1Wkrwr34 zp>{O9eIX(#vN+1q)9G4)nqQCmX|}s$<~(~gx43t3F#oZ%Ryn#uZf*WyUS4^LAZ}n= z=Hx}6i>}O_SrRrgrtMVqQoqbaALK;tIieYn$G-&qEvLQIZE6>F2Rl?02Z zE8)+x;ggA{$Kf)!xY!i(DC{A6WC^2HaNb`SznngIH^P_j*1yz3!w_%h0Ixx8qQzB8 zE<;}GU~I8H4vRn6sW<%aEMIrRlMKm<>ZDf&L@OapyC3}$IR}<-G4bO0@R=8gP;Nn( z4&Eun9xV8fJrEF}ZyDW#?$zXFX{nDfIZjqfimInvHdPvPFyhgLfav(Mty7+GGbd7!h$K;|g zXuYQ^5Um7Ys;*sQ>2`Tpu!))Gr!Emg0W5MGyD@iZ9?aSsYZKSwmf~)#8kdN&vP>a7 zJw4rOUeFKh=H1fkhM&(Heh%yQd4?yKR0yD|<6Vkic5dysZcN{^toZir+xu6*9msDC z8fvejN3G2x1ToB{OUIxCCPv6>NJ6)KVh#P6( zSJV)j-rEF|4qS=O)e+%EFGO@NB&&f69b>FvcMG;z;4T`e=pk#FBtVS?-Uave<*DtU zYZL2jfk4EI29K^~E7aCT@?(+cfOifQ?I}%8) z`$Dblp1B8FL5s`O4F@IDpn~PuvJJMj#-mb3kMUfp^*+wM9cp$6UsVIARegpU zEFlR~_UQq*=6b-qVgZG$;>*?!*EKfP$Oq7nE2KyAsmQL}6}I>AzYPTtUu4eX$DFDk9 zVP58*2s?S<*m@3^Sh%3WxB>`+2*TAxdD+cI($qCon{!JQ!f$_lx(f=l{gIQEqh7B6 zyh>etpStGF&>J;mV~tR0KL{1lnDf5cg)=+TcH`a1AzA_hEZSZP0*;}vw3o_ zuO*i-p_OQ_EA4A7k8A@c#cwR+@YpB{HPs{9D-ts2<&GkT4$OC=2CZls{Q^*oNE%6+ zhAx2A>%4p*LXAPcS-f9u-g(7ati4G-McdA~I(7g29~Z!U&AN3`QQU^@E|DhkW~jJW zK*Wtp4?G8&@j@%Q_)zj_{pa7(&`$rlBrLx2ou}1{&5%Q2BTSUDxX>`ABP$EBe+5Ig zkSI}fq&W2=+Jb}OKm{T~VIUQ3pb0(>f;A$l1wSUhb$D-VU4MTD-(>J><1Yx_rsBC0 zg-?UWDtvW6_R!*=MEE(fJhbU40vR)otk^rT(LDrr4dZ6jm)2$JM^UjyBbDBMJ*w<# zy!P1dB*Y)tz7Lsq@@ZWWoH|B_{aHN=x?y}F09T!Hm?!oW!AbgJYXf|{e&D3Vzk zMV>(uJz~u#k7%pA63QS=QQWAQt-g?NvJnw+5gBhZjrCckN3-@e>Kn{GdsF5N@$(AS zqb4;%UkF-5;@6{GZfbQ0Vx!N6#>K_KqZp*Ne?qV3z-X&9KGCfb2)VY`qunszf-dQM zT+{IXvC!(A5=K7H%7;ym*Gn`68#6-{&py{@5I4WPJRToAgUrU`oxgwohR4>QxB0_w z2ZDP0$Z~I_t*z~sbSwNzE0RN(Bg5w#ysseWQdie!z=T3YpHY)Zl#y7$KiZAVaGwgT)_PxRdRF54t7rk9w_hZD^ zG+&I(w0%KGMzNoE%0Ro;+}zA`4Tc*vST;1Z8~RZ*r?aCVh0FU4LI}sYrH3!Ho}71; zYfOPo+t&lX6bA^PZ$zL(4Xdj-CTCwB*H9#0c_5tp7v*vIF!B{!z+Wo4Nl*80>@LcE zt3Q>()!W)}JTD>?APPjMT_g;F;OI`}*EM#S!&1ejSAR*sMwQ}i99W+`W%6Em>ZGH# zgH7H9!-RQf*ITnj+e{6Qu-3Ql3{P9$5(Q@<~S0sJGigwy5;bsQ0~*7mbNa@CGC%sEK{2 z2td=V(S^|vnHLnTH&RU#?H=;K7OPhs{4doJ7Dlrf`ouyrQJ{SGQ}?R;svZln6EB{3 zlDJ~|j9mND(sCR#yc-Xs#3BcOH0HN|-KD)}ED)#85Lj{pIs>jb-iK=m@zDYTy=7;8 zaMQ&r318;${ZTuL2SH0&)p+7J{7*rtF%JvH>yiIEe=H#Zacq3Wl4_LplOQRa!1rc` z;G>|!tS^)M6u-s{o?~}l)1rhQflk1dHQ4y^z%CrOngE?Kn_~ibEoo0Y)WF!<;{%^R zrBMAhaH?U57Z@C4nLjX)FIZcwV+ke&ag41MJBzwZT=C(0gyrKG6={3c@KiKS80KLs zt4=S1B_AYg4Kr#PpqRJGglR!9n{#<8n@0C~ES&uwzL?{00yuHY9Hh1isCVD40*zg` z&jg-h{rJeL@HkMi&3o)3=vaokp3R zUZV#`H?c)Uc&v7E& zTPlJE%f}XytoxuXFaLTt9R4F=bl}@2N$pnu{-~TLShbMDJ3h1VPqX1@^TTz=4rJ|R zPN9ddDfV2eXLrRKy<=0**vPywQ4U_;mjC5H!YnctWM1qW!oP z2ayimoG3B2MnKpV5qG(8rCzG+fl3W2!|dD6UG`N z{BrKRdDAwQ5S=E_>;+_i;>T=wgB72Mu}k{KLE;ik*VrT}>rJW7;K;v$C&3Iq8EJDU z8$N1qZp4t_Pf@;K_UF_U&sm(!sTekKQM2rM#8UqWlrNjQ&Ycy>P! ze?>X3S#s_lpswBYa&-h$-^ASxY&4&vN0A0Tg55*z*ys>mKbb+cm`xVdP-=V%R zm#AYIj%1?^LVS+HhfD7ZJ9^+~qYRWCP2=GQ540-(Hi%Hjl0hTn-3 z=M4_{lKP6TgF9S5?59e7b%}dimj1MJw_`XeVR>kwp;1E!eR7!qE5b#1ipcLwL{va# zmWMh*Qo6RBW3HqSKA{92^oT9N#ArR4Y(}ppYi2W312o#V_(e`+OuBgAqfLOjDP$Hi zMJfe2#r$>YzQQ$-OOp(djl~iS{!YJLSGanrVOMa!NDi2EPnlVBFKxOwQ1=tMC9F80;BqM~%j%B1s;jg4SThwDj@(%Dai(+mL}0*JW9 ztti;SNl$+alxW=!t?_EDhh<3Bl&V>LtX1F!0W1O|;WXk+K*G1n3^rkr%2JVz^f2WKOPo#<$Xi`FOmpEyg^=^W?m^HDYogJUkS73zn5*rLyAnfD>wf~aF0(yXK7MiCSK7IDA z(e1EyU;m&BYz(fp+Su|6G4dSsSyFO8DmaX0jpIw*+EN~_EmCBbQdD3`)vhg%6SegB z`)1Z#R>q)v46h7G0lJkn8~lzfR#uxeF*J0KcI1z?9UkjHyehMXFZ{Y1V+u0Q0cJed zX*!OXly*Phx8VKJLn=2h^^L**a2~@hgLPQ|Y~$-uj0@3MNxLI{>M7wV$zBSuzDQPA4YydYN#;tyU-c{ix zMHoz&`os!QsoygkLbgoyfsMny7&9sfMvPHck>?G<93DafyNlc7+)#xZ)by#+9K@>p zlT*Wl;(M;y=j%q+_$laO*1mfvr)BmSgi?kY$~FWjn*|nOt5yGo6&^}79yRYBu}V=G z_wtxsQwu5fi@E|7qv{O6yVh7ka`gG3A#Juun> z_&ULMU4Cxvuy=r0V4!VTM1EiVw-fE%e&(7BTL%=vi=K$47QWLao&GkgI9_=s*3V^7 zQWs}V^}|jAz=RsVE+=dD+5K5-@9{Y?01`Ek!ogKq;RGmS6%6?(89%^H&Imij^n$fs z8*My+&vY`|r+A?$e)APFJ+dC(Qvn16PvtM7@HB-_xM z%(#pz+Xh}eig8#1j=4x|z=9UhE8d9lBK-VyYbm@VfUI=; zBAxL21G4x>_qS?QCRei^C~sTa9dCHlAfx^>J`BBYzapwCL$M!E6w?*`T}Q_tTCl-> z1@@z3#j@-;GjVOYH+p4E*<>9Dqm19uwUDJ@p$9JzPb+yg++e1`j+ieja^Qo3*Q1jT zG8K;0EPjT_0|k}wI0k!YfoOh9!#`#_waB(S+4-nn=S;62F%S&X9$X!lZ~r@8lieWt zWgtl9XK2b8$n?=$!xXY-IUR9~9Dt{2O)$r-EoYsHCypQsfH$Jwq_H{Qr_pvGaN&_R zp<{+wAn|}0Vvr+5r@YTMC%#pxV4W!{H1gSf^6UV6`t2Gwx9fV8Z{|^(S@#n&8={s#!f^bQM#8itq?|6yJkU>@=Z4RasW=59T*%#XThxO#xi~H zoBF@6_1=hhTja1GAOZFmR)!-wd!Q3an(513svfnJ-kU`W+u=KIJs4Zp+q(kZ(eUBc z;QlASkeT|QhkRLFNaB*cGxcvx4eY@)Pj+TvL!$x>LFjK{0SZYsJtt2zTC{Jt2mvKK zTu1zxhDIG8{q9N+@9cDaLEIX^DeyCGrS%Jj?HBodgcl^+ZiA=<6X77-Z9xAgqA;m6 zlIevCLBw9C&k8q5TGQxpH07vZ&uKUtI4~D?;gQT342d*vxtnGb3msD%rB$){@%RFF zxRQ4Bt*msB(R-v79RXn75HC$I?a!#gIf&=P5847 z0>ad78tHB_mb@BJUmxcj%R~}Q$o^csQ7(LraVpDX2H0-5qB)MnTPmwsPGGC~O3z%} z!g>)jx3H+9rxRYtmMy}<#@*O9f~gr15rNbr_Q1*hN|HSGZS3;`vXwHA2tB(Yq( z?}LfBQb*M21{Vyw{(If+;nX6qxJM;uaUYK7+3|J~Q5V2kvocb7U8iz6wVyPgY`inY zFU48Q+bO-i4CyY-bCrQYbhWJU6``4*#P+5pVNVPyY};>nq@&)Lh-g(Dk7Wjbfn-fk zsO{EB;*~a1rzQhHPLlwbLEX_`9W`^ZkDS_s5{Dvzy&`}jj1kzP^7wqjbfDhl&M`-m z_51e|e*f>=kq}6Uk@RJ0l+~Ua=)V8ogbbDI-Tu>hlr^Rg@*yb5^L5MnAR#pqjswFW;K+o4s6E?uflUA>eiJgTJ*FEVrS^Ry`6k19D> zi2HZk!o#}}>7odrOr$lS7slcru7PF?5I9vMYjhf5g4|76m4jf!s4$2bE_*Gy>h;j| z6qHS(|AmQN?qa}nhQt7bxw6t-Fn9wdhmHDs0sG}DVoeEvn9yFNQR17}Z zkMb}e+(Fw$YsS8(fP3T|d+%vxz~C@~p@)Ko7m{>W?bYR8Vgrwh93CBO{cGRK^nJcT zBhlD14gdZ;*fBUbm@ewZNHgL+a^dia=Fa?~3qW74gadqCO0)4qG%BphwZ|*O!5)y|-9fcc(&H%h zr!C^kL2K^$Y=?PHA6+vk@_1;TA4mq7c5S@z`w`4MAu3x2rp_GEmbTQNWS?S&keL zG@%Wcv(GoNodrj3k5PVzq2 zk?MzyLD>Ue(jm~>bq-(j5K?*<{!t0WLXzQE0=JXo?9hx=<#aZ)6R>zreb1n8`rc); z3e#|;M4&|ga=8OtFUW64kh%;-CmMtOia2L_n(~_*K6LwHlXy1~ywUxNB%r_*zC%bC z^%_9)5Ez)3Cvx=j_I`qI7`_SP*k(`QThJUkB~^VrYU8Rgsc;G^RF0^prKKNFT;10s z+KYWu!2^XJ28I}H2*54&^TnQESb`?Dn;3pWmf+ApPlp_ke1i+27EciHhSMjh_ITbp z1B3WhZek)}1A=zJ*&MU9!=unpVY2`AO)&<2254-fklwlDi7;76%L)Mbv>|YX3`>{| z^zvp5-~}2-h*>+nN7C+v1k4msfl1AU6!5M7R#PHrAa6NBM&KPmI!rOMVJQZXur9`n z&9vu-U`2D;8kP>e=SXI+#-|&6UD*Bg^!sjnuO|;18vf4gN2z?mi-wu2-s17#&XV@_ zyLd$SyYIt+oA6S{k4&y#!oFtlLWOzH9Qtp~^-DMI=Rfm>5%mBHuJ3=CeV=xGan%Dr5+4-ELy%h4E zIyB(!RJHjr-tVz}sJw{zjE9lKLK0eu+XoB6_sSm%#|+^#j*&}^4BhV#;zD)F=!|cw zT{VmJ>H0PgFTed-T3Wqtqqt#){{dfmFC1F!#}s{~OLgD|!}I4}MX_o@NI z5gX$rXFuWS9UbW#hZJtcX#2#~+qz!(f(!m(E=9o9tysvS^91VirN^rb%~xvmJt2r= zC|1C{$c{#HgFIkF7@KUgtztf}nycx&$_o7xeiXL&M;cae+L&)i8N)LYJ`w*o=>QB! zFxbEa2oY&2n_xc-JTLaSpbd0D8kgwnpc^4uD&c$=H z;GY&xkaBZuna*yJSB3hOLAHM_Jscot{x`nZ^?^586en@3Yn%POgHN86!V+cCpd*<~bJ|bwsaP#`U0a_1UhK6;?1H~M0`QptHW$_|Hse%%$J1WIK#sKEyvCIV|J{?pz<$<6-iCazOliYvErt&vXP;I zU17r65=k*Ixee-e&DUs$<2YDJR%4x!Vm~N!~(jsRt=0xJMG6@L{OQ?%U_v=pzXCoTTcl&5UDecw2t0 zQHJ~~?88P3wj{fU-9^wlRU*hqxb`3<&suPPCR+f^SvKmm00`p=M8I^^Kzesd@3nv! zU-}PL39NVKfcHw=+UMQt2H=vXgO^%i7Gpa{Ql7mHfFKa61t%?&4R!j%8_%Nc_-#4s%0*4kHohZB6Gdhr^1%R@0rXU?3~0 zgv_m(?C=EB%!*H$d6R8HvMiQX;!%?rldyb-(Y?ma=!r&Tk2P6KEsM#cPW*YhPnWLh zZ`$S^0+knE%E)%^6Cu3T24GzT=?v6Y{{FB5Is#uWHEfR+1%<2w~SDhUuTQ_b->JQxI&`TSA*qQkl}X_AeWKZ`uWhwK>Ha z(+c=Ln7YSzr}WA5tz6f<%)EiDsx>~(lP6!9p!>Z@Rs@YSlK((W7?0S{z)sC zMwMuddf}09zk91 zq*P>R+}txYiD)(c%^_bN1*$d1%7G#O>tM6bf-SGLIi!Jc-Tz{@Pg=0Z%mk;ve_cFE z;))d!2ecLN4fpF~YFc#aKn-&S5^dd~m=&=u0sQ!PTWwz93P4Y+AU+Xfw)!^p7rw?( zP~*@ldS#F$sXL205!q(;VW)I~?!E(iIPPli9(hR@yn3Nq<|eV6kT&5lw~3=~)?HeJHNW#eJ9FnBHc^mo;fS7 zbOF7>Q|&XnSyY|pI4zj}A~^9wn!O2F${)@*UtI(D*Z{)VY4Kk-H!`I1ewnVGUz^47 zwQ|Va+;7h?dawIUgX(Kse*cvxP@fp@K$866^)v_NoZE`jnW&h>jB1xXK2p==I4<$j z{j=-e;~C6t`W8~{0%3ri9dK^#o=buy8m~MZ@j%Kg60MFvez@XU0cu!kbqfK5S4YTs z28?tZ#x6xRB)Yrs(|2O*or9^m_t-G39`cDX8j_;)lx0(zb;{`w`7++?Qk;qvQQR|Y zWF$7HN!Y*Fb!Xrrne=VobhiK&sJkqwdL&Y%O#MX$t)7bQc!4YBA+Gv&{p#?El7V1DhZo!xpZT^dl#KoP^gQSH|^cH*NO1yJdfFRAyvW>(Wg?OtmLg^|>kDUMF zP+#6%;l1Mz`3s!+OvCY90Au6Jz!>D^a2rLXQ%j)3>-5&U2(jW6>3W*`s%En2n;kBX zyBSw{HheiT$OTCf-a}oHAw;A-)(!j9-eXJT@UtL|B&P2>Q++g%236Vaz19LNQZ$BY z3aisEl&_|KujC6W+a2}Q?{y}>6@;dVnCS*G8@pTleO*C|v!l{1UpaJ9n;jOEEQX$= zyw6Qv-CWc7vt1O#fGfuVoKHs%@#>_IG)bdJJFPn)%}#V@P=`J&0M@f4$r$mM<4uEJ zJ!P@fEwgMO^o)f(+npn~zj9!r z2h}x>vW01LS0%*&v-w$Ja$yHhAA9*@119A zHo?kZvt}aW!)0&1_+)3eD#>TdACyzU8mikw-ic5t7fvi#9RUX*S&Hdesl#U>)154< zboDss!z=29uDSNLCYbbcXzI6Oz>jj<3>-%tjTBWY^^O^h>uh$b&-ESS+(b?VSG<6Z z-?Xxw_8dN2`>!*>3KpqInSRD7KWuM}CDn|Jee!u+p> z_>SJL;|ql?OxKph^q_&J5$Rl*>OiTzsu4HsD%-!XfU=~OmeCZ}H_XuEOcyaG8*$vP z!GwOpbOp}03MZI-Yn3#8c&HO|Waj$dx5+Ev5~d4YxgnedH1*u)w?qI zLb80S=@fYk!2Sw8mYAfoQu&hyES3;|kLKQ5EEyq|2cHj&*>JuPm&IW0XLRAGttriD z_8i;pP2ooKPn z{|625*UtDYDY%ljW#&k=08sgIxeN^DD|NVw!;v4la6Q@E{J#W!QqdTX0$LscyUHBE7f;Dop>7?FC-BpeaX8?rA<{W zfM;TEc5RQZ{$19BlI}b-iFi`xiyJLbepUfZ#pYy}6-EQB$AWYSL?UFZQ z#9`FKO5V}xe>Pih^BVyUmA^R}r@y?#1Rf2G%SxDP=FL4@O*F;dAgZ1>@^fJj*e8bNJYhCsz(;;o9v-X7U#BdaKXN!|01iue zSy}p|@a}N^iZIOnu-h+&a`?5yq)i=Ks@p@=UUuBW z!6^(T%h**?hHIq&N==Fa)Ig!bXy{#;QStY4-O&`c=9OJ2?TL#sg;jM@AoO{+iJz}= z#4q^U74aDP_AjDBKw7z7+0$S*JNM+u~*^D`fL*wpHkk@Ki=lwWSbPAg3Y6cZ7_$bE$N(%Lu($PRjO)_7^M_OMoa&Zi zb5U_Sgsg*D=@YiXbf`VekS{d9awg%?)B;_`5@pJ*`99xw?OazLHT%Om&~?Ft1D;TZ zRbJ9k5MAYasHpWvyWBi4D#?XZBK0qsup_m-7Nv&X`J1BEU4~aF@7J-lTPlMCPHmbA zhu$`D&fS{N)AamwDqtD*Hg8eVa*}Rp#H)7N;6=_e^T%Q1<=0o29K7z&q}bgp*<0O_ zzgQI2yjoUNVT${t!;aqJz);?(tcO#vP7t8j|?m3T!x1F|U@D+PBv0L2>hn$UfK%Jsceh>iY#$ zM6mlElJ4`Hf)L*$MFy%$2zCvFI)gb z>1kqVGkWTzq7+I(Rl`22i_2|OpVbw-pu~yRsiSph8P)=E@zgTyr)hu|joxRt@TUgj z=)ls*Z1Ur!B?E`zbjyIje33PhG`p;JcK>SuR$3cPB%L{@0(|=n%pnB!NG_+e!FD7{pk+iQ&X6E&q6(vA{xpI<;Xn zynO(-?GDX2m?5m{DUmdq%?=H)q-cL+3ZRAH=aFu`=}*sqcDgxouQXOxPLZN=@^X$1 z#d|6LW(#Li_5WLrbA++_uiKs) zEunz+`85XS2(#0ETKuy^ApiJk9s3^xhPZuh(yOF;G*&Hev;v`P|O5KM;?+?ibteiKth`#w_4oLZL zuauK5g)rJQT*T71tlWLB+y6T8-zQI171`Z`F6P^B|+sICwN&Dx0h zj5!%%#xGMl>t|`%3HoH%pC&+U+lPI(LEzw%m=k|~d`(GMhw@^dQszrAc;bzO+?H|2%VmmOn`#(j=j9nF%WgE)R@eRqlgN{$2;Xe?9;_>#H&0eN9G3urQ~;w~qQ7aD z(U5K_W*<_9mXrEzRf7Bf?<~ZOBR(;}bJ2Q=JQyE5yomRv`C}4q1U;E%`?0l+4Gp;` z{#d`jHm~^ahTHDXQ7W+^S2w4znW^0Xt@mfbMeJusbt)N^eOPvT-I@g%i9+Uhf;d>L zvTXe~910K&q=mjz?WdKrO-sx$OFWs%CZI6~1sx2}x=l_wFk_EzwV7Ctp57@#L(A;L zE7$Y8WeTHI^ccJ?oZ&T}+%j`^gZgB6mE@tGbxbpsWQQ(i@~ZnuCvz``vyq&#h6fy5 zZcFciKhAY4$_*npmK2t&BIcLuRTYa8yYalu?Kb_}q{~%{HPoidH6KrhpcYXIZR4V? zzIJcDYb}@##^zHNsKHw}?mignr;|N6pi4<3kPI(0A6G7J?){A}ufEfjgA)Tena6F- z!;D*3*VJw02B z(eLHNIK(Bo`%>zs!;Oq*wuqOkp3ze=;LVCV-Ho@zhibT)eqjPGi=J;AIO$AR4;LQe zvFL-_92Jz><>OMA5~t2zdh|MSi(Z{h@Va(U@}q1#<~g^`I6Xj3hIV@Fg1&c#7|rr= zj6Al885I{_a^0!YCl|)V>f1>5VTT^s^_4U%n1A0|c%Pyvoodr2$!%DuqrHp5?h2~$ zbZqhFgyhukSG?h}2j@J03xB6R&0R>W0N`Gufzwzm=Z1oZ3w}o5+WKWlv~M?4lWEXf z<2LSBT(&H;aQP1B*krseVCKS!!n~s zuFjYOj6xzbbnkM79;R!?FQs?7We#HEp+??>%4x5U0h@A51!6)ayD>%f9yPJ+Q(n0Kc4+W#jDcX09Y# z$qeq9FC=p{B@g9MW}O87};MVb$oSKh0y!hLmDx;intT z?Lbnlb&#-_ra!yJ-umX0MpKd#*#c%~^uoiYFVmgMNz4zjxe^HDvcaO5j5MQzM^>-> z{W*Z>3g8<~oOzxer`YjF%5~Y|5}^}06YM{y?-`T)l!>5`KB*j z4??RoU4*mS%;j=-sH)AIv_(m^QZgS~Jc9iER#{of(-p=mvltD>NM;W3VSZVLhL~Aj zD-|s>Wk6E(5Ck_-I%g7Qh`qkg&tUSGds^Z2T@-{Cunmj+6&ujnG#!FZ66ks7ba<@w&wzzD2yIt3L#b5e$Q$5 z=Tk6{GctO!j-aa!K9g%dOArds0=pr3k+SG!6qE&WGMw4eqZgJn*d69UQKdjBi;n?X3XYvH_P3qi)^`(Gu-FAf~+Cwgo z^;Ur7Zc?p(e+uF84+nPcF&xa9=b=02&bYU5ULLry#|QiOfUssewRvs%#^gk2y=tb0 z80I02nRx$bV(MY9%gwU$@*2MlplRU#`N_+~&tkfwjZcr~ay&c+$Sc2K$sKqoS-&Az z13XiN9hkL{^HC|B4Ujf19$b#Qd|jgbja`5f3??V|+mCR;Sc1M`Tt^I}q+%);`(HO> zEy(djk!UZ*hUL={_5tN$IDzPccUefe5iV^;D_p-J^P)0(XLGPe+?u^#5nY_)93$60 zktjZ~)W$gKn$`Ah$_xrF=-QqHuAPgq&odyPJ{CK~<9T5LlJ>XoY0|sVxXUZS*`|J+ zCZ2jJ5wp8xzFNU7RGI}4c-k^8JczvL@r0$iZbHVY{wmIp|9A_9TH^cZ0c_Vh zWEjaf>cJf{kV&;RM}u$R2cB(YCHAB%^G)RSo=>4NsQZ7|?=H?fO=Ej1?@C2z zTL!L3Z+r2)XdukkF*xL?oK=g4>KopqDTUAYzIyRAF(yq3q00bE#vq8w&dpuYe9Yhf z59D0a3a85@&AbVn8M0=9eJyd~;$M7(ogM1*vz(mzrpAWG#zv8f3lFV3@DoU=hVqAU z@`rYf4R+>_cIKb-@_U+-qu&+D`zz_=d0XQ&3CqXJXPLd?9?_zFGOEuwV?KGnACE%I z!1*?!G`ulG%*=(Cg>X-!fqU-W6>2yYU=0OkI~zhlH9F(-67@q%)KAlH2+l`f=xd{8 zfz8Ch5rQHuL6#b6mOw}A;F6Q@2@~?l8Ep6A?QXYGo^%n_KOcBPa&}ve<5tx8(#pcxtb$IY@-TfM! zM1~j%&0u}>+8cv&7hVEre%<^!p&2t)jx=Qeh=$FQuM(j3@9|?pho6mfAO3duF!pJ; zO{b9vXi-YM3cZNJrfyaENSd+{4@15m9`A z_a7$$1B`>fq(rM|`xSx4 zx@CfJG0v8wGSq4#9>gdXKZ;qD^d+jxZSxO<4+^s>A6~lioX6M^(0c8})8^>a)0$;O z4Pb8kJ%=q1JbnL)2&~BnZ~`HMWjg+1gP5Yi3Yf_2m1^yKb}jjX9)o>EYutfSAdp|L zt!`#wtf>(_h1we|_EL$G2MoY=BEyXUKy~3Kq}sDgBIBhr#^TUq~fKDZw~lrrv{tto!(0pQISdePgw*-GMpmKWnI- zs_J`8Od_z9xX4AN93-Z_;74jvwe#RueNdLiAL|YpGX!jXc-TuFNgDfN4F5DYNpHR8 z=jYe=s~dKAm;dmQ4{12s{|zh}T@|rl35pw@8ZIr@n;vO6F17hwKlYXErhhpHt(}`7 z5&@IR>w7+H9mv0>g+xN@8u*J+VUSiUN(ZfxSk!q^pf^dH>8AcOi|5~reWagy6kkU@0VG*7Dx zjVHo;RlxV>Anqtmtt2Dy_uk9aS79>2bPZ`HSN?C;3y!{WD=zQ7FC?waav4VL+1!b2 z$NfvpB%&5m+bE7nu`E^$Pyab;SG9OjeCQ@cng#}=0uS1$*8&$&V`JG=zA)==hUL$^ zCrhUnEGGd(dm`teuH5s*?kzAd2geIMj^9FN+onCkDZ?|lOqb32@PLn-^x?Aop6}%7 z;FPnEq?GAiIMW?!{{?GfvLg%&eH*S)PCb>dUxf;as*HUpC%otq-GiXT1#J_)76f;A&;bpalx{Fx?`M z`SmR+IfZiz3R9)AhoEh@HQv#FWVK+se*6}jTC!FtK#s&;s=+W1r0L@ zkE zmJ~h9e)mz7D#b8fzk{s9d(IZQ2rRZjnw^2qXAsd`UG#OiOa{(-x)(xY$FTyN^WesJ zu_;w~_NMwai(9TdOP|ZeEaNZOKd+Wa^;Gs+M7h;KMoyNGb5j=Q6C2G^ag1JNC!`9d zj8D^IIx~P~+pSxaWcESJ<8X@eVmbWgbF-~q^oKi@r+{pP2kx3IM|HFMB>UHxfQtO` z2W;yxN#=i_l7HmSM?A@tVzHbN3He4>a2fK~H>3q2XpSAWsz&eIk6?VO|AtdXMK%Pj zZiQ*WFwr>|O=}$EH4XA|3fr+;92!}n?q(Vc3v{zrN_wy}(x%@o>2N zGx{`dY{V#ku&lD#kkMoY;&fH}6GLbpR4s%{zt(e$rEUuDb)M0jI-emY`L{c!N<;s(FT^1z=e*W zc7KjNU*7S8i0QWd5%SR+Xr5uhVCWNlK*FSDDxNvamLlnShYnd5REV(hf82y$c9D~W zA7W}fknSIHzXmrs|BZ8AH!D zOX>HhgA#z@y3sfDM(kj0WdtY*s%PDo3B$eJlA*=ORVp#?92;Az|KE!1SjPtpCG~q! z5gegOq@_+4uJyJ)C&K+5`<^ydPfWAEd#ot$J6+U(CQrxY@ye`YVhkz3Y88SKAy`92U-{kb?OE{u@m#Kgr36%cP_@nN4?fEA z1NQ6LJ9l^t-pn+dhFD>|q703rk%13mfW{3BjTq(io-JzDVF-y)VUWK+?)fk8;N7vS zE2~J)BsFvYMVAyyw-mt8z)7X>93Q?-Zn^WAbNNZ?^6qmJx##8@KZcJB4>w@e1kf%w zVe?-r(jj*8+6sUq@*h6(?MJKmub{z~hEup%wPY=qATQcH8DZ5N>$GZdghSEz50gy) z3oa*e$gyCt%Tybk_p_>WCHCcupQ&lY4Xe2Ws zbGG@-yOA5&R~L*eR2`O$)sUKBd}wz}$H(l1jz<5KWvwfUFFb18QtD-PFzEA%>wQD; z0b3?83jBEwn6>8^qz1FpslJnN>_dOzg*r|qhL!xlr7F>m8nTx&HI75D-fODJxdhrV zwxB9lTaG7UdS56;5R9_ax8Wo1arIwg*Tz9ZK7=TdLXi-@tKM5&mh{aK;PTmod7kjc z@ZO;ReF_Yx1J3~@H8R=`lMBy*(o$@DQCg)}WxT1xaYY-@%IYxLMWR@x2&x8mQhd`g z#H8_!b6VE-SIfhw44|~7h1ccyS)M883ou_2=7V#tw3$ds{{T>hl`!v9Sk%VyLdu%=q4&uY{&dD{dCp*6s zXX4bQmX?ak&y(dYMQsK%+g}MWHU)K}<4s~5XM+*n-Af*b-^#)tdFsmCMl?$ZNo!042Xl z&HqL*PuhiGMF7FQ%j8yuK~~JuAGa zi@(k67Iw?h=XBshhmte`;KM-W=p+hoA%w!ypl@yK@EH2pS;pVX&pbozLlfl|k58$J zM2Z|f;hvz&O>w(6W`rXRE80xMAYhCo=9%&BEcF9meAP(hDtK#-G1|Vw*b$!-zoDv> z-LqQ8Nv15Jz+=rZ!YFr}V6tcrq|}U4`%<(^_wc_Z^Weh#*4kVXG_vlBMZv@>{cSIuD2IX?Cagu?ksNO!;|bn(#6CU_0&^p?R|<=`XvDnS;OV_a zF-aWxx$8g6?o!1*<7*fv@7lF(J!{KMI#sjGkzcfVTTa=-Lq1d_Cm9!jt;9F#W+{kg zR?$^;fvcXGdHDSO0iJVXO$wuztCnkrIC0>C90WJ5Bh4QafeFw5d-VINkxfE9U1%}w zpGY}dUX^wI74E`q9RAhFLxH}UZG|UHF%EVv=zH3MqiD>YyU|fqcVYyn zE+4yqL1IALQuPdj;vs#LQ$n3wCp?&;IA1zdY*Mj;6%h%*_lpf?qS`tYI_#C z>NP$fI3T!a^AT`cDJ+ygYPi5&k8%3F>az2H$~^>^_StI7IjX|gD_HrIW-a1_y{Z!) z3C{5(N4AQ5UxpUNng-_O!#Oj2HtoZkzL-c@3n^4;B;U||zvh?grKc@VUFBYtDkzL1 zF60#5oG*Qx`R`GAYT7n%pr{hZmk^Y7Pm8W#)ILF^h&Teyp3&lN`$QsC3{d;n;j#j{B#W=#G zN%Z;@p3RiZZ%9KHVC%+FhMK@VTI|Mi@$$hFb*VE8E^4?p>{U8WIe3bk6C_H+Nf*er z!Sbt#_fGeL?#bPsGDqGB`;hNdI69?2(B3N33v8Zjce9In<>Q1JapnUZKt~#gR!Oc z1^m>{Wo2c!);Y8VEoA$TJgICgVe!Eg7=$r9W$!Wt587^7BlW}gru3gp7#Rj4 z<@{C`btU=(omXTF+tCV>ZFb@isGOJYh;3XB+rT%Vby*}{3q zVkxyet6qGxHSU46OVMUdV_tyEENQb^tS34AX9fgrg($9sW3A1{dVvU^Kj9@o)>?xc zjS0o;q7pIQJ?K-xy$Tux9(7pZy7NmjHdG?3i`)!ZCC6rahdm!ksM6~&5f+{vO!EY% z;vVhAMoVuBUVs(Ws6A0f3)9VLc=SE73u8il7Ea0I$4eJor%0P^I&zRQcs0Bq86F;f zl~UU2UAk$Rpy0f)oud)X%;Xg>oQ9Xt%bQ~qYcVGT9Y}79O*F=Oi{5X;KSn^dGsvq$ zOlxPd-l(s9rZzD`53@aYs{9Tf{M)Ryd!Tw#0>5SRDN#dSfd4FM3|d0nxZ%89#l7X) z31ICuR_MuT78!#_ss<{|Ua!-H8>2wGxrwAfG(+zb{qrO8iTOXm6fAD|Ux$#BM{V6yolAhJb8~ zkyEqWOIoWGBeRGPtG{qv?j^dOH^u(M`IB!NI=4&^B!blm^!6e+C)dzW#o#u*j(rjM zVxgeL`vpxr9AIAISH)w9#2cB-PgRBZlDcM;mrO%gZf41vJU#Wqj6rb;)iZ44d?5bx zxO#xh+{k%kXNB+d zNU>4g!H%jFP+G-9@35_m<93}rzr=*~sdd)2_1qNg+mA9Gt>i%>GY5>`IsGMv5b)59e!E&!`gnWf(^R}AKC>CJnConBN3>v(Mwj=tPTqe9Vz;CKF*c}Dr02ttK zF98?;dAjfwymUYaAS*48AWfjB4W9aPdcIJ^FP=tNCOJ5M01}j#zzGa_#&kNa0Ef`> zf0b5T!T=R4+Ww2p)VFUZ!yT>2mgc(#8t2q&0}CPSyC^&kOLxN!00oU_FiL}qwcaWK zE}_Z2fS~La1x^xVZ*XV{gzN91$G>@c-`&n}f<$}T23H!H zbp{+V|8Z|iIdMBWk{uoz5)$hh-~ISd_y5FcEPYv)zsh99_s*EiU27&$5Jk*3h?|k> zIQ~kXv0&ZF>6n@VnvXdxRK^qdimK&uYrQ5$%ttVzBrk_2dhJlcg3}+1zOcS>tXmDh zuBosfgr%@|{F{qdkx@#NralYrmLGc8a{W^SZ6aab)mL-YVwS;*fTSq11y65qW~-K{ zvXqUyW(Ak_!TxxLg|PXB6gF>I@JHJdHUq($S$1X)HIW$02&tddeS!JsHuy{&9~xrP zNYiEoB}_sop1IY<%~^@AeOD->S}68(O6fo9^RvQS*S7n>xIJU;IT^?bm#5#J&kt_B ziEK%b{lRx69|O}R|MhIQc!^%j06SZZZBGZn0pLEGl(GOE(kNvV7-VVC@#eFJTH5Q9 zrB#?5f=0ysdW1@YL3lw`36N4#?`n~$p9*uS0N@zeMiCVejonjtWjg=&S0J<8lMkp*Gq*t zTFsJG1>41y4~MSkA8@gnMRPE;IW~^`TPGD^dBRJ?FoU!K1{0~2Xp1YEL*kE55g(IayB zOd8N8?%Oz5FJS(_M4yKFCnNwkYnxMHF5#0Y&xBHYwM_|?l*^Ju%oKnm5Grp08n*;|g)!xg(v}FPaG=l7+M9Ac60~|!=9OmbT$P*s=+QD2&~)~@MNh~2;2|F&vDzSw zWSvq^pd~?*pNxEOyI2ct0*vk=uU2pC`eu*Lp8%N8BY}Z)>C>%U=)LeU#o0yUwQ%CR z5xBf5G-LIs{CQ_BvRdFoIa%sx*Rw{q*T{mL&Q^>=oK?zvsiWAAyONj?dJ5BD?u=Gv zfv~(i*f?wl^I66Bn~tW6>v6sMOvJbsc`TS^fVA>WB$^JtR(iM)hzgJ=$7V2TMY3FY zHKwgqOh6{Jn%U40K8bsY&5nvw{K!`@b1meUx{yS zBDb#M@_2hkPalGLovsGw0NCqoacKY@C@v23P{cxP?3dkW8&c6nL1UwEn@z#SCx&u2 z8KI+4n&F_a!UUO$-s^^xwWf8a+)@5!-LGn?O1h>*tq3v4kfdQOhE-d*SP^IbGd`EW zEL#oEN-n8$z|c;{GQx?RYvvwS(IbHgzyS<7KRJKiGY$19f4x2{#?cuywuFGWauY*9 zb_rEFV5TZclANuR*0QIs zB}Vk)$AzdOoViJ{Ncs;vu;IcI19HHQ2{aB$u$0WrSn0xjwsAZP`$`m?gMr0GLh%~! zeP4n!@g?nP1!E7Ix8CLtLL*MLQ9>vq!-~I4KanKh(YB?}Tl=-R$68%)hWf+$V!N}t^)zRD`L+Z4t;MO87zg6B9u7> z+SHmJUJ4#N;=2(NV;3k2$AvwAQ>wK~Q2%ydJP~?>%%4uy9bP}!Xg6xb-+%FjvtLi? z0LFiQfAJq6$gkm{4`XX7x%KS+_Ab$^=e@9Y04=pUpr>&h58BtLy9!W{`IW0Hiehh9 z)un9j3dG=WLt|cl`|Y$k{$!Jr5N)>I0R~;f-Tmy9CP6pzv;8~vz>01>04HN9S5%@y zLu&CB0NHdiM}7y=p*2fUtfr`mUhq7%VYGx@w2Fi)#InYnam$Ip$v&)N>VsiCOQvI% z_>9gp;hIM469=uLeRn~QG%)2~oB>~VQ^$Au)-G3&6Un8|kP=KUIk*KSV(y9u?{mve zGmFljz^E58>gji%PAZIom*#oTsT7S+jWGk&wp$&_H&+x^K8x!w&!vWZmz~-f?YQeB z=Pg}b9S8!k>k4=9tPaQz;Vi|^7{el zUUS-AOFT~KW}(a_OY|DDaf-Fvt3=eAMT@k&b9lh|Jr)a)W?(WJ4DVf@XsLI}n@kc~ zLXRVb17gKaQqSD0edurVMbVT%S^F#J3yZBm$0rRz43+`@>+6f5LL!t*EfcTks40B- zq1z7B)&uazB1;wOM(Ej{s@di!;&K{VPU8xJ zypMGnfu|3&H@sFKBURQhwyEVF{`v*msdFgJM4IZn8x;)kJ9s^X?rY!$oze?Z@q=q_Lt8~rx(OiFmOvQj> zKXL$}@Xj^-Ew$MK_1UBxBYba_+oHR;Yw=hEOb&ZHTg~g4e)@y}c9SXg0GZ=?KEq7p?>xNF_K%rGlcnjyEAw)u99rQ8cJ`1DaG zjs(uTd($Pw(MjJ&_me$e7W64CMzmwe23DWE2_M}pFKR(AhZ3J6IJ!A{Nd2KrQr2&< zgfJCMF4L3Sw!(dYSz)ipn=o>#!d0)%?WQI%18*NrAhE+gt^b`_7_86`RQ)yM2SN$uoypd^F zAWlj5t2i<9kya_1Cke*Bhx$KjmV~Z@^b5Z7efRtiV?S;nG-qdfbyPw50xB-;%qK(i znKPAx3rRZ7TzBWl$F9BAE!Q*uuyt`$d5%@gS^`9RM6h6X@AHPfPi)}d`+Lu`a!LF7 zs43!@#`9NjBPoZOIL0rOU0NAna_N4 zUP4u48}=0`4tqYD0iMfC!aaquV3N#Twq5U1I_tP8;LaT~$;J-U|I7lQN$eJk7>QY$ zK3spJ_wx_=T;$AVE8d!6f}9VYbgteusK;;aby`H8TvF$=Ng(WDboSl z`4v-novW2P!P1*1MxbghYlZ}2AdX%HKrBL zAZ=hwvH(-HSds&xu%(J*SXPP@YmpZHZx8Uy8pT z`Wwr>Ik7Xm=m-D3fdcsH#D|59r zu${#RJqJP|!~@)v_^*gUf)0Ur1NA4qUdX8^+3??=UdCZc|HX!*@iKpfBslSj{G94{CH)76zz2YykvUkVVQq0?nCcg ztdL?8*7T{}NZQ!M|33(`cbs;Uf@hKLP(W^O=7X7w(Y7K&{QOS0s&o8rWDhV128 zVsTDr1f-5@F1}1WDR~S6RHB&EdfaCPx4(*-ihIP-3iItvxaOB^KT!eE@ zKGwr^EavGG4*dNyXeOr)s)SrY7rUnA&@jCvSkhUzU^6!@~tH7t4& zJ{hibgy(T)1kcw+R#~Ni_W6`djzf#$OEm|+d5XZ`-j%oDXC=r(2CBS&nY3rj z@77s`jMu?&iK~XMjWvVfLWnNdM3OVH)Yx+!SvKZk0Sqe5;7G{LH*=UD_QdH71>111 zXPrv_#o$iwqi`z0dEuC?nLmNj{GsA0WU#@dJXC-FQgqSLxADfl-+%O~QL(#kHY8#3 z1};(+Ef`s!fueya!gN_XS;GfSYCMLXp|6UF>bHYo(M**AT%4AgEknG}Hi<+m>2fFf& z5jhojPfvXv>DM8h6vFCJNYKIG)+KyqQkg zGMX8R71WJS{me>>!o%DQ5hZGh{2l{lSA* zqL}w$4^%ysQpoi+2mz~_{JyQ${dc`Y<3ZB z+J6(pZ@DC2xWp-xHczl1WTa0J+8(H-r{n@F!oD>!O!P99_cjvM%p((Qzo7AkD}@037OJ(P5jmKc(^C^ ztw&`s*i57ZHdSB2I-G_zm{aJA6w8}(EjMsES1ajnxG=ehBV2x2Js~pr6;uTmE{cj+ zAz*0!lcUh!eMdKc_#o7hrheC|fE_KIj<=3x)fY@FO8Vw5iac!QcwtJ+p8#-1u?x5f8 zy=7$M{R!8NU zgJl#Rt@=)679;>x)d5f7EMZTG<&q|=6&>33S-7szmPIees$XADavid#SLeQVQ4jS+ zN_gJGrg>AiL@2KBbfFw@k+7mYKL@N~BW>t)=-zIADgFZu%ekw8Y_3&AzO~|xB7fT{ zj3s&U6t|Dc^)d5H-=@UPhggg&LENK;Uz-z|J1!^8aT!1w0 zkt7lJ5zH3f3k5Emw4BYMfZ*rbbEw2^U3s;xS)cf`q}Psno^kJtA8!brU~dA{y4+&& zwifE^E|-xOqx|0aLEq;Wx$lhrf|hS-#<1>K-&pYfX&L7YB#ahiXoX|K$FHZ$pWb_Y z#Q+)M9~(#;bJxU@+f8RC?RI8h|025p+~7fj&HiJ*&W-&Voj)%Kk6FUbzhF*NN-MaX zKVn0~$!DE0d87Slc4d>73-z-7?^>HJPGnBXxBT`Z4$}sG#*(BXq=cG3Z2Y0*UP9A| zbvyHq6%xo(){z=ce3DKzGimm`3?)j`emGWK6e1#jb8ESFBJD)`x%{ z^H%@bmWhHpLPZSbn){xY*Q@@oWe&aMA8#t-o5|0fNr`! z<)2w}?I@8Y=a4m=3NgG;sz|)aa7kcwJaP@VUIgn%O)^$%%OA--06A)`_4z7{N4M+K z7kzQZv}G^+Lad_KDcUpNXr7-#P0DBNSqGBudWdu+@)taNR*Ogk$L%sL#%o7Iw8J)s zOhX0n&AS!#>ickJt1oPdR*Fjly#i*?*TQJW7NffFM*#Ogl>XqDGHD@TH9nCX78IAk96?j01<4zGKon2EeSmac z1O8ksRQq(Nd8We<=>E3VBvn9NYaAz^5b)EgJ0rlSFFBc6tFtu3`QlOxn3$aC)OV9i zKU-J?giU|@yWS%}MC?m(#EOeGo4Vh?!$A+KxE|^O#r4Br)q@Xy9Vv#eHypmp6ar)0 zM->G1E^#Rxb^bAI{qxl)5*se1EUCbReeEPw2@zLWU~%c6 zPOpfQR|a&6}jt!q{vk$mD_fV@)R%$VxID|LS7uYp%`xlq*NKZR0toKMKP>!$5U441#X_ z0rPg=yX@2(mD$U5PIso()kNOkHh3m*3dNlZx{>`%?ooBum?;I`Y+@W$Y0&TJJNVs^ zJ@oTIer|$I_lU<*jIU!L@~@!LVL)YqAD_<#A_VL2*{MX@M#b&6>gbU%lDH553hTts zCxBB}ZwPIo2vPu&0$(n|2pg*rKVUU|j~JZGjNS|SS&lJf8;lnJs;w+%?Ad=0`%glr z#Xb3ws6#QfPUuW{h0LgOgI_VUo|wyxIm~+QepT6hdu=SI%%*BuunX}AU4V|F2q``n zPK~58yKkYWPbe3mlxj)PWc>3l#!I!G|6+1|OqGncd_2@Bdz%H&SZc6jm%aFb_0Y9zi*fHkUDNl$SmW$h}P3YHk1r3(38X=BAUydl# zFH=$*^p&U=)N5;hY=^gu$eXaK^s>{`5gOLH;+HXu$?O!9L33!qd7IZ5WIu$aOyJLN zwZ`2^&VHZDp5vLg)cR;(bY9?a>-eHYYR5p{KrY#Rc~Cz`Aq^~Cjvr-mTp4%(3@u0t za|ags?x@bZoz_to@+rgY$?F;l1VQu_@P2P4ySBHglKrtJ4e_6tJ)J67;LUrqRyYw~ zf|+%-b@Z2qcVaVaT>2hQ-27z<-k=+PjDL(&fuwXj^P)WKY$nJ1az(CQky-oJ#8R=OYL9L8b|0UPY>D3MAgtvi z|5lZy%HI>)(Vv2I*Cy!L?VCq{|!UiQ{^ZJrgB ziE@FVGo`|iz$7}B1=g}R#EL`p%!KB-18AWCDWh7$k+}P(?B$)9VlM`TaV`6E%q-^K z7wI~xymuKY-Ep>=RaikYvFvUz3=S0~HaS{JL4NSSzuZugd3Urkf8;?(rK}0nkv-Zn5Jal+#yJY;xCD7EkE>h9-^OFt z1UuO1?Ye;EuT`)7UScw66O!C|UR^<<#lH?Non2jB&rY|}cMn0c$p3vifBz7s-JgH@ zI~Nl!encfipV+oq{CJ=V<{N6Vmpfc-s~dAVlg&N@I)f_(L-t9<&KD`imh4oapPj3z zKv~)8*uC^z`K-l18gEY`CW;0YBBd0Vy>8yhR3oOI`A8{u)E`i60QrqGy!IbtrAJcLmi=K&uJ?EWf!>p^lnu%*mKiFq8URVZVYqC5sjSVKG^_l{a@O)nxTu z{FuVTXbFv)D3|qUvEgEXb3p!@Lb)D>YYct}=i{0M!`cWVBo6BA!;UNE@coH5ufLIu z?um?9<-$Zw*U!fSr%2Z`duP{EM~kN%x04wEyHAcymNrb++8TjGQ0{d78DMM@-L&!{2qV)S9jSZxx(vB`> z<4C^wWMl|&Eo@QWEk&AdXMoD=?{OSr1|%lhw9bIFXw>kSt+u zqx>2f5V|2`dsEJ2W~PqtYsO!luUZ~8%!B*Nc&yD#K<SwI1%^f(19LM4VxUa4w#0^=Zg$1Gz^8tZ$-&Cu6SK9z47$8mX>AV zjFqNquNGS1WnK_}&Q5*qxJ(5Opcfp#!yZp0bA7nfkrq-XW2Eh7vZGbFCq3ZD9SyyYTC|I{0LY%PZQOCA=OC@OnV;C;HMbSC-2Gd+?y zGFvEe)|ZycQm@%n-49-qkB_O4-=y_(Xk;X$dhDa!@aYF10$RaBYHUP0yXx18F-bz> z9Mz%Ymk*2b2Xe+@JD2@xyOEHpYsY)%f9}Jt*0JG)pdV!lm;+2*RPEJiOF!0ysmRCu zUH*9VK8$@G8-0UrUvJ-k@zyT)Yi|C|aADqvLf#MpZa|;Syv7`#ayg*}wguxYQZf_o zogLy0}Xpz@kAE9vU4Q>S=b0&9AGnSEhid#Z@L< zps3U0i%;;`=^O-o>^I3yEmxEz2{oyz93)=&`uO`Vva0BP>oys2%)@$UeU;UROY){d z4UPns<%z-!B)N!Q$ojNKQM!JrdaZO%M}BVu7SQs4r;TNjH|}bFGdVRoXbk<)f%sKH zqaUA5t~WudTtJS|zTr!<^$&4h{{pf;yU6#keYMTNBQ~0~LPkv%3*iX^j1Ux)K01%EBHr z>jxTd@3)F>oLrFomK1+Lq~b6^irybq;ED_1ag6{zc6Y2tpAr z1i15N>b$`4mvLWk;>2N;$*A2-1lZZ{&Y^niW;@sRR9uWlcJO|tML#5h`2_usGLr^sLS;k~nVMDngmN?rU)Ae6--PPA;nNu%qS_@!V# zlCM>Yg|TpB-T1gXmU6C6C^*4XK%zB7+(B`I{jC0|AhF+c-pFqN zjL1iMzlw@@yO}qu4ujFVW8A2@%z*DD^Migm1sPgYlJ(rNwxCfvzi!MzZQ+V8F!g9S zYbtx1D1oH3FblUg=2c@JA2a5x@!f(9C70GT`L~=2kNZTF{L)ZB@}c%zf@hQzgch^< z7!tAgq)iZ8wOsdJE<7Eo+BTUxR}Y_+1|@&Qc2+)ix9T6`j-<5ZjLi{)C2l68c9vgE zF_hkLE;bd03~PFdBL& zzLof~^WK%C@=Uh=ossG?CAYdbE7885u;x3HoHJ~Bb)J$7d=Pg|OAv14E~+P3RkI{k z9+6{j&*m?VR^g@DnmJfj_Q#g*-#p~M-zR|E)ff&~L)j6vvkS{!wsa@TgZB&=`Z?TOPU9J?x>B zlqVw5dfJ{l`D^Y(``8zu`_5MyyctGicrY0AlE-7QIfm2*-$R|WYDu))3zVkp*c;-f zF-RE$`rEzZTa$%s)UlMk?RIY70=mGW-qH89lIz~|Fbg&h&_FP{c=YqjGVx#ilet-H zPdte~Ga26tuu6W(=M6F#WKZ3u9U*nRBGBies&(60BVFP*-Q#~}0qj{ikYN0HvZ)K@ z=!MnP>lnY6~qmNMtisXYY7sYHKV01XM(p;Jp>{J>B^!Ce~DHpLpYaNyHaH%5R`rpl=uuq zC)n`i=I4#x82gbBIJ7l*OAKb|q5kaBt1`ga2-p-i=f+Rs|M z^A{sn?0PU*cl`fxyKu~+2XmtvDDT>?*-aKapgdPSS49TAidoGK~xK&(R=B z9If(ykem9>y7bohZ%>dv75&DYA`>p7YG@chlcH!$S}m4574IH%?fwZBFFz<39_1p9 zT1BSvYyk&N7@~AhOKZ?TaZT}6tJQE`!SL%gGQu*lgYt<)8P^xguw(Gu9vG^cjplw* zQM2l!pZ~;cS?_2mU&OfNn$gvG(#nNS_xLd;48P-VwwPyilr*#j?YO(i~2dusj%<_v!173 zVtAD|gUp`z27=1j+lBqf4XA-Z&jpLV0+4%!qS(E9}2&G|n&@_(0Mt_=D~{-Z}$ zeiKbH(C>X;^M01{G-mIN3zw4Ge*cCg4>#cE!YNs572e$q-n=g+`m9}YsJjN>ltub1 zO@$elAVBhDo>AkU4{{WFr&#jCCP6K7-`N=VF>u5vou0CP_u&`T+{- zYiUC2QzJw|%iVjytmkVW6DwTH<4S;6Q5TI`O}6RCW4t8#v3n3m4OI~#C@==V8xk5f zEgJ7}2uo^!4eGc}9<8B~l`NmNs2~KPO|QMS9e3j{;e4l5S^wa+A036$uLgt_s6Se$ zX&JCV$pbA=w)6RqCrNfc@`ec2Nm8{@4n!hRHozrAD<_piZTmV^YXGp5d^Uf1C9BzJ^B z*8|i>(L>d+gvp;`YKtdKlw;CfOCacq@Z_ehRt%X%J+o4CKCbK{m`IZM;-J%RltbMg z;%Z6;-_@+86p6O_hgWSPAf8PR##%lM$HvYqS9|g`OY)S=a?VB)=U}f4e@gz3M(!Rp zl(%#NWbTsC0$rH`Oo4Or{QCFXZU?wM%z?jaiZJij$3Y~&XRGSo<#wP|Zfk3cBzZE- z0)htTjeQEb)H)dFlYg+g@vmwTlggrc7_1wvm1x-db$8U=o@9b=E^}a)-QPGZCZA(q zzTN3fC7Z>%Q(xRs)c^eu`3fX483o}@V0IOCT+Na1hEyUn*J50+@j_&JTP_kqq>AG? zmaf_~;HLL!>tFC>lgz{8428HqZf9rrpejkzEp22g@3oRNH|tNybeV#+SE`FslPT9}zQy}eCXl>?e!c`(M#Pz? z!T3;7SEImH5U8&Pl4MyXEK-Kr8~+m89qqk?R!x?(c`_2APA^;3Bu!I{On*EM8t1LAP&0 z!vzBwSN&|{*?2J~`qEV5Vh4UsXeh2RA8h$kC9}{r+1VrE^c`KwIrJQ7D5aB@8YO~C z$+()y*Ox|cr7ax~t_a3aPhF`Ou)A@KAAblG^83%R`hI%kq;||39vuq@hsz}>CKSJP zN0E8iBePd|8wIBNSp^&S(IkHZLs83R}YX~5>y8{2|=TS z`C|&JhDpI|lmJz?t#am#dN13AG}HS0(cB=irGQ105N4UG(h1+_Wsrh3!j2UOgGP?a zdc^hCLj8mEWB5j59d_14v$qbbJPZSO$FH0Bk6n|rJd%xnd)CFc`b1%*rzGn$^`WqFVlQJLry^PS%%{;@lMH)dWOHyL$ zv8-dX`A9y_Y%X4|d99;Z}13X`~Stc%>_>G2!{>EcCxRt0VOd_6czkl~E zS_eXUAqM4Ae-eT&`pU@d>pT3~bGN5ZjPyUlCUcqRp6_+(te+RSFK0l$fUNx@xmluB z`u%I+2^2*)lIt`SDQB>aK0Nq=Az%_#(UCM+&hpuES|<2*JJ@W= zElE&SY^O<~$5uc)(J7_&L5=ox&~$C*wmHhO1yCX3Au$^S z=@LE8o^IV)rx6Ywn0pNP+z;N+RG|Bo45k_b}_!|MPh~q#8&=ET~n48uy_7Je+kehu*aI@8+q8{Rq~eVrM1e zf`qm}E`D4_DeGJ?Z&7Iw^$x9F#hJ)(&-|&Bl9}vvtx>(U*a|^+yrslEIQ7*FG^5eh zIZoqzlny)l__dTT>$hGDLcEoy16-T9C5U^7#ta%{&n;vh7MT)CR=@2+nD#-qcQ5Z4m1*G}}NXYwJCNW}A0`GSn~L zj1n<)8PaC#{kX2X6m19W$;1(8GX_suK+r@C-5c@NKW(9$3NAJcull29g!Ka`)x(#- zqWc65_yo-?c%EP!HT?}Wi>B%;tqRU00-_2^%qCDe7e`JhhzLnO?vRsh80gC_rXGX3CEm3Y`9NXydS zFmR-=o+rfiHcyFt{tsd?R(UjFtPx(|L<}6Y8|(Ujs~bdJEMygRc4nud05ha89ddv7 z#iU0T^xZjjHITFN&ZEuX-wmZrnH;pTzHcZCkzhulnMhWbJLMSJo7d>FU!wUeKCDDYpLAW-UrerofQP#laKU&SKVP zBBwfGPZ_#h5N{wqG<}Md(3aYuU5b4Lf>G{i9&x^S+;Iguw}ys>!pEAlbQzN#{<}K= z2imfd=VSkn6gr^8$G8A5ccxO<6zNuPvO5ReN)iy1XOPC zfYV4M0))ABb>@KlWwxBi*UO8?^YM93WJ$xn*iz_VL<1405VE#=P613KLmldNg(M55 z1fLBYF)C)`0)%_V!V*3Y77pN?$9bWdl7-=Hh-!Ld=s}p(8&%`LceP&sw6pUpx(l!! z!5*^!;GGl9ui_JL_omOmMgl2OONbIeD;PFo6Osy^U*eSzoLtd#%t4Og940Cyx@u^h z95`@$(pm`CxJmfMaE#%6++YWp;B(}qBV}ED8|+uDCy{^LAXQPj^`*X z2qkXMBjXMrt48OIy+Nk6siWC*`ABpA@b+JI)pD%1uE(oPvIn9&LW$?;m~TtMaWB zatEABk9{_ULfQ>Nd^fgQC^2q9k)|r+#igWM6F7S=qv@(D5$k1p+pL}EIBh1q$pzmP zCLtCEixcURue1=S>WYQM@|8Mal@Cj6`ytoYrVQ-pdor$QTJAao(Af{B{R zS|n%;H&X-3*2yR23t>;uBDfVv=-k=1#87AxM09S*n)0~Tt_(Fz^^h;5%H>A8sjdn3 z@%0*v{Sgj;(T>m9aJIecyuBUYk#eu+@;T>DGmnN51(h|8a=!Ger7?FR=0duB=#yHY%VEpmo*1D(8 zwlokyc~K|NHlYp%8ZueI1hme{0_l3;i_iATn@OIkNa><|S7~6|=|d=%-2=Gav#R^w zmj6*tN9K>qDJ!wE?fz)cw?d114y|75Etx+9%S*)m9aS?YQ<{nvW`Dlce&A~Lv!JIWxD3fg?*eRAU5ZXTWR0%kiZdNmvM7#vB}X+&>f%oZH4_IhVOvjmeaqTw|$ zk8eqMtW2=WJ38K_JOHbWq8j$ekmUCDJnr|`{xJp?mF^E#OzHDjs)CU-<8lQBh5XU7 z(&SSwNI2H*K3DTX*iwX9x@!&1_~R!hV`NWQqN=1yO=BKhmyww@kGj+0w=&^>sx# z*%pO>_G=j$CeT-)HxxDVjfgkKKWC-tOEZj(jj`pFk!ff#?SgVW!o#H-kj&5%x@@7i znN2NEC`TJdU}$iVKHJrWLbhH%3kUa_E%->0@BAkgKvj@q?%j8uzI%IjZq;OA-sMg) zX4!d;IRhKv2T039{eX($gwaW9p@+Si0*+VKpc&!cE;&L;AOW|xS&OC>dT*^y0SP`j zMF(y}6L17R!^qKPOS)}zXJZbI{1jDI87_pz zZp?f+n^t5c;vw6gf^XC1-Zt%0#+Bs6@Y85Zc=KwDn`n^prBzRk4~y)IzP=9AW8VhA zH;?cx0v~T|M4_v@dwd9q_G!GAhWx#Iq!o+VH(+hu)1%M&5HJu+M&}`XBgPn)AI5?+ z`k>9H*7EC~-A0FnOhyI4yXiwtW8e_*y4_(zJUKO4SeixEKg_UDM(Hp7eEK^NQ##yPoR5q=lZ)HwC`cab;ju}lt2g_2 zj0aTGVjb_x7EI?pE;dX(G6AWtHFI%t8KTT4Y=gbW}-uA>euA=+*~ViM!JQTbOLK=&h-ZIl&8gQEsj( zOiY!4lg*CsEX>+GmkK3!22zM6krPn(FFcC>otkxQX+rtHa|Gl2+cHm!9N3cS&|GZc z4ae+V!I3z2%mL5hR1MkCnOsE~_cPl$bsAxXI;6@)XJI0x!K}SMM-mAVb9E!9!SKnz zzyQ4$&6oTmy+ondwT@S5D6) zfiB^n3uloDLeW~j{t2eQ%XZ#hfy2PO!YexjKN<98{%Ptp@;4|&Z&fD-SJlDq00@`1 zO+kS{LHR4b-F^wX4f^UNHySBFHe&2A74whbp$_Yx>TjKar-!x7Vhbc4YD(6zuetSA z6hd&0#}bPz?9Y@G_riEViUe+!exHZ`1ra{(`NI7L`0i{z2b1zsb?^ZmusV%tR2$j; z`zAS+5|?Al9%alTOq97m8$1+`9DJaypzn6UoGGZx%Fch0SFglb!;16MC&?tYP-#1=iC|1nYrLgZy z2C6)d{D8zX)--Xfob>24Eg=4 z1XAKed!p(4wU?78Kq-ELtoZDst! zk{9BtmRb52*0QOlR=I-h%-&O>e=-j3XT~(TfiK#abMh?Qr3KJ+m&f6`D9n1vbF4H> zqawO;q3i-#E`ck%=^a|K4IoWjz!Lq5&c>L)yBtO?e2s@jGPJU8n^hDQ6}dkc!u+}t zBq#Jd@{t-Plk^BtXXAHRR_Gs&uQx8&0kj)bRZLRiexg_~0DJ2nGv4}iCwg*~SJaQ5 z9uL1Gp=gU6P#PdCw`$1hQ}x1c5+*aH@i$dfklSF67$rYRHfy^u8H==98iJ=joW8i!qpX0+|$$<35*!KQ$(e{RPI#I`vNOpDod|M<58+h z6fwMVz9=6eIq?A7ZgWKjt}dE zB@sGCv?z&e6-s8Ll*l$(sT5;tIHl7;C$c0avbQ+dQYm4wv}z%uLc;&^IKTJ0{_pjB zf7kV%w<9y(=lk6E{kcDj{_Tt1#kN(^(NjG$T<8a8={edP&|1J^DrZpBga?#!3*fB) zUBAQkjv!?^ZtQb^S@I>G1-muwkr!%ktb~7MHfuY_#tOOzi!(uJ@>X+`Y1?L|^j2O` z)ySO@b%hI350!`EOimzsC6k336ci~Vm&Q&muthfp)(jyc14|<}Wlho5&GszPh_%0b zIeS`(kPSZGy`8B74-ZWy%Q1dyVz0?w@LvJQ8ulG&GI&>TRwhOG!s!#{ZnjU5W1{wY zr=tr5rQq8R`C?0ly#^)5z=~rOXCb(63tEoOK9T0t!XKbO;f;sgQq$O2sE@n~6Y$ZZ z&v)9YpA);4SEuJ8@-vr$>-Y!WSocn z3%@3@GyfVozi5&_thb~x%Y&l`K#N6vf35<1RMN{Bb)l(qZhh%a##(9%>Gg_Uleb_m zvGJFgMtz%w-8ee++s#ZTaADS~JnqsJ@1h;&hAhdG-G#6G5TOSaFUgxreJDy z28iXifmh=pCb{n-FJ{c)A&EHn1y6T=)QcDiG4gLjE!Bk!UE~$eDaj7BdOxwx1$0lK z`03@fHk1d*KWe!TskAThh2HRyI<2C68JAsR^~vQiA+-J0Dfy-JWi4L{zeRhbSc#Ug zbj4&DL9qf*+t5hHoRg4tW_#{Xk`_@#%UFcct7*te@+>Y3{`EXJ?0d!dhk3-u0YJFZ z+4~tFHfaCZ*zJ0jbykgml@L1NxCI->p=kX|9J$eMW!B2EJ^go!Eev*f;rWj?F=5v^ z=3##cukmC)QnQmB^=p>PmCT+2>`$cln556a8d@_HPG?+afb)!?qB5Xbw;D}cFfhB~ z<#`NPiIW{0FHs|8DGcwY;||kfZ?o@1LYDeur6l+_;=-|}8BnIi6WP^Bh@8esO4qGp z))-!i>{=96w6}OC$r%^^4zj=t-`hS_*nDY#(HMUmNHNk9Wh?L9`w zC}9<2YsMPGp>z+ibmB~4EDcAFQpa$T1u~T?v^#$u51$|Poc6K+2QN6lzbRNDsOey> z%{R=~7c;Kkw7fqy_BF(0UecS95Z9L)+1tFv$8UFzHUmr=9?|D8*&! zDLu%i?PS%M`B;pdfUdE@f(&9CH zGJ2s%P8mIonP!_ZFH%UGNl#lrb%DHblWbfxn|=Uga0qgFq0MdnGC1-pZ)@LJpex5A zyDtBmXS9qLj@^8Lc(^o!PaW-Jarb0!BUL#`k_^z^21iO4pOpX?s_jeJybFKuO$oa7 zE|Z^!5gt>CJ4iD{XJp3DdnX4Bej|X=EAT{r7nSK^ueZ9hqodHp&bJbua2_rILNdgw+K$nKp^x5w!B+cdyT%-rD}TGw~v zwrEa9qZhPeb73a@YibJl2^N%<;&E&MTfUs)x&Zp-&P4V5F}j+ERuROyd5wY~prrt*@@WUwxIk2^~8E*swd~Kk9~+v{=`K)J_<{ z4Y{U!C*wyV#?M0OxFu@iot*y)D6~{8(%tyWJ8gsBW~{?={a&DPYv~q)aZm7D?R| zZc6D0Cfv(?I(XAb)uu2&QaJOk&tSF1<4mOi6!dg7kdWvCf0|&G$J3w^0kf@dWW}4Q z=yl4DI8S1iqhKUuxrN#cWZ&)x0#=D;Z|6lUqEHwCpvr?4D|6rUAfhzd$e$z#)cE*t zPwTBU6N78Qv5H+#F@DI!A%$<tweU`P$!-T zyJ30Fnfj$ng#Yv_pCWWxzS=!CpuwW6OD!y>3DLin=VZC_RsYG8mykkE95VteINKyliPk(D@~}a!Gdv5F`q_R{rvq7_-ZbEu5;|9 zJ1E{&3F_5d@p6_ieA50Fp_LAwX#IG|>4iPk!!+N63@ur{8&>Z*R&7gO7})yz;3~DZ zRN@Ir#VWHvLazd<3mh2yIErbi2O>^(Y=I7RK{N&qv*9aJ4>?9H%^=-91EUY3$ z={V8<#Ssqr4kgSeziRK~h;hZul%9|@z%{>W=AjK-+$0$34j*@zj7ZQR5ed1q^Fl@y z503aCYpu|+ZE=d7lUMp7{Q+tN(A>w#?1h{Rz9|W;sY@Q zMAIOozXV4h8RgJ|)sPk0rE)I%+2>u)B{>*o86TnXKp~{|GR}BlTS(a0RMA(TS!AM?{En;w|naCm}z~?kk?xX zXztSIJIO78ZO!EkX%|7cr?`9pCwopt3-<^7guTu;J4rBiS+{kB`Z93?%$++INs@hl z@QFb&g#Dv-kYM;M@b*v6a2tEy1X|H_6_B<~z4Y>4Q43Fb@6AS-ft`K!!M?H5+8_DN z@88{f8ocJRipw_~5<5h<6YL$>|vx0h6wY1#U&;4 z=g^TcbiNl0u005&59k~F`sNS(lMQZ(r%#{ubUfOZ+TJWd9CgSoQ368mok|j0G3t0%VV*Q)!`I)r= z%R%$Kga#tV$G$A^>#k%?c|?-ByhvZ9-`6*fnCfmDf=)$C%LypzpVJ*^e!K636>w2+ zx*40wtTj&o-wJ_ExcVd8Elp}XB45P%02*(HVaN_v$8)JUr- zwx@kUFZu4#k}rF^=oDs#oh}X(W_ck`7291ipsyn2nYb~mq*8LhL7juf9b=&(Rh4T6 z9cAiNLJq`qF2Fq7=fXdY_s(_r*m3U^++t!~U4QKZI}n=yH2MZm1@uNzOB)gK<^@-? z%c-lw2Zq1yX5x{MI$D*I`RO>9VThHPZAo!qV$*q+R25dh_RmXxo@})l!1X zF3dp=XIxPXm%-5m^PPD;^FtdfOIUEt#Wg?tHqH%a!PC)73U{cKC?;#l@zaN0h@+d^ z_<#yv#YV(K-GkHHzZX)`W<44Ny^LUBe0uUj{Gqowu&90+Qz}lD)HtJpt>yatXe7|u}RPZVMOA?*?in)oHu7!VbVYuxo?>Lv!+otvG;xO&vL62;r@&p zR9XT2H3v)}f-RtpEM#&%XJ-DIP;gUfk)Ziin(j6yiNNm^US^>FbFpch4PW_iM{q*_H!8}<83FaQc;<@)u z-fG(>pos*2zSnEpH?{|iWu#_bYWy-!&!5n)1MbC@tm6N6^Diqg-|W?4hY(r;CU_#+ z7}~7FNlW#|zHP3`#j zIAOq(tr37pVBst&{;-}N&_Mzg1Meq@Is}N73jbQS>S6jkf*@tH%`2K$>$5EAHjznV`gT{QrHLbX`JIfEn+B{C_%IG0P-k(Rpe|^slAN%noCsXm|TLxnZ_?!*u z*zrj$uddG7`CJl`Xzx`(jtQcURruyfg&Nt<8=6|Mymu6Vs~()dNy5N%g+tA)?N_Ah z=ou;a;5fXkFNn@!ad#^&F_w9Ti>s#ooV>RF zHSgN`d#|ukoab8pjAHC%v*1&7owmu1=(c4|pYmZJVd8*%&*ef?8Zc+zO;s<^_16*Z zop2&-!>sUFoDXmD@v!R49polY~0^N%; zt&ZZCz$Xe-&Z$3(aJCp|Q!qdgV^&YiL8fcdYh@2FR?*F6EsxMv)a8fZpk_<5W$u{H zb>^cq|V1U1mPFp>VC(Hi*h7a1A5|lm^ z?w4=l)ebuT_Wk^e7=x&(Bggp7nP_*uclfLpL9*-U(*W`W{lH2c9OGB7BGi(kv6CwD zP;;1@=!rOdnR@kqHXk0V zgCjZgrEC6t1nf2bSsh>|@Kwp$*Sp>)DiZ1JU0+O=VcU{#|(B!3%epiw<;o zhoi8gSP?TK`INqM5(s0UjI!tUYnUmS$+4C_Zoys>GqI-OvifK&9Ca_R8AI6PKz*~{HX0e@5HWR8xgL^&0?aK!fQ>)d-7Lo;js`X=@R&lHd~Xk z9xW=xyqalctvyQM&i3{O7f$o$&fVvtaX>~9>sZKFVnQ^~eDU$b`MpFc!{T+U@^+Sxa<#4Ru;sQ*u=EVa&JgiA!^z=v`!A4lOa2(_?bRu;zN%}5u-C`1;VUa^fGJ8p;Ifc!PyW~M2|Qp-k7s{<~i@ zR(MWh1oO}2Z?cbIXfgD6TP1tQrHy!wJI5BtR;K>Vr4gdDJ${}Kn^~Nb^>LO}8x~7x z{0c=Y(yZ9o0soG+m9VM?IOo+dI|G6p2uGpWK(_Gr@X=1f9)M!51AZtZNEiTEC;ktz z+9As`2u^x^Z%^$q01pl*na(7m+5* zr|o&)-V5C$hBQPQe-dY#s-41XuA^a}pj+!ufO$N4sII{6wMRbR(>G3?)JGFJxo6?Sx&-} zu^8J}2h{nvp-@cq=ikKy5qg2cqrS zUhfTTF*7Xz!$1$6)PK}k3{YeZDUW6eJfjBtKBA z-w{kKSMu%SMlhnfs7Oc-|`7SsUf8)9Oc9L7bEu8E46vY3ML2N_z5sZ++! z++@z7pKka1{$t05aFTmm7e2CPW7F2;tlFG}qp2AmiHA0B76Cvys9@IPxnop=29*3I z7EhNbK*qFC;qa5-7m}|3WVXK|&KB)EC-C2%jsyl7PnkFV0laK@q3zQlls4`#7WjiHVR4955FQaSwl3H@43w@S-zI~{+MSWR6K2R%nv zw>{Ak8}!C68_`D&A&agz@)UNqWX-*Zzx^cPheFc&c5+c$y$FCUR=5mIZ?GDR$j$TK z;ZPJK4Mm?+*Unq5#({pp@cuxKjR%uS?bNXTG%zJ!it?bgzfbOV{6aXmmW1;I;6}tX z%r5K=5MvD4`^Z;jz;O(MOP6x@zB1RmkOxqd#0ir;SIoTti1}x&L%CjK9eS0xj!^?! zJIfO_naSNFr7LyH#gKjs78wTjZ6hFxt&ma&JDxEEui@xE*Gy|AfIHqPi<%4(hbn0y zfnPh+Opeb0sfi6cC!jYT7JiE4ePFXz%T!xC10n7WyWQEBH1IX>#yj+)JZci85kekJ zN#NCi9;_`9O9;pTt+pw<5>0eWy$vb0qMwUF?&A9?(@WuHou>uot)~EwtJHN>@ojQ^ z$dh5n!dJbB?d8vHJ$Vxk0$oF^eBmo^-tG1`L{j68Z!g0T$o%|Kdp*NpVD``Xj7;bs@? zmK0MQCfV{|`XK%M_rl-!hK($Cld&p}ZiYgmGfVo02Pv=X^Sz->!p{A+y8c&w-c_R2 z(W@+Szd`Yz%wkjah0n0_&tGybK^$O|*r5m&D`C-ixD)lL5MW zioO%>Ox=waF!Z{7D$8;&Sx<3Z*UABxIQ&;8$nT1Z0Cx1JSGG62s`})Mv+}Hwzjr+o zyTx9Jc3|ZQQE}fGsQ2UGwPlrLn!vWiI~h3p{`x`Z!KbG& zR3sQY2m9v^{%+s}z}m)d|FH>@hwo zv~Gy!nP(CbDaXbJCU+onYF5zYi2>b-fk0zVO?|6lI{LdAfS`H5;mcp|dwYknRq}Q= zB#KI4CYuwV8OIPB9En(Ft%>GJU@F}=eX2>x3K0}(XHV9*lS;y`S{C=?&)LI@4E_`F zcwh&_p4-dXcy08}*X{3Atq^qJoeYro`K}bgVT-`c=RlCOndWLj(e=Ur>^1<61YOpk z?Nk$=IhXRQRIbUV{)3eKfV`wgNyC9BQ1RSGNlG2R!Xi%G4Q&M&qe#@$mzI@rv*$>Q zLaN|aBTiLp1x84K*;#X!;*~Ag=beq9cRVxrYy)!I+v+r5Uuqh3V*#|KGof))zKR5^ z8%!`V{7iKJeRFfjq;b&hdGPH^f+x75s14WRvIxp3^)zdV)u-c-wFRvRwmngUugcB&n>6_tva=4TS`Cqj)l+DBaPK)O@|nPi(6zrITM2_#F{ zeVqaP8`Q#OzJ^Sc=th8!!c}F>Fo`NnE=e1Fs*#Xq4GNp{vcOo()8-Zz^K=fQ6<(ho zZB~SF#P8!((Wx6#pVbarn?lLw$|z9AA2e>jazp}7LB~9Ji%eCCcI2WM!&zcU58%?F zFW?s*P-YM?UQAcg{XZ^1aBz|1oQzVWLEN>D2VL>uERJ|V z_FDUyBsN5O8+uYK`h0rxM0jmQ+=7E>rm#;bX@IOOqY(GQ{I01>>hv1@vu}{qJGu}y z1oNJb=+6lGITBM+6qmA#wXm>#fq~Kcz1T=~Qc-}*3f^e)s%w@PBPUN0owg$Ux z12RJhQNrH}nN(0ECATyOKPLRhMdRsFr3Xrk}= zhU5Og$Of*;pJ2?(2yd01sjMZAk>TA(!iLcGgY&Biysnx+xibCQr+$k*&i!W_KV&l` z-~Ea*B0LYU!z9or9DlT^lFBHpjM=j8#3_@l#hG_bH0FOW!*cQM)KlC|_L4( zUsFik6M1+63Q~NM=o$2*XB>s=a&XetcB&T4G9EVquj(hjV60_0N*=InSw7luTw3AF z+#YbU_cq&`vaZ>7w6}9b@qh*4QlVfn?0&g>w0i*+K3M1Gdt21`GrKbx=9Wup+U*O8 z!^;0O|AYq`58GD4LSAX}bdyB^a@@ScV&p5UI!0eU3BDk_o~f`VtbApIzx`oHm6#b; zaK(bHkkky4x%&2`8|B_4PRa6@%IKo(<9DlRJ<%NrWW?>OIiI>%qtg}QpS(P6pLievUsS4p6?B~kfQ=((^$Q# z1B-{P$fE#16$V2kOJRVC#(+=P(PzimEM@lGwQKEB-?;; z-u24Tz3GZ8SF(ziT`` z!n%XEyqgTnRO}&d7tDm09t)~VU|2e(pmrGc4DH|pS3tuLi7kvxFl29UO|*D>X6KD# zi>@2PqLdD7PLT>VL$?~5UUl3(M4Q5VoeTA)kR>-8?z+=XoBQ+{w7j1Rz!ED%v~hL| z0NGlAr^+xT@OqxS=~KJ1OdKmnV{t+O4tU-2hD+l#^2eo0;5j){$DuxorRePGM*-^w zeI_aWeGur5B`(FuLOQMM&`PsBf@7hsNDL9un$YWuhPNRTG2Qxjv zSrV$}LRLWx?)2iC3=q-1W;_elh7DdvjAn-o!ju~>iN1zvBKqEJ_JHK-nET3XQ-VzS z{t!KH3?CmPSlZxA{lOibKbr{%cdhY){qIA32^yM$YyS z0$-B95uT<2*+v$|0Ejp^)MWaI1WpTaFuGOVk5wzZu@V*W< zIo+B=H(hMr*A67DZAQU=C#VhrN1$u{Idz*S3_IeDxSPSfOaW-N@%ia$inZ3SS&Gej{CO01v{ zW!r?b6XwUca!RbjF0j(k(m#@Nb}VeF=@;zXE_VZ5;5q??uLB1M9@9!#U!^vNraNK& z{40}rHALOf4q@4+ao)&FZbxI7W40|D8uS))3tCxE7_El*`@RO=cQ3J_=AK|Wf?i&K z%^xy20Lw-!tlRl?jD-e-aK-oZc@7tuqWofD^0|tY&_~Us0+Brin7Se0Rx1pvMqdWs zo~RCHKThb#7R(b#rpd`xnpGm4dLGu)&Suv*w+0f)IL^oCXkwVj4l}*lsL*6enImZ z?Vq1WaA9eH2)=5f3x*$HITP&)6nBnE4eA*f^Xz1W1|v*+{_7ukFl{X~6b+MJ$rnXp>rN$5WZPh>v=FHjM`gBuWoEzp&c=N?|~7 z3u=)Duibag==eBM2u{4N_?5e6sJO9gVtf=5>+o-YXYlC2tRE#a1JSsG$6C?=4cz;n z@`{Qzmo}_NCUSSgx37VdULzerLzm#G`RQz0<;l&i33#D4-K{l5Y6IR^c~5&~9lprB z1oAKXli<{DNBD|L@-`P;JvsH&nct{3);%#;>xlANdx)oCo90MQ-~{lf#rkMJe4;(x zBOGliRb%4eB`4V8>i1lg)hp)S6o4l4Dlz^kIso0d;&asHlz9;FLR z)y~fOOPqX}OlbyCzdpXxebfsb>_|a+`HRNejNvB6<4J%#MJ8sD1pdY-=aI%LJw_U8 z?$HOhi4|s{jRvE95ufehH5EHYtJh~1shNTg2fT@T*|}y%t0s!!)j~Xfowas-w^-DH zCsylDa2ZR7tplSxB#XFUwU0`g+dNw6gx>@dXgSg%jM ztyS@(uDmjHpjZM%RFW7^ad@#v)wt^n3rQ7Wa1;)@+}M2!^iyn;)R~ih?!f&x{xa|m zove%uCq_a%c>>R4;4=LTUosgBq;fi=+z+W1^vUUVZ|cKDKUL$nkm0mb=VFTF7s{eutIc5aHH*g=YS3U{oF2PFRT3Mvt7y_ z6rIs3CKyTA4gHE~cmkmex$q*pmp%{QWpa|IVBuC}9qsy7BPcVaIT;ll%@BqnZ12$?=Gr_Olw&aYn8`d^QH&)-XFM!oisj0V z$j@cGMrq6gk_}EKMuIxKvLg)6n_HwQoL0n)T9gBW1A^@8QWexQw{X@vZG9 zZrXtf*vE-)p5!&($2LOSZ3cyck0{-Sj5*s%Y<;-58c1EF5k0`R=f=ABo@%B>u;5cx z#FZ{@swBlvX~u~}e~l3IG4d%1)BT<=x+sd)&-iQ7Aa&pMaxC~?Vd+j|Y2;EiO~m61 z%B<#O9gzoVU9Y{tI81L1zIJn$5Y!w|FSHOYnv}xY*m#`Wq(Nr{G)#Kg?I=K>37(9z z4A^E?0WL-OnUi2{0@qmpxsD30Qk;V0?H?8!QtIz-Dn#oY$%E2!N=POLTpO)ca6q_` zk(v1)9jM3%5IM1;;b-E9umdHD_Z=1|*kam>_}J_0Vt@&#L#$AjlHU;r@zhZZQ#eYL zw0kK-7=dLV4vcK&@g?rTgc5fFL(;VSkMRZ+T*BBa>MLarq$0|NOpk4y8m}=)x{kbG z^Ai%N;lHwi?a#9Q39;NTOYaspLpeHgrAfG}y(9DEC-{<*Q3iX=&k%nE_(a3v_el{7 zgpC+^b&{CJs;%w%Ts~1Dl00FWw)j7pxF6enxp8>CO$~+iZ_k|Qg`6>M{xJcZIlml- z5d&8LITCJ>fszg}+|sw1PB2|jsTe*9Zg4YGpO~Ri*<8q;*8~L+0IcZ%JZaa*&X}}K zqgXl`XkU}ap@BI*?sDdd?W>JA!19VZ_u~%V1!uF7pW##og0|I_rpZC3*;1Xrf zIJh9yc(fWsYH0wf;lRC#P_1`=_$Yiwz)`@u@(3XyqGbNBOy-=0UICN-5*?BrfG=)7 zZb@?TQAs<8e>$+&N;3S^hm_@Uao2sLx}Kz5*x>^%Mjs5~dUHONH8G35@mXOK)a*o@ z;S;Vam-6rQUb$)4I;q!qoIj^Xrp}OfqEC7%_|aKwj{dA6mQNNi2ZvM%fg~AzW(Nsl z&kHBo13ibgHRhxdNp|RC;3+Hx_)Z-xY44C5>fYkAU5U!QNImL)hwr}e+TaLhxALRy zh38~a>hkwedF{UX{w3{v379|rP2s|kW-DM>C9ViT-b0(GtY~QI_@|XtgN+Nt4&AO!~+eor8W}Z^j^S{-~xfTz(CjtN-vZAUo zxN>tPTHeDJ13VqXl3hFnQ5)gi2_s@W%=s`Jj|4{`cDpP%&P3F|!{A%PB%m`s_?o$=5l)Hm z8tsOTK6ekSo($M>{(UTw7gGzQL|m1;KaU}unnxU zneNa}KHzdf+C_D2l=Ns865I56G8Pt31ta(#*grcb zZcltau3!=ah=4N$AtC5C1VimB9~?o;yv`o7a{Pk3HU5y`745~6F)a;FhknYuTtptQ zDl9}|pdXDD-=0gzaVUp_#uH?{2xeTzX!zi(N$32AfRfd-r{Q%}_%aPk;BJ$G<{zWD z8Tp@T@w8FH$fqZro(3d-)Pa+KEq3;k^m0bI02qk|U>BpFq5I9Z^0FsbImVg|%6ClOqZ-WmK@29(zvN`^GULEfyY6;Lwoskq1c2loZM8 zE@k3;3KnVg6&e)Y?uM>`lDH-LFyRdv8T6XZ%6MaB6=WrbibhCQ10)ja&%p!<;r{yOImv*+raM z1y{Cc#o~QV+IZc@Pj@k;gt6J{F}H&PB^@t0{HI) z)MQVB7r>+isUc;>#WjGd5!yOBU=-$INhH5I5fX;P6m%BSgy>1nk1jVRK zr-nSiU_Jlu?%T}Qeno|$Cc0%uhQ$0v`va0SuM_g~Ebvp;+9_}I|Bm}ll|JVHu;(XD zyWQCKh4H1@Eg9hL@1_{eJ-0>BkQ}5;k80EiCEPaI0VjT}Az~eVcd)M=_6)+hcT<06 zs&K?7)md*%$lW1V&@AMZhMg$1MgH+NaH*Eca5I61!68umaw7;gQ6`jlSf86Nk z`J`I@>?H5#WvAT;fdT-L{AI%*B2dF zT=I#xy9#eMrQsPs)GnKh4Fj=-PqhTxFA>-5)A9%*j#i0!xDqNsBq>)k0ibD(h`NtA zo;e}kMmOy1S(rmEeU#a2!{tB_OIbwGOlQROd{R?DCNj1%J{D0jq83(YtbiXvtGvJd zzd1Hg7RC$IGpB3bs1!YASgwGviG1ASkM6J(2zk>3#RF?lwW`A|#8S_D`;zzY;d$n? zekU@D%6_<7M>$a!Po~*YET3$dHslrr8e8wn#x|lJb+T}qs4Q#9S4~`(Bi0{d?$Br> z63EIPKfRJD;H!>j5o3Uo&>ta}yY0?!$#)}RniyHB7y%pXUr5y(!TQsxeC&q`8BFjA z>x8tCE#G(>Nmy*ay8FJDacnWMrV`D?osw1S?xPcoCe9&4*8)~v%Ac?Ac-IhmhuTv& z&Eknx5Yl;v+jCHgarwo>qXTJnYSfIXu08?7_=C^|h`X*Oq+B6w80OuxSUY|D#pEmR zpZX@1N?={iz7J)$1J1}Olp-Wx6SkceO6C?1Bz38nYPfcvxJ8-H0yI7w+@MAXu?w4n zUx4p1?3ivt-#leGG;A)%VF-?(2i>ShJ8O%WZHJDD|W1BdZW@(jb<@?zwzGp+hTO2GMHb?24E(U}GW@5jcm{-32Gkt|hkSpn-!_ zE+hJQD{}jb@1Lr^J5>C9PV!y@jmIA-gbforhVC_^5Aqiy@eGt?7arSR#-v0wvJ&2kzL&YjaYsQ%IzsrQKT`I830SpiObbU5Nf-M*BgfE2P7qZkr@((r zKx*N#53dh#)Zi}i2e{K>?ooDAY9bZkB76Oh`}v(jkNTt4UjavPar(1==$loI_1RVU zU$W>1n5;1(rbk7nhD4Yd&0i0`6}+)}>*FnysP*pzBybIs4B;}XDSyJ7+>q40{+V3= z$w+ZKYp+i@RMXOD@C%zGyU367%#ebu`y{Xf7mT$SWLfjCB91jG(g~@owP?}zWuv%l zKV1(3_Xd#xzL`61x^;HeRRXGiI>eutpADftfYEqidCnrm!fp9*2GL8vg%LVgl^p^R zI89cdr2|8?eZR*0kOfw-9g`sAFk6uL?4$}uqV=yi=t(a}oUvcZl2d}jBH!8hA(tCnX@VZ2^~ z80gMkWKU%7V100{xz|rI9$TR(Po7r|A+nNyJ@Dz%C%pRYz7A97uf>*RGbj*E*KT7? ze{J`F88f!z(!*!h^Y1OLig^#+oLm8*5O>6aB#ywVbosxp{4ORv4Q}M{ml_3oVGY;~ zi&6}8V3GtF&wW*Xpwa2GuOs$L|4_|6*@ZAzE^G!jB-uuSC zY#uP2)0Jv)xjeg5C2a zH0hI}R&ceLzt%2Wzh=+v+ens9m|}OM3o}P}xemW2;Ax0Bf%} z?!>+0OZ2Ai+3bUv0b48HOYUdSDBCvHSEUq6!Wtu9*%01`E4Z1WWvGy<%)&28*PCZa z5<+1^G_FT!xs9pBt;?U9P0C}?<=h`r;Vcf^n2?4{EhJ+EKY#!8KqT(q?8E3T{*FJ0 zo(M$J7sT7lxG}w+YChasCQ6jxsl}spM*iKQ+!gNs6h0cnUm0mP#ntN5Elg}YhKVv& zF9x|d=gl!dQIt`<9TUeLNDr)|t+i$k-0;R0k+NFbfvw+EkvA7rwwpwHH$#7vefV;> zrz3M$vUR)7W}gQPIkWwntlA1}^P6WCdc0q0wHFn10h?#FuAUfFvr)QuEE75jR?*)A z&a$`Kz|{13r_W$0z}2@`1bqog<-TnHZ1ne%l(Z=fjUo7Uz5pYF4!qNweIWiU#5g67Ow_HbK^hpd;u%T8=HAzS}^`8cRce*>o}2`5l>eaaMtbZl#Y?#V5W)( zao>TW1`cbK%j3NEgwVL`$uJ>tR95t3E-riEoJ<+dK#_88sg`83VKICH|I%LPi+Q$Z z)7(-19!vA*A`Hn5+doArAKX};imKI{#eO@dr!c5hw8vfRao;P^XQ!3tK+R?6)plMc zEHmaDZsIA+sgOkAL+C|#(!}X`DV?59o)G?OSv3r)>m;OR(ar9}D=G3`xRw;(xdThQ z?lr{EM{S+3`RJPO9ew-v=jP;$-^!f`usAd`^__|x^?EuAX@0yIL!bL*i=;vE=$YfpirmhVW!! zW+!{Q8Axfz$kU{p+}w2E9anUJKIrY`_RZOY(kY}p+=vK=$nM1WT@)<*93hl((d27PQoj*r;{6%YN4NiI-yb-j4HvXUa@->EAgdYoZUR^rUG1AcaE1OUa z3b(OgtJrR!jKcq0HFYIs_;*LUd1<~W9u|RD1n3>0MH@7JV>6qIWUfenhp_V^o+?G0 zB2=HY8NmX;%Npy`G-)u~uM8QxqeC+$_!e+aoCp`5}hr)$(mk*6iF4RQ7!SM{+ z#%)Nbebc5F$D-7&j#erT#|H&myw>h@9s!&8p6@Cd`W;AG#?iX^7jEH3jklosId8rR zBkGO9M@`W3Sr(Rg!DT~Uu%c0)&HmiB!>8;Be>AAI-v3g@b-b8UXiME!mFN$SjJZH| zoMUCOCMRVShK~W)hc2IDMGD2Sz$LPipFLm|1mQ^F-+?dpC+tH7&6KHm+Z`m7D~725 z$sRa)BKj$uc99&!z}s6V%ah>`+D%Jo4|Du&&pM0jo3A9LF1;dV*b_D3V;eE!;D3k| zx?>bLb;VFw-Qyza}q8$d4cSp~KgF+w&0qxIRQ0!Qnc@)9*$d|>Cj?3A6g z9BWKT_NCE_!-XSQ=Z=MGr9X4J$qw2Mr~?BCmc z3SCEu>2KlpB93t({=WHQDg_zdD|_BM`CKQ2J+3bY2j4Hm0Td?#4nsm) zV&gq-wF<``kq&XGrd%nRLW zEwIKcY`h5X|2gV31^~FOloM_MR;3ffwkYU-;hNjfN-?e)IBnJIVObUc)1yhnA9q19b7+%~NQ)?n;(XmTnVGyw< z+ekDidRxTVoMX#yYT$0abGOlCp2)>hsKz8e@hT6ZuMic|>k_WV@|U_EgPvo@S}$v)O>4^jGjutz@u?v`elg?jktx# zh3RSDYUW;9g~Dc5A)!rB8MXrE)pe~cvXv5zv*{QBWA`)!cvP0 zc@R$tBO8JnS==O00g$RmpyCZ`&>{Si-Sto5qq z0#rgfM;I(-`ItP_S2W^E^LE;o-L%!}x66fKk$@bZfRlNN&j1ex6(oN#G=4EFr7jE7 zbp3t<=P|o*%V+rg{!_^Jye&$&Zej5vRO_AF#OF2Di!gT{iNXw8;Sh#Qb>un*@K07h zUcPd0!3TByzmR-$+9Tyuug%1d{S!Y{xgG7sB$HDJFOjh@w{GkFc%?m9^LEv5;JmGm zf94bi<}^GW3?)QRkO5~)_Y;@E+IP05Pd*jlTb>Fmj-M_C}`{zh{@z zIqL(}nN#5Y%%vb(LI&g>Ee)~s8E~%+-k(i-JX5d9uqNl_p_%}%qjAmdJD{6F?8?B* zGP+eVx+sElv1SrB$NL~OcFSMDD?HC84kwE2)%I|*1z(9T1lHPX&~%6qMg!bi-V(l_ zZurPqm|B6u)e|s?h)iUWQ6UC0fk1&#YA^izH!haRV!J;_0ZX0|1Sf1r4IhmLyp&b= zu6d2=uPA!5DiKb1F@u3P3G8af6W_FrTdp1(LfehFq7Q~KtIU|_sY*^i~&;U+-j zPtkM*>`Q6VzJ8)RNb{y319!Yk3j`3KgtU0O3^O~gjyV@7Ktgymj`rbdZIOVF+RQ!b zvgXl&18><{?~qOfAdBTAPsO`!e^FS71Wd#cnITmKXeQc_hxNXmUVUPUn=yj^`5e~L zIX+%(M*fuIBM#XmdI&z9@|X#7N=85JlYE6Dh`#N5Kq?+;h20p8Tx{!D;=*}r2lXqyv2rt0uvg-*ODg^zG3y2D9|AUZO)(>9-Ph!d|wD7pV^Wn(3N z?^QoSP}Zy&|9SyOpd3t!Usdyd(XN6nwy3OXsu{tU=~cIs(D092?3(`>L)76RY}7BE zsy`P2)u)S#T?RTIX<&5{uE>x_m$Rg3nUzx@89@PTE`aC50d*Kzt(JD4>^|fnzs1sw z2VK_`lvmd-8>6YeoMt$;VBF?WZUiK-@O#M7wSr!(lma$Q1~4>KEbe+Si>E4r>k%x& zD*PFMJ0Ps7$tZy7YspKIiCJt=1BwPp>Ua&9378m12bK6vtGwQS{j!7^);%wD%+IJG zk+Ny2J}Cu@+N*gR$V#5V--9chc3z?gf&Jy!><)ZcJ;M`&x|4IiBZbHley;7b-kpw%c4uCEY?R-E)6-_G*k*chzfP zSOsgmB`5UTaC9)tDe7-I)+=hdIkcq8@ED-UN?^H8J|^=~F{%&`P!vxMBL zWTS66LxeXO7*aN!YD|vLU*W$P}vzEqe-4zD~3Vy9H8arRX`o`xrJN#Iz8a9Ak+uj>M?&hZ-X%v@l z*XePmFcJ0`O$ItmYx9>{Yw@h6V9`%8Gr6Xrc{*s#-YmAtfCUqqDyR~0|FqOfZ??9> z9b}a+5FDdP6x{?d0{np06clu6ENa|>|4s4{hTH#!Ew@RR7IFX*K_ifklJZCQ3}hWQc@{N zF)hiV!x%$7q$65e(}7e@spvo>rB*o%(E-t@RZ+tK^R@5$zuw=q*Y&&h+G6H8eDC}I z+@C{srvrDWs`Oj;r%Ln7Kd@;Hf7_iB_4#Ni!^loDp?+5~=2B6A5`ZWp@cl+RcEjww z_nW_EG>88<@PO#XIIunl@O&p*TZe zXR(ksMeJ{kU;s;3&H+3CFI7f@eSCNW=Fv?bjo=A528oP1SalR5Z?W&=Le7EN)HsG8 zov9BW6omp>%o`_R`B-{Mex0=O>W=iK&iaUXpOpAx9I3H?vSSx1uh{x!1__pG>M~vA z0;iI3E)CCqd%waZsgPYS7A3@Ow8*dZ86iSzfBrXRqY49U$L_+ClKGR4QY6zB0m>^& zZr!41USGIHgZF+}XJG=!{z=S(OI7tq4)6#rypn_rdX5=sbCit2ckEbPle006_rhyS zF9KZ6b{o~DNb@ZMK*1k7o8nDXg#i~z>D5_R)%O4<6t0KF+XB<^>9Gu#Aa zj3+Y%@P2fT;HBdi#BlS%U`62(Gy-TYobu=?jtwCc4@fYH;!;Z$pstwyi7AHJ2=gDa zY*`nvfP>h>mBC?dseEPPepy$+*CzNgVV8gv{z6^xlx@DxuHQ!VV*^;3jwr|Yjn`Z_ zV=f)TY(EnN3w-rYlh1)?gjjEM3}V4(LU1q+F7Wp&=8K)4vxL>?DAxq-dnmKmjM}3Q zFf8l1MHc+Az*4#xv{jlSK)Tv;STM?WX@u}vg?{4eJILuiv2w&Z`07q(w+v0a$s!o_ zMn5t$Snyi&@Z7}1HD1gj+tI)C(YGM6r0GR%T4vl|`KbbX$3aA0&pQ6m)8+4c=F64&nq)U)76%b2LI&*03V5tmtY=A(&{VK%-Unt@@L5m1%T zpqY9)fF(XK*gZ5DSvnHS$LF3SjntK^H6Yd8RgW_k>d4E3?;kAay91w1P8Qa$kKrRN z-B<^Unrhm>B zPKYCb1j_7CPxW9gOp{7a91}?jNR2)6X2Fko4?yFg_LtbpP-HV@Dvr6ESI?V8J;cr3 z{Q9mX3%HYTxO9&Nyb%t%{dlMi;{L@<|9R*;gfJLNwvPVxz4P*dJs%KY!N*_^d+c&2 zo#*%A>wx0=dIaKIQgzZ(_sKsu!WhnmI^H)Y{pQ%mN`a($NEI@PQI4lH-z{*8tJ|~R zg6@S(2vuzWhYGV7S-ay2#@G+cA7zxi4Z`0oKc=dWKk#YMFRxXF?DWDbhq+s7>UW=B zVtv-)QEqzY;O3lsMXGgqHo&=zDlvS4Fqm=!m9E@m+K>o;z67Q!&rQw-G=mAKMq!19 zXro5fMUvIm*SeJeT>SIZI)T1+BOA6LWug!ql3A-&jBd|e50CS|aIa@_Q$(Sg20(i8 zj-dY?ha)Py{r&Y>Dn52fSd|0WRS!gVu|<|_r$v^Ejg5&)kIWwaU6(u4qE#CZ+35XJ z#le`fMZ@6_X+FNwE z(Zps)@@6!yjU@;Sm|HTnjF6%+ZLxGG^B9MI$i97K`-2ACpO|VRXB8{&5$F%_9}sTg z!s(L`&(SSw{ps$KEFeQOS)VTjcxDIGhsp!rL0?#U@BfUXgNZ}$OJ%ZMh215K`8ZxQ zro@VLeS)Nyv38hmc7RN#ao>qR1e46+dChydChWSC*&QJ-{~=rn?q;6Sw9GAzO_|Vm zHx*@|In;@M_TaTPEK2}?VhMQL-n_-D)AxpDmdGf6{GZXYL@^uexLdLF|aA4 zjit@Xr+*DP>?r+xF^c(g0{ZZr%j+8oFA+TCIy-FwRDK-`PYJgiM-wydvn$m%LM?d2MF;V@UB>6PoZY^XA{bXN7mMoyMG^D5F zOzG_pC~aOpS&JRfjpAsR{}q;rP%D3F;`cUTq4Dp>JO3aZPB~b*@0)AsrvsLI&(spQ zX8mC6RzOeZUVnP1IclC6vA`?U*Ct8`kc{lBxfS^YU}}KC?L{EEuZ#I&nD-Ly%E|ir zx#wRaGW>PY8~c0N8qa3`<7K*=e&dOVI06wE0R*0deJqgat0TjzQUm^BjyH!L`sGD^#HnOY=Jx~B{!*GCiZL^v zVca#k?#yWZ)0R~+eM$1Qzuf&kI>zE{@VP%zRbGl6m2%ULo^`P9=_+}Vw&T!^7bg#T z`;V}>JFjqslf#$}1tsgUzhYCN<}J$7J)f)sFeiyI=2`0tpDdwWlzeD*mBxMSZW?T? z$2oS(SI_^fSvErOmN7ELVLo?u0y=r@?Q>!gs95Kc^A8%vWh)D=SU>lYn^W0)x}{6H z=Y!PIQ4&Zy8p7IF^CTW}(jDka5l(S%N2ebT5}}VI(`|(e_Q!B{9rDUUF;;O?Fyx zKm8d)@sb!C8G^Hy(atFOau})EFYh0?RqL|7^pq>-iXVMOBFR}+$!0m%Xr!wxajI@F zS^DVkC2Q`Y@hW_-@@))0w`Y@MB>(59)&QHQ>A z7^%p3^&@ynf8`fOa02R=fpG`jOv5v@X${@T`dmvMu1%(#8xA zrbH9h8w?)L?h;Asx?k|ahvg`h1JeiAAoG9jk9-Cp-KNlouiv0*4j<3j5 zdh!!|`N$$eJ|8S3b*FN2h{KuYH<)dFB8YxiX}|pX#Z!IdQ?aOB>w@GZb@?N=KaADi zsd})@d`*=dTP7jqBW>F=E~qk=_zJQ^>tt?|7q4X_4Fj?k@^K~nN++j_Ie4e%n-r(o z@+!L?<&wscFDbtxgEbSr>N>|7IriY3_{^eoeO#%#M(U+U*hb{)XdN7`MJ#aoWaUO2 zZ6=4u*OP5d%PtGv0}hTZ9>IAlIrrpq>ki7mJ6K6Oz~;Q;+4;_I8b->5qyUmg;%emY zrWM_2*EZ&GvqHkSrX90^u&ciZ+vD=B@9(RsG~I=mT)bD;IHb0o2o}8z*`=niRr|^}_~ew;!$++HwK?eiV-q zhxqooaKIWZQfM>rx~h{m8*QXPSWr zKh?Ne4g{I3+tbl3X&!1GJk}Jk#$9`%84{#;Q({Ip7^N_s-w@B?9>~8mdX(6O!L)X{ z`1|`#1MZ_UwS~>qN-|_u_;km5Ec);PZc-Cu0*DiR$uyBFlE``>c`4qGI#qT6i zDr-skx99Lhok_)A1Qh?93p!x*3K5Gac9JBM;0Zo| zlUI>l#>p|_#)3=cLP2F!B+zR2&rMJ@RquPpJ%!{R_)#tRwsk=yws4qjDq54bB)EQW z9Upa}caRL(cySQtY~lrvdu?g$_xINxt@E}A z(26NJ$9og!s8R}tWyv1Nn4jM)b^?b&U3OtneIJb>iB@-vn=68(rrM1kv(+X};#8QKzcgs(WgN;r%KW`-u*J%5 zVNgg=j$;YYB;n^0hN=^_I(23D#KoMfb$y6wkY?$I)q2TG*1A#0H%Y&o#1sxEW9b~E zReio7NGM9~VzwYl@%%F}L;tMZSx??Y2Gx1Ln=<7Iu_K?7Z3Y|of~G=C2rDHMQdp=T zLzKQShOgwNgA;|_@)~nV3;)!;AFz_Y!a$% z5Ozvcya;eAbv*k!^vS@&TS=EJbz}QVBphnKk@^))j#xY4aPHRHCpcDG7a8b9r7$e0 zz6?xE@&aiM9!7p>LIxlt&u^}V<9YSqw}|E)VSF?Q#UWa|SXu#pqUSzV z8pYP!up9fMbqx3~S5UK8JXu2V)I7vIrH3+fMc^N4(ayeQ=EcJCk4JwRRVorw%8oh) zJFqxTx@rA!5*0S`w(;37O)%a!jt4$S-;?uQ05YHz!0yus@l~;g?3R<;{-71XG@H9p z$A>*fbi{m=fq<>qp}^ww>({SK7xWF1q|fuU#T%&F9z-N9k8J%?y-%@27?7=on+MYk zwp@O3b7KZu2=og&VPcIU+B=)=uyd+Z@+NGshB@kM0`f!QKK-K=OQf@a`^gx$C&!<6xOP7%oa0 zjp(b*t( zbydo%G?Y0S#V)7wYy0bA(;6pI5r&FYlfnB`Vscnkgr|RpPsK~{xA#;ZR#nDDpt$2K ztzZO2{Q_u3lgdOxF@9II{QO31u7>&+(Oq=uc;L_?D>B>A z;x6o%)<^t!Z(m(#& zt%vdB+*9RHA-qhcAV-pWDoo*CBMYg%GK;&GZ83wJgg7=d`}JcdQ0*gBMWHpZxlA@{ zir}I|91TBhXsmHYuQ~Qm_WB!^cHMmIa@(7Bpo%R1uXygy^t{S))Y6tp7QKxuz5LI- z*^K9`M{b(#I2bz=Z281GmQ{4-_$KAkY)U_(n*mXFF-%=R->;>*-T^C_{H`O!=CtGF z8z`LXO^*e1Y!sVpfA+Sdcg5F4l_%p2rn+)^?2C#rarz$DuMoI={VP9hKU-)Bn%~Yl z%Q*LBsn;h#1MRgrGw!sS5qiGgX{A(Vf>E$c0~h~H@p%?Cf4*rzzy0tbc<}+o zc(FKHtWcx^HGYl#*U+)3Z^xz%eVB@z)Y7n?S1rT=X>u@vp@8`jX(0r9SeGrp41wd| zV3`7TUtdFTNr=h(a+2o?;Xlvish4Soq9_N5-phDsTMtx6eI30X`h~c@W8FhNNYPj< z7B^1kUq0|AeQRX)@cayi40-SiSXFQ%BKN|r?%csKz5V+#dVB1XyKsqy^J+;N+ES}(0-lQ|Qc0r1u-}`6BIS#|f4Cw0 zH&X;Qq2LBPP$6N|x6wDPAe-AE135T-a!CFgto#v|7x(ZtbPB9K$D6%C&JE}?9gQvDT|yI z3bb%EkG+~?!mYx*;B|rdvKpsCUhRa_@Tx)LC#ovMgUl{W?Jtk>D;>MNi?0x@TgUWl zZ}C*l!IS&Rd~%)jO2KCFur)%7X6A!yqP_olNfSOD3GW$mP)JC%Ju_XO z64Us=AQE2GU}G)cjQs50HKW6Zo-G)7HoVv0ApNp1LFNR8681bwjy1AuNQ6M;DI$op zS&9Hpu@sI>3!*;1?*#CL_ZIubn^*T&9EK7iX0$2uWQo7iG%u%%Pxo{OZS5?)UYi=Q zaZ80;UT#u3%W)cJZ5(oVTf`JtP-P?VusGMK;$RCA9%sZ?&QKdppH8GiV2Is-x$AMwy^Cr)3>t}B4hFsAPSvpAMeY1Qh zox+1iV?$Ei%OwSYG`WG+Z!=|0Ohk;@jD#2b$@ z;IMxI2?Pd|(=>k8UPc0(>LYr+2;FE7ZtR2C+W^;0=peQAvej^9wZybo=BVQ#w&GzZ zjb@9iz5J^!-zeaUDkwwODUOI$})$c7cU#AuRO zfV}Q$V?6i57N*C(dsk6@AlgLs0l{J?-mfmd7-H?ZBv>-jq;cTCcA?UKIeR~QBjyRr zt#~Nm7tuY@F&htqv#L-*v4e$gRELvrVGGMWdLD)JXj{OzGs{}<#%}y8UkUR5*u?j% zTwr`s(i>yFvUMpc>@2npwcdz>L!-0sJ{ly|XqFL&!xHPvfeUvH+Uv&=cgK3@m>qDc z3HPO69^ZBw8ds+`^V=s;oGW|)rK>P}PYD};^{G%-RSU-_nr0~3arLD6hDfCok(LAt z2q)@^a3NuyU9hVta0d{$`$ykZX31>a+Zp)7$Oj<=Jdh}Ihy7bNNl{#tMH4=D0vnni z11-bX+B7F>om}Q~_zl3!W4k-Djt$Pywk-L)wQ}g=f}y6|84pKC%iIW(;S@sod~E99 zZu_O_=^tf6ye`0R2}Q&z87R&(*EnnQ%7pJCiE*M`Di;bC>3vq(Y|Xa?L**HbleSJn zVZq_@)9P}sVFBrq5Z9!ueg19nrJyNu=l?n~Y@~>p#lFUJ6ev?+mI2$t#A5P{+wr5b zH~viuE7PMSWKWgLH5^{5s^6B-&dC^#|EsGHUWb?I@(G4C^_PEaQAbAJcs4sL>k@oh zUaX#%B+WnRY`v1H1JI}bC9(0dN`>F5OUQ@c<8X?v6w>Rr&SjP|{x%0vD3)jgZV}h+ zG9tJ)OYb=+s3lN358c)VOz{z81Nd|vJ%!V~5a+-IYQ@Xr$U%}fO~SnJ;e#T?X4(Y) zl94`CMPRl2R!!oHG&E>8RDJB$=d7|1(F?vMFQ}Usj6BGHAKP{BeQnUZ`}^nUfyk}2 z!l4>y_}429OUgIeT<#3VX_d_mJC!hh_s83(QAo3z2V1*;Jnp_3(LGQa*|P@jk;WLv z_bR_e9bSkyQhQLlxQS?FLhUDGZD4=%ubx{#C6hwYC1^jb*U{eRebqOuZuYVOk<*_B z3kBUl2JC_e&WI^t4{k4nPDJESGy3VZEKx9x@oeEPoXg%%WV|$H@l7iigEn_bZF!?qVjX-syS(4hr;1Xf*rE7YgFUwfQ%eeKy>U_()Z;>az3%uON;V zvP)O$ROA4KgR>*d8DXK6o%rN;4(NT$R$>FyRwoboBB;doqE25z8l8wCrne^<>v`PC zfOYsTUJ*o$CzpG7PmC^)6N#|y%3pOCx)p1lOM)67rSMfs(GE-_rA0;kucF7u4wW8Z zQUns2Z0t7Qn>E7myt}83xgQdunO{87h^H}`#6WTLmbz=Tltj=tG1`Pk=eVXEb!SSz zv(CeZz9)+b2?ITF!*FWiKxFr0ug>DqZDCyHu{uJHa_8}A=_}Bv>uHy?mBfi825Qj^ zM*AAR%l0sCvP6A&(5AOazhJN}>D`#-fD!cZjse2)Z7S-fVV(im`NfbcqeY+3=r)jj z@SgrP&3m8?vHmq^;M{`m=ZMwjrkV9mB93l&`38o2dOTk%d@`rKy+uRa(B@b_lR12f zU%n4fJo`S3J7quVC@?s@##TyK_E$tu?3TL}`&z{$CcaDis&i+_sTTn_pf&)Th+S{Z)uQJvTPaP6*1_T>hn4<(Eamj$ZyACA&){|{4-<-& zEe#28c|RLo>|~tf_?4k?f}yCM+HD!Ek2a(OmiC{*pG=8nn-lEq(luiqzOI0sgg-oz z0_)r=54!`dGK|1j{)=?h5iE6aVSnTT&_R2f2I}BT{N;5=PNrbBOGoFu@q_ZVb^E^j z9#1)KxIMgx0M_~$cv^v-kaYZ*{akb|>Adox|A`{qqs!Xkb-;z!@B0ij@JLdAnui9O zhkAN%L8ONt^pCB`t$iJ>qXi}=|89zynzq+Thi}D?wKjR|+RVP0q-MktE8MLYQJD|j zrXrE;^nNA&ZT1`xby0;%+`!z#iuZF98cJJgN_;f)X%svMZ{vhQLxbYTYjx3qvl6M1 z>`T)^@OEHS!}TFG6YM>F;t7DerC*Xy?f$Ux)c5Cm9QO6K9L(8CUWJToPQ)<@RpE6W zv^7ZV2$@n*$EEI_ufpm->$8&+)n0N?08NSn6m$slxQ`|o{N-u_7YRZqC`>O(#%W7g zqq(Wa_#hH7dTLV{iXTt$SXSA1_a3+9#TNY$fp@9qJCH7=u{tBUJ9=%2%uJk2oe04O zE28_1L`9F%ntKzVyOI7Vv7Qa`z=_6g7VmD#9UF?bmM2khRIWg?Ii9;tZLwBKuiBPH zCLP6AT(Q;bp9q3ua&W~a%4oz~jI<$W5K;wBjma^(mv9gj9WzGS1dTi$4}SQFOlBKE zA(&N)V#q$%phou27Ki1lma>DC4BJm+TLcj_5oE4MZg|UwL2ckw8?tlYUO0V>VNYZFjs(BS+GzTv0sAOjSIAx)~we!5QJWj&EFX8fVcv z#q6XRsAhahqw)CD1$U`eWBCTKD&LsT`wq*#`KPMg7=5834|K>L*fDUcxgzmxiKH;@ z@lNk!lcf1EEUTWl)wZC<*Dv9X+V77Ja|`vv3u6$q*Xp61pCoe|(AnloaJWeOQ&>OC zy5eP-Dn_CE7b^Quv-L_Oekd%9|HKYL^QLtfFo9xoFlA8c7VhFdT_wKvN>P346sV@v zrGwu)LB$&=LRSwiZE^U=_60u<4z0+R6X{aaj|WkEv8-8sz6b}Zg4*;2g17W+nf)m^ z@SaFrNmk`f8>m-`{_wOmeV`FrBR_#l+&ySfvD15~d+5jd$RDpKFDDyOBW0sSIz9|1 z2WD;p8k6(MffSE*b<2vN$FZ$O7ZceWi>2;N*9M+3UMdx~&^8=ExEaeNURNk1)WMnD zDw&*xr`*>HfQc_M$Y%LxKbsqH8vf*OMxYZ`9a(hG^=Vd(yd0(F1nHk!x|De<)%k2jXoPS6gkUe0g|QHDab!&zH^sK8wq z>7rS>MrQf9PEH(8L}C&1a(245$j3FBvhBa&gWjn%A)wg zPMQR8i@5;E>uyT2LW_%^ms|J(zm)w4=!x$NPaX^KeDS*&FAT*yizb`mS#z=7*p_5~ zCqK=TvqTLkj7rvdm}u;GW6~{}9K4mFq4X#NPp8k%M+BhNA9p40p%cmDTh4GVo`W#tJ-iL$xU#>^A*d$Fs2%>6&PXsAQ^x0!kf1Ved+; z_v81E*AnXTpHjzt%f|bhzCE65-zP6mSs(vW??g1y;$rY8arIRf-gQoZv=5mPBMp%B z5wlKcKB|{Dp++87)Pd$xeroUy1i9ZoeTJ6iIv+R%ao&aJTw1v%wJ+wO`E8uS>se1m zf7~|Vqmn^Ffu_Qu^{xe5B3QTYb31IwrTGXWkNV!Qb>M}dGU#%Nb4|hvuQ_OB|7cO= za3sTpOkXIX^em<|n%4be(pvmEPBe{kXPFWk>=`FYLUfmar!Di5jF=fnkLqk zt?jav2B`s_BX0wi-bfqDG)j+nqb4GELxZ|ZwF6MzdxC9b=6m|ewispIr0DBf?J_G*kPtD4 z`w3cm|6P2*-U7~B)RZjAq@eDMLTEWxO0#O;yB9g4%cGp8aZR5`9F40@i)2lp^hQ^x z@HT-fW=PjYpqpF+%UJgZumD(-7~tsza98igpZTls>?e_4>pUwi;!jn|5Tg{paY}6b z-;z)46|^sI1*ja66}!#+&h7tGRjgPycNb&?m`vc#`cNj4$-cQ-ksT4w1$NntzCjjS zW5Tq}>}_a{5{eQr$UC)|8dm-k3p;Uynk*8)vl0tLY@b_R6^G9k z4Lum@i+Ys>{Pu+tu-sD4ss72O#~F*wsG0!P7Aryd_qplVv-*gmE9gC$>>9qq?vS2? zQGExGPAb8zrQL~(<0dJM9(*1*ER9LVDRu=_Qy*gqkOzi;)*~!x@N>tvz3+Th$!4&` z_*@+Bj=;L#dNj90?+2`6Xyu-&r zarE?g%P5_-sag5Bia!!ENhcp;MG%lTEg?a)czc|hk=d`p(}+{Xo^N;3E9k7U z(XyJFrx7Ecz|r?b+!ew3jjhO=*g_uNq=hva27D%d;aOaeR6+K}J(0yIswKTI;~2g- z8!s!tqRNbNQY%!62s7f(dZ+iJqV?h1`pz43Pj3%0GFMXd+vnyL?BTrKt0;xEJUk+z zzvUn>+lpkIUu7T6i5Q|~=OD%!5 zO0i>Rkz9+%?e7Y77+|XRX4lq73|S7nh#LG>9R+B%B_z&*Qs2UZ3XyfM3qGF}t{nAp0NphBOpH9h|fjC>26=&aN3>j*(c$eXSs)FrY&ZgOUkvQdWu zqXb(RgCN^Dys3QM#(fh+^A9#f#8{Cfh50qj1i#HcqCucHu)NVU&K16LGlNjAJf2h0bj`vajx}8(r^?C=L+5uxX zbMp&-^XD!|`+QjN9O;g543vt(DI z;oPFSE_z>pe>qHtad4Ivb;nAZ<7%x%;LP_X} z?jzou0K=u+M76M~zi32Xy`l_w7%2;$sS~~_VFNa+_^wAx(b2_PWh-Qq|J3+Q1{OH{ zJ+PC81Ee+AHmtCyaGT-zWMgiIVeA=Qg9qE%T{w!9b09i->SbrBg*x-dZT(?FLOCmZHz&H&ftPux9@*rr#+b%zN;d95#f{kGPwlDlC^&g%fSV zCdb~{LW$J*80j*wWr}ADQ^BFJ6}uM}r7Y5Mq??M0L&@|?j1R{g+$a4KVncm=EMps| zFz=}=WtDNsk~fMnE0JOBLR4!?gd3Y)MHk6a1s0bs#roo3bym61v}-{2H1T^XSrXrl z6o!S?#@s&wClZ3wxCimWbg!%pB#*w<>pF%?<`<1JVuud~KT=D7^qo73K?7iqPl(-) z^Gs4`m^pB?m$R2O4=TcvU_n5ygW(*`hC z;$;#&?X#@0%P%S)Vq5={*vV#LM?(Qn!jH}{-=`Ow-Wg$@ z<9Cmyv-+&y(J#=!SAv-V`qHTHAf$)o6>hgqV|ZL;(NxV0TMB9fWbj@+8}nH1`pH*M z=0htCV=?7lPsQtlGKbwqK(@+Gwy`PaBw7@1S%N1(8PInlBH%#Rc@~@cC^$1@tzy8( zWeV~nep!79lJdun{JI0DwJ5u8oLq(FuC!_hlTrDO#K2UliDIx#BE?*gJC5 zv%8)`?w+Ayy9>MzJV6tyt&=lY>>JPUULE;E|G`uFL0`NkkRf=cdUfW`00|Tr-v7LI zvO|G_)5$SW&VX+L4Ch|+GWStT8gNR?g;?t@=o~@7`hGRoEh03(_zUUNoetg){srROHSy#AR3TjGg zE>)Lb%MO^!cgH2xHAM#2FGv2sImoh!|LIwgAi=nb7>{-+zUuJy_|k*zrv^J)LMSVZ z#b?m;i_5HrGYNtwt~2J0gOc3FIi@^?as7LlcG3#z7b}P>3kwTf#*zX&oa2aPGJL`* z+p>7RwK>)-`9D_%{A0bU@~06QXOd&amDO2kj2}Oq+9VBouvnUMrHgHRz(Z7gvk?L_ zL04;Q>z#oJV3Lo+=((xZNAN-c*ayd&Z0K%2kBs^V|L!rT7DNq_0Jh0c z@XKB)(CB1jNxFE~Yu|+jOP4&y-cU4qHzy!Z|Df+QRsN}=y9S7)I_CN*{A3gav_#mK zUR5hUe83<3pi3fsZNZ_}Hq|}wkr@3wWam!Ad~uIp5d({Udhx#<&)O~&71`|)Ys4q3 zygJZy#xzHb!ee~+FG^$T**;g0K0a{}D1R;)Bjf}3r)Pt}Y-NY)mY8E9z{P%SRN&qU zOG``G_{al1Pudr4fvyG4$Pis^E0W7gqnZz)cBgm+j57Ch0?$BO@pybp%8aKN6-V42 z48D|~roY^Nc$vjB8S(0@IjwMi_ILhQA3I=!FM*7|%w#a^)SO;lH|6a_8|HgAK zGh>En`0yDCxid|gqJ{>}ADw)o*5s~SQ-V+e=}o3!3?3?Z)horb*_ve^$AGX})O{-` zmaqV-=9PXfD(x?lz~Qm2-YeO}E+d9rED`f2$NEmFBwp5KQ9oK>#UuSS2x_-)WH)O$ zcp<8!xqETWk%`nvmQh9~z78*YTD%}s?Df3%AFpF?@%-gpgSixncYz%yZr1|wG!C1R zVDBZ=xHpQglhNX@r^-zZ4G)L$!S{il@*uD?5hSL1#fC6Pib}PYv7WIg|0djin{EwmceO%Hd$g*QGQ+nt9CGZ zzzfz#59Odi_Tvl#5N{_B)zHY8d+v%!06o5;17wA}5et3{lbX7>o^qLfZ%vRwCWCYq zzHaF{9#p6*G$GW-a#s!>5M#13&iv?Ut8C==yG;5=AZ?|5I@t4P@t8@G!N0p~lnzuy z{WuCxt0Zb@5Q=@&tzYw;W7t%1G!rm`$vN^76*aFsKA9ZxAa-A?O-<8IieI~*dI{cg zl6&sk_!cv<%`yE9st(c0j%Ioh{BmvbIKf!C<^i<|@)mN|h z0&EiFF$9-GjD{~XPKhU+DAc$p^QFbHz9GGFBo+w!u}@csH)xrC^~@Ztsr=kfw4|;0 z>Kd}2uA$JaFh9B51206D%55zx3NtL3~Cw;uoOK41$y6Ft!`l)cTlMs{MA3reMo6vgkQagO_jAo-m2mz_a@+;BK*gV}`$Ur-PxX$vEv6 zU+Sg2sJItw8i1Nxc`iPN4>~)8#M-|LW@(gJ9SI1ascC;ba`Sgqp-54+-^N#mP=8ZU z6%e1P9NXpo^u2WtbGN7ISEJ32e=G}GM2WZmwAySjK4Sbh&Q52H3)khrmKGNGx3S|> z_OnIeC;8cEpjQa!MXJKjwO-Qv{8fu-XG_Hqi@bn?k7a1@hTB)HK25;%n9ez?H0@oP zmBbG*U~jB6vXp&n&VXcoEai^uL~eCj_8H0c@O-i+Y3YQkr>i@eq+&$N8kiEM|MXvH++~YMhB+Pb6GTA zyT=|rV-2IJ69G%!fB#-D0_wSY_Yg@lzIP9MM#VsH^H9a|Nb4ix_&4@v^7umEl$>Ow zw;U{M!4Pr$`glAt@856AtHTlyEI*C1yucgCbi~Ww{{IUqBV`d`4z28{E}Vvnsbduu zcyRn7c;yicxh_S3gI_h;D=0rvZ71V-Q8YVmo1r`-gGsupzy4pS3B#Jg+c5Xu2wRE~ z4T;1vqzKsaUb}Xkx3}ivJNgG?k`NPYHyHJEgd*;1=1SfvN}+|lb!Zr0v6x1mJ5IQH3CMIGmlEQLN;cjC`oplA#El655XT4F*5on;nHqP^# zmZdS`mdPqWM_Eu^oos_tYsTnxF6iU8-)PV*^P#14vU&J8%bo#I21OQr{H9nbOJ^O4LC|65?qk^nGgNm8#ie1MesM#D@X`D55sYXw^hMrosz z*al54s2LrzQ(=MQW2)d|Ip0M_c%cb@VW0gd*FRfHY+)Hjyd!{r{OJ26|L_4SyM;B5 z6n#IXp>iL}QsknrW+><-r9)qDKt9&3jM}j^@~!!LA~)fX(fgt`@ZcDCtT0_DovJRs zqHjnCZTdFU1mcO#v4DcG?!i+(Doz!D`7(rO(L(Z``uI~j??K>_MLJoS-uat;T@wai zam~B%b*ZZ`$m1(cr0ggdDg9Sm(Qldg9dKG&LjgW?@k|XUk~{4FXv9rH!r;jFE2&T& z8&lLSG$QJbflT}{jmsD**{fRBW4PL<&|mN6+jF_QFo61CLZ=>WC!kp>Q=4?;2-}Ck zDamGCadi|-fd}adkTw1*t#${oWX1#RErxj8M8dom?O_SkE~$te#l?+Vh9$v$ry~32 zA@*naq^KG3<&_y?+<{UEBK-Z#)P?It{pY-tmurnJ?_;(x#6fn$10to(&iJZ?oG1>8 zn+)D?J$r}VJtb@v04~T8AHb^)-(`QjSa8M6O?Vbpot$X#42SQP5(eCS?%^eYT~10N z=p4m9pqzMh3P37JV$QOB0?~EaR-^)XUx&t0=yo%LgAU!*E@$E)g_coK94HHqa$%?Z z*j7x(MyX?Jj`z?j=VC_1Mi%TJoy$BG+l-I{8Wg>170rHnK*g~^pg>6xY(a%_PAY=%d>aX9tgFbxy z8tj=Gv(yQI|B@Qn4>$W+Csv3gPo`sV&;Dt-3+I-}Cs#7jCQb4V+ERfqJRNPOPqN=U zZ;{S@Y+!%8MBaNr<*TXeZQ|j;D+wdMsEmD2`FfqJ2m^kg8GR4d)?6f7x3}-h)00xdh_*z_g`?Ial{Xa z`*98hwNtEMl+del?`o4j1x{8P_*%tb;ollc2O8kM>`d3}GklPkxaH(EnW3wGtZ!QE z@3WRp<=8FppJL0WGH=K8M`2Dh;XX~$5{909C{N6|`AB})n!Br=m!@yaZH=KMsBEMK z&B}xd@rizx%<$2bPJ-9#nDeRJAcib1;Tv30ust!ZHaCCQ@e9&Q@^;L4bhY+95Vzw@ zA|; zi3)F<+}mHmTum;Q6pbk(+plC5D-Dn+_@dC=bkn3G(mC-qXEN)bdqrhARK~g3s8M|?7?A;jl2|a!u5EZ(1gZ9;H0KKip<&4LFu++EZzqTTyn!GLimR%Ph zGg>L`H`?S2080AZJ=~mo_eSs+r+Lm|>Q--lLFj|nvExL_=pK3nfT-`oP)FD;grkZV zJNWb-^3I<5-%OI(&R|oP$J(?Ns z_3P91?YN15K|%8<7kQAxs@L!V9Ns7$lK-+IXiI4n7$!mLApYx^wpw9_z3qex$3Zug zK`q9rnqO$=keErJUD#LQ4=xikSGgZYbl%@KBWptnz+l%k;2(*ZoX0YX{aFbk#D02L z*a;How=Hi+FB%0HN&E!|PVK8RwwT?EEFFTcr5OW=o>c4mT8_9%W-Q)q89ONyd?gaK z_s~U$5eu(rnV)0u`PX}UGe3!~EVB-kIoH%|I_Wr3s6zPG0OKHlbh_D(Ci}jYr5ROI zHDjFkEP)yi0Y@UP=)aD;9X+zwqo?H~>CHl3zVJFX_oU5&x3xcUu><>@TtzoRwmN`9 z3lC1s=%{aRq+26<(le`jPB7a9T<%$Viom=W%SS?fgLrZ1Tle6ld}mJrgDe<)y9={P?8dxN@tLeHq_M}h%-D7|CUdXxCi?pIYqcbP+20yJ0j&=}F)v{v8nZ`f171)o1jQDS5#{-4%xqu0jV6&bo z^=$T*8*BK~dp>5e%yl3odsv^`u(Nx659Cg#e)KIROP{Ny``mQKVp{0!UVu1iZO5>q zK<2Mh4v%h6*H6zn&2^jz%c*BD~~y6FL^mTO)*ijI%&hl z11)mT1*U7HKG96vj??L&Z+-BMnR)rw$(j+&2Y(tV4OKnGGe(1gseaowEO4s&WeoP0 z9Rq=*qp1bslDpHHR9mW~e4JUuc4vWh!Ckm@>>dHG_9p4W^19#~unfNS+ac+kGil5? zddgsp6*}zzPZ9+ZxO{6{`1K>1=sGVxa`wvS+MDauMnPiO zDaaTrWnQLS*6NYMjNM9@-+zaio&19b4R|(|EQEh)kLARv0Gh1{9J>hXvVE(hbJlM{ zo-RgU+g;e?=v2gcxfC>d!=5X}k7A!m{w>HGJ7_YT%T5&f!Ui1NV*+OrIAw}@2E?PX z3DVl>+KxP`7-_qMQ4jvlAZt1BZmT~%OXQ>qF}0h&vST4r@JtTMNn2Ts7uU!{kKjmM z0I0$u+rn^IwkZM(5BeU@Hs)qMlwCdH_6+6f8N_I?Q#}(Wa{}bAOR;IX{n(QvcO5G+ z*1c1!WZtxMCgDDY!WMv9{zO|SX5u~A%8p9nCplar?gMKQAV{x-9qYJ#5QCm|26rP9 zZpm+G=XsQNLR?$FGT%J9=$zf8?swsnV!@t1fpQi_jOxvn+?e5N=gIysw_&@V7%q)A zN6M^@d+xF~*Wwx^YL>0g=(@P0*Z1S2N3O=aTfK^-Cl^FnpceC|NCf0ygw!TZ57+^( z^5%9M;lQ?FX@H;E!WuzdzVi*30jUW+JtrQU4l}9uS-165-s6H!y+3X$w)DqVnfh(i z*H#ahG9shJO~=P3{XR$rniZg+Jt!(`Ic;%3mMH?Xg#wF$ws|f+*G8VPNxUl^uqh5D zU`-C-=k;GQGwKWBYF?<_4zOds^0vss8N;>NBeOfu1 z=p01NVuF8dqv%C>u^u;Zxyo(MCAVQ!2}=Z7sc&Z7hnNv zh6$2PGiB_1kL4&f=kZD5lJUYTYc>CF{MCkw_n*2$z6{7SK9pf3|Kw~*I6 zQ&||{dB+V2=VV)BMZMCuy%ZC-LSTMZz7dB7_I48ZT`UqTLX{Ak#Bc%KuiZTFLhEWq zA6N5O0Awb>9Dp90s&5!U0Q>vfN}F%U@C6`O-O2D1yy>*ME87c;wsW#VV=s`Xzz@D@XLlYjrI?;eaDOi| z(^iGzrPq$Io$c&TBW}d4SUQRtajBTJR80dT^J}rQCmvo2Wi385iM#MV9EUz=Dao`) zo-XXh48gpgUx*W0BEVR?OL41ia{^$2YpZ!CD|JK|0flP(^s0AFB@yXWk7Z8gSvNHm zlPa~|Q*0o1khq|xx_Iq{!U%4HXOOw{kA)=KlyRGgie#9*@SYelAGS4DDf zb5v<Cx*J|Xc#7TpUtY2COr_~mkX3XGXDbiJ$G zprv%J7>ARRf&tX$Q)m`7+_&e|{eUNNOVrR;; zKvS=QfDtz~Yo_;_0GI72DW8MMvb;^u-Z>_5hA{ZRmWgGNj&ji$ZLE&;u9^9}N zIU7^dpO0>5v(TN9#3MH_r$my8wrJGIUoh96$iE#TUj1u3I|*w8^_zAgw)D062}o|% zv0m*iCOym)6oI58<8ZQR2cjZXosGa{Qi?d!@X^4@~%(~RHv%5g%=V#KoXif_<4Zj{X8f`FLh^Jz`KF|F=Xs57=Hri{mRR)D&;Z&qG6$` z?HUwDN$da;+{GD5#N;4JY=jBIOFAbL0SOmy7Yd7u$RuWx!D_$>&oi21cKDBGF;LkJi__;;&4TzvnlzNqPR>|-M^>d->I&*QcJ z6i=N#w)-sU@nU^njYj|GCRGzd7ERsMS%qa;9SPf(eS|_YfQz_{xs>}&JJd~Y4qWq3 zwjmv&`NPp3`@n2mVnS6)E>FPSa`91F1o)rs`Ex<(2XLr!U2ZzeTJ?< znmp>>p*OT4=mEso3(NvQ9xHXMfvz6Q$Q0p(#{i6gs~Q>a=jftjYpxaF_V7eo>{0Go z{wkpT%uJcFt6&a8U0FQpwv`6yi)L#m!@!NS?Z8l8lXM>hW9e#V6I z2$7f?X+SXsL(NICEz%oJVuG5>hj-MYUilT7XB~%MkN8CPMm<&Vc)TvKJMZ6FMb>$V zN!QS%X+|FtfHm@sn4baJz%v|wDO3^sC$j|pw0bAljg-xaH@-O++%8(@du_U2>jQMk zY*l9RiO%g25q26Y;V$W}Gm)QJcsu?KR&rAb&DTQe?4-HGX%WL;7zllXSy>&O7yj|p zeg;q2#6k@zjtx-;TYP;xG@Ess8~4q4r+D~YaSx%USaG5z0H}f^&hiC6+6|if?w1a{ zUQj73DuPD0slWEdt(`Wo!Fv@?C=Q_l@K9Z)zt>rF)4YNnp2+Ta_wK&@j*8FyDtbqF zcawcJF_aCGrdQ21Idp*SgQ*~!Jw4YBu@Dc4sD=D`kV+_jItK28>|1Oqlb2S8XXr^l zc7U^rXm!AQHV7j=7krP)+-4)aH12pCcHbIZAQJL|=cdD`tGRnk5M{DxBDD*n!g*Ze ze}@9cC?YMY9$Q~s|6(pHDkCzdB_EnSlJ_I%*VuRo zGo%!6s%4_5QR5gw3+KKJZoIkR@4^cgnqY4eUR&60UcK&j1CQ4gXU2%$_l~1z-ureh zv-9UZ%w9Hmpf9gGvbShQP?qkEO|-gG3?naz=xqZ-*8L}p{%m7wZbw~4z(PzNIvYcgB>C?#GQVJTr z-?}Sk3)ihuB$vA#_rzGu$#Q#kU9xB%9&)aUhvG5GGQ_q=j2_|c!l@*f(Z~D=_C{p; zP1G(wVX<9YT(B-R3qpCF3j0}H@#-v|*QYoN-$Yiqt7xF!u6s%Oxuxsv?Cgq)?bpZJ z2(+}%YyeajVk7IB(eeHJcYuHpF(Nh#RzF;`y1#X~rhx4pKYpx`7i^Yh6|()`PaD=T z;nfGG+}3uCR=rZY>E8K`o50t~VF{i1#&q@~OrVZ1=Qh7(&AljK?_ZmQ{xzkxz9mHD zWPLEMy>69iwahNeg6!(sPDKqqT{^j{XN!|jzLEwAj{1in=sS|YJUyytF8Mou5QNU9 zQN3YN2)iXJQYmU0p7R}-ALYV%C-5r?=F2wm0IBrQQb5Jn3s*#aiy9iu4@?5PJ`yKU zXKDYjp?{IXbp8mBQWceZ=&ADKP0fho*Zgx|&Y8u&{j0jC@!-$P#65FRkl2xTDZY^P zM06(ZHaS7i-FXH5Kc>DsF2?o!|CvhUWNAZ$nx51sN`q1zg`t@wgfOT$H6%-EleR%p zaWaj>ln|BEp`yi7S}1FiC`H;7Dy;}frQiGRe80cf_n*(}ygts!^vrYL*LA(G_oCVA z9}FABj~_q&{s`kNj^N0HX;8v&fWMsoKw0TZB2G&~!f^A@bUyv-M!VUwuHa&OW&RK{3J!RKaT!s`71mK5H(fO-LoMN7c7ta;IttRl9?4%|Yw@`@`em&jX-?55!MSR%I=s?u>ZNCI&=f7cDPK zBd?T4Z*N&f3~I;f=fi;n$nt^BlUVc5se|@oMB(@UOXR&Nmh5zJsrmIZasUQ4m3=#nc33t!S%j<`pe_TX3`(1qjXxVI-GH`YA@|#BMMDg8W%=LZi@_%yV zr$p`9AfI(a1$_?i?q-fSZ*`?F{3j0e3=9?I#EK-*Cr>ZNXi11c*aG176n`c%BPf&s zVob#cABU&^LU>U;21n6F{Ll5A3l}fKBgW-cHCJYrl7xrq5MAOvNh$Io#<-*l7XAlr z)r;iJdF;0etEGE3zb!p$nBmk7TCx$FH7G}IoJIYZx)J9RyBEl}sH0M80#1tSR1`nh z<)Yu{wU8CbowG9@rTHaJ9+z`;P8`?1>o|=j*|`6mY0ZpJ%~#yZPEddmGO_h|3Z%Yioua1@0iQ;XjmI>aTmwBJ|*HJGpr3p?H7fr@P4wy##uYR zU5Qau=FJR->|_Food}K%zuoX_=f{MQFTDbXL^bvJ%(~V&U$+i#i;Kt<~!eJ1WFCKu~bl(Mh0qA*6*w>j*s3YraEKi+b zs!^2qeZwqoIo`_BhP-f?=NzG(y9+Gq3J!j`Tuq!UDA9wWGa~B*+8M@Zq7v=VM27vX zs-kxce=W>de~vAF3PXFZ)~Gxv0Fg0fs$rZh1HC3V;Jhu1u=DiIn}d(zuzs|Wntt;6 zganYXdV9U7i+>I@zYgwt{kv-TN8y8^6IaWJ5jNINeDBy^_-vYsAmU-c2iJAfC}A5v zc9f)Y{-1$AJ+f+&4hd{Nb-TtLA`XyHe7$u^xk+ildNDyWF9`whp02-$f0wVC}|y|+s{x%uj{0{>+hK7-x=7xYp*0FLUpv??L?B!)#R}$b`(G6d#SB{Xp+UEX;Q_bF{aTR z<*!5S9^qpy;W)U=0%s3qZxFnlxL@zKU0`P;W3Q~ExagY}6zCE+8}g^ua?ocGsV2mD z(6wje&{$lo0Sf=SJOhKH1w>ezS+}`Gzp9ESe;Gl~gPsR}V zUbzsRwRS4LFMPRY@FI^UKD3pPtS!!|c5K*syBanX^v7v`=Lc7q(%t`Fn`u*YH&J?3G2P#sCF5B}83hcp>Pf!HFzR z2}l|tg}=HQ;hekq5CN;3t`c?VQW;UAl!n5v;M)})rZIeVTt8vc!0E|fj$o1p;4?Re z)0D0bL!Jl=_1Fv#EU0OQZRIPqv>d?tD1PyiUsLmigmEj6WtS&3ZQ=uzNLDB<;R%+? zX)0K5r%Y*kWj!kF;>6_@@Zma{qz+bof^PS|qwwJZ>n`9d+{%c(lr^E);_8BRkUkbr z()HP-TLbr3&S;hEsCOW=K_^6|g9aagnj?B{$qfd_Uj`hk7`}6;D|Fa|;y@O5rrvp~gu-*PPH@@7Y&wIUHEnh+Sz|jN}oS zh3fJZ>3~_VriY4QOZkQ#M5^gUcuxaxs)n?3F~kFmUGHwxblR|tN~I7W8mwHZflFeB z5+e5&A;wT5ffo(-MRcGVj~bkPbmYdR7dVSTGi<=6!_4E+hX)QXmG7?pUz(Q-WVjlh z1a63t+tl+XzhfCZ6KvUacfDEzZ~OF_!NzS&kvv%n+q=Wx;>W|Yh;DItAWixw=NHVY zR4}o+JvuWEk%gKOHtcIvW!D`tma%kHu!0&-gHlJjSBZ@1AP{O9sEKP6F5V5`oU4J1 zBYd)xBchS2@e9E+3M7@O0MXn8M#U4ABFThptfH%+{RtWk6dLkUxH4fLwW0hqbE&K| zj&AnG$kU)Uz0^UU`Q}|A)j zrGJh4L&EPS4xT`L3=}}HHs?+Iybkaj1R~dZ>wf^l>LzHcB3xAB;Cv)FFk-q1w9Z}` zymZUu%3;z@b?Ao~Z4xT*=k4L{#`l;se{E(q9O}4urZ4#8esF3ztIo%#ktQf-3+%=-{= z2}=&}9NP1N#I125;Dx>gkViBbEJ%83-WBOdk91oy{6~b)+jSK5)rD(zJRBLVWsE#v z_qTYJ4`^M+xG+<~!tW%&N*?o>>c2U5@%4hNr!Y~hSZ9xCCz1mv_bOo0jDFv|AY%Pd z)?0_vljU$0B%F(?(#ZAW1-EMUzzYK@G_i29U3s9dE9Lt6`B|yw@@iq5O8#U;3HWtUE`k9 z4B$hSm*gNp!JRT+6uQ=03fnGD_L`nQ6V;AMU%{S)s+cDN%zz^#sOHx;*4?VcsaW22 z4a?WWG6Ar`lnwLJW2neP;!=VIa(2Bq@JsW<{ezG854H?{+hXwXlkUYJ5*mWt+k0u< zp4nizDW8JET_eZ;!Z>MSUz8L9=QsnNp3&`aH>TNFNZW(OIV1eTSRF^ z;P0#7M`k&s$Czr+=yrtGOgDM4OS=6>+6RBvEE?LX#R)K!i9sh8ieFTd}Iv zer!FxoHIj#T1~Yj;j)5QTd>03nx&AD1Uj4pZFkSH7;C_E9YL^N`PL-?J%L@gC~%E8zdvOOGZFy4 zN4}`RAEM$qT=rZ^^yYWMr@wM)ajuuYkH3Gve&JU`)arcu6jS>d-%X!}(wYmLaUB{u z24bu7+R%~vtO@21g}*xrf7cGTJ2lqT8EjM18ugo1906~O4-@UL|Ef3@i!0N=3c{9o z5Q%CihMg`^8cj;9)v_>$DP%p&mR;k1MvJ+S%wq)xsJGm)m|IZ}B9cxE!bpFblB7ZH zDzZU!H07P6&x=3=FOF{Fa;eLmCH^k*1q|ww#Z46|t*n&ft$@(^% z<;`I+Rbhk#@QBjb{hfa;uMtlPW4i2T7>*kj4jw49bV-pPD@omWj?yb$Tg^8)LrUUH z*ttDNZso()ixTxqkcShVIi6uMc$wr%mYwhX#5Q{2Pgp3>lq!~@A&`W}lRL18tj4)% zaOCldOQ{9#>?5K@Ni<>k^XH3)zEvXop$Fd*WPlRa7VNty_PP?Bwc_J_D_IwjG!g*$ zPTz(6l`<+vC*(L_{hGRS1#UL*vy>$@fXWiJE5O`lU+ad!*DKLcJQ8B{#w4y|x2lz8 zVEOSE+PqWYfFD*uij|74lgB%VvOF^C95tohU1AJdDg#ti-)KWk=xH4O^}4X2vBz?F z&`Xmim?f0s#xjmVOP_|+c}aebyp_1p*E*ixA?N`AXv?BgxPVO|M-Be+aB_L!y?t;q zC2i9BNJ31U|E1)lJ|&R%7)2zpGFAuHoya@8^toH6|4nMg!Op2whkzC`1Ie;F)T%@V^wkegWr$W-10=W3=aDJxs;q z9m`+>R}a(!QVeG@0JbB4+Yc!u0Nwj^e`aWXQl(gjde(hGceT1QGy^6~|6?vFG$xZQ zf^F61$tX+h8spmY=Thp>ENa^CuEK%7|2xcf6#iP-z3(MsQ&;O#pW!V2gG*=EL(19LR4?;4bDcTYM~u+OEV+EFCh_PJzlD)C>xn&8(U`0UV8etqlQ+3V_EXl&KZA zx}bOovLun7$+R2SuW@{(Z@dIU2+{xcPa7^C9`o+XgphB<&XEv7l$7FERZ+qi36^8H z@HXYlAO!Z95oXuJni|PO@YtA#-2bMd#%SV(Aq>*cGr0~tN&y>TAM7sEa*CTK0+>_a zY4YL@CoST}-HZ{l*jEl5TQ9I-2oLGt<0|N5FUcPo{WO#7E45`quy>|GNg0h2iViqcRN}2J~t9n2O`<$|C<&` z+UeW1X@~KA+VW3(`%S^w(>#`BtB6X6eUnYPGdTXR!Nj1yK2ma+rSPBc3uX-TCrXL0 z3FC7r7lQ431zpzaM``r9plPC0dzw0h*PE^8EU;Q3he3`hL%^ky_0Zi5`2cPgu;CF6 zr#&EDUVaob6;^^D4O1XfdM^*h)ndD05PN_b~fN$Y~(4^Yr@n#fB4|chl$QhbIVf1`&D({H6O2AZ70^$2z zw-5U+DY`ozHi6KA8M=5v$a=tNSZAVx7fCiw-id=8^kuO0l;!WAz;{Vf`8^|!-2ZX` zK0Pv_jP&Wl-%fY=&Q1n_c@T20z^|WwAH~!ILj5D~1GjX{Vjfz}lLVasAhOmPz%@q% z_BPg-kFgm!VEW-HlKjZq+aL1#^)Ol|wrj%2VO|N)&4F%GIT=cmZ61<^aZ#y8tiuPZe53$H-!+F@^=7 zXNAgsri4q`$y^Fm8>JcTYY&GYV(A_!9M|2z=&Xj_>bd+eVU^PQuTD zEj_eadGR&~4$ zO((a9j@Gf^sp6lrF(bzk#Yl5EF0*GQ0PfEcpt+vJI^b5Z!#Y;-y#V|BllVs8?7IyO zB?fYY5uxpYF*6=Xq~we4R+Rsrv+=mMlM1aO=F5#{4_E?legN0WV48-G^q zm#C|Wx3VH^#@{`H7iS`NWZC|o^7WUB?^Ao)L7(W^+R*>dY49PCAfg9}lpK@0WL9Qy zxXU-7=ea9vkBH^gP^qCK#v?Y~{%eB~FO(Vy#hG*^-ealJnmn_;%T-2WIfLh;3@g!H z+%Wpd9pf)@6QAzbCxFQx)!mu@7{m>W+mKhA&rESMe$(H7SIue3ELIX`;SWN*TuzIJ z2YZK_G$W2;iQ(;w{>k&@SsgIGkbPWkE2f^8`*o*l!Id_v23S!hl-eSw4C+(TrAsQF z!l$;WM3ImOe1n35Of?Rbhre@=MXwAbM`QDdi>0e)x>($@7@D7G%t+Z!8uG-j6P@5C zh&xl<^g@MB#-j!lNC*LFe8Jj`b}Pc~gWM8pgeYlgB>z?d9_IcC7uyzh;5=#Y%Ew!= zRAvpN3)CpKx%75xYwM|*i)lA`_7y;Q{|)M9=6O$~Lrp&jN3Nj1Z2zIOnZMtS9sA|p zMIdHKL&Pay=z{#R%m7e64j`DRhm*|9_TDt6FU5#jbmG(sb5@t2>dg!|LuYiB3WB#3l*nmP|F@PD6l5lZ~M z%q@d{eJeF|im`9c-kYWaHPtiV4w1zmoY!_$qtB7#`?2sv$Xku26kJm{=ebPvXr;sJ zS)(4Q3BxHuVUL%{pXVOv>+S7DQ6P04Y$lv>=8yLN9r61NE@Hd?gDQd`JFO8R0k$G$47I7_Rf-)88UH(jqHZ&r-mZ zM7T|dQpj%1^&uQ#=duE*cfuw1>6dT`PH}(G z)+W{hY9h;R9eC*JF%|s0hM8!ds;cS{#x-r{WIy1~-~|DZp1%sqEx4R}Z8%A8jITM1 z%e{KA*pe0p7hY`bFEuQL>icd%FqDmFf>~FZKp4-V#Izzh0AMh7emP{*`(tP0Q-#nXSKVq@Hu<-?D66zQl4R2P$qaUE23cM zdGo-C$h#N*f7E98Q6fpz2}uN4c+p?DP^)_Ob@?9XvmAJSG5G6K+{Ts#Uaij!2OpTA z@HlnM!o-jG9hH12@IU~bIsEf6K<}rEUcWzwb8&;t?TJB#dw_pw!q`<@Jjg|SEsz< z)ECeWhd%)1i_n(knmNh72q;H#m9#{pMJ;j`jk&Z_28kFrjFh4^+ETfq^ZM*wwTIeY z;21g@Z<8h^B|MN!tnuUS=uI^>$u)-Ma0o35#{i8^( zJhES;Z1v*>k1J?#D3ktyD&WAoevU5d1i3-l;-7+1o;WoWZCI*L@pbC+m+v|V8*8l4 zT?8`&Ki?;3&h---Q;9m9X7LS9p1c#>DMQD5Fw{d$#tDwYsvnB9r}##59Jg)_{N34q z^GvaC2NZ#4t~IE{$~~cbf^}oPfLs&L=q_7Folc-%IXB* z5k&qa8pwCShZ;Q?0~5@VLi`vxzz+-uWke8Sg`AeS!v7LHPes8b_?$I)oNHYK#_*D{ zLUm&CyckGN7QC|7d-*9!q9t}%40q&P4u3s#p>>RFisbIVzT0>2+zHOHitlFVKSZ;WEX)72} z3TZ^I$ks+76kZ4q*C4Y+(Px_-XUr~t($!#J~{y!RWpDAaH`YJ zX(pKLAuv_ZF>sqXv>j&`0!E;;SA-`g8IMK$rmG+$d`XIF2IO9HNh=G8F1XD+&>!qf ziJA)&g1$VvbaA{SZ$BX(|0Qs4rtzQB2+7zkIQG!4Zn|(>qPC*=^E$K!uL4#Zu@`v! zYz*nKeD{CA=lz52xAz>2S+Brb|CX{Una!jS-D;}w_TIM!HAa!M7#x@HpMMvV3xs4s zj6~9CG4$m9t`4C45Ad0{O64gzQmZY4VkPin2ds&t+cDD#iYI zKc{+~zufeP-**?D8bi^gH>Qi!mw}o?3&9hq-?mJU8-OkCtfSV51SDI@wC{V&tN3M0 zGT%hwNFGc=EEb_1A1ZG!m#-i+?}yPW?0;8n>tD|>wP40>Lf`d7o4Y$&De;3vx#9jF z$BPet+Y}*K@o#l5*fA&f(VmwX))Cs3IR7v*2ZQCnh1TTJ8;{5<63Qjy&d4uAB*}`< zB8H{QSMq-+kK8XZ7*j zqrM2bHrF}KvzhCob?JgGnuatV^J=i|LAIq`!-D1Yd0X!@py`GH#OABnt!m8g9T|ne z=yB@H5|XN$La|MYON_A}oslC*NeYjZgw2%|HtA)h%4(YN*rigZ;nu?7;NagR%Lp)M ziuqH1(1sCP?kp)dblo&;InJBHJRvOc;7);+&F;!TQw^z&Kz@pnS1Aa@mI1zq_-z?` z3r#oX*D^(`Ia|-z1E;Hml2DVqOm`H7wa-dIwASg5&2h+0CHZ+|Df&-wMBYUoXcsWd zgMUNJ=8{}ndgJ47@h3uV=vaZ@!qNRq_;YF44$2SE&r^Ge0QT}y_Ya}P!d8c6tk^#kF}S11UMC7E@FMhJ`CI;={}wKhk`I4 zHwx6$()Gl!8?9bNeHzR}E=fWqYL)^cC9h&jluJ`_Wz%}*`m4cnPh@jmx)meA<6GDFX zgGM3x0E*}!S*k>8V++i8O##(3hM~DYvDo(;^bf&3h7ALNv*N*k%B~LI1iNA}S(^Cu zI6~sULj%D+tz2YWX2ugHZCSuJ1nbgf$3xCWcl=@4#pn;+0CY5kp)cId#KZ_OVl)O1 zbRn#bz;~FGN4oECpQ;2fk3)zD-$Zd)nxjqh{BkzNg&mvu?(M`puER76u+pmOkI|$) zK6N4Z*QcuvvxTv{(#pJWlxdyx>t1G#;H&QuztC}>ZcfcnQzC&L1Zo`_{G{P)HUgwZ z3bl<)(Rjn{t=)l3p4utf(Kk$H=3xcSlBJ@g`KEr0Uq}IQWLRw4A+jDh z2`=29c2m}>c@#!thd|eN&!k+3+xC&>_4Q^jVezJzGB-dvh9~78yg4FWnt{0ZeSQ!q z&^pj72n|}oX)$>3Oh)LXi;19(ZyTw{hZLap zeS-}WESNZQI^NxmW<*_ye(Z|!HVBa;&W4vn5K$9ggP8SZ#N{7^#ZXBaZ$%pP~i`V<@++Fp`0Z_0q+e=}&+y?+aHCe5_7AGd@zsx=KAz3x!80oxU zHR)2L&YhlFtjY;_~V*w-l)4Z`s zPiL(r7+~V=;9!4Zu+&5hIj{}bFY}YEejz>jC+EjtzZVZoCYu9Oqr|is3)lMYG;k@! zAD@J6*Q?@Ah0dGd5*GD&HLAf8K)!d69Q;6WMtgXAenC@?ixu)}5JyH-u>?>Z3O=PG zHj>dC<*b1dOi2y?a!Xru|BP54vwS5loO(5MBIJuDibT)QLnknH#)M%muF4~>@}+Qp zyJ1jjQ7$IjX|WytB~J~;t9Jbqhsyc5g0gl9R_@+>44~SCi_ z{7q4hq$^QmZ&jzbY4yK#&wyB&O!N?eeYV z$EUdY1>YrzWypJ|r)#sIKY7&UJ0;BiWD@7PayuM9t>8Sz{woK|ZP4a34SEC5!LKL< zLZ*HXFR$JYPp?$J1#rpGo9s=G(^U9x$OHKx0alu|U9paV8;DY2e19q#bA4W#l{f6^tmQOQ z61HBrxE$-^{M!bl2%6>=)c^hd4mbrala*><(Gvay1|N$*K>&!8j%R8y(}o2!hY+;R z4wv?vu}|NhQax3V+Ho0*31wH{ERo?`wT!(Yb~zC_b=R+7Q^CUqAsTZIO|?^-bZ0E8 zm;Q4_F-@6R_s{e4>ws|}(Oufy07*(8j>Te(!6ktT!p;}GXDUU;D%-$dW=5Qy5(OtH zvF;6R6OjQauAfUr_~v5!Y&+1Eizh4Uif?3I***n_MJp6y&N%q_ zkvq=roMZ|-QM@xY)LzFO@O?Q<1D}MNs!C$O)_zdGa)F;=3(0Uz^3W#AJE3}Zps)$9oSr^mHKfl z7L~Yho_el3z8yhA&>61t``$TKNc)PFQDUc?`B40&y3Z%e6%`RzT*(u)e@;t@1Ir{O z{BsmJpZE=ZtKlD%;KErWqxrOcrFHwoO^Xg3f`u4NwBedUk&1hUOt(I`nmqkRgbX4u zX9x`eFB%lkmh;$Rv!_>ZyMw`_gD(iB2B0qSG-OHl=-s+3)&~kt430i~!GaJafYEvV zJ@45!+)JOmyv3L7ke}{1+&X-Gqoe=F$q@%Xo^hJp__MX~j0;yR>&V5A+p}<5?(&g- z1U&_O^;>X-F+Aq6S+DqTOV0>yHE+CYnl~la-lpw|B0eXuggbt%JEnx$8t9%{JfNZ5 zsc5ax7T(575-TOX#)W^*rVZ?N%vYZ}#Z5Ss~jqzY2RVnyQ1RbyO5eDU{BKwDF_gDebI3nij8kFJ8K6v=x2#g8bk}U znS@&aG7ivon}s=`T0vKQtr5-!tD~K6aS7*Q%I%mUWxP!n3D*t*I7}lY~_HpXY z7_`uEvl$!@AFRCzi?BGFslja_u{CZ0^h zhOt6bbT9*g+oL>S0Zqx8cJjFW_Xvkv+8>FUK;d%){nJf$U(Nr&~ZebvOn%F5ZA zs{P6OdQR+aeIg5dqBy;26gfh(PK9HcC=G@5Sr?mK0Gu-x2i_S`6JrwzXK=)=rMQ7a z%Z#wIUkak?jryqgGWnuRgMFHAB8gV9^t|*+Y(mmRo#lO73cs7bH!bLE4S`Fv_S*NR z;L^h0!YC`;RAamZZt6tYVY6eSBGi6aH6lDx#pr7!<@YFu{f80rM`ZaZ;>kQkR5+I8s&Ll3nUiP_M3;Qz%4+$rN((P;!a|>0&F3|jj#OMHimXcxE{RQ`<3?oj*x1lkU%z(Z z)rBQcL2%doVyF+cIyP8t*|s(6eH%$fxb>_gl1T+=LA@rY>97)Wb$d(yL?yx+;uyf9 zp}{c=Mu8y%ftzEuPodT{M`QGJHf>fI5wSu;yB$|>_u%E2r3YC$OJV1)C(&;kMKSBA z!)kVUvmWE*dsKCFYP$*>^B~iNPX}>N%v<@dBP4}nWmDW#J)&tHODqz|J+k{DE)wnj zxA}Q!t>LLMLrBJ1ns|x4b_xl)T?@(z%4g>*S0Kd%DCfJE=elmb?zNNk5oH}zB)l@i z9Y%`f855ME$Nq24HN(+V%#m(ozFircp5yD~byQncbJS`YjsJ5g_kp6-&7~DQp87Mj zOXICjZ?V5+rz_Howos!2xsiJNTss{1oH>PhZ%g@Ok#hMD1uHIj@|sUQ=m=T_0}|k% zR+-3Ca7N{TKQa8+q_-l+ctbhLxf+Ec2p2J|_@kkhjZwYk>XrtBUOZzU@a3aQT zdjRw@eL4h5Bg0irLu$$481hm#`0kK_owK=n+RoZvzdAC8-yt>{rT6vgjoph^-!9GU z+<#RX_`azFBRwk_7qhRBJGW8;1_CK^Vk0jkaD>fe>&%lRdJ55o`SR8d0>=Ha|8{Sa@uw} zrOPwuhEsDO?ICXl|5ELm#}rMD$IzvniebKm&{YxAuA?jYAe71?Zlbz zb1CThQH-F>q6@6-Lvt+vN)V|77KaOX+@?_Md7De|2shh&f#(kXfpv=SiAt-TQ)1$7v> zEjNMYDhip5Ho0x-u>YKg_G3c-6!<#D%b5aZ}r;aLt;!eXbW9QRrsi z6cJbZtmB}m#=Z$q6Yu*m5dJPgGH%3RSbX`k3kIBY1PHuTSzbIqaedm6wKFm9lupbDV%{ z9kpk6-8};R`P;h#H&T;T1F_#^h~~1GnJ2opUm9WWC8>(}rD|qKd_lyIX?;D3VAo`OhpH)vA3htKIpWGl-;7m*yGE|$@Ap3+ zP1|n~`15lXm?W?>+d_0VF#U&@>;g8tbyo;70f^u-UC3J>x7qWKxpA2^bwf#}{p1}S z+sY5!Nbwz>T7+ck;hLQnqoM3Vi(@~QV#gDWW7vmGgO?CUL4TJ}TV;euvGJN!=yKn7 zbYY+ML>*ef;AE+_~m(kE&>)*s*gMo}A85=u_NqnAvUiukiDUACta z^xyLmSO8F9B!NnO!>i9zqfB}V%lbO>^-xvz_wGbdq}fVJCIhwMPcD(@4Jqy4_dAFu z1mLWxqXuPr6t<#WzC?!E-&;Ku+u{+r!`O97iMC>R2?HSV_6opy-}to4Cn*g5Z%8q{ zIH50I7_|i#zNTl%S=_fYRZ-G~_oz%fOSQpD8{pdqCERQ&6 z0cax4Mho@;XqPc0jiokvP?h)gr`>Ps_Hq~a`ul=y$IZyu=i7?>r54|Sd5X*G_k}%| z-UCFg4AHSr&dSUIGTfS6{|i^$EX%WCT>LMtt>bQSFrRcSM3}=(+T^Y|!jEK(rtrKw z`SBZ-wqHw3X9B;NcQOykced=wq$Gfx>C(e+wDJOAUOY4SU{KH;wDvG8 zCg>2xVpZ5CgCYn^2X_$EkG%y0 zQt%@hgc}lH&fmD2PQ<*o=|2DjJ#m>dVZ_AUuQ8~v>vp4WA4XkW5(KPfO=U;E;{Aj8 z1S^(<`=7Pd#MpWWB3tYqy82864u1fScyGO$aqq{kd~{PW_SfG>#9+Ngw*5(R47h>g zO(Kq#JFr%OQV7;}PPp+Pa$8Y3vIr9zFm5a}F~nA+Pa4>De;NXlUaw@4{jSr{J44v$ z1@vWlciX`%$(%QZF-0%6tQYKG?{4(j_8_H9I%gD$;6xG6VFRr9!DxWC! zneacuxa$o~OdY?})(1fpknLQVM){=WbfUQ$iEaRd3yv;cXKciun^E*QkgV`k!I2Zt z0)Smx&yj-W}`tQRIClaa-xeDnU{K${Z zUtzWc1Ngmh;|Vrpp;$~1@_sI00Kbws(Y~NHuXT?APF&sfs*JQgVffe;rpjipz?zsg>C3OFtj$8fIGa|!14`wk-bgCl>$G^$O}@-G4EGPR1-T;BO4Tg%bI3&52eL!LSH`&3BZ z@Voz0bS(#F4hQg_>`C*NixMX#g&WB}t*(&9x+3tc*TP!Phcl0CP=b zCA}+SuY7ES07^9g)XCMk2BlC4h78;e86b%X1+dyZ?cE2K_bX%*x$TYpkd3X!MqIvk zBiC?lWJQe^@AK$uA5VmkVK51p__V!Bs#z+9&B)c#%stP`ZCFXQYv-~3LSWNN1{VCJ zZ#}=ed&0JZ2#v`P43X5F%O~KUSt&*M>%#bPBI+OSzGfq~ji6=y%CjUS zcu=25E`^;JgJNr7=KyM=Drz`Su&^BW!2&`+L`wve%As}N?P)8qYEYG(c$ZURkuwx* zxYj!6l^oCO1UM(qpK@nmrV;EurnwoJdpU5k$gAB0Kv!ttmgaiP;s||@qx=*Yah7@* z15`Et5$r1tEDj)vh`hk}IQWG4Ni-IQ`1pVt`WFwMq?E(i+SuTdQt^uP0h9f@+ro+b z2*pzt++>8o+)pr{jA|M1wGFN{F23(gLEC08bK$ti;VkD}f%>t@m#lEtm{n*u-;k2y znj@XBPpHz|PO0K_bG9gE%zx`J^nzgjBjY0hReufVU8t^)27m+uH;uvvly$}yFl6X&lk)O%_xfsnkcJI0 z@CElYf=U{x{5osF^!-l-E5RZ!*3A){<_TCDo>nalj!VI`T7T9*#LH{h*y+5Zh^w); zF99J4wC+5C3otqvayYYS9T1Ax%UUhQLKdNfO?E+T*W#b=tO-3l z&8rU%@lo%=jj9V;EXCU~??%jlbA3vTOVztCC3V6z#&}(*;*QAq_R%T=CS?_2$+A1@KnM%kKAPn^UzBasfN?1oc ziy8VVQh|6k{{Py1D~>>e^%dyY2uw-QzB@*WvxU;BNHt%+4t%VNi1OZVa>$D5c4Tze z(zKH#BP1kQAjrH>xRrtZj;>ZTM>m2tv$5c5NDe2R?%rodRYj-}EfuCauHaVZi|Ckh z`uCjMQIKs?QKgW(A=TIXpcB zgJ@G!WSlHgk@3fNl{2h7rM-ilpS-BP?#4xymKizxR=g253YT&wZA-^gN2s=+bZjAu z-Lgn}9o)R96Zox~+s6Qu#+B+7tbff~q& zCQ`hu3i`fPgh2+iO+#JX;J2%mqt;+kJuCy>vYq`b0&RmJDUgXkVA#jbzyMFr?XZ87 z_Ga%+BW!|gy=z0h`ToM89~CJWXWZg|iEBnEJ7lWWuWaqkxlwHf zbS55ALOl8O7do#1ZAovEXZ2kAVy(ai$s)+-SZ=a2OBGgtl39LuB zuF5G|vm$gUy?eMhICXV(+2|EDVWqbSm-8H^u@;MlhlnfaZe$-P!kS$OUt+TIf{D)d z4UtK;wJ7=Bu#4l$a03q~jp6kx6GcBEjk}LS4eCVtyxB+{2BPWLsz8aYeCNQBFcDY! zd(-j7l+{fUT+7WUf##>sywlm~)nkPtuB_`v7ik!Z;38@D?3>r;##wQ+cl&Q#{UPuF zPxbW+dH-5x?aj>ff@YodV%3{iYrqfC-z_cG3z)MAYWspAF@^^Wd*1`I-u5Jp9N=IFw!lGzVCpuix%6Yf{Q?!=9(V;4AyYpEH+BtIew9d!b z@aD{vMF=D4qxabCJJggY?k^>$qG;?~w0(`(R|n;+1a>R4t5Zk^@Y)1}f$`0;T1@44 z5$lM@n1r`fK>yuo0?M(pe6w*GQ?Q=p_s*L*5u+OhPQ|;QNR_-x0FxNYG}i zXZ!6;%$q!wXX>~qcKHtXza1F{$A7>^0Mo7i1(g~45j5pz==x92@0~y1CGX7aG*jsv zNYCk8q|~TmcxJ;H1N&tAoAlb-M;ScNae#-oAS3jO=m67v2n8%dRr8 zV%96KvS;qHf4I{1rKx8n43@(6nJ=HUaZOAPMYtKrU+yi5H#1ch7Jt zd@c>AE-_@E?f`+vE4A0+><$_+Jk>cfPd&!cB_e(>p{*Pq}HmKk`*wquBzx<~dW zB;A7zM~_3}6+Y(S<`YkrOrAnVU(XpyPyln`y#YEtAvP4>8yLu&Lw+TG_g8#`r(k#4 z_w{4x&hi2&M?=|x%~Bgl@QK;fH9c5P2f?hH`#e1~6ij(W-Sl_3~5_A!>TeVlmr5*S`=<F)M{q!Nr^}r=lxlFS1Ic8Ut40qy}|MWdQ?cF;gUqbaI?*n zEheEAL?I;LWVdBF=9@L-%Ufku&wg3Y2!yx!a8<}qqg~~<_U|mFRRUyIq;QPk+AJrV zkFd|L__K>B48ok=H^K}s{?->I_mQ5U<}`VQ7};sFKfH0A=4%h9~|N08JFAmgay%Qzh@jVQde zMN-Ox$Um0;w273Zu0jmgM`r1R77zy;^4$l9W(Z*=Ep^^$#I9K2GE0=-w`&`GGV0FR zu+RzPgCSaVbw_5p`*?8mq}`7B!N3HY?g&y!r1yY_;TbDweahCT_JI^ho+(w#90!;u zXQB|z1e(U(Y0uf3CZM$&Q4$%r^32_vk2K-e3)ssFVQhtJTDI0*2ZU?zuhR12lmuX& z);cYBj-Jv8b1mEhU~GZBcus=RP_riB)+)p-hZ0Ex$@l%LC^iD#3$7cpAr`E>DV$wT{vhc-w9dmz>;iyz^SH)i3Xe^O{{_BZ zO}8h1t1c4RVn^k*lMsgYWWGOgWN#!wEXDG7^TvsHr^zGBb^H|Wj!O#rqeHb2QQsyb zq{RnMz}avm6L^5mQ2Fq{a0D?%o2l~Ux%qHXV29J7HT93EGstT_wVl_pcw4GF+1Pa2c7K%oM9J=SE@G#k=?ninEa zKryKw-}rg>-O-G14X-cc_f_W3Fu8gw{ThdIKh+Q*bI)U}5LFJhHiQ<&cL-lfb)m8s z5PnIk|Lj{Ysbh1ELY0Lv@zuX_(-GBo2SyABPsmeI^kyz8=NrA)rxl<^UMf-07u?dQ zCP&Z%xd~u-ML5BkEX6)@BaAceON~VL?%tKOPE|^RqUg}OFBv+{PFiYUmyrhQz ziY~ck#z7QuX-nFM=xI8%=fRPZyZRW-7IDVzRB%Sr-SK&B2B)M9*3<~QEW~CMQiM&f zbNVjSfDO<$WC4R!dmGNTCCYQJzo=K^Wls8q{WS8tA#pb<_rjN*QtA0;f*p$C+++iU z|4GM|2YOk|AZGDozeOwr`-q1pC_)rX1fGDAkS{!$xsbehD0EAF<^2qi;xJJd1B?cD z=aID)hxphw|I`inI@7T9YboLl@gEHgAy{fAm*f}p{r>g6gG5L{E~UvzodS~g>fRJp z!1PKt(}SiPs~Az+-h5jxSixjc=QhiT4_(ji!$$9toUr8k_wUxH3SlI_fFoxd&@+c= z25uwfu; zvLQRG8qsOn;%S%*$b|jDqB!o7MP(n|;f!p3%JOGTdGL?^)gkTO_s}Gm3|zx8{F_kv zATl%JrOhD|GusfE9(&U26Qc0&HMhaeK#OtXuuIQ$jPe4gg|%6R%*%bj!@uEji-?t} z#xEg<dn+uhOTwXCPORp($Sr*p$tLrvN5s09>U0hOv2f+9X#ipSo++fVTIx zDnWwUH88@IZy4s+*m|*!1;;V!i#2e_ zEFmTJdPnYczmD93!2V`$Gp*$nZu_aWd`MS&4_Z9;!du|hnSa)pL_O5kp_^F(Ulf2H z%k5`j8#EQp5yw=;hc4i+C;Nbb#^EMB%NGAf$hwCDGalkYr{9BTL2vFq-V;IyVx_u; zn{eUjs2}w6+gUV!mA46dX8YE!a0BYpO8te@dpPSNZ7XgTj5ciMtwd_03pw)q*J#eJ z`fPrklTrG~8w_l|HW5hS>h6G-$FNDSMPb1f<8@prk-R~SU6nb!W9TtahjVWIAl`c0 z?8%R@nDLiLPD!|^@JJ&aA=@eSPbry2NX&E3?_7+c3|?w<$taXoM5)V&LjQ=sVk<>e z{B@~)xe2`IAjS~=R2xSxm;#tfav$1nF}!U-wrQ!G@?2VU8`q&2>TQf*9AlNc_oo4Y z#GH9OhTri)ZL;{l6`*-U0dX8vB$@h&!blvf_#G&F{pe(We(!iqJp51R;@^{xlVGh3 zuM31by#p9-PC)RpAN8J|%kR6j0w=UIxX|w!JTd(e-Jh_RbIREd2$cjlp^C7{wt0o} z(;ao^HnWn)8{zbqW`5Y*`UtZt?>^ytI+j9*ZTYKBn>|n)(q}>x*>^8?z)mfp6-(B2 zf&)S&VWn}_IlvCcau4z7LpgrM$I2nQ7MUew1KU_S2#YQ*J)5!mDxrC#VDZ08la(uB ztWcgTsd-xwU_#6njMs@1)clSsE#tVLkP+>rktpW>m*tTy!ux49_m+dt5%`BZdiDoJ zf8S_&@wyU1kmECh@1%D$eU6i**uCsrb9hc+7fjiINI8zJuaz>WlSF&xKYMvaMfIxj zI4d1){zJdMmu@^RrT=8_-=9Gq?UZV~Hye24s5*G=o(=_z`5Y1@h;?%e42d)qlIZb5 z#uL?rnNo|iQrHE5@|F<+k3*_;jsyEjD%npOxwPb_8#)#2ftf7t3B@gW^fT5{u9)g1vAoSvB|cd`%`rjMX-e=YE_;25nXhd3h!MRuy`9Qw&52_od2@ z*k|R0M2}Vq13@#b23+WlpU9?zHaz zs>qX0vR-Z{Co~^lm)Ij38pIfAvUexwEDxP)YC1~D72Cz!FW)7&6V7&>hp$d4>I z+WdGR<$uUcS13leUsJzw3B=Mj=dB1m4Co2|?DLQUl)tzRTzMUx@IS=pc)O;9BpL%b zyoB*?lu$(NdSbhEA{dL{z);-T$#r@87h2W1yzUsz_S2V0YR>5x^sUP|5(w;bp2s%~ z5dHqgHvywHBkWmlL+B^5lY z(#(=s@OEpy4*TAaA2mCHCH)@kEf4v6`XZE(Z7;8&mH~6L@HbushZ$OBCmeNTDcvqb z*BgxZlMMrIiwLVw$N)$DXy44fhEtE<=cdmm5~6La@^B%#2WrO^gK00Mru1{V$re6Z7}Xv;y5kuy-Sf7q0Ns)0 z!OsPGJ?Z;y&eKm0e`-t>!0>(Y?tWZbxYq93B zmqmsT1rNjXhQvi%4t-i(uRmhyaA)cT=(+2$i>h25+=CGr$=ie8W}Cmb#VHb(XPQcm zX}?!cFgH27x*CSJFwPa)M<($*utx!9-tsTj!|Qhjey!*s)EF%4F!6BUWS;Z9a(-F| z-~I0w1P8u4TyqgER3+3nrY9}{!g5+tpad71X|C>jyO8e*bH5+kx4lh)QW3YmV8u~M z(;V@Qd8n=$F>hQ_=AuF{NVDE7KOWx&jsJxgkKP{pDIm4O*5O!^#vzz#(KgQ*s2&QU zSFlr}ih(X3hx-w^N1i*e_x#icbwv=iBvSfnzoyXk-V%FR7F@UOXWd&4X(f?>n#O?C z7}wel^DitJ%B93d1yXkpQ)t5@j)q}FCX}dML1fgsrhT^u8X5!p$bjs&$R&k=TLY!y zZF#TszLfixf(en_#AOq9y`wKC-Ddb99u8- zF#%lRU+C56bMSjRLjS^_u;C`Lo6`Ih<}GF}j66BUo__7K7h#cUj2nqDGG06y7Opk? zjz1T?n}b&#TkXfA45`ny7=E3U(6og9!G2E($z)70>bmnw{L40tFq2%nh}<=`{fYadm)G^&Q*A|X*ERI4$BNwisFwUJ7bm_*S= zjaZZ-W79?i_u!IsIKU1bC(s8M#^LoPF*sw)q01BD91xQR+xT+>4Ifo`X|c8Sh48tWgHIJRg7OqEIjK2S zH2&5>k`4hoN+wkVLLCvq@9&^^wtv8%o_bvulsG>G3F9FGQv;{tCoMq|8Pu8H; z;=GXMV_MVCR&1AiHtGk@9#sNQyI<(wnpMW_BF!AnEC#K&3wsK4))abiz&{80BnHRa zYL02DW8b+d+4fc~qZqWdr!*n-%gp@vB-h*@eIR>Q8xwW&3ew628tI;Y-D6TOWKvgH zk7P1@C+^Hy@U+mUHbdlHS?jc3T+0HgC%v?SQk13B&^K+fg%liM_3_Nus@!NMf^jZ_ zWXR9bae9g;Ux8!JQ=>51ai_q90TxbEjn^>dtiie-ree1eqAhsc1v>CwUf}%`4lv7S zr0{Il1MZ!$RB$C|?*I?>lf=}u6VqbN62`|ONbtY(wJc;$x~Qrer3%N`PG`>~Yv>P8 zqk)BP|Jf32C8nRNmMShK8MjeVbXBZipv)066?P?XKUU;0dVLkQ?b+bSc+JU5l z>Pms9ASp9b>FXrS%F<&kH?Iy|>1#9q_Zvt}Hv)=H*pw*lcm6|xXz{zvXHBF&FydcSkGD3upc-+oRxd-)HS*5e^OaP(R*OB6G*{* zqKb(_P8|jehJDL%OHUnxJtwWV;}jUY4_rR<6MEV2?^8PWX}2BbJIJ`;k%YOx%t_Hm zmxhZFbm+x*!TN6WLta+7%(oPDwt|Bol{4Y%Y}+0JvJS!h;9~g`fk+gVH3eb65O=s$ z5kJ1>j{L}7J@^$^yBUJJ zJNDebj3=;)t(PYRk{k7Py@|RG!Rwb~i&{*$hcs~^#U1}A|DASu2;XWKpgMR5G#>`6 zdC+~V7F38kcI1dGcxo#*^3+&BEgM;YEJ=h!;?#y;!0kwNT-?j{lOEGjjQEeQfC1W& z1IIx^5=6VKRqNXJqzr&yksf<7IOOmmL0%tGDP9F6dt-ifjhFLg$YNV8r!di;V6`|j z(DlNpc)+A-2z^)8pQBvO)ktO$xWDk0L_-y=jf@4goDMPpp}G2vwUA@0>!>olfq06W zz}VS7d!x?;%5>_u%F{HHOT<{9BK;X0(es}awAEofpU^zEw_mDtdZM9@JA8-MB3%_? zf`wQD*)JtG>)^=JeI%rKmi%&EKHVOTupn;w5==(HCi7^U9TPFilzR~OW6Y2DY)>kk zh1-w|R%(1V;#CY6u(qz-&7-IcsAkx2weI_~+1tP{1OY*EAHp8X(K+#oamOzfucEME!gT^kMa`@go zy>TaW=njBHiuIfsGmhKvn4*=m>20Q!feBWtpB_g$#IfYBIBJH*Xc-0fZ1ZW5CgJgG zRpdsQmbvm*QONRzgbpWj_1afiuyY%2K%r|U#n4v(YkT7*fXT5phK&x+Tigh-U2Jma zaLw;pR9`{+;bl?~)~^OS5D?Zy@((9dmBzGo9SH=B0!m`y@WiN2T|!ljViLsH#~q;i zKbXFT2P1lmn_(dO{gL&Z-e;=~M&1;Et9;F0#@C-^LeVFAH(MP4@lVzXbJu5y9EH?Y zn703DHHqj(UP?hxQQx|BLW_h}U_dLO*v^flGT(%hIOD)a+3yHr$UaU+!h>QPokN zR7%X>c}s+m3!dt-fYd?t;j+I68L`C?Bda2@%gtVY<`g<{vTYx|6@`u;M2ty|>)`w; z9xrl~HZ5X*Kr}1Ny!DTVC+_gef?)?k;*n0g@N8`a<}I=6vbxYKg`&G`d?45g;Q9{y=SLU9h08h z0AgJn*4@>A9QG}LKXMr)2`&I)gEzxU27Hg+e{b!Z0WTDhJ^XI*pWWvR#1|4h( z5*qF`8<|6X*pcQJ-_0-%`nCEB*85uT*RZh9VF5^=^#<#f{MXn)z3Hu7oiYY)cozy^ zlJ2H^s4dZuB=Ux1MMH|@&<_vmR7Y#~epM`GQ8{ZMqgOD+@&HfKX*E9cY|@Q0o@xXu z(>zCfEQ>^X&0Uymos-{_Y#8Z$_F&y9D+8PJl3zbU)%tDo$dBUFSq7H!{DXDdc0?i7 z8V>?iv0Hqwk4*M(ehD8x&I$wqyRivb3+kG4EGIt4ci?zCRBmm&3AojZ+#GPoJ`P`&>32p=R?A!yua0=wOd zhhL=Ly*Y94VWImPQ#>5Qp4wIGP3q;vPnsO?tumcLJ;200ZX4AsB9U2l zb$%MN-;N?TG@7-8nW9}Khd0s;OrN&b@hlMY2vBb|T^q*uW53o11NGB-<~P)8wl)w< ze!)?K0o6`|E8A)NZ1EA?vcD5mYn`IGWg3`+Zh^sC@tRzZl;3SZv@tPxiF{Zg3{MXq zFGKrXZ6c=rum`>8=H%r^P3Z57DtrC%XT^=<%8ex6?<+itbQ3_UWG@QmA(p}fpv`;- zI6b3>My|t45&}R)K`D+OmV~C9n0`*#R|+$o|Jk5U$CAbmy>37%2BdgAcd==_cz^~9 zSeBfyPV#*x-XvSF#yaWFJYYpnQVBZcVMz1uc z3}X(yTKq{LO=rLrRMFT@1x*|pkjTbEwb4FU&o;&OAa1uqVLzGIE@=Tt8Kp(sium^SZB|2B(!QN%QFdQ)9Fgbv|mIaTkUhi;=g^*=XS&&l)Gr! zC0x)@oBG6tICv&wMPCe|0Z|c=Q$!UFz{IZ`#AaE=v2F0`hfN&Xnbwg7R(Dan=TW(ogzr4s}mdaeM zW9}#C&pdOYXuxSt#j-WsIYpXzXV^JKe?PylP-!rPr#L#>_fm~<5*!F2!9Y0`Qtvc% zb?>3185ZyB!(#KM%_&Fk>yBY-qOGY5e;8bFz@)o^3Z9M7b${e9bW@?-M@m~-dM2oA z7%RI$xVCb}3Dh;^RJs&+VI=mK$`pDGnm7gPszhZ@=M)aU=-b9JpzPnAw~?=YymP`= zifidzZvnz(d{|iy1I>ttrg|16Y___~PUcC{yoJ1v$Fx#SQ#BK&?f-L`Xemv1@#E!J1o+C%Z*x3numRTK4sI_}1U3MzAw}%Q z(BNWfhxfTH?zFL7^#u##3!F9J-CT(0l;0Yo8h0EXacv|@3(w#j=C)K)z;Sm^Qtu3G zaMxu^Frb|V>{xE07)dgbe6b+xC{))qQy{1Fdk zhAqw$P;->EkAQ|{!dUbc+@@8-pNVN@wke7w=jjUL% zVu!digbyHAS`0t#oHnd#!^VxCicS+%8t{(_ADxRR)6T~UO(5WF#_h1hCT!T;T7YeV z>n@ucpJ|Nsv2qFV4>qTtMUPWW3RvUI30{AF0M1P{#91)n$4@INs8Qs2pA-M>6urNc znxG$dXju7rLiD|$P-!(4SW#d7w^v1-=kKesE;DJT&QWz?BLlj+?VSn z=oW;G6c!Zh3Qpj!`Oy~Wl>B~pcpEQg6XM$bMY<{+$z)5`W!HoT2M@Rmy&S2)MO!rB zcY)fVJF;3M4KEnD#Fb3-~T&TpRk>Y9*yDE&I9{RwP<;)svX)-*?ksu3LF7(4Y7L~|8 zz*o33qXCt8Wxn<}JldtQaTWZt`HJfE(J7xj^Bj0?3tda4G0kf+msxV0&*j<7Mj>gDvmwl4l; zbsE#(P-}%2;Q>~dy>QCCx>qar;HMXtI~a1iXd#=*C3 zQ`Pwoq;paoMeQIw?=qW_a$%*JnY$%gH+W)7M7vOfr%?O!3B%fD;sKGU2Twb$IL>`= z!AzU)3#Q`#6aO%)%mh(ZtwaivmTHpHSxm3lwWoAxl;+yym3z|fBv~5i{wUnJBkgLe z>5LO_7v=;TPN}!HwH*VF&x4Qfanj1Lz!J3fa$b?>-tEPTTtyT0<@kV&*tw(3xBR)X zL)~I0dNslC7;}nWcjERTn|Tac-rg(3wQs!38&@n`(kzt^w!*3L>5QtXu#_Z`cenbv zd##H4Ll8`^J4QN39un5(W$QZwjkzaRf2$m+ky`hwhWZ5jW_z7S z=Y*F_YuX@M(lvq5QjuQJ2L^A`_heZc!ei2gxNvMd}|w>wuIfRT_pIDXIt&~3Fkm? zjU!y%muoY{lj!!Dr&rmo*d>ra1;- zqfG=#aU#w8fJ#>l9;qbTQ!$4U#m3guGdN4wy!TQpV~MUE#1R*CJZzv$=Z4bnhV=DVb-4KE8}*IP4S`D7 z-&R4iegF~0OJQT#Olfb2XX`>+1Jo@X{Op=Ggv;SoB6?Ys6ih5mKv9P5cDjnPdHnIr z+EWL$v@XFfK_Z&8huv$*p0|b~2!Hh{daGbbX;vzhFG!??bGWv_mg3@Kgqrvm2qU)( zk|?eLW$MhUyz5AQ`!6Scg?lj|UCg6)H8;x{aX;dz!YqBeW z)E<`?6MA`n60+0$ck$1s#m8c0e%X-d?%K15UCCw&&EL%D>f6EIE=z|Ycs8!YD9=W| z#|`bCwn)x51>oaaMiOL%T^TEDgO(x$k?6gv>tE~Z>X~gC_t*b&0T}W|gFI78CAnN< z*e_Fns#Qe?34Eh#tignrC^yoWx}H$5;z)|&>YrV~#bJZ*)XYVDsp`30buC;{w&#y! zveKd(!6Bf=YH<+<$Kr0#nhVC4!Gj_{>;A^|*^fY`?b+p+T+`MQxO{Oa|87WcdqtW_ zjv-~VrTdr1hz{lUTN}J@>-|u(#JSTSrsVTbO^h~z2I{O_1MSV5u7QCgP+udN1+)6* zfshOa=STVa17DEWN-%UB)!^Ei>jQo9=FAJ{!){m%wfxEW|Ot1x8HTmgt^2UU+-aF+Tk$Q1NB=QB4DlNlB z8?Zc$nNDlEDwe-#cy$(jIJoS<2smrOTRdBIC{vD#0ODP^8-O1gEyabF2tFi17$mW8 zmY0iFeX|x6F99Ezk)rFb$RI%q#P#xV>FVaORMIOB{OBS1zR5srVR8WSx=U;_nL?ZyYe z_)z}~52iLCYD~mP%|c*@lu$~@w5#NL7Hbb+S1&iI7gzxQME)v>r+`DWCz^vr5PDYJ zzt5>Q==d0+*kL9aZioTrjnKN(gYMVaHnwwLfE3(1YRlgMH z{2P`ck42h~nQUNisG?#W{Eo;M%8r@Qku_e>*J$NQ1u~|hyt9xZ1XLR~Loke<7J9%+ z$XNa-;sZi3se-hP78gPuT;|fzTKn|XUuMUZ3ir*rFe{K=&fk^0#=5YZh5zGeh$mkt!4sA8g$reZq*zam$v zynU2EdO$>6l3YsMfQw6Qu(R9A6z;Y7a(l)ZZ2l2k!uiqDG~8Ku6+2B>1dS_~`Tfe{ zso)z0vH{%-tm04dOiexb%Bh;=%kkm)7%`+5>}!-vsGJ90dAEX`b!OF_2TAu)O=#`k z;)e_lwhmgJ@T&H~(8RxxBmgP1Q=gp(e&_P^CDgTiau z;s?qWyGAD~EH3$LCyaiYkh+gW#^B?;XieKrLlN&1HZIkor5 zkEh0`hSCJOi-fT+{F?>0w^&4flF<9pJNw~<%rD#Y6 zSoAmi@^E>oXor>%D4;H!x3@_feyLir?&V+y@h3n}y7=sXJsPwpz%XFg&tZ&FH|MX3 z*5RHyDZP0v$v`)`7H=|xc%xFI$!&|h{@a*?nY2pRU%z*+%zNpy6ti{MLolkq2_jDj zxzXu`r@`caFBwJS8BD)GmLLL+>*p3B`Po(>nr(YX1zh5;VJxhNYW;_5hkwMsyD8BX zIdJ2@%?6>yNH{^P18fg0!1JGxagQ6^Sc95Ni!jskJu*BC*DjwiK1Y0D`PGil*>CEYPfo&{c`SK*`A=xwb4$s3Iah-73dK+HTL+a5oD zeAlqy@X?VkHS1TO+`+$Q32z76_*gvZ8JJm-rv6eaz6I(MLXI)kBO{{G66d?Q3&uH$ z@UPJO_c)|cf@lr0{M6ILfW(=MwcqW7yC|~CR4zYmj+r!7gw6;kFVV!duU3G!6p(x- zCETrzF*G4Co{-2+1Ey@iGR?G8#kg5F?*kST7ugD9eq%x912~c_qvV5_Dn?Y&Of}lz zHpR+}e9e?r7D$U2M4>7lO|)s1NLM;j_QkX^56|AELF|(K@)fmzuM8qXZmo{oR%b7ed0rwmbtP+Z;|a zqFNdwMd1O-lEQg+;&<=-M9?E~H@$=4wy zq<;tyO8k&kRpx1uDHNwrRbvVE7+)I`3@&<(-azOm_I`@SU_74pSI7}Rs;LG$UJIZp zrK-a?`>yN7(}(G4Zl3WCNjou41zjbH2ow1+{;3j7)u(7g5AnN;{@)53I3Q;oqEnz% zL>JK_r1>Cy)~P%FbFEY5a|x9gZ4ph}N01RT-A$kY;@BdnS6VgUUZ1u<1wj)y*mCP*^ zne5Un?xG|k zX9}>K8SuIKVyrl}uG#I94N88~U}HB{U|-SbLeAu6fyN%3I<7LFMFSm5gEP(ihQ`}9 z06M@SP-nR2rvawtPi6~+AfaG=uZVs5gOmQgF@qAiFA0#mecJt1P0V*RLORSPbnksG5n2 z#;vH`RTBBa&8utG%l59!hH%(gJh;6W$3j%luVg;0{O#K>#HV-xkJTnBxT#-$<@Sov z!Q`q1%c~dNsW`|vtQ*A7i|Yx? z4=cgeztOvl!47JtHXv&uqK+%4o8z$Gn4W?j7msFVwuo*prK+~*K8IUP2Cjq*dw3s+ z9lWuk4(OkHdi@Y8q0E@>nr|2Zmh6|D`$6E3Gqn}kdJ#7^0$RpB`WPr!q zp+QRdLA%83D7+6(gtZ3hyOyWh*|VgviwK5+wf<;rJ))7>K!^#abaY)k*pR0CIwJRj z7>6T^h;vFEPyZ}nZ?=#MJP(`g!T-Vh6X2A3`MpL3atjiDzTQk9O54H{>=(dBvB%Y^ z!x2JJeF?RpDrT~J{!5eKwCqYK3J-*bJ9{svc_yviX>h@ls~tl_9dbF>2;cdo$w2OmnKQ%u zyVSIGL-orqr=P25st{&C3Q%gpzlt;Q6ys;& znW0af!6pcfe_ia$Oh24{PMjPkJ?)LX-gk`3gFnCb@_ZbV4PA;tQ4goM>~HDHOcN!V zVicKWDHOeE7dt=*3H@4Ipy_lt)3}_`yXlpK^8x~oB0PywE`WL-G5ES^7_04H4aE*6 z#>=SK*vXy?AY5Az13G<8{T6S)8Q#_u@>Pf)L1;{Ad+@)Vg6{xj9IIrWt}{xT9fak; z>EdQ47$d5{%b)-p%SD~$_!#LZPbvIZv=)5IA8R;cAwnafRMaJmq4g8A6ipu7Wd`Tx zYv2yq6Kpzk41%WHk3RvTP)~>g60{R&r#zHgepLc6juf>3i|5>ri2iNg6wHpDZdX0m zpJ@a^|5N2i=b7Q2nIk=IJ?Cnjj)`k8CVi+p)4g{y#$79Zyk}8v%?4W};&l||*Wxi{ zpfoPxDx+ng@Js2S$y2d}S^W)7gLV6f?DMe#__iHNN+AsGP9 z3t&G)@^JPH)Vet)zwJpC@wL4kn23M$^@$(H{sF9Z!`82jv)tzDF{#aP49>E{iNb~L z$Qc{w*%-EdOyt2dr=r?ZakcdwFOQh`H(n{Si7q=%3lD7PPYt{W$c_5xabGZf5fSi^ zsZv|H8>Hsj0?=`$O0S$2o!Nz(7ea{4yORlZ!lPemopBg6-qw(-iA0Y181ZkQvw(H& zwGuYG;5EVdTfw{>3V4q{?Qcw#s+jXn{TXbWra3Aj&QlG<NCX5<*;t)3rm+d4s= zkIf4v(JU`vG{N8bCzi&5dS??2SXCE58V-`m6y@#BHfp=z80NC*4}QB=lE%4ph>pXt zvBn*W5gHgi57%Yv7&$b{6}5HsnrW#-a&TV>eJLSL4Jn9qZpJmBmHiiaALy@u&W`@i z8!jh9X(R~HXf-W>#POWd{cU$4w?V8a^jISQrD_No|xyEZi&US<3k z4Or4fADvEj4uFRmKgO2O*^NjP+CfE1&HD<#yKkRM#}lYO@62!#@^bk7-@ffLo008R z-wit%k_`ut@$Lg@1Ms|}SImp5SPqalv7#d9mwkY>ItrH;CGE~@g2FEKWRP>p3}BS| z%((IH)?beWIlB~v;Qm_>3Ia&;5+MsH!B$VXPKaiM0ZnM;M!_yfn#Uy&$HJERRu3Ui z9~<{`;vO_3ADzkLW?hYvdGd|te64KJCXo;4(H`fQ(o8LGrtbM{9Ju>N6GJAm7R~{TV!+^HGQ401G4cHpRXd@G@dxJj z$&|W|I}{w=1|C;WMu||#fPH3Ho{@xY`3qvnr00k{y&|3_5Ut$ED#y2dV>#qzz1i#Q z>&_!*@y<2Gvpuz7xzkIdCqP=phIsAo%a>&>0sHXJ{{2#aG)NgF+)*jg)BX#55Uof) z8)r8N;Y`vk;pznh#c;*N^9oWV_ifsh97aGrGpfaB*~*1azqC9}AwG{7D=u%&{p+bh zWD{i=`3~&Wk!kO`7N9X%Y`GX?{p!taOhKAVrk1~Fii_2G`l9!?9ZKvWhLO1t?#mj{fYFGGB?wPNLH1B zovL*m2nzDxdtBQY_qGA*R!Hg;A2%K(h>&2$sO+)xek% zoXsOWIrb}ORj)6epomXB>5V9WpCLj80@S(x$Il03-LbyrU63(5sUWGEjcN{8LsuiA zvVy>J%D!=jk7t@r1l9wo_;V(9Bd`&{=xtLChH~7ev`_1JH!ln{)_>XA`+mxi(w1Js zRan2}yy{?y^C39&>2nhZb)PJ%L3JG`eBo{I9tN49GUqHU($hs< z-QtZu03D^1x?Ug#UVCy#LOe2d3+4wsv4&-aptuV4&wO_f7tn%r7ZCx=#l-1(Asq{r<2u zrhpqqA^+iuoQtE$SPPLM2V8X8>Q%#5=O#3UdnLRlEde8Btr@tS>|wf!6k)4`U=lR8 z;#YWcmScU6b#06990*H=?CK%bfj~^g$744Di@3Hcp-b5YP-j2WWm_4stJ&CRt289J zb!Egg4x%^$T+fB}SkI04=N=?ePsunHd2ysZld?eX(ot44{5*Ls04grF9K_a^n5k_2 z=$$~+gCK8u#t~1)Q>9ov@z;=?&&DmAy*qE-ibZn>va67aex?$Dd2nZr{cCh0l(6J9 zF%#M~%ZDQpSrfh(aR9RsBq7S?->}UHm$Hc#LA3!AqxVUrNOyQ#ue&uBAW(+r-;<&R zmU48pgpBfUQXt5|i}&Dv)Otl5|6nrQb-`62nX}^(NTcq@ze5Sh08Bh7uo#dA4#;j^ z7T+hgB;hIx;2wj88fZ#qA0LlVVhD7RSt^1@(N@m=!&o>8_W?iI?) z4iMgA%3G{fISP1#gcbWi^zEwK!(i?kDpDU4$VX>@af;lng0fLf5OttFW_kUXIs9Ve zum4jYmql)U4FlO^Xl<@uNSd7=JUG-CKL8~-l*!}AgHJPEpxc%ysU)s8;oZT*bwmXA zwToZev^t~KsiR(t8as`OhB~KV49)oF%Ksg;9-KKrnd59!wXDaDE8tU`RW5C9H^y|x zDygoA&i5P1Z6vWV>mz>DU{joy6_Vjn{Jnj6_&~-7r+J6?$rC7@n_Ptn5VD90%4HRQ zz!0@TCJ?edv$47F9vDO^k(=UwsDoMaJCO0mZp-p=O1?G!X-j~1LI10-Rc(QxX6azF zSBI)0eNLhPDyu!BvjG$%r?^N1Y8Qt}9r%^kYkwZOG1_otvhT~2sU$@%e1>|0=6C)! z;pX!m_cnbQ7t^Bf#IJ57`}th)+6X(<*Ef`=T;BfACHEUDQ~SqjAcS3|($|iW4mPWH0%#=+`pb9>!@f3}`HlSY5e?|Ik*7Cza+y z`rQmpaIV<49sUW&4#GWzWv<5WM{s#a223Cy-W$zM)x5X~wrWN|IlP+3M$)!a{eCb7 zPMm2NhJ908QE_Nrd*E^cc_Qq%)RiMdr}tw2q^cY9AHAIpB$@DKd+sZN)?EfEl^sH> zK?P3Onyi=i7FL$}RGg5r@F^>S-ebC8ZMRIuu92acy_!2vG>}_7oJ`hMDj2kHV`X}y z&W^8-%8U7WwtB)v9Yz3W4rWnE5Kh}JxFAqEd(H+rK2+}?Y6p&5@~63?Y-;PpY;A!e z(MmyEQ~esxd+8qT0t}^_tvR}FhcO?aTw%B)i^~1K&YMepTyZS#jzn^FAw`Gd9Vt3U zCyiEo3dy696)y{PFlB8frR$*K5Un_&N4at<3#O=0mGpu{R9HuvJV(cMTESDsI;>$Q z-orj0xjUzU{7wtlt{oFw6=}gCG|PX)C|1}t-Ql-ZZ{g2Xy!;7Ys9~PSp#F8fzf19O zYvA&t;fnlTvorR;f~}P@89_`0zkQu9;v$;vZ5@m%|09;(4=ZLU!|(Me3X6yPh@c-f z3CU5kP`&4}%TW82;%}oOFMb1LJ}?M0A$T?-O5-OXPzf*(jx51k&-0X8Ep4`DSAQpm%fx8Zw{`9HX@?#1pE81-j>U`cYl1Z963V@(F2&OwW0r5 zh6zkNJT*(1KMnRjWI2Q7gp5o#xJm1LfV;Z#$x5kvtu+VbmKy^ijln2R@QDrl87F$v zO#Icd3&fLku=M&NH?k1!MuUH+gmjAdZ-to$35rWaM$!9ck}d;9&W3MGq!)SZSWVPA zk@zXxY!ffSlp#KJleWkIask{Si$UCL_^63^zPH#~kTbWVv>`cG5Np92t+H}rl*B*# z;uR@b6lOb6*q3$bv;S6#)OZG&Sgq3>J)OgBK7S5KgxhW-J5}amjNAr6?PP@u(uA724rY*L8zGaEncU4c#m%vFR^>TQSH0AWLurbN?#@Y|%EW8^X~%_u z(Mi0TVN>SRac1O!%Nt?^AFjJ<@YDDw#ot_pAMu{_ls+nLsY)S-(ZM@BAUvS^BRiD;;W zF);Apf@VWUCUwquts*2g1_Nv|Sj?eYbH2Um$32hH+hwVin! zBKqcbErd{19U3Zv1#s~w;C2TI1A3OVC#3YnNh@`CQ#_XIZ2^D|L{cF82~uT>J8%ka zyw7^~83w7r!cyJd~_ zkyN_*FrhY|I~YJI+s4bcP1rR%T|Q%<4bl0p*0_q+e>_IPXOjfF80&knZ^I8E2jFqiv#-p&`q;?o7%cSO z_4)bp85pPE?)nQJpM7kTJM?ycqSOx^O- zj_sY}o1aEJhkcEDakmibW}155{dt8k7)*Zr^VB;?_W*BP6Y^M*TP@TVud9Jecs6gX z0gNA8t6u}lK+pqn61gC~V|NBTkU1tQvr3aW_wyD9hb|jl<;NmVxO@b7><-@63_=&A z6_BbaDsvzI1(*rOF)-irC(IT2us1wPD!XSsQ+mvb|50Tg_DC2d6e43M9X@&8)kCS| z-WBU;(MovX{QEZvIPWjKD26uTWyNIkCyXjzJ$aXWBtc2V6Lq+2F=R2S2*aGWbCfyQ zO6d0R!Culr*}i&y?fLWK+LSu!`3nE0yWu0leK+Rk-W@{fbz_<&Erh=Y2w%Q`Q|${s zP!?AmFq?kjQOyl%PU(_w8@xx6yVR!4FYmG#$HRm?v#=rytOQ_=aM#Q5ZoQRs2x)7sJv4Tdir7RXbD`d zhc6Yu+_$v2m_Ga$gm%X__!t9G89!5o(DoGY9*PSJ>OR3ruInT~Ml?aX_D}CzahiWQ zL;c?)Q<0#+Z=bOhKx(|A!^4y0lMP;P&blD|ogk7ne5mP=w!BYAIf`z?QxYz$GOsQ= zrFlg92|y_^eFcT&aAt-eNm+I3OtlBO5-zg<4=-NjtAuq!@Ymg z)_0op;W-9YgowvPlZEe7l8EJq1X4MOeL?6mr>Sie; z+1aIG6!TVXhFQoL;3NnDF|+FaCDH+w=T9K+*@LMq@*qBToFFCF+bEX*hzlh|G6MdD z00^$w0UD#!%xLMcuU@AzRvoy})V=*jYnuP?aCby)SX1`^y%e{2q7tY8C?nOZ~S{6drNfYohr>;2{;E+ zm&lufg*c}qHS2*?iP%=L*kIqk!=$F$d5C6a#7(*VD8`OZbJ5atym&E*t1?YjfwPqZ z%MEz`qrPt%Gmi&#lNBBgvM{%ZlB~aQmFU*EQ+F@I4{s%|I(r+zx2IooBMZ$YVztY;zY_JQ3}ek@ao51$|F;^Bd|o}WHhA@&k!$nU zx~L7!Uu$5p`6c8CNX-!#oA*&@x<#yVe z7t{YRB313T;4sWo@g(xY#ka$PwlL}p>4HJCN}Q=+wfnYZ{uRClPzj+iE*}2TfnX2} zw*J|q1$*sZ96s3J`TI_T2h6FP@i|((37)a)HW<}jT?;SJ+T7Z9C@t|O_Dar-{2W;b zr$xwUM5wVGV&{_M@g~6ZbaI{&WFv2P18j1F*8AsQX`-6`!EggTU6p32u77u+VG}Sh z|8-|e09NWn!B>n>n~^CA{)f>XFL<~E3?Mae2H3JY7F9_b(%=1lEVHKlQWc6F8lgSj zRPtnEFMV2cqy}PmJ63s{k2gOMfx791<`}zFrctTL%sv?i&iD-BB6_~AKoLGR=#Erx zA5o+ZJlchooZ1nqZkhDSyBck;6~6t0E8B{KZJs-2BY25}`)HT`C<`~k+pd*p@X@z-k zAxIJ9G3o&hv9kVp@Ew|EzkD~;dvhLtF4B3a(_oBmUP;@eZFc$D{GO;9#+UX4rifsY z=k;*CRE0yqn*^@T&z;!4;MA&RLl^=`u2}#QJUQ9AaU}jgPI80qwtE)6|HOMdN!=Dk zY{t!xQ+-miyd+KV?d|VNYm`V7t0u4<45(-9U<9nfIRwJk`?Ez{y~rv@%U#!HelyMX zU90oK1~2oEikymGyHI}nq0E{^ob#mgQDYwAhT$r3`pm|m1-zP7IO^Kh)DHz>f1Cc7QRzg6oN34UF;PF>1dxR!&0n(PrW(%(lMO5{{+5y;U2%NIV~ zefsYt_~(;DRSVj_N+j?*!_FY@H4umcI?K6=$sPs|VEp-=z?y`w-IbgFItL6HDlyQhwQ=xgdG+S( z3%PP+4pWvpG0agP_-r@*nh_!}h1b|Z5!Zk{38z13JeZ8CuwM#E7NN>90s>0WQrfub z!SeAk`Y~b`Nf@{^2x=P3|K#5qldg_oOD@rq2Wr+|a>$3q&;iLd{8qR=h<^~3lyI8S z;M}hAvP-jX+F~vvBG4JaF154rM94ch%ZeB!j@<`$T`fV$amgMnZD9|LTSfHaZQg^ zg9URU;fr7L#1>}=-jLwOn#yg!Dx@+lJ{ufQm>WXELhLgBibdN3 zGdJSqjc^lfHs*bFdtAOgZ(b|HO15D=^U(w2`L+b|gg4U0J0ZPYrC?+0-hAUa z@NrOj4D$`?*5SHqzMC>XI6yT=M#R(FODTZAikOG$FiB=gGoJ}`y<#?5Qxg`y8XGBD zj|%uAMBm^U?!?|64InS1p;I=WLnk14`MHzr^>eAYk#rmMALA;H-Jd|wwh99Bn?T7@ zPcXLzVojpq$Q`Hywkr_!HP-&$w~**lhP&G&7KJ+hF#}|#chp%=g~!o!JVD|iyj==U zCD?40F$Q2LpvKQ)V`>nB9(!U81~hmXr8)AU`Jo{)qHXV=)j5~P;VNSWW=#Q> zI~9oB*>S;5&o9=FH6H-utuZW!uV0Qk2#F$_B{F-VB;O(d1fa9T+7&S{@tR;*atl{P zx_M6b!CW{`?kNOJLR2`KxTz3c*b&|n*dJo9gABT<`M(Ckh{4rE1M1r^Hio5jJ9)FP zKlHtYdl))bcqz+{jGyU*e24@;KBlC*=~)&0UYDV|i0@cnb_@-F@BNTXLJgI)ZMs*+ zDB-3)!n5tOB-m$?WiK;LGN-ntwmcS^;$%LJ6#=P(CbcP_IS^12ok;wjwQqcB%C=V z{)Sb`Y=nNxVA)1?72HS|dZHQZfE%jMzYG{h!^F^M?`sdoRd>RgoY-tBY` z$JqFyu~rz(eN1csV|FjC++z(C0UbUfIBZ*}ckMUl=ZNhfAEIt4?6QCq1Xg64xUxn? z{+@DkK0A`vP9FH+&aSm5Al|HLLjefUCo8b&#TV8;MqS1kT%!cVppyBhNc@~=sgHX2 z3ls|y07aQLOTS!E3{cY-u5uNW-IF1_H1z37TE%RSO4q^+?(PBEi_TtPab_V%7EKhv z&Z9zFBs^AT8x8+fIPCa&{;{l*pt2ZJK8Oy&hjTMRL>VP5h*)iCfKWEe$(Au;%9D>p z^PKo=R=^S!_vEcwd=OwK-Si-gICjbIQ5C)Woml4GLn*~S-@hIJZo)#q9NHU+KOXkW zl8ubB1FI@~`FXRx!we0>K89Oe!(@-|;LHLwJtG1zA6opndmul5yu;wot$`U)HC%;T zKZvg(fb_SBk_5yGY!~TTbK(NkfI`YClnG1nO1-{+>zOs0qD>?@lC|wquCdhXBofbl zBzD7Uc{ZHvPVC)mB9UEH%TzR7um|>;%NIP|Z3c_t3!dKVcmz?~iMRvLm~lcOXIIG+ zcX+`StSFaeCW+#ITC?D^lH^WtRbV-c^Tj!xpwt|*-YD;g-0?skoemOTYjJa{Z&xh- zdy*^oB7tl0H(M+f;bqF12AN<$uohgmVWGWED)a6m(+bUa=Xjz!an8lV&sZ?8iHs85x(R%FXn3E<$W2b8-2#4BrIf_DkN_$UA4B zVb1{Xl_v)e(a5kN19^>ECC+x{p7)-V)NU-?#mdEl5?rR?Z5^J zUPIbHC2R%9-Wg4e{<$%5vOE(rofgms-w`#6*V$)tfGFa)gWfQeO9hFM+YJdCHinHU zFM7HJQP0Md#1kd`xhhRr_*{q`_%uOjc!Dckw|1v$9-air$n|OnM*`OK`!{7UuH7T< z25-9PrSAN#90P-mB2DLz{{U02&<+41cc$>ep$91(6K;8hH4j}tT&6Y31gd4!w-vCv z(6)ir5PAcIpxZu?#)4mwR`C#x8&tRELR`kW1S!|MX*ri2hQEStyaX*Wr#%B3&x_Ax zexuRh?*u8VXrNt+aeRF{l0iOWyIO~cPH;0!y_<25ZA6t zhp`XF{R1Z0;f%lCa>QuIL!IWj8nrMRE2wsxe09oTOn(h9HNFg}%mVUK{ss z3K!3ZRd)OsaC#NA<8*ex)+Hr*F{U8ue9NIshyw6!Djq(m$yweuuYPBKQ>vyBgGOg* zaIx<+1{Vwh@|&9jFI9k9L3t<9Z&{$E5jy6RPs?XfYD_+U*h=wzLQU6cnL$EZ&P}JL zBDzl0b6?7NG(kNZW<6Dyoq{F5L?U%;1X`{(f3W#Ga*H!gJX(%U^73TJoGgWojxRtU z_yczM@uCDHwsr-u4x35_Q242|jnWb9W{ysVMab7ihCC=d)P=Lg`hWCIsiJdvB*lp` zO`Rl1-?=KN9?~ZS&s3pj0a(FPhofD=pQT?JZE+c%Qnu%x?cVUt5jI;5jjJGsxAE?j zNrJOW)fJCG*Js>H&nxyaoP&o-*Gj1MO;!@c<@EyS%z^I{S!p+3f zK}3eW+Hu|2;ZiPA5SZ3b_;}=cliF!q=V+x8O2`D(4I{*Py6itAk44d$q1^|OS4W3` z`>ex;Jafj%(3^EWgl~ZZRRASD+E~kZsF|CEoN3SYjdwTAi~T5~RH`@TTFX7FB4 z;Kt}wN??%Uh;b!%6}1{<({W3qqsh5UqO||y6TH!l-}P+$1aO)ag~XD= zncL_GFj#rUo^9Z!2ZDgyJe&#m+1Bz>lBFRf^})e1!-l`DCar^%^A2XD1|d|jlmw;| zSF4x1J$QDF$l|4AE6eUlAyyF<@ZdY9N*%jf=L0iABwzS}e3{vpB8@iE6%g}4fFG!! zPTr3s=@373+Runpk z$KOpI%WPSJmQe-5zsE0S5_1aKe^GVP)&30<12nA(v27wNjLmy zny3`Hyp&94_-uD)98MBVV9@5fHzJmhs=qe>C=KIV3zn;>4!Z$GSB(CGBqZEWoM}7w znYdpfekEdX!&`958Xa6|5#Ja_FjsMvqb@rLrT`1~oq(2VtpON3kz_?l(VC-BSlEid zBwtiwpZ0Dp3J!L`T}IK-<6!578(TqO zeIxZ(>&99Cl6yPZjbwt#Llh`&WzX_+xC-%#v5R{?8*72rSRG*`fa7!?7|dvaJgiCD zsv-`c2;?wj%zRj&dgn;U8SL$F8JT8ofNTW#Fge+D6pg?#ba$}LRXn$!CvuAnvum&- zLD+)>WG;)?TR$EHEM6+x4tP{f0D?w?sWR>VXV!cMgcoap#3TjJ0x)P%e_50*mNT-1 z-)!58*4oCp-=_qZ#01001&Jb0_u|0&+l4DI@=pJhZ@ZNJFOn7@HO>i|d+X9RA~tLH zT!P?I&vQ-NA)bwf0RwRIU)_-(K^V+ht~V#mF-Sts0*Tpk!DTqKd|8#sq?8#|D_7=; zCr4$*Qg(_|91>E{t+}a@2I{BUXd;ltse$UH`o{dd4yMGu7XBkuNZoP(6N{e9RUp_c z5#a#|C;o(#xe)9=f!)VMv^O_GLq0b%AVU~~mcTlio@6QDF(d*8n`VrGEKg7}NgmCi2YC(Gh0k zIQ4&1qMq&Gr!9Zs#08bg`v|cfFa^b`>q1f|JP=2EM?S5`3jZj=9@5gZN@&C?;+&Ix zJ#Q+cR+*CZaGP0-EyT~i?$JPC=W+p^2b)ypL3rRGo4GQSlodR;>Q?qONhLSt)3Wdt zzS&+szV!@YstxT1wfp&to3j5b%t27Q|M_!2Kd)|jcNaLXwr@m~k8vORD?&v;cl_2o)OVDCV956)r0~~bw04b z6)%v4<@;nTQ_(-ipgQz_!hV)cK23JD&OoV~X1lV8b!ab$G zIqPNh*X84T!*l!YbPt<;cz%(;Y4df-a~2)XGI(t7Gv{Cwy=cN8vA*`KuxYO~nT$i) z=1hwTv&`3s-uds){%t08E`j-D+_VV_oXCXvO8RLtonLJFaJpz<@QS$W&fvvH_kUxW z6POC^g_kG|av(3Ej~TUT6JH@<8sYc@^x&&nS(9Z~TP7n5^%?=yZL5E*h#1gn`t~sU z%<#wc!|&D~_!c!2@xg$ZxCQZ-Vg)?m;B#j1nf*I+@WBO-9_wjSt#bK@1U8S1;hQB> z{+9~?yu^GH_tIP;5UP#dIVI!_MI&xddSx#CUVCxn@1BC+%{OiTXD!4 z9DA59^qOHeiYMRNy4$&W$vT+xW_YIV(-%(LFpbA*_e|0=2&kYJz~aAfzA`C!pP5F^jB2Pk^~HLl8QU8JN=O0 zk((OXa5-~Eb|gFm~6hNmK4U@Yvcp=-KCuEkYX%>v7X^gf8;wi6XH73EvfO=TI#)x?tC^8b!%2u%M z>Ve;v39rqYd67rFL7Ef>=Wu;Z*I+j6`h!cEgs@z}h~uTMc2UnYBuh3@w(;BUMK&bk zz+~MN6KB=2T7C@lvY#ihCSjPR5ZN~tTO-w;zs8~u>RYQ}7IYHfldBMS0+?g3X<@V< z(V5Fwt=5FddIbnN3(sLq4>=TTM$nVwY9t&`u*Fw4$9>qtlPpDf2fm(`D5S*pZwY(> zSI;qeCj#|q0*j}pf}68H5W8DG;nA_(5)(*01)#8G4LNdYj`jaG(st;?#EJ(YblB*t zp z%Twwi<#OgV9U?&@Lg5im9~wGpaod0+oZUp$XWKB`O7|Dh%T+Std4cGQ4roC%?{E~>x z$WfloDa5c%<(nWf3n$B68yBt@PZ`e+XowJExdA#3|MtFO^n1z3dH5>ykLau7@3$-W zjzo;+i_hvABwa52b4NA&b0%l&Y0sVwSg9w7rGa>QDQIJ_gPV4lmi)-}48p&5_)Tn^+N*q-kmpFe~TZBYvzD%x2(6oe{rtyggrszk{y{1^=GgK(oP)@-~> z6L9po6!kM;qrQcA8V++&FwJY#%{hGz5lHeE+Jq)F5$;7rV^|K>Yh9-Vzz+_@`%ka% z`34`u4~r~Af`Wd6VQ3Ts;mql^Db;qe?E$3ItZ1i= zc6*XE@vceXUn5|{QInW}Up)sd8>oP5>NE08mjUG8bDI}=M7{QX*LBY#-0^8Hm=4AC z(A%%EfOKJPio0qE2PpwJF```B2@)Q4LCoG+ddwYCwPft+S^INdIs)Y!=ggf>eZMEY zg_HF*lerw9j*^%xaZNPo@V0jO;Q=evBaw}cAF|$=O z*IhRh6eoMIo<3&MG{YiAn<=}Se!O{v|A!u6i-2FYg?GT0p?z{vuLZQsVQ|33dL;b& zr}*2|uvCy>R$^?OcTPibnp2yQTw^jMut{uA3eHdgCBEdwXM8564FoOQm_k4fWfa!5bg$}&gD*Z4y3|=|&Og--fAR%Tiq&zwQ zrE6doj*i1tA2PGh<*C3B^!JiIO*05>2Lb{P9Ei|OM4G7+_UjFJx00!Ihd^?!y2*Y^ zX>!2Wi8(TVFXPmt%y&H-A{d@)8ayK0xn87SnAG4);{0H~8QrRmD}r&FfU;@Pn3X{+l^equskpbtXuOZr zZUDESBo4f8nCivaZn#LSW8fkiki<+|MPEls~t@Tf&X%+)tA(oN2^9t6Yy{DWf%c&fcV_rTX+8|)t z9lZ$-UQK5vTzFSxk|G#z5r7o+1B2Xw=t{B7iR~HaQ^*wkv*#UV;E{pzqXVbHzF+p) zA?cCvma~GaBTuH38GjUp8+dgN_WQi@i#vKzOS&uPW&Vm|w{tJ`SXZuMu{0QXQjr*A z1%prswlZg0TklA)l-JidXUfk$?O@J;B7y&k?P?b1d)uTx{n;6vT+o7Gx3-N{1>fL?lK19!UE9(6MA zk{mU@=vaaBq~eBABf)TE@UkvqE?T z=m@wZF?6#lR|Ve%Q2}KwU8dCJ`OIvB^oSv?Clw{7zo}1U>>yxd+uK9?PW(I2x`m|gGITLZ&IWnP1nQ*eMd zpY@Yd@hp=~?L>&Vx~n2Ms!(*S&4u^7__D+7(0)1Dy2=C$F~ zp4X@Xyq#T6;z%!daqRr_Qb!vu$39e-erO&V>C&09@^>%GDO2;_Ab1|HWzd3R>j$xv+l8qFXjc?xzS2Yz3H~QMtd$jqmJ(&>L z3}aI0l1-l)7Kmm#CkmIc4HRstl#60~P$LH}O)mzV(v)i6o|76=yswJC9K?pN(#su( z^W~g`_cIUE+cEI*GPb&(%#(RjwDdr~c;|dya05G27mqqVG)eCSd}n*MfSNjuWc*P@lWXQY;-B zq>UgopLU&w9^M<1;pivr;q_$L3~LJvYm2h{rMsnm$(>#$EmbYCVO`!O?~kp1mvp>B1=mb0oJQ`6()PnAdk^8roAR<h~LXvj{X*aAmisU~E)ZLzJI2&T2VjFUf1%1ELv5buoUj z5lReCe_uK=GSp;f%*(Q_x`}mu<5m;qS=yDqMB+NDx`8A>0q-7`e4Af_20RLHGW-DX zLmo8^jd{8rHve$bh>J>J=}0OR2A-ISOz_?8YVYVeZP;DX{HwPik75ANO7sBPU3pGy%Kqn2mkc z9lsQWhl+|+k*MKSSV<^Mn=_k7?~&A?*ON)Ki;YCJyBd?vl zp9$kq5eTW#cnxwq7J$n2``-2w1v-Fwl~7K%aXDq~TgPA{ykIb=P$7fx*no!)GInq9 zJE%9LCk#cfhQYu zJuvkXkJ*vI(q}q*IXte(?dIVY;!MEKn+W`O&|_dv_Uo>=l5|(yx`3C&J4>2L`t#`h z(O)I+i1APgF~Ds$4DYraU5hRj4&e3g8NUNs{#2xW>LH-5clUjWQSG@UIlRB$^O6DS zlng$*4i7&6!sfgNX!PEs{v~qs`lyyEwgzAlxEFp&gg8%R5Q6DaC1X?>n(+)k zFg#D%{maC;CWvSL17z)$m^tZ}#0;%-qUhW3YGvIt#E9NWv_yMu*Yp15VJc!M-MmS& zvUSry+Y3wg>PB{QE5e$#<1rKnQ+!OB>9c3gK3R1W8>H)d$wK!7ycwK;f-(%4r?9TC zwPuO*nFrFez)EQgb~_l@y!#_c=n7Dpg3~&cvf;fScpe#3+4e5A39b*sf&}48L*|^F z8eD-fddn;k4qfP_i1-tT!@R5KWUT7eM*<)QSP1xjJI~ea+5T8AEDbIjG4+6OEedTn z;EUnC{d5|U?r`A~)JY{gN^~Z?S>PGs$WAND8SbGZ4u5 z{kdxywnkh%j2=RFE;a z;c3G7b8TNP|8{E6wQG>K*rVE5q=FZzx|LV;72P*-9W=UB-Wlc;f^vQ5GckP;lCfd4 zpmicJ|73*U?mKM$ln(|M7J7jj<*l%&&<1qizdRLeB<-%QY_J7WmT^=WbEk8%7_-hW zmwN#H$!jnaFt#kk-jQ^wGFP~&R$>NswTmlI3s;Ti{l_PeWLB#>=UXyu&knYA!BI?n zsC&F?B4g9MM4?9Nb`;rhlm7wPFC6x3raO*p>T@ROocfh}(vPOL4N#xgpy`1b}>l$JYC z++!rZd+U{0w0Xcd#rVVU6?uR8)T-o6S~O( zEogj5UkXaxDhmrl-p*2yFCc)olTCN17IvQa(g)0Eip6Wf26l7xIzkI3 z6p(S8gp9S;I841M{)_u<`G6sY((Mx9Y8OcbH?Ma;7FGfRM)(D>2bMGLUDfAP$jin;F=|_bLJMzOGnKY zW0RuXHHGrs!&~LNfn!iXDI+2h8#PKEQ@^lq9oT1KL*Q?P4~-6|SPs`C|E+#4lbQ4< z4@Y1+oMp-zvnzeD8!ERwV(Ar8&z8xve`YwOraF_F(~chv+09&3YLLCkCz69%6MBZ1 zOtuX0T>3!b^}`!vi$6J+SWCKG9hf8MZh&2 zDY7vBqf{X3=(P|SR)lNIU8fuSsbqjH^C#6yCJk8!-2 zrn%lw;Pmz?dn$;kxI{osm$AH*sdI7{AbXY}ZgmG!d~#l5T$C=v$JRKpUAHlmSzW&b z2V28*zS!ksyZ`bu^kt_R)X~$qrm$ujLugnM5#y!wP3WE`kIM>x*gF?ksby)%#Y_jo zR!6~xxA4gsulVh}Rhs!YKFM<0)tU8uHg~+cGU_D(K)LBx2xXoP@4)v$9JMhNvZiz> z+4TT<6Get>vEexl9JlPZvyfhM1BFfH^b~%i3|mHD!4A;9Tpi7?)S2ty^#NtKh^){} zw@mg;#9BAn<4e>R3vl*1Ts;MJHSjqic+^cA0o71`xg^9CZ+i7BXtpw9ywT<0vM2=J zKB6v<+7%D59a<|R9Npl_&19q>9gXvH4{Mzk)*3$aeAEo1XHf~K9Al{DTmR_s(OiT{ zIA~MmGrJm7?FpR*K}>$;glqfL4_IVPPQ_foffT&{#orRITZE4s&UsB0>Rve*+ zZJ(6ogXRr4IuImLpb*&by>e#~)Hu`YW0p2iNkFUy1H(%R_pcAXx(?bRAXFj($TFl7 z&_YgK1aWyR=E5@E4y;_RUxyA4OL3T1R(hc=yEyKGn1JqGP06R15F>E0Azi$4&ygDV-b~W_$5a zUnzb>&Wa_$Nz!e}QvS%?2*Hvt)&6C5fdj z-K^2c@@^oW6`CR4^Dr;0QIoR~Y8}Ig-{=WGn>bdtZ~QNG-hVe`%#+%Hk9I2xwsLNaqd8q+WRe!`L6)1^1Ot6t)uDzhj zItE6ba2FeRI>z?r_I>PqE*KfG9NkM4CgHu{z>(~$rUM|`pLQ^5@n6o}YP+0b9*YP zo&`lkyXzYoGXao|Kg}vi#2>Uz)d>674=f4;(vX`v)<4BE?e6Pc89qBDK9uv%zl2N2 zViNfn&0RjU`dx5=Q`NSZXLU4o);;OZ@gxu$j!#9uvADJ@<%jQj{LC$|v{H#m(`|=l zrg?OvKid$kd*(%g%TzYzL>1l+hDn$tFF5Ub{|eF#YAW8u=yQ54V;yMMK+g%wRng;j zJDkRNl?vYLB$jxa8n^`27OyvTf-~0D)_%c36UYLj3Ok1TRU@vwQC(W{vQ_re4xLk$&p2p z6|IGT?_4&|yURcD1-PNXQ-2o#E+X4G7jFBd1aA6m#cVNYNfM(#ZU=t1N3_dx%+IL_#6X6FJw zXKuP7-6=|*V@mySL$Um#guBVm<0dlhMnH&+LI*7xH?mL`_R|?slF1DljP)CR5v4Sk zV>y&VLR<$2Up4NgoVk2lgN9cJ3j_Mo46+Ov`_P+!EDX!fk}dNeH`3zNSJ%n82wz4; z!$X2$J2#6aTR|ppAo^!EST5qu2Sp2>UNSoF^B`z2Cu3u=tnoEhMryfxyb)i-pa{78 zO2@#^Hx7n#1~lxez!qk|z0q8QU6>8;I?d`H75$;B8i#3Te+aUCaOsCygTj}mVqQEa z%DaOb+2w=~UPI;)di(n&YpP%TUxmHP)%3T!YlC8kmI4E#7kU_IbYWi1h49!lF?J~x z=ZfPvN4#I}vy5e?o5Oc;r7N#NN7c%nQnZ-jhHHk^%2mU|7eUnS#tjvWb(||;tK1m6 zANnFSK1(tIsj4wY;Dkl2b;WgtD5~7?r3>Gr!V*{3>Si1m$lV5@0m7|92n%v*rAPJK3B4ql!6`Hee-cumMy=WKlaq{p@_^EPrLq7Jdz@))m zr8qx*aZ!mu(&*smVEF$J<{g?eQY;)Ud#H^J=%~Wy^-FdiEF{p;nWt+XMw_pi3EIMe z!{$Jz1#)pu@Sf_O zIzA23U1{D*=o-MC9r=npuk%8pW7iuVM5-_^Sv!(2HPn~3lr?f>t{57u&79)g<JWn9`f_vI|E10~23Awp*|x z!YXEe!n^@Rj_A=$|F@@4onCG7h%&Gin#dnfTFzHbRlOXoy208+*7)C}h3gQgQ1)-b65I0P9fqFM-`OPXtY(?p{6*Z;_C zP>G7rm}_v1p@<%+1|bN}-HnPg%?UbFQe3V!*rR)2D3K+G^ojKLA3vOIQ2Q9s0s(P| zTK2a{*?12u-JSX$f-Prq5rBVdl(tj-_ma?F%dl@1b4eA4l4#xIxvkOzMVA~@p=)Vrfv3h;x@nBqB1ldb+O z-ASI@WzlkrL*E}YD(??eon9Fy+`Y^e9!JnhqL>p}hynA!^%=4!AHE~TM~c(&fVH{U zON`Pr_sbGWB^n8=;U#(NZ(AN39t@B>SU9UlkdSZiL(aojRni~k0ZW~FSM&{h$5h+m zi!>{1BGcbanIPQG^ZC*#Gn6&2=40ydl?dWwtY8KH`pZFtdM?R%2dee+fWM=qC&Mc# z=Zh0nykJUsFc2n~x`(=V|J@X#Z<6C}UkMSYSt2l2p)P=jeAPzj62@5}3}=4e!{d-n zf zsLd;2*ncqss9kq8w?WO#tT*@dmxd;?`%*+up)r{(zt+XYv?L8`5XS2@;jyHG@O) zkkk-X1Y87org|-LZ3R<@5QEs`A;Ryy7mE^RbY|W|L|6O433uJ zTxmH;X%Se#@lX(u27B8*Jgc3LbZcNEoi!0Ph8^3WM`E^Wk1W3|LsbN)HO@1LRA;|k z5W~c@LAFsH1q~ikU>KcX3NkKDsD>=m$69f3^5c!{$WczH;_T!Df7%2T6bA8N zv4_|qeLDT3vJ7xv;#rNX)XxZ>5Zo|}WoV8CQ_Cd_)dg3W)by{l*cqsp{)`-FRYhuP zU-s+0p&c7XKa?Ck|GuZotu9Kt7#q3+c+zCy{DhE%9aKJ0+zn^E+@EXk>)B<8 z|KxcYGv}HjZ&MhftBY{C<>>COzy=q|lV+6YH5ff$RwKzsHK1;i}L ztAReA2NvF+aT|Q$cYiG}GWS|GgQAk%XQZ%a!5HeAw`c+NX*@qDV(l7Drof2~d@h!ksN^evD{;kIERbmSi@Ych4GTD7u&Ke9S zWQ#i8WC|{?+P);-!53=^8&#}GG!v!f?ef!jO?~U&k-{08s z;7BEvu42nLLtwD~Qi8P_KZSZRZQ!I9;+^cQyVShX=V;)Ph! zBUm)ephEhymT-2#1joYD-VjQJ=N`1Uw_~ng`GrSj=)itwr=*_fHq2v`r^w1fbgjua zh6XH**q<8Xm~9CkMX!$(@fD-V(MS|G`*3EoaI~Od`ExbZNMrX}b4N5xhMKXS`kQPA*mN4ep75L%|j-iF=I(Zf2D$ohWms#yMd>|F4h@hnh?DtzP z(L+k1gWky#!u%SZ<4NnU?}gNq@VxP$Q)YHn?sOny;OwIe6^33SUGcrPmBjIY?XYEAu!ap4L+5^VGG@)~4e z-*~sH+6cZsy?0S_ad!BEw_CV;Ef1y+iinzGKB?V5N1r1L*)($v!kH-?Xp6em9!E9n zN5+ysh-IN9a%L`vZJ)tVahl^35xs_ISH2(k2({;py#dUQQ6vWPJcs+qDsiNMakas0t~V#p#ZDZnEen z4Ao>Se6A!y1)}UlQq7PBf78e^tnUFpwgl`s-1Is8c>gq-mZ}T;P-y>7=s@9Ids;pI zh3H#m3~ZhJI3kDT5^wmdKn-8N$23O@5`kbI+ghLBkOWKMmU}jVB`ao=6KyFmmQu6a z`evRn9Aful^D$}mCIU3+pGDt+m^w9Pj_s!tNU$_Z#C7AlZeqVFRg97_93k9C zQm6cv5(CG*mP7ZNB^@4()sEj??5~`5T7&zKQ_#v=*MLDqE{Z27AkF!0ON4NZjRBaiVI}9=wAd6< zr+R@*qiWyYf>NOs>OR%B3eRo>@>%qBZDbLTbA2X|-syCh*?ixM0LcwW2bZVrln|D5 zArg_af3?UHRVz?L;-MO_xefaZig(cC43^`c-Ry}4P0eaYN^}}w#cl4<%XYNbTEjSY z4uV@}SR;>RjK`0Gz6^D2Gtni#($Tw@Z*+VG35UX>f&`o60n!T&562+Yb!zwK=V^py zLRldR6?mlO-|Ce1XA1<5^#v+hyTF<(NZSFAlt&bpK1qbVd8nLzIgu63>2o1v&f z-#-T%2oq*VSd8~VFkgp}jKc`-{gjdL_IubZ9-!$2nX?dCU{qtkzUxVKMd&t6fFa~gB1i_0HS!#S62WXCRHmget!4LaDiJv3hTwjJ>$(wym`)A}-)tAq! zO}1co6*(9}o~MUg_+mh52=VH*n0A?1ftb;5m;v>PFdc{M2`gaaz3E~$kTSrK-*bT| zjRPOrBB931-Go^%qRPJ;ZN^eYNmcgUD||ULT~+vq8K;yQ5A#A5)mNA+IX^Rz;euWg za3l0l&suM!4C)xbktt7iL;+7FV8i_A3A^dda6)M+Bd9jR8bW}gw#fJJ zSy|}7=rQ|@3!21F(lNFvQx>i^C#ldwQ#=?wEY#EZm6g6q|6hhhVt?0hndp#zoEj4^y*g(lB?4vu{|4>Ur#$1eU zj)TYAFF$_VTHwHQiF!X4@zEu=9NqF%=+TFNKJ?6Opd-+LZTJlc73Qyw0+O^5f@;lN zC!nDn{;mrajO}*)I8!PJd`qD4-JwX;(A)rIB`@X;AafP4tLRy5N_g>j=jOUP5B&G% z(j~nf9j<|Bss#nf4CZNQfS%{cGxRp4Sar`5nm%PVcpTpc_u{+oa$iy#aQ}pqfh*&< z+i&V)eQV*%DcIuw!(p+)6lU~vetcp>fisCm%T`H{uZsRv!K%-sws*uhMHmTOZxPnT zr!d9K?lMf@zHOcFcr>F+IgCtLD9R}4T+DfdnaRVq$h&)%9rN;ym~Cry$HqU8r9=w?IcE6i-=3i(zXp&K zHQFy9{#9NsA7M>A7&j3-nz9$}lz_UD^cG5FB(QxcLWzZWSqh=AsOiDKoLq)HyPJ7a zZG69=&Z2PZ+))C;m5fz(rVnz@5Ht-D9(oR9au??+x0v=luMhVEq|9wH7rvg_nQ8{n z`NHo8r|)5)m*ZfMVyhd|DSY|ds~3yjD9@kAJbxB74;7Kn zRg2kYJUW1hn?C4-#v2|T1 zUG$Cx4FQ{z((?|2QVhQ(0O+AT52ke#;5O`pRasXPvJd5DA?R#;-=)xsgmjFXa(mR! zmcs3Cd@~=_$%KJOls|E>QlBuw!S18vs2s;i@CyT(<-q&XlhVSEy~n8Yyss;4bCTW^ zfeE1-tovVqjmIAU!bXD+elO4lp^>n{4mWSAH?m}{h;k&NDH`^FIDl1qNR#6615+-@ zx?m?K5L3d9zE2L=VC%_NG>}XE9n+6O+_*Z^8`537E2PAJg7|d8!gj6!m^pDv#)^X)Jc7vX5Wgyw>5fnYr$ga4TWw;3~7$av&L!W54C!lk1UQjZ1hB zTILKxc@7R21{JXt4U&{46c+YgI!l}PtOQ#+$73Xzpcn<0mOtDxO*nw~NgzJ+F3~Q4 z@j*jwdHD<^FZx)lLkc-DRYYuH32HY0A z7nu0eE8ygbgdlVl@Cyu`V}PSRL8yjrGtO$pUm`h|uHy5V!D*>d=+fXed!aS=8oa}{ zrezmCU;Z#7Rnn2wzYzTi^YlEQ=`8!5NGB0P0&BYF^a=+9r+0QTTU3~HR@eE!E%#51 zgOJg}SV2`64m(2N2DcF7Atw-mB9psNHU0?VS5~_y3AJYYPTZN<+ctz$Nmn6EaVbM5 z#{ZAEFd^Jf-jdEU`ZeI0cbz1%+O82iko7)) zPsn_Znebotw?+d~WVW@~P;IOW3ek z*c4RXniBoDsevPF1`jEnjZ~uOB+9n*&`$8k|5%$TW$k>&pfY8z{6Ty(iK+p| zcvJ`0ByzSum}2id;XmcAY%GDn|4^`e%Y)tVboun6XaD#|aN%+!Ci2PSmEUH{$MMyhZ%3OQ{hIICovxNrjJ?|c_ zhlSxWYZg08m#N{M8Stg3&FU3TOt!7#mgALa2-q!2H)7hz>3Cf0h;?MnaraI2J`a}) z%wqD-3kR+yxi}gqxUg~?KpfS%u;!>q&RjZuT~R;#{V~>VHno1zHF)|UbPt(}aCe4B z(iWW>bi)Ginc*jEJF`7lWPKj?K@3 zceLB783th}(Uka!)5jd{ znJ@}>R+L^nH1MmpHeJVuFYE*UZSxYua@acxcvCmSdW^Cj=Vvi{qc0LDC-5Ut^AW@X zuOq~P^fl$kSCH@lVi-((14*h1c%!!jSK->rIHyG!?jrawEPrr({K*rrp)5b%;Gv>g zDV;oLn^_{RvjCROgKB0stkvu|y0%C@AvS8}`5_1p!q)}c2+bpU8c9cNf-uHTjm?Q+ z=E(44b8gv{o0SY`7h^#@`b2vevi5=V*L|VU0XO#)VOhCgy*xV7?HPtd^>jz!%fD1t zFPZ`0kh`m9Ay_T%ns4_?nt)C--?dI^zUA@wi^zk^pZrhjjK9c6xddh*FXg*YYBWRB zyyveF2yx`8#RVM~l?z)P7y&dGec;$Yn%#M5RR~lckk+A(kR6niP=#p#0g*82;rrxu z!L>&ikZTY9!Cnm$8_H=;dly`lGvqdH=arE1TMfeld_y!t5X$~Kj>zlT2z}k(?_ys& zZ^i*;_OoiEi^^N>-Z)Zbm;0X??n0pLZ=hY*-HLQv;5*~C$ezfDw;Y~mI7=_tC3+;q zN_6;5?eLq2mi?TuoSwjb;El19`HnjtO;pC?UhclF6XEGHi9(>u2r*<&MfAK0 z@{I!@&Z$wd+=^zU%xVKxFqHFH+;!pPTB+h9yerCCAgLN_Lh34YOxWx<51wg##D9NN zH$rB^`}dA~yslR?_+%0sbZSR`)mjFB6ZIp82H|wxAOK-Zej)ef?8UsPPxkMS#OV0A zA?OniggJ<@6xrBeR2$zuog$zrNe#tN67a;DBzq04U4^7BVvk1xTVXL5Wur13kbqAz zlnjSKzs*Glb>;&iArYlR{H^RUW5Z!y$o9$r&MY%89o}j?;BI+qr_JdE<8yjpWz>K2 zhIji2E~H085(9PkIM5O;#XrnR(8SMLsOclt@nB4>EacQRR^ca;;8c7#SOc@mbpB!# zCotMPJ_e`RSF8phnu!C)sbhKV0e}oH+0S#9F)w3QrF*bQ#yj8ZBQXz-r^qRd;Aj%@ z$$aW@d>L`g*y^3DoWGd4>jW=y><7`_>%gSFLi$TN8GgznAJ_IhK~F~r8_jX-8`l(yUfyNIfdbx#kSrF88UnD7;5uI(c{RV%RmXJ3;WaBU^qb<7T{L= zOS@sF@-uS9BJ{o(`}x}?#7${r{h$5;E|oz5S->K85&Ll z%iI{oQiv-fu9DX1FQ?%;k~WipM2s0FF@a6NZJtwlfI(;cdK*6Endow9K~bQhw>}}9 z?W{T!9^Rak-hYkFk@K4~7)hM;JqOc0vGQv2oMmrtAk|b@0fU{7b}l@ZB&_#}Q5$+Y z1*?9wKww)<1}u&}a^;H7YHjcD@Ao|gwqr=(?Q6b2R7zV+rQUc5;B|$k5YJ0NNWfez z)zH&1e^-DOGqh=Lp#0>N29qg!UqH4h^eM&9Yu<H=S&IbfXXqehX;`#>wt^F`@~A zErO>va;K`=^AImCvGrY}8+c|(DsehN=vd#^oq+)XTpk?J_Wy}{in%rZ#W=tvl}r|^ z_C&N2k{HYYQ0T2GbO(_Kogc}RU;$0gsc}&Ya4YIG9YWF)bTNUlUOBXfCP|frF`+?4df0*wHwcW$f_RpU`TMk2>0Im8u z;GSwY09%dp?mUNM)LP8+eLyF&K`0=Kk#{}U8V+G{t37bk zmTG|)icd1JODYTrn4f<1Mm$0%%A_|DGzjCz3Cc)-X6A=TKz~XAwoE^^8ni3)2ScGB z>?(6={$9_F7}#@rem%fWEWfXJAdA30wILw&VAS72&L!5(saT_a2Enuc)qcZtO=yZ| zVo50JPx~xXxX`cSE?G(oe0avO&g85HN1;fSg#5tw$j=;sdOV)51mffCyOT49pF!mm zIEv)Y=TJ;*vA5xjvus?1N>#8T$|S#DO1#ASP=*8QQy6ssV?oKz03;E(u#6AChG7zxP~Np4kR`Yq&5#=uRD<$ z0!_@bXCpUWu2t=M**t3F`}fuJ;UfdXS>F0m2ZL2J&wMz(sCdJr-&itW!t6pAyq_)t z3!g@o*~wD7t?)~~-@*!iL|z+4`<|irVPPei&;NdjV~9VF__MG!FM}a;-m~tUx35j?t z1n_70_ufKQGTi!(DO3Ky_~bGjkXjaV^R}OH&fCL4tKK~{8{6+ADyI>U(3ewsq3D01 zpsqmn*?1-j1>^3qF@MnQtnCL${z2_H5|pwb>tLiyEP{=3?plzU{%64VrGf-kv=^%yqg%g_pH=PT@RQ%WX5KE@h>brd;#Mp3L>2WCn6jqR#^BTq)(Z}F}@Wm@UjSPpk zfKZJ2bq;(m#@`a z=&=ziS{xmf%1b6&$>2$ZzRTk%LLYztmz5liAf|nAh!4AlTO!N=_5s*AkYa3{XZBcb zR7SRxX2aTY`W0&&B^a6FABaxyHsib9E)N+$al@g|1I#s32z*yRTqKgtRwZDLzBI|=MPDT-5}<4c`GMilabi8f%=GQ_WbzWc${n1RseuZGS==W7pe zo4H1UOY=;EvBOIx|LSQ^$qq*c-*DIq=**R!dX%&3W5d z)X*_y#r!Lb?UR;Hj;lS5^q7fCFii(vFQj|HUkpdngv2|<=5xmaX3xn~1j=(i!g!-= zXO0UCj<`r>foD;Fy-y5wQ?WYkyWdvs9*>MHU0asip!+os(2%SdG->aq`3?r_dSD0p zu2Rs!?`AQ25udUVVK$OO#eWv{Pc=}O#`{=)ST}Loo`RYx65B~LU0LQxCl^PA*Uk1 zoZW^vwveHq`i>2-&ov8t7>UY>9jY zMS=Fz$BNo3B_kart7gs4@UcE9h`L{lJ=AZK$=Nd#ps_ZF=NO-b1JPs7N~X<#Q+H@# z<0^z;fBtNbG_TUI5_w1weq71xx^^8A&fm#~5AlEv^h@xo)k8TWI@*Ei>>)UicdmrL zA0A}1`gjDkx%au*$7`wz>{`8#eJ#L1D(@?6Bl}$ojNaIENc(UUB!+vpu@B_u*XQ>Cyjp=6{jl^8s35s)v z1CNd?l;Z&2N<6hhvt}OfYUUhpSmenwE7ZD3?#Pe{oTIx{|7nI~znkPWf4SW}`_w}( zcgB;yMIv(g0*6NGE@;^7_|B}msCh?e>@m3bI(|JP{c$WZ5wIo5hZ__QEYzlD$l=wE zgLBa(6rMpuWc@;qb2bB(O%^lH5Q90Hxcs^}8{jlx;E|L%jxiiN0`eBfa$?4&8iXp4 zp%ZId6KuFM9wj1D=ZG3d2MzV@=CIcx eWrBK|x+3Z5tM1ORU-P=kF3nCbS;yH=q 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

    kuWUM}N}W6{+)GhBo?QB=0!cdE z;7gliqcnr|n+4LZTKKF981AEle=S_8>B^eV+EopausMYWRtP_pjRmfO30RY(+Ae*u zTB1XL6!FJE72o!RWaaktWEZJ)i#%Q*Ry*<^INv z--AOsC`%`bvW#U;Dj7v6l4?d$XX@0URLYE`g`!EqbdsfY3}J+}p_LXXOP0bZ8SRaf zU5g?Tk^Ompe4pp{`kg<%ukY!UxaV_!uIqYV??qbLG;t@wVMc#^T+TF7-ux#Lk@;Ci zQ=coGlUc6N6aWbLt)vqEQ)}IeJ@9xok#SOb>&*Q-|aUJHS zsM00~dT_OYQk<57Y!|t^H9LU$A)`Woql8qRhRzA_y#2QCcYRIn-=-;SFmD_ml6eSj z@`sg95%2BEa5QHc?n$4fE@34%S#NRd1@QwxGQ53x^L^pZiW4bbQZ_tXSRjusi6lU% zo?FX{%>MXxEzA)0eccc&R1jy$gopVNvRobGMJNlN?uj0!@Wb4YZXA6`(uySOWD~ZH z5f`S&nm+XO64?D?arf&~@#wI_+g ziu8FV^@|TlQe)vPH%?if{CH-!E+ieMi)`W|`Y`Gqkyus}`uatmhD_w@;;?>3E@=dD z*8+d$_UXOG|4I(QCSGv-Z-8LB0;KcNQ%%)r=X^v~5=mVLaYI3?5Z((QBYcG0i7*Zr zN#+n*K`CJ}uKjK&g?V+aJq?p3(s5NxV~UT_sdC(sUX3w3N@8e_4W84qk$G+<)=@I0 zy>)!K7AoL1n;%Oj(g^EC9dSmMagU=hWMZHNx;B1cl8%&Zo0+o@0R|}1JCdK+Kf|yp zd-o319zW4lJ6JMniN!{ApKT85}i@!vv} z0R{}W_!$uxof_08n{`=GhX-IEUC9QN2r0<&l?xsT3fse=3ydu4S|9;A6 zaXhdYHfEA1K-DSO5Mf3nKFv4gqdhYA(vOKNYhe85cmaeMmWdNbO)U410@6MLl z@@Cj=gIf|!*mPDO#7}`AVVt9vP|-IJVVBjlP?SEUf^$EfGnUMxWvfhS&{$GeIxx^> zouT(OtsNhGJtskPMtZdAe;BO5h%*3%h3kG{#!9@LyrtVF9d^!40zlxz@d2*zK)PW- z!-u@0KNM!D&tT7|$nb~?i9VaclQ@vJ3L6C8+M_$?O`Xn?JEtO;ly4`{Wg&JPi@Xx) zejZP&{?a6(-te)VkZ&hTVz-9wnqA*V2f)8_rOlhVffjo9Wjq7 zUP*%M4*%FRdT*4_RBQE?veRAD<7MyQ?J{z0)9BF;yGH*I*g;~@($=N~Uf=$akK|e# zcPcu{`V@-jD^g%-LS#mCY?RKWp05H2mGgu*cLfYO@yfD*;KH>I=3b2t4hN^zEr>!s zTQfk&97TOie2XQT1lIoK#+>nK2J5s@DePL z%4G3adi0R#6KT~35@wSpgEboiq@jpZfy53>9>hc|?5Uh=4fCJ+bU z!$k9K^ySD5yl0M-ikCbE&gO0D(7?xUsH7)n(u3=uLc{Ld5u%3uk4hd$ZLr6`tkpA@ zqW4F6#r6uW18m!A1Nanf1rceFRO&F=J-VZyuGf**I}K;LXA+Q_1x65RBp*d^(^vQ~ zjyAW=h6@yCqO+c!p4?4{l^bk*fl;{Xa9eO%I1-*v|75k zO^~+t_U>~ZAX03Ekf+jMWdOVdzgFCEriL(qL^s0^_3`B;7cbX%|?0@JhN!>vD-js>L_)dAkqp+p;KnkWn{Fxb9o@W6onJPNK{(&yttgP?=7gBUlQX zsR}L(iNRd12_f~*a<$Kp9)1IP-(?2n3qLq<{j>UQCkzvnP* zj7vtolRaB71FUcFj;r=O~zm6EYA7F%MSN z>01BLuydkovy%53KU}++ain2Y)`3&eSoMw9!xw(+jJ5&irneZ_F;6D7sap6Bs z0Z~BFw$wy5$HZFTV>pH)Esnqi-d4EPA7kGo@<3L1!6pBi1WIJ2r3`n$U3q&ZF%n&a zx|KUNrz*3>|FEC9s#13@xWNr*|Bh=?@Iz-*R8|sew$PFO;!!-FWHD&@?>FqKP1OP> z=w>+Qp#m zU&dCHOZp64AtTq#Nfd{G$7==0Otm311gOgcXNu^@#y0DQ2m>Sl(d3r#KJ*6|PZCb+ zuo?zKMZ0-;s7)7)Ba5V zCHVVCSyKlQL63###yh{ng=)bRDK;l`5ew0n0^K7`OeJ~#9S zB-*sVR+$j;-hca9UjADY88YU0?-MEJ+C`NqHyDBK3HMwfSvn{S>Itb)4Om_JKMZbm z4WuiR9G&0qm6`47+i+>Hk4dJGSdUttx!Lo6VYUee*ageX8=o<00%@9fIl(JYAH|TFpFTX~hY{i%{ZN(e49l1j!Z?bua2MF8?7((;gX`uZ5GS}WRBR8)b^o6RDVA>+k6;?hf$^A838{99lX4JiF0jz{lbI4 zzJCHecEa?9VM7XzJqL#ef__h`K}$l?a!_;~z?DJXhz8aXM`j>yL1&8LmgFb<3W7-1 z+U(*HLqk~pH=zA!|Jha@IfBBy;K0z$oZdIaRLmlmsvJqNS zWPVXXL*)1gTkDoe)E9v2}W8G);W`GZ?U3Q{Ny8xQP!>C|Gm=XOA&kI#^2m$KCqW3?8& zlv)VyJn)sr%SF9p%f&FK)?O=EE(ZWz0#Pb*f6Z3UW%hZvRJ3nU7U%W+p}}yhvB@?4Sd3{0#)` zbLV|rj&2jrKkW+(Z=1fe^-Wmja5mC1ko`F19SeMj8F!Q5&*LP=O)4y%G`5Sa zt{QY?Va08bgy%f%-mvmunvZCTCDZBJL`=YhbW7w6>H%-RS&=Zm?3&lMXj#e4?Bg(~ zBSh&fxSyYr5fgu7zubpEF_~B1-uzfIE?#~!b?}@W!jlj`2kjShg`MDyQ~HH{ZZQ%q z$|{NMt*&=qXYO_#xvWay5zJ6K2lgY_&(>$YG&f_@>nVSQ&x*8EWZR(GSq!caj<6J` znw&JwuYy(ou*--E{u~Hk{#-FhCDG*^?F=(GqYQ<|d{JD%-y0pH5*%x|YEyY{ca+AY~#Px_Zj%sA2N z0Kz;9c!^kTW5Yd@gz+)b#a10CR7vLM%mD3(&$Oz<(n`;^YP+c={u<8=tN*4 zx?&pXfi=O=z#R;5!9&_$Ag*B_m^p*U1&HH1orJF9zL%N_<0BSn9Ebnb*u=XUvn(sG zV3IYOfXosA2kod%c)bx?t-@d)!V5^iErv2lFA_Bj$nLRRj-s1<9TnY(JPewRvf~g= z80m}2t1Crp;3;sr0u#g@>Kl{~L%FfaCBTOyG>ZEA5G_9XdGzOKGfBz&|JCDTfbEaa zH&bv*Y=BSokILD__IJ1P{xyhseRPYn*&XxW|1!ETFf=*5YqG;Ysl$#;?mmipd85CH zvJZhEcs3Z=ae%=FIaRn~*ihhy4fbY= zV{xrg2mUl1xHY?S&p)=nRthPL$1At-R{zFc^0d3XLv(dLgF9;@;XTJSQ~KwkA3O6p zPVID0Xt@P$#gR#R)aWd2z;O+8VtZ&}x}P!0R?*@|)in95fOk zx6K#ecPH1_KSP_{&1*)hCd&PHN!j5uAo2O}cW1JjJ1KoIAPm3UfsriGkpHQG^g-Iu z#%3{Ie5UGCb8|Ba8eGL-Ud0E&E$sWLu+hOBS^95dX2vGL(5Va^gBfghdm;ZSO52UI z#Yk!Zm^8Gkv6&5-vO;U_@K$#Gr<(a8@XgiDN+-@Xpg0J z9sY>wv)>;W9Q=iALda5?6DbKa2#R=B!I1b11qsT!Quv>$6}&+ulzE`Wk{vx}OK_N| zZ6LGr`%IDFI~yk7BcJx$Z``;sfs<<~415Rg-pp&)Dy7&%zwhkR2Rx0pFz>*BO&3l<01P5g5b=4U$S!MgEDpa$p2GC1s6l@D=@l?vr~8T9+hOmQXuIwkpT z$5M=&QM&zVH$1LVO;1hVv}x0BqD5Qp_nXj>CsGh+LD`!DJi%uF6a+1 zA!SkQ%02i?3Gd=t8;VQy=zu9%qPj5dl4aV_@FOPEG?%%f!>fHj8 z{9QTil@$buug;vAiu5Bp0O?)}S0LV4LH`N?a|PqDCp?xdy`EE#mtxZh@BRe-<>ZWKbSRtSv%2&pD6v zi$}#Vmf2t3ECUR0LA6Jx8TppedJZ|kB&Myryc}LebE%j^-e$&V6tIj{Vux`;I!S=z zQ-3h{M89@!P!>Tit?aX<*_y-q^wgs*=t+*$?>ibUl`XOBlX@ti+DOSoI z8Tw3q{tpF_W$a>zBTdjj8bV}?eEB71FBAWU;~uX!4WJfcmW-4;F+bq)gto&8w9k2v zlHRriZ$_s=>UP@|HBL3E^n4$PsCc|P8^wpf>Un0VID_e! z^t=RjPCXJY=8(}IH1Mei^oa)^S9Jny7aL~BsE5lG6h(-zr9{fOfXFKky9V6I6p0Xm z)YW!*wB(S80@UR0H?y3e8_S$Kk4Z)cNBc(+@;-ei6#f8>)8j`wibrSH)g6@EyjFU> zZv@jvVP0|Q$WSmCQ4>WL-lwE%*6~DXV&1E>!!>7zTPKVnF2+t^>6$L;p*dnjP8S7z zoW;1nmUHCzU{kw)pvRZ-TPd+R@p`NY-Ixyz^b&;Vy37&rNS!6PJY+KH?ns}2&$=_T zxM6wnXR$Y!0YYUqy-v?jPkLR8kZpL`c{uUK#SYU>eKJdD0l3+_fYxZ5(S)mdcSBJS zUj*8X$SFEHtiAHK?)vMvu#)1e9@n9_xUz(v%?ExUlG;4$&H&1RIgC_zIY>k<_Z2zZ z{V2I%xkLj=kyXcwRjFrE6>1$z)PYYz-~Ad1VfLPxZeEyKH1zdnlYgsDhuZ;0`jOf( zt}oB9*nmO9VN2kE#O%&X;7HAxG$RH+dNvHvY0eRmrCz?7@bm-r6Ucu^ZiZ4+ICNP7 z?g?9AAhQWn@z{Onm_L5x!r@`FqJVH+Cdxv>hgu(yPx&7Fg$3fS1t2~Bzv>$-3wgFk zgJM90i-8)8B>&*xyqX;wiw@RAVM}}d|C*qJ7c*}x#Rr0*lzlMB9{6~S>%Kjmz6={} z0K(fc|DK&At1rOIQLygb>0c);wk;WoY}ICM7wAwA*+&tu7FG3W&sbYVY~VhI6+cT$ zj|Zg+o&BzPiTJxPluplFI8q2VWzS8U&ba$^;nW=Q$7a|5?%C0y&+tKn+r@*!5dlZG z@FaUbx^bL&|201KP1Xts2?;3b?8?XkoFTqV`(dK&4&6nls^gy7z*|Mi)Ail=duCL>w?W2!PVS!Gqk3#niqg{ zl>|5eD7vaW85v&sx$ERUbWiI6jT@Tf{Mf)79cmK#c%BKbGt@mnn{_wZ{sGRm51d?3 z8Avt*TD4DA#Pn*$LT=-(!5r+il}Wp5EGXybxIO{@lG5Qzb}>9DH}5K#&B zbN#t!%ZWUWX7d}?ex%RgElsDVa5MfVsVxXIGEf#zVcl)-SXk|`_7go+2+*j#ZyB4H zAa)ep&&?%m{bvekXQo(wq2oW$2{0mBWLZ$q_wgop;8;b=2EI3y5)dYit`D!=^F-fX zTc-m2lPm9dF;N{9s;YrL6Avs=gVvn_E=tr7WDuEXUC*HoM^&< zMgS%GDD|%(*+Kg0K=Z=o@AUSC4_Ally+}hpTh|$OyKdL}fM=)AO@c1$0K`@6s4Z{A zVuLcO1gakt**YZBkvu5YFm8%2Qxk1(HNZ&>!4tvFTyD4>MzHnVysC2?e%`#?XFq@lMuJhWR*DZyb%H(;}+U_0lruZzq>uZ*x%>XwjRJ@&k0) zzaq=rTO~P{a|o$2E7tV6^2JIfW@9&$ThVvD?&!;Z5m!AfZyXwurOPx}fuirB^cS(t zmo)JSK&Ley`?cV8E(X3lF~j%WiGsRWOg!8JHoCXB`jFNYIE zV(rx_QF{C>75bxq6r?Y2&uq&F;h8_Z7TfM~VLIIT!42=n$#5fE5}?My8d3$p{4!FRSgH$F5pjfbpFF0<5wF z%&`)z0JpHT6q3N}IT`QB)Utcl>?&7JMt%Np7{v3Ru>rUcuQBz!Y>M9R zf)4Q#KM{8fC~+ccJ6IZoN^#3P$a7tw;y;g6kLzLeNF<;z$*hDy{)Y8+s42?$75>?R z0NpAT9u>Xjk*e#nYKyiCTza1~Pm8_5C zzI4>Q!$R5P)R-M3T%KDnbz`>n0l0Zfhgdw{-~Ym6z1jrqen*;id9GVB7gD|H>KaCJ z0-($GCtH60%%KO;nQ=rXFfLAO;164o;C!VtAv!w9Gm)E@o12U)Ja(#$9p%)BHkJ_s zk0BtcfHd5QK<6#m+foZ~_6hqBPZDSFc-)^ARBD6-8#(k32f^abkrl&N&zjlE@<@EK zYuB!@u49{|-9v4gMkfb{?4|xM7hnJ}EaL7@xREM?g zFZ5pc2RU8H6)p@8DllJeGS6*{ej`v|{b|66$6fD~7;}P-J8*u0ONmY0sy^%2>iD_lI)B?AM0T8$&Qk5lXn~e}W++605uo?MtYLBaS+5VL%{z|e< z8T2>626N}Aq#}!SGb?b6N1Uv4+UC_gvn%PAdv~tDxUg!=VxS5x<0S=?i8sb^S)QGc z#J-TxbI}v5!lp!?*J=^#)D|W!an6L#E399$<@CL5l|?nOt%+hFPQg8`e=*8!IkMQm zKF*W;tn_&4-G-1wp`mj&iHMdFS545B95C_=2CY`WxvC$p z5#XHcW6`cVJPhs7Sn6k!J8{i2OK@e9P_~*EazBmahWEC+`?V?It&Tf;5Vkd%L9r39 zP2N!6OJR`+J&1)$Q1(^X6em0}RzCba^3jeX0iCP+2*yCNZQ>f+-|zwe{E2Y8j!FaW zi6;aomT?kyFQs!q7BUaj6g%SA!lK$C%;Y*>##2BQZ;bKDpzq+c;xLuDx#GXYIxq7w zQWwzoi8dR?oRnMnp<{Bl&5G4`T{HwiBx%_blXf51bj)^zQm1Fm_=GZ%;%$PyQiK?9 z))Y4ujfFGK@ZTazndX`KGq)^1i^Y=D5V*dws_M315vNln4Th*~`~A~7GMPu+^;pyB zaV3U^c0n;P4x^s+nYwQ4dvcJ+j!NH46*N=d5xSjb6`-w7W)MnThh``=TA3S^U^;0S#t z%qH@22DmXqeC)Ve9qq029^GZr$5()F^FaAr{B0}}pTRc%0kK}39kai)F#PY4mhhpo z?1%M#!v4^+`bKg80EVL79lNsQBG&K>H60@;;WYIYo6+)3L*>PT)}tmXr%;zpb0T+j zNOyQv-%T^mSsD>%Q*i=jhhS3#g17@NpSO0T^dJ(|K>l*mfc(jO*-LlKn6;^?I_(Ph z)+q+n4ur!Mw#B%9uF8WaNgm-WLnK#9q=C~}9@Zx>imSSRVV8)(48iP_GrAAl1bI*` zo`QHR+G7SMN0##@$n(^riv{veT$z5EM-bnT9HjZgwS;xSXzt0D##%vMti~CHubYPj z1k9Ph)m9{1YHO6A72ABG(zDt;{Jb+FPHe`Yj!p*O0^XB!trT_TlH+i*SWyb5O}6j5 z)0~dJDBRbjw|AY43er^Pt$nh=Hz2FeG+kd6oAWtRRynH9;= z6Fi@eW`KKTF2d7zoMxS}PK?i2(ci;Es|S4pCP*7y;q%BXpFxJk0mM)IKt=FZD_z~> zOWdimuv?%-BNCG55p|L-h)x#6>U0-07QCxuw+WsR#gHCPr3Zq;q!-yVR)uk8V(5{* z%g-vcVEvh13&?E4HxlC$U=8&lP}R!PP>3~7bK=_qvK`DTaW$vFrNff>Pi&c+59PcA zFQB@f9rL1{wLkOX1R#RggQR5CVNuMRRr%v%B9cWH&qFEt_31FNTs(7z>pt@3Y*;sl z*Kp1t%EguZg36Yz{o%#Mg@r%8YP~=04j+7vID-QL0bbmAg3)kH+ubUDVI>tghRo z6p#!HZM0HhBzzaQJoR6IF0QPX9#bPRe#XW}%<{sm9UtHDaOoCC`9J9Af=$xt7C{=V zJtw7b2dJy*k96|UV^cuG;ppe$w^Lh@`ssZoheMp-MIwY=AWrsMX%DgL!-O3VH*@e0 zDgt!FyDA+(nZD1 zhQmL8{2)AN;vRv;bN`1et6eHwV{BujJH*JWFSSqw73nn&V*Tm=Et@EI3^Al5tZds- z699BLqA0dOIKYx0t{QffTN4-u^48~a57ExK!S%4gC4~)eaCZ8tMzQ$TUVi>*ro444 zy_~%hStfp&OECnrn(es0-}$wN@p(;#vY2$*U>{9#lxxe!h5%0(j)kbXW6Y_2#SSu$ zs-tx5Hv=z75FCZziQ0cax@X8Tp z3u8+)K<+eu4M#Kl$;~XZ27l%GUXjMYcc6 z+3eQ0Ft%iG7u%vB(7Ti(JL8-!3xah)6!|feO}%9so<>X$Wl-~4AlU)gXN$d-M5%6VdQ5{^{4c6QA86YeFny1q>95a8uT@v9Oh=YuV z#=kGGpy>WSejAJT>9#q3!SQoP%RkU+00fmH)^*-Y^7Kf%mjTCAIJt3onQ!Wp`u12Z zD;wEAG|+a#&l4|dc>gj8Nq^m1l=qjsP)GC_=0h=Dch>sqoUE%kS(zxCx4KSt(5s%T zZ?Q?>7+zRfDZLD8imD?P%nFXFLB#r##?l6%Et6Kkr?zFj@$kBy!LM5=Bif&vA za~6D(SimyhklBB-daLse%#6X6DKO-Oo=$QGzYB;_tE9xv&@hffOndl^V;#M&KF9Ud ze#>^G52tIH@}bqmB9Xka>M!P9$#*wmuCF{%b}(vQStOl$0+TfUadF<=4GG5aQ`z4z zROOh&Xpzyk!62qHZk!{^-b?Axyq!lAId65e)ww;mg*f8{0lE-RAp6od&#vJw7f|=K z>N!#HSyXmRL%2L%cLDh(=c$04(f*w6ly-TssU3wZgvrPHN#!VtUx0qeB$at zSsEzcl)baxH1u=R=+D^;2h9y7!Vh->bT4%vTPw|nU3vRX5Jo?E_hwEK)9bLSswF0s z-S(rc%N(XW3K*kUgn@hy=Ur1|hf%9`+{{9ypE!%h^Br}{9 z1AGUS44on(^(dAP={|(_@7IQ6{=ilkGm2UI@xu%3?d`)y>rH{rt`Z6W^UzG%qlj`~;4osbEc9ypBltSn6x`%4*UDFouoTOyQkb zzG$ju&Xon7SmjK;R{Za&bZpH;vD<3lJhVg0o>l?z-{+cCoV%Zw<9}2gO9UYB_wprW z`FB*I2RrM+n3)5*j0%kAq*B=)O?CVnCFo>#@$d>lbE3NpEdcjl$+%P~oMGWXM!1oM zn!C|WiJq$?!kR)hmH{&I7({`i{TUY>tZt&Bln(nYzO@(a)2HBRs30PNSY6ps&r7|l zWqRm=pdjNh2hk=yYM;2~-4v3ihw+E@9KO+nmISo|@m7)(zV-lC29KxOT50$FtTre@ z*ZZLeqjABT`huWlc?E{z8laP>`uOAlH&XF_emfT+oJ?euz2&Cn4vnQ8vP7A93$LJ; z4ai1;_f#t*q2CZ-`-M1cUu%`aV(uqMhLB ziTDQ`$4~#W?R}7ECVh;S6 zDVIpk#!7I`S{L6;uzJvTN1t@CNaZ@2*5<12BLJSMoW24&KhQ|{)Mmg@I}Z~kiC7G8 z0lZ7Zx%xeO4^F5{a*&@yz} z7fk53KO>g7eqhT_)BrlP5A8SRm6Vt=aJJh0mvRizq}O<$-Mo1~PaVODQgih4hrL5%K2RiJSsez)m=;o=J zt2G4e&#|iD7#7WDA|62MtDWJCl_T$}QOs^GQDrKC9+r|+kj=zk1#dvT(>AM>k|a}V zJl1bNf$!9{7PXg|vq+@7Tqn|N%737gp3xD0qx)szu^P=)LHKINF2#NOKKS&vTBj@DfKNNuVnJBSslzgp^+@FaZpA*6znl71&|}W*^YMWf2A4dcYo)9K9|wQ|Pu3#NCmh z;y4rG3DH}L0oFc8Uv7`{B*LIWU0DH04#KkQMmb}FMki33#9!)2R0{s&LpxDxN`pv2 z;LXB$xAOc+pSbjVv-1=gA zb79}e-~G=<`@?_JC*CO}f%X01AVhe@!QEd+M#6Ri8I@SR+Kj0iKRS}eiHq4!n5HG5 z+t#r`%aDjM2m3+QQUN5StBBbPf5L>!xl8_8hGAY$Ko_;xJnc>qi>6JR25Pnz0=cp^ zz}K#*%LF;sj@|ZFCpwNE3JXK~e=H$sZanSC(%TSK9K&Qt_t=P&Cb}2ET}) z);5*>xEGUhzApayM*#}wu8V8%7@5)D2CRoCydP2#do*LoE76szfH%eNm+k4w|J)-h~yg>3%{8f{0>Wo{ID+o5 z1V$*{sWkgwCs0$@@h9|AYpMZKcAgsa(*ExOLK1$wZy4$AD;_Nrb6W=n2Jncah|0;# zK~m?dj~~;a>-^BsPJZR**RSfxrGTF_%A@UhTT$l6{Hzv>0zkPCH*RjmtPlS)jIjzy zz_;O+PW-yjMTut3nq`Qqax$jzeuxYrz2I!jT)*Bg^RJbXx0egBB)EUS$Lj!?HHb!h z;W72m3p-IcHt56+Bdq7eGQ{DI_F$_{TWU$i{Fpq}&H#(Q3ZkaJp+@Rcw1L=pFmVg& zF^GLR-B`8MA7;|{pd3b89CUE!Mh2%hv1&m*0EU?yjR zO_cr%SULzK*kOqQhnJb4FaK)!Dj)VQv^?~U&dW3e1_6Me5AF6^Oe*z6<3moDPSS<; zd+{pSqj|m8oE}fE5kTyK^xSCBv>iyS>+vsxs zQNyTE2hajC^SU}14`L7hRU=;EAKqPQYoKDX?T|HxqVJ+N*}>)HyR$lNbK2)q3l9zv z@6aDVpt}z+N29H%A1FE>{oJm0Gf!EluxG1HEE@H%5h#Xx`Y@1l-DN?AxCKzHLCL@G zH*;7jr6w-bfT?1$t4K`q=a*0sU`I>i&0>JqLsPO|5p4>aQv7Ul5+ADpplUfR!N`tQ zLok2%c)WQ2N|Ng$lKmCqrsw9$IdMH_TJ>CjzW&-33O#!CiU)=9mZx4>sGzqd+N8C9 zCoZdxY5%fQ(MA)F*IrAMYlPeKoQ2M&&`tHv6z-^*hn<{M3e*>LZuToHcn#^-khU24 zyK*X+z%u16$OyKTQBe1kcpE8h{!&|K+xcGr{j?a<$rj$-2wWnq^d7Z9oRmF9b6Ho_ zAH@xWGO=v>hHy}Q+YLc>2egMHx`wlzi*Ox5&~b(2$Gsi9`_#GayH6 zqL=`s(aFuBt+JWZEOkuLMlbo_iN!u3%H`$dCrx(n$V`GBDNMvT?* zzc-$Q_s<@kiu?ZykZ4q(ljO!}J~rA1h7^#gmM)e7Q&rK?Gh%yYb+t9|;pj)12Kmld zr?sPHo5N7k1czUZ@_g$?qU1~fU|SFc@yT7D9=i>qM|T%Y@Y3GF1r<1;cV#X*r1!3n z0vL2*)MH+On4p%mNF!BZ?~4>z-ABI3^d)2{-r%_@w?M~u$%oR?#hwWsepX8&aF68% zBtkcOar$uUGCaVuOV54|)_p`4RR{Z>UIJ^$jw)?xYVukztuA#7Bb}Qhwxx)4K32R_ zQ>cYCv4C7O9UE2N=~Lc{^GLN$ZOlqf^iNy(jD-wzMR9$fKA_FJ3*^Q z8scV2|G_i4g1H4eOice`edUXEDC$dZCy{vy3jWUN)23;8fy`!*a|N*#F{)z(79RLr z7Aj~>(0!3DJ*L}4E=>iFi7dS2FwY6lC4O2jK*OMG(rOR>`t{?-O98ApDeReaA|K>q zt>=lp!}YzO;TC3~Ou}Pi$;A*{TNv1m60;DHD2@!mov`_p##^ao%`*Hi7`dS>HgOwH z4F-8$fpiCq!hbz@fc+F{7RJ;crsA8mjzGU#rjx+gR_y=wEmUc-(J0b+6bz*Q2HADp zX!CfIE1o^e!w-b9{KCQ@HPB5#5$;gy@7jNG|NdVWt7eaq40^v4Tz8myjf~V+=K9{k zpTxFzMO=T9Sd>G0EEfnFf1iOBE{k^;d}{1or4rxP+F=qW5LP_eH#*XQjWZizYIUWB z^MXRL`zUSls&|zq5wQgGg}8Hiq`_i%U!Y>{>m!}y&P@27Aix%qIAB(6G!de#8@mYs zFS;z|)+^;Vu{&nsEnP_P1`FoSi4+LWRF7H-)}D`Gu&1U+^N9V;BVsAJZb&vjAL7wSZw50u1#&E+IkmPmxu z@pSZgo|`tRmEPQk^KD3jQw&T5l?8gjR+e03Hn~s1{su+JX^RoVE{OPxgTAi#f&X1? zF+nW>V583;Po+yE%#^ikgXo9I&h-^GfMPL38)#tfb9eE+f<-8a{--(z;6SpN74*Oj z@jyVYuFZ=GRZ0_M8vpO=EW?D4*l2>BwEiMmsj4##qa%G2CJ+VMYY(FfJ2_`u@5r2v z5&+hu>P^$2nYYOor0aq1I8{SnR~_^lT+ORmhy?sYMI4YtukT*kRGb!Pm(%Vg5&6vu z`e`f!SaCAon^7C;xjt~hgb8i=P`?vb=5V0qet1YRJ=jD$YO@cXYBFb%Hj1XGA7BXK z0gQdIZ4iB*NqBLTsN4c*4oygqSTYS_me(A!SK*5~YPFc6R?;K~Ttsbcuw>805@bWQ z>@)}Cv|G;~q7RLx1-{cppT{o#e_Vh^FCaUO-sM@1H4%(Ipm7c~eOg;LPau)uHo@-O zQR7Q1ooi_QnE2;H94V5j2!_MkA5`4n)&!aKcCPp9+`Fs0{@CNk^O6`xFKkQL`QRMg z&BjRI(TJZs&Up9~k^r-QtkP7SJ8`@s&62&U#zHKem0w*O^0eMBw21Gs(DHWU6-Bw` zKEOBc+_#Vq%0$^h1y*K=m~$j|M4qgQ*V2L8(i9T$MDCnyg17-6-@|9%c%&`jtlajP z=EzGVk4F_VA6(m(aG>Yn&W9}WSRLM!tXaLhwf0DN&@gQm*PH=IAbpA7Oj}vdf~=jM z)iNh}K?DTa9dB^Y?JGDPxM7fuLzfXL)e`qvNztkYX$V?#C#%Ck4b*Tfoxqt^TIH9T zp$e5Km$xuUTo4BmKHQ6+3qmw-M%XGHCl5&!lc-fT>H(m{9(iCvY>*Cr@e{MXSnR=X zLyZsQ8E~yr5d16dN~6nT&n*zb>m(X|1k_@!ehTbtAVn^W>_iVg7GADndf9Vq`GnEV)WlX8#p{!reHd*B&{v3So{TmNV67|7tnIsM#SJyA%vDlZu^>mZj zR5&|RCJd#}6Tmc|0>u}>D#qm;65q@V`=Abo_zRAR3L<(@Ihd7V7UlNn9Ida6Dc`O_ zhd`H7++voFjrX%|BL6(tTQj-x_G_qo?_f^Ez3=s0kX^PMLr*+do0taRvxN;a52R8> zRYgLPhEp7D{JA_#?y{iY8apJozpS2RtAgE5tQe#H`Dl|K1drjZ9O3Kdop}Y15j;d- zLJguPO$X+zOK<8EnTp*N9h!8CVnrjkAUAz~GK1v(ZVdj|5D)sxD4DD;#Ko_1F~G+e z1%6IJ!*Iv78%6≪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

    #{$WO90l4DoeT~ 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¥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 z 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 z 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

    ~c~ln8B|Q&({{7yQ~F3fWhte+CCYp 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

    QA3c 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

    p+-9Y!OX*+uXR)Z>K%tl`KpgZSMwXsWQgjxF zd&(XStJ8BOmVni9Iz?yp>uI>N`EB?oiy_#L$!OVr4S~)MS$LivYkL%pc3?ZNF5VR5 z0=eHXSao-I6GXhK>fAI%0?L%fvOR`CpxXV$;7Zzx{ZdkD6)kbn99xw~mbjJKmt=~y zUX93EQkRVy=i>Hi)1pKxX`fDVwy2Vg;t>eHGiBMk7OC-hvrDKQKR0}yu|TQk67p82 zaV!b>AKO}3Ff_s;6<5o$3uUhrEMcMVi?%r4`=U~@8dbE$fM4I_*)jd0>gwA0#+gQTAvB z<=GHdreJBnPTGhLbN^XO4*?vSEZfck0Guu2-4TYN-OYRuBCvh~J0Ogw_IuJV{1G-Y z@EwX|hkhcyftC$UFUMh@)eQT}tLWr^6vOmv^Xxkd z7)-2!hnn*Mz{2hj_#e`p3n!4AQuyuDZo$W&8~jK%m3LjqYkROGfs-JpDpH^MBE{mE z1zM?S9n2q61j9R>P6s(%q@vi&9D4lWK9j*!#JG!jBVRlJ@-$KCF#Wzpdo@t5s~T<2I? z12N>_Q7k9W7~J^!;9HaY<$Yl4dGCHhlwx)OGl?UGBqWGZrjeMs{U)szf>)veNbh-_ zL|!aK4^IThib>8YyDzA@A#VDl*OPkgea>04F+>P+j|aT%&Mo#Bl+%vBFObf(Rke65 zN?8<2UG=tM>XTLj1r!}L<%vd6N*OT*8F81rbD6=aA5l#12Li zgc;f$z3s@VO}jm`Sp0Ty^!tE{{ika?&V;Z5sMT*Q_(ewQ3>twqGJHFmi#+kP4~s}j zQ_h7+74=Qshu+)43bJGJGui=b`YUKNU`HV@P%YQ^kb7Rg-Ve-CYA9q<11V0V=wvQI zn4kkXXn(Q$d42BoW;>h%!@vL!sEt)>Sc*TzE;=bI9HTzh@^41+BtDW!i{} z8X$*E-3nvMbZ4e#5SuHDGX)`Zm^|r9J7rwtmm`?|RRh2R(o#*P2#Ad1NQ?SBZ6Fq? z0L-G|8OPC@zym5ZEi51);9Wr|l2#>jCt$_2J?UnqrmtFCr3u%;izF$+-3|KhqCfGI zrGTIFL!8C78*z>s5l9Uo0)__d5`+uMVTY9(a+fE@zmB_2fH*QHeQ7yZ61lb+9Ye7l zSJIUKB+hA%<-m00q7Elx{~j90mvdbf?L=438Y~!0*xWBLWx!!|bRs~X@RPNwnvd@d zE%9ZWG9@zV)b*dNP@^8*r6Ewb!UUWudGnaN%=SejJwZmFBP4d>f56bd6($3qX2Po- zKra3X2(B4feVUZ_u1woYZq}=oRMiGq*#7V(uYrREarrK;#TRSt#cZ96Z$E09DlUJ{ ztEg&N_GsWX-1uVvofktxD`6w5l53ksvoxqcOGa{*O*Qa*4`^7bs;q{&ael{Wu=y7~ z1p~^CsiMSB3%NVK`Ggyt=W|2E%gg`M?;Z$#NJYU_S*&0T3#vCvv?K(F;%(djJMAse z7z(P&tqu0T!75sw!Ur)E&)@F$W;D2$xFy2;cb^#MrzAQ&WG`=EF(niI`4_Yn0EG8M z?T8y%?IHNb#xe(%Cdfy~_7Q`5FcfkT3ge4|u;~B{i`Mqh;a6@RG6vCy=4xOoWq5J! zW$*KUZJ2d~nOzSH2@kf=)A1!b)R1?Z(VfWype@SJ|G1nGV_nvCd$+{T1LhLMS3RQmk)8FquqQP| z_X>EO<1gGJX#Be_FpALk6bcKha&H+NAzI?D$$Zt>!SXTxmf^3ms49bhFSFdea3#I7L}b!XeKm33BWEmot? z@jfQ#uZAbt;lKvHJQgQuPg5N5>lARd|BrEJco-w+#ilkhdZ}X`vVh$&d2U|!hIjo7CCjjua7}qbz zxX9>G->hIO zhyml!L1R*M`;HFh`GigoA2mE_vHPCN>Uc=Fcu3VD0JS_gOAsm95CpXDTJk?V_m+fI z-kGanz>_9!A~wes6Wc5Lk3F_&`+6$aj+nIS1(uNY?yr*V#mBK;1v{IS07nJw^xG20 zP+P2YaM`p{xQA0yu1)hL`C1j#uLfam`lKyYqnVp>5F~<= z1uIZ8<6;ChPd2nu<^SL64+4PT8;Aku+VDmsYt}me#{d59TYle|yB4W?O2zYL@QI4& zDPe|6EUK{zSiMD+vgMu%N2=y5D{KML>KN%(!6kz|gw?eEg)H5Q>-&hy)pp~fvix81 z>$S;*;VB&s6fSyc!VIAwx+=?8qwiRlp{$a%07fTwKm06;MWpib_S1IOZ71Z#mrUDF zxY%4aZKu!k?NlIR54^=!F^-7h4el=yTg|&5BZaP?uEuv1oZf5kCtz4Ic8D;cLttfU zW>$bM8`J}w)r+T@hThW0v}!2>D5}7nK}TS4e-j2bRb}MG{Qi}I)t4B@v1Nx@LOLKy zz_M{CParHp$pi!<2%Fl;Jn74C6i|^UOh7!3Dc>eDx#I=xZ?Sk33 zrC1ee6=5Jj-~v?OV}ykD@^Riqm19~crW*`ilctY`jrEWfixXXV0ZS}8tlG%7%f#`E z@OUs)Y$b<{Pp)(1d>iJ2UjYD%Z=Fy=C{j4s@4(#_FxYz~z!Yc(pyXql%Um8*A^f`

    =3+ z=FgMgyu!b7EAbNfth{4Z*686;`=C^*<%bDmso7smAI{*)lSw3KCqfU0O-fs_vNkna zGh7xfAO6C2<`a*cB(!isV@r!Asg@yM`u&>uF-6^f!-D*ij~hzgyEl*v3%lo@!iFq4 zt+A1?8L;?WgwR)5 z?|z!0jJq;YVJ68okpN9rRj(( zheBiD9()qQg@`oqP71HRtmBAUy7#}={te$>iivig&acmfE2Vz<`^7SEsAD_?#*7_X zQ#l0Njs$Y^UiM8~sORJ(fIKos4}w6kw8@mmmuf@>X6AasCts=1$h=p6Vi)AQzJtJci->VT%4}*bGS2hkPHa)Lh#D>8C${w)d z3IHMS7(osE%vqqgXQBD|>B)tEEZ*acw!8bpFaivxQ!>^vH)-3Nje%!T^GGK3W|Z|q znfn~fX}qcKZl`FRVM)cc(YWWuglp|yyw-d+dog#pgwa^%ewE0XJ9PRtGmdDD>+x58 zb)zH9I<7QkB^i|CjxdA7@RDb(Iq1lb=AkMKEi!*4UoBKC_#QE6rPsg!okVmI=S?mq z(MxN5r$@RhFr{hOP&xs);|Ll1_ISrymA+Tl$OOScOfw}d`jm+^$_}GTRcKr}w1ln_ zEU7=xgfE zyflBgBySV%?&b%I+%41+O_T>(ggqu$P*X23#Lq-Mm8EV`pOm>rkImXd_F-(xH5Kvg6*HNS!DPM>Zl# b-|!?&EsQ2+p3qFB@Q1bD!7gi^`|1A!W>A%v literal 0 HcmV?d00001 From 8b72117e263d1ca3fc91b211500ff5fa402ebe75 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Mon, 23 Oct 2023 16:40:28 -0700 Subject: [PATCH 32/42] No public description PiperOrigin-RevId: 575964625 --- .../pre_processing/new_json_preparation.ipynb | 1120 +++++++++++++++++ 1 file changed, 1120 insertions(+) create mode 100644 official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb diff --git a/official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb b/official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb new file mode 100644 index 00000000000..b59cb4734e2 --- /dev/null +++ b/official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb @@ -0,0 +1,1120 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "0JmF5ohLbPlF" + }, + "source": [ + "# Pre processing steps of a COCO JSON annotated file" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uXwwz3PlbUX2" + }, + "source": [ + "Given a single COCO annotated JSON file, your goal is to pre-process in order to remove noise and manipulate it into a form which is suitable for training a ML model. This script will also check if the annotated images are broken or missing.The output of this notebook should be 2 JSON annotation files -\n", + "`Material and its sub type (e.g Plastics_HDPE)` and `'Material form and its sub type (e.g.Paper-Products-White-Paper)'`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E1SxGZD2bv8E" + }, + "source": [ + "The COCO annotation file includes the following -\n", + "\n", + "1. Name of the images.\n", + "\n", + "2. Dimensions of the images.\n", + "\n", + "3. Classes in the image category.\n", + "\n", + "4. Name of the super categories of the classes.\n", + "\n", + "5. Area acquired by the segmented pixels in an image.\n", + "\n", + "6. Bounding box co-ordinates.\n", + "\n", + "7. Annotated segmentation coordinates." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j0v31gxTbweO" + }, + "source": [ + "There is a lot of noise in the real world annotation file. The images name could be wrong. The images mentioned in an annotation file may not be present in the image folder, which will disrupt the model training procedure. The contents within an annotation file may not match with each other. Even the files present in an image folder may be broken or truncated, which will cause errors while reading image files. Our goal is to eradicate all these problems." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PyFn96EKb7A-" + }, + "source": [ + "Our goal is to make sure that all information in the key values corresponds to each other correctly. This notebook will help you achieve this task." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W6aXxxox0DDa" + }, + "source": [ + "## Import labels and sample JSON file\n", + "To import total classes for the material, material_form and plastic_type we will import the label files from the waste_identification_ml project from Tensorflow Model Garden.\n", + "We will also import a noisy sample JSON file to illustrate an example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WluEHMZYm0zM", + "outputId": "7bdc802d-4b11-4959-8255-64099ff530a4" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 3862 100 3862 0 0 18499 0 --:--:-- --:--:-- --:--:-- 18567\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 2427 100 2427 0 0 8695 0 --:--:-- --:--:-- --:--:-- 8667\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 264 100 264 0 0 935 0 --:--:-- --:--:-- --:--:-- 936\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 422 100 422 0 0 1525 0 --:--:-- --:--:-- --:--:-- 1528\n", + "mkdir: cannot create directory ‘image_folder’: File exists\n", + " % Total % Received % Xferd Average Speed Time Time Time Current\n", + " Dload Upload Total Spent Left Speed\n", + "\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r 0 0 0 0 0 0 0 0 --:--:-- --:--:-- --:--:-- 0\r100 3303k 100 3303k 0 0 4518k 0 --:--:-- --:--:-- --:--:-- 4518k\n" + ] + } + ], + "source": [ + "%%bash\n", + "curl -O \"https://raw.githubusercontent.com/tensorflow/models/master/official/\"\\\n", + "\"projects/waste_identification_ml/two_model_inference/labels.py\"\n", + "\n", + "curl -O \"https://raw.githubusercontent.com/tensorflow/models/master/official/\"\\\n", + "\"projects/waste_identification_ml/pre_processing/config/sample_json/dataset.json\"\n", + "\n", + "\n", + "curl -O \"https://raw.githubusercontent.com/tensorflow/models/master/official/\"\\\n", + "\"projects/waste_identification_ml/pre_processing/config/data/\"\\\n", + "\"two_model_strategy_material.csv\"\n", + "\n", + "curl -O \"https://raw.githubusercontent.com/tensorflow/models/master/official/\"\\\n", + "\"projects/waste_identification_ml/pre_processing/config/data/\"\\\n", + "\"two_model_strategy_material_form.csv\"\n", + "\n", + "mkdir image_folder\n", + "\n", + "curl -o image_folder/image_2.png \"https://raw.githubusercontent.com/\"\\\n", + "\"tensorflow/models/master/official/projects/waste_identification_ml/\"\\\n", + "\"pre_processing/config/sample_images/image_2.png\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MRhCAFlVcRm0" + }, + "source": [ + "## Import the required libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Mnxbo8GBcN2O" + }, + "outputs": [], + "source": [ + "import glob\n", + "import tqdm\n", + "import json\n", + "from PIL import Image\n", + "import subprocess\n", + "import copy\n", + "import os\n", + "from google.colab import files\n", + "from labels import load_labels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tGOCdeiucUgq" + }, + "outputs": [], + "source": [ + "# @title Utility Functions { display-mode: \"form\", run: \"auto\" }\n", + "def read_json(file):\n", + " \"\"\"Read any JSON file.\n", + "\n", + " Args:\n", + " file: path to the file\n", + " \"\"\"\n", + " with open(file) as json_file:\n", + " data = json.load(json_file)\n", + " return data\n", + "\n", + "\n", + "def search_dict_value(dic, id):\n", + " \"\"\"Returns the key of the dictionary from its value'\n", + "\n", + " Args:\n", + " dic = Mapping to search by value.\n", + " id = Value to search.\n", + " \"\"\"\n", + " key_list = list(dic.keys())\n", + " val_list = list(dic.values())\n", + " position = val_list.index(id)\n", + " return key_list[position]\n", + "\n", + "\n", + "def delete_truncated_images(folder_path: str) -\u003e None:\n", + " \"\"\"Find and delete truncated images.\n", + "\n", + " Args:\n", + " folder_path: path to the folder where images are saved.\n", + " \"\"\"\n", + " # path to the images folder to read its content\n", + " files = glob.glob(folder_path + '/*')\n", + " print('Total number of files in the folder:', len(files))\n", + "\n", + " num = 0\n", + "\n", + " # read all image files and remove them from the directory in case they are broken\n", + " for file in tqdm.tqdm(files):\n", + " if file.endswith(('.png','.jpg')):\n", + " try:\n", + " img = Image.open(file)\n", + " img.verify()\n", + " except:\n", + " num = num + 1\n", + " subprocess.run(['rm', file])\n", + " print('Broken file name: ' + file)\n", + " if num == 0:\n", + " print('\\nNo broken images found')\n", + " else:\n", + " print('Total number of broken images found:', num)\n", + "\n", + "\n", + "def spelling_correction(dic, typo_dict):\n", + " \"\"\"Correcting some common spelling mistakes.\"\"\"\n", + " for i in dic['categories']:\n", + " for old, new in typo_dict.items():\n", + " i['name'] = i['name'].replace(old, new)\n", + " return dic\n", + "\n", + "\n", + "def labeling_correction(dic, labels_dict, num):\n", + " \"\"\"Matching annotated labels with the correct labels.\n", + "\n", + " Mapping the modified labeling ID with the corresponding original ID for alignment\n", + " of categories.\n", + "\n", + " Args:\n", + " dic: JSON file read as a dictionary\n", + " num: keyword position inside the label\n", + " labels_dict: dictionary showing the labels ID of the original categories\n", + " \"\"\"\n", + " mapping_list = []\n", + " incorrect_labels = []\n", + "\n", + " for i in dic['categories']:\n", + " sp = i['name'].split('_')\n", + "\n", + " if num == 1:\n", + " target_value = sp[0].lower() + '_' + sp[1].lower()\n", + " elif num == 4:\n", + " target_value = sp[4].lower()\n", + " else:\n", + " raise ValueError(\"Invalid value for 'num'\")\n", + "\n", + " if target_value in labels_dict.values():\n", + " id_match = search_dict_value(labels_dict, target_value)\n", + " mapping_list.append((i['id'], target_value, id_match))\n", + " else:\n", + " incorrect_labels.append(i['id'])\n", + "\n", + " return mapping_list, incorrect_labels\n", + "\n", + "\n", + "def images_key(dic):\n", + " \"\"\"Align the data within the dictionary in the 'images' key.\n", + "\n", + " The 'image_id' parameter in the 'annotation' key is the same as 'id' in the 'images' key of the dictionary. This function\n", + " will also remove all image data from the 'images' key whose 'id' does not\n", + " match with 'image_id' in the 'annotation' key in the dictionary.\n", + "\n", + " Args:\n", + " dic: where the JSON file is read into\n", + " \"\"\"\n", + " image_ids = set(i['image_id'] for i in dic['annotations'])\n", + " new_images = [i for i in dic['images'] if i['id'] in image_ids]\n", + " return new_images\n", + "\n", + "\n", + "def annotations_key(dic, incorrect_labels, mapping_dict):\n", + " \"\"\"Align the data within the dictionary in the 'annotation' key.\n", + "\n", + " Notice that the 'category_id' in the 'annotation' key is same as 'id'\n", + " in the 'categories' key of the dictionary.\n", + "\n", + " Args:\n", + " dic: where the JSON file is read into\n", + " \"\"\"\n", + " new_annotation = []\n", + "\n", + " for i in dic['annotations']:\n", + " id = i['category_id']\n", + " if (id not in incorrect_labels) and (id in [tup[0] for tup in mapping_dict]):\n", + " new_id = [i[2] for i in mapping_dict if i[0] == id][0]\n", + " i['category_id'] = new_id\n", + " new_annotation.append(i)\n", + " return new_annotation\n", + "\n", + "\n", + "def annotated_images(folder_path, dic):\n", + " \"\"\"Get images infromation that are mentioned in an annotation file but are not present in an image folder.\n", + "\n", + " Args:\n", + " folder_path: path of an image folder.\n", + " \"\"\"\n", + " # read the file names from the directory\n", + " files = glob.glob(folder_path + '/*')\n", + " files = set(map(os.path.basename, files))\n", + "\n", + " # list of images in an annotation file\n", + " dic['images'] = [i for i in dic['images'] if i['file_name'] in files]\n", + " return dic\n", + "\n", + "\n", + "def image_annotation_key(dic):\n", + " \"\"\"Check if same images are present in both \"images\" key and \"annotations\" key.\n", + "\n", + " List of the image IDs which are in the \"images\" key but NOT in \"annotation\" key.\n", + " Remove information if they are not present in both keys.\n", + "\n", + " Args:\n", + " dic: annotation file read as a dictionary\n", + " \"\"\"\n", + " images_id = [i['id'] for i in dic['images']]\n", + " annotation_id = [i['image_id'] for i in dic['annotations']]\n", + " common_list = set(images_id).intersection(annotation_id)\n", + " dic['images'] = [i for i in dic['images'] if i['id'] in common_list]\n", + " dic['annotations'] = [i for i in dic['annotations'] if i['image_id'] in common_list]\n", + " return dic\n", + "\n", + "\n", + "def categories_dictionary(list_of_objects):\n", + " \"\"\"Generates a list of dictionaries representing categories of objects.\n", + "\n", + " Each dictionary has an 'id' corresponding to its order in the list, a 'name'\n", + " taken from the input list, and a fixed 'supercategory' set as 'objects'.\n", + "\n", + " Args:\n", + " list_of_objects: List of object names to be used as categories.\n", + "\n", + " Returns:\n", + " list: List of dictionaries, each representing a category.\n", + "\n", + " Example:\n", + " \u003e\u003e\u003e categories_dictionary(['car', 'bus'])\n", + " [{'id': 1, 'name': 'car', 'supercategory': 'objects'},\n", + " {'id': 2, 'name': 'bus', 'supercategory': 'objects'}]\n", + " \"\"\"\n", + " objects_dictionaries = []\n", + " for num, m in enumerate(list_of_objects, start=1):\n", + " objects_dictionaries.append({\n", + " 'id': num,\n", + " 'name': m,\n", + " 'supercategory': 'objects'\n", + " })\n", + "\n", + " return objects_dictionaries\n", + "\n", + "\n", + "def print_incorrect_labels(incorrect_labels, data_postprocessing, m):\n", + " \"\"\"Prints the incorrect labels and their count.\n", + "\n", + " Args:\n", + " incorrect_labels: List of incorrect label IDs.\n", + " data_postprocessing: The data containing postprocessing details.\n", + " m: A tuple where the element denotes a condition value.\n", + " \"\"\"\n", + " print('\\nTotal number of incorrect labels:', len(incorrect_labels))\n", + " print('Incorrect labels are below: ')\n", + "\n", + " for category in data_postprocessing['categories']:\n", + " if category['id'] in incorrect_labels:\n", + " name_parts = category['name'].split('_')\n", + "\n", + " if m == 1 and len(name_parts) \u003e= 2:\n", + " print(f'{name_parts[0]}_{name_parts[1]}')\n", + " elif m == 4 and len(name_parts) \u003e= 5:\n", + " print(name_parts[4])\n", + " print('')\n", + "\n", + "\n", + "def print_dict_characteristics(stage_num, dic):\n", + " \"\"\"Prints characteristics of the dictionary after post processing.\n", + "\n", + " Args:\n", + " stage_num: The stage number of post processing.\n", + " data_postprocessing: The data containing postprocessing details.\n", + " \"\"\"\n", + " print(f'Dictionary characteristics after post processing stage {stage_num}:')\n", + " print('images:', len(dic['images']),\n", + " 'categories:', len(dic['categories']),\n", + " 'annotations:', len(dic['annotations']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LG7OgYECSL2g" + }, + "outputs": [], + "source": [ + "LABELS = {\n", + "'material_model' : 'two_model_strategy_material.csv',\n", + "'material_form_model' : 'two_model_strategy_material_form.csv',\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XCyyokyRoydN" + }, + "outputs": [], + "source": [ + "# common labeling typo errors that have occured in the past data\n", + "_KNOWN_TYPOS_IN_MATERIAL = {\n", + " '_PET_':'_PETE_',\n", + " 'plastic_PP_':'_Plastics_PP_',\n", + " '_nothing_':'_Na_',\n", + " 'plastic_MLP_':'Plastics_Others-MLP_',\n", + " 'plastic_LDPE_':'Plastics_LDPE_',\n", + " 'plastic_HDPE_':'Plastics_HDPE_',\n", + " 'Metals_Aluminium_':'Metals_Na_',\n", + " 'Plastics_PETEE_':'Plastics_PET_',\n", + " 'Plastics_peTE_':'Plastics_PET_',\n", + " 'Plastics_PETE_':'Plastics_PET_',\n", + "}\n", + "\n", + "_KNOWN_TYPOS_IN_MATERIAL_FORM = {\n", + " 'and': '\u0026',\n", + " '_Cassete_': '_Cassette_',\n", + " '_Toy_':'_Toys_',\n", + " '_Toyss_':'toys',\n", + " '_Cup-and-Glass_':'_Cup-\u0026-glass_',\n", + " '_Tanglers_':'_Tangler_',\n", + " '_tub_':'_Container_',\n", + " '_Jar_':'_Jug-\u0026-Jar_',\n", + " '_Mug-\u0026-Tub_':'_Container_',\n", + " '_nothing_':'_Na_',\n", + " '_Jugs_':'_Jug-\u0026-Jar_',\n", + " '_Cans_':'_Can_',\n", + " '_Bottlee_':'_Bottle_',\n", + " '_Tub_':'_Container_',\n", + " '_Flexiblesiii_':'_Flexibles_',\n", + " '_Paper-products-Whitepaper':'_Paper-Products-White-Paper_',\n", + " '_Paper-products-Other_':'_Paper-Products_',\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "f-05VwsL0mCi" + }, + "outputs": [], + "source": [ + "# reading labels\n", + "images_folder_path = 'image_folder/' #@param {type:\"string\"}\n", + "\n", + "category_indices, category_index = load_labels(LABELS)\n", + "\n", + "list_of_material = category_indices[0]\n", + "list_of_material.remove('Na')\n", + "\n", + "list_of_material_form = category_indices[1]\n", + "list_of_material_form.remove('Na')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uZb1rvoWXKAr", + "outputId": "d63cbf50-c3e4-4828-ebe9-242f78bbffd2" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Fiber_Na',\n", + " 'Food_Na',\n", + " 'Glass_Na',\n", + " 'Inorganic-wastes_Na',\n", + " 'Metals_Na',\n", + " 'Plastics_HDPE',\n", + " 'Plastics_LDPE',\n", + " 'Plastics_Others-HIPC',\n", + " 'Plastics_Others-MLP',\n", + " 'Plastics_Others-Tetrapak',\n", + " 'Plastics_PET',\n", + " 'Plastics_PP',\n", + " 'Plastics_PS',\n", + " 'Plastics_PVC',\n", + " 'Rubber-\u0026-Leather_Na',\n", + " 'Textiles_Na',\n", + " 'Wood_Na',\n", + " 'Yard-trimming_Na']" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display labels only for 'material' model\n", + "list_of_material" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xK-ae7HqXcn-", + "outputId": "350620a2-ae3d-441c-9636-fea73ff6083e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['Bag',\n", + " 'Battery',\n", + " 'Blister-pack',\n", + " 'Book-\u0026-magazine',\n", + " 'Bottle',\n", + " 'Box',\n", + " 'Brush',\n", + " 'Bulb',\n", + " 'Can',\n", + " 'Cards',\n", + " 'Carton',\n", + " 'Cassette-\u0026-tape',\n", + " 'Clamshell',\n", + " 'Clothes',\n", + " 'Container',\n", + " 'Cosmetic',\n", + " 'Cup-\u0026-glass',\n", + " 'Cutlery',\n", + " 'Electronic-devices',\n", + " 'Flexibles',\n", + " 'Foil',\n", + " 'Foot-wear',\n", + " 'Hangers',\n", + " 'Jug-\u0026-Jar',\n", + " 'Lid',\n", + " 'Mirror',\n", + " 'Office-Stationary',\n", + " 'Paper-Products-Others',\n", + " 'Paper-Products-Others-Cardboard',\n", + " 'Paper-Products-Others-Newspaper',\n", + " 'Paper-Products-Others-Whitepaper',\n", + " 'Pipe',\n", + " 'Sachets-\u0026-Pouch',\n", + " 'Scissor',\n", + " 'Tangler',\n", + " 'Toys',\n", + " 'Tray',\n", + " 'Tube']" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# display labels only for 'material_form' model\n", + "list_of_material_form" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0OoDmNC22ycz" + }, + "source": [ + "## Find and delete truncated images from the image folder." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bUUu3F6I20w3", + "outputId": "a1ae3164-3f68-4745-bdee-23210113fd64" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of files in the folder: 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 1/1 [00:00\u003c00:00, 41.28it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "No broken images found\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "delete_truncated_images(images_folder_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "65XuyPBSea7-" + }, + "source": [ + "## Perform operations on the file\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "l-uMtZK2edPY", + "outputId": "771215ed-8950-419e-c7e8-380529f6beb8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['images', 'annotations', 'categories'])\n" + ] + } + ], + "source": [ + "# read json file and it should contain at least the three keys as shown below\n", + "path_to_json = 'dataset.json' #@param {type:\"string\"}\n", + "data = read_json(path_to_json)\n", + "print(data.keys())\n", + "\n", + "# create a copy to compare the results in the end\n", + "data_preprocessing = copy.deepcopy(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G8w7MfDtvDIq", + "outputId": "6a48ea9d-084b-493a-e5ca-80c48fa5cbf7" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6/6 [00:00\u003c00:00, 45590.26it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Total number of wrong annotated labels are 5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# checking labeling mistakes as all annotated labels should have 6 keywords connected by '_'\n", + "num = 0\n", + "for i in tqdm.tqdm(data['categories']):\n", + " if len(i['name'].split('_')) != 6:\n", + " num += 1\n", + "print('\\nTotal number of wrong annotated labels are', num)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "q2jOWegZxPEp", + "outputId": "e988f4b0-e254-4fbe-80f3-99fe3a3504e7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Total number of labels which has less than 6 keywords are 0\n" + ] + } + ], + "source": [ + "# remove category labels which has less than 6 keywords\n", + "categories = []\n", + "num = 0\n", + "for i in data['categories']:\n", + " if len(i['name'].split('_')) \u003e= 6:\n", + " categories.append(i)\n", + " else:\n", + " num += 1\n", + "print('\\nTotal number of labels which has less than 6 keywords are', num)\n", + "data['categories'] = categories" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qup_-ReIz-iv", + "outputId": "13fae63a-e34f-4e1a-f071-475dfacf028f" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6/6 [00:00\u003c00:00, 51463.85it/s]\n" + ] + } + ], + "source": [ + "# According to the collected data it was found that most issues occurs from the\n", + "# 6th keyword which are the sub category of the material form.\n", + "\n", + "for i in tqdm.tqdm(data['categories']):\n", + " l1 = i['name'].split('_')[:5]\n", + " l2 = i['name'].split('_')[5:]\n", + " l1.append('-'.join(l2))\n", + " i['name'] = '_'.join(l1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dYqGTRluopxb", + "outputId": "8fb71664-1bf1-41af-ae05-3b89492a0a44" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 6/6 [00:00\u003c00:00, 43464.29it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Total number of wrong annotated labels are 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# checking labeling mistakes as all annotated labels should have 6 keywords connected by '_'\n", + "num = 0\n", + "for i in tqdm.tqdm(data['categories']):\n", + " if len(i['name'].split('_')) != 6:\n", + " num += 1\n", + "print('\\nTotal number of wrong annotated labels are', num)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MfXv6qrTpDA-", + "outputId": "111cf89b-6be4-4103-926a-9949fb235139" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dictionary characteristics before processing :\n", + "images: 2 categories: 6 annotations: 6\n" + ] + } + ], + "source": [ + "print('Dictionary characteristics before processing :')\n", + "print('images:',len(data_preprocessing['images']),'categories:', len(data_preprocessing['categories']),'annotations:',len(data_preprocessing['annotations']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ro8KNGaGFv7k", + "outputId": "05c388a4-942d-4620-d502-742e6cb989f7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dictionary characteristics after post processing stage 1:\n", + "images: 2 categories: 6 annotations: 6\n", + "\n", + "Total number of incorrect labels: 1\n", + "Incorrect labels are below: \n", + "Plastics_na\n", + "\n", + "Dictionary characteristics after post processing stage 2:\n", + "images: 2 categories: 18 annotations: 6\n", + "Dictionary characteristics after post processing stage 3:\n", + "images: 2 categories: 18 annotations: 5\n", + "Dictionary characteristics after post processing stage 4:\n", + "images: 1 categories: 18 annotations: 5\n", + "Dictionary characteristics after post processing stage 5:\n", + "images: 1 categories: 18 annotations: 4\n", + "\n", + "Dictionary characteristics after processing of material_type_annotation :\n", + "images: 1 categories: 18 annotations: 4\n", + "###################################################################\n", + "Dictionary characteristics after post processing stage 1:\n", + "images: 2 categories: 6 annotations: 6\n", + "\n", + "Total number of incorrect labels: 0\n", + "Incorrect labels are below: \n", + "\n", + "Dictionary characteristics after post processing stage 2:\n", + "images: 2 categories: 38 annotations: 6\n", + "Dictionary characteristics after post processing stage 3:\n", + "images: 2 categories: 38 annotations: 6\n", + "Dictionary characteristics after post processing stage 4:\n", + "images: 1 categories: 38 annotations: 6\n", + "Dictionary characteristics after post processing stage 5:\n", + "images: 1 categories: 38 annotations: 5\n", + "\n", + "Dictionary characteristics after processing of material_form_type_annotation :\n", + "images: 1 categories: 38 annotations: 5\n", + "###################################################################\n" + ] + } + ], + "source": [ + "list_of_categories = [(list_of_material,1,'material_type_annotation.json',_KNOWN_TYPOS_IN_MATERIAL),\\\n", + " (list_of_material_form,4,'material_form_type_annotation.json',_KNOWN_TYPOS_IN_MATERIAL_FORM)]\n", + "\n", + "for m in list_of_categories:\n", + "\n", + " data_processing = copy.deepcopy(data)\n", + "\n", + " objects_dictionaries = categories_dictionary(m[0])\n", + "\n", + " # create a dict showing TDs corresponding to the labels \u0026 convert all words\n", + " # to lower case in order to eliminate case sensitive issues\n", + " labels_dict = dict([(i['id'], i['name'].lower()) for i in objects_dictionaries])\n", + "\n", + " # correcting grammatical errors\n", + " data_processing = spelling_correction(data_processing, m[3])\n", + " print_dict_characteristics(1, data_processing)\n", + "\n", + " # create a mapping table to map each label to the right label structure.\n", + " # find the incorrect labels.\n", + " mapping_dict, incorrect_labels = labeling_correction(data_processing, labels_dict, m[1])\n", + "\n", + " print_incorrect_labels(incorrect_labels, data_processing, m[1])\n", + "\n", + " # change the 'categories' key\n", + " data_processing['categories'] = objects_dictionaries\n", + " print_dict_characteristics(2, data_processing)\n", + "\n", + " # change the 'annotation' key\n", + " data_processing['annotations'] = annotations_key(data_processing, incorrect_labels, mapping_dict)\n", + " print_dict_characteristics(3, data_processing)\n", + "\n", + " # change the 'images' key\n", + " data_processing['images'] = images_key(data_processing)\n", + "\n", + " # remove data from the 'images' key not present in the image folder\n", + " data_processing = annotated_images(images_folder_path, data_processing)\n", + " print_dict_characteristics(4, data_processing)\n", + "\n", + " # align 'images' and 'annotations' key\n", + " data_processing = image_annotation_key(data_processing)\n", + " print_dict_characteristics(5, data_processing)\n", + "\n", + " # write to a new JSON file\n", + " with open(m[2], 'w') as opened_file:\n", + " opened_file.write(json.dumps(data_processing, indent=4))\n", + "\n", + " print('\\nDictionary characteristics after processing of', m[2].replace('.json','') ,':')\n", + " print('images:',len(data_processing['images']),'categories:', len(data_processing['categories']),'annotations:',len(data_processing['annotations']))\n", + " print('###################################################################')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 17 + }, + "id": "nC6XzQYL15Ki", + "outputId": "ea8e0a7d-79bc-4321-8a63-4855afc190e1" + }, + "outputs": [ + { + "data": { + "application/javascript": [ + "\n", + " ((filepath) =\u003e {{\n", + " if (!google.colab.kernel.accessAllowed) {{\n", + " return;\n", + " }}\n", + " google.colab.files.view(filepath);\n", + " }})(\"/content/plastic_type_annotation.json\")" + ], + "text/plain": [ + "\u003cIPython.core.display.Javascript object\u003e" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# View the final JSON file\n", + "try:\n", + " files.view(m[2]) # use files.download to download the file\n", + "except ImportError:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S7_PnincwKTE" + }, + "source": [ + "# Visualization of categories" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ty6WVqyywL61", + "outputId": "df519b20-2776-4a3c-d22a-14becb58992d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-09-28 21:45:30-- https://raw.githubusercontent.com/tensorflow/models/master/official/projects/waste_identification_ml/pre_processing/config/visualization.py\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 3268 (3.2K) [text/plain]\n", + "Saving to: ‘visualization.py’\n", + "\n", + "\rvisualization.py 0%[ ] 0 --.-KB/s \rvisualization.py 100%[===================\u003e] 3.19K --.-KB/s in 0s \n", + "\n", + "2023-09-28 21:45:30 (24.5 MB/s) - ‘visualization.py’ saved [3268/3268]\n", + "\n" + ] + } + ], + "source": [ + "# download visualization script\n", + "!wget https://raw.githubusercontent.com/tensorflow/models/master/official/projects/waste_identification_ml/pre_processing/config/visualization.py" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CKXJsmvgwPpA", + "outputId": "884e658e-6e37-4ae1-9f28-18e03b55ba48" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['material_type_annotation.json', 'material_form_type_annotation.json']\n" + ] + } + ], + "source": [ + "from visualization import visualize_detailed_counts_horizontally\n", + "files = glob.glob('*annotation.json')\n", + "print(files)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 736 + }, + "id": "UjxwUBmOwdSe", + "outputId": "3747ac0a-b298-4d37-fb06-468776aa5a78" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "material_type_annotation.json\n", + "material_form_type_annotation.json\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "\u003cFigure size 4000x1000 with 1 Axes\u003e" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "\u003cFigure size 4000x1000 with 1 Axes\u003e" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for file in files:\n", + " print(os.path.basename(file))\n", + " visualize_detailed_counts_horizontally(file)" + ] + } + ], + "metadata": { + "colab": { + "name": "JSON_Generation_for_Training.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 9b783275e8e341e6856ba6c296a108eef7985722 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Tue, 24 Oct 2023 10:08:31 -0700 Subject: [PATCH 33/42] No public description PiperOrigin-RevId: 576178270 --- ..._json_preparation.ipynb => JSON_Generation_for_Training.ipynb} | 0 ...ration.ipynb => deprecated_JSON_Generation_for_Training.ipynb} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename official/projects/waste_identification_ml/pre_processing/{new_json_preparation.ipynb => JSON_Generation_for_Training.ipynb} (100%) rename official/projects/waste_identification_ml/pre_processing/{json_preparation.ipynb => deprecated_JSON_Generation_for_Training.ipynb} (100%) diff --git a/official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb b/official/projects/waste_identification_ml/pre_processing/JSON_Generation_for_Training.ipynb similarity index 100% rename from official/projects/waste_identification_ml/pre_processing/new_json_preparation.ipynb rename to official/projects/waste_identification_ml/pre_processing/JSON_Generation_for_Training.ipynb diff --git a/official/projects/waste_identification_ml/pre_processing/json_preparation.ipynb b/official/projects/waste_identification_ml/pre_processing/deprecated_JSON_Generation_for_Training.ipynb similarity index 100% rename from official/projects/waste_identification_ml/pre_processing/json_preparation.ipynb rename to official/projects/waste_identification_ml/pre_processing/deprecated_JSON_Generation_for_Training.ipynb From cbdcef015b2792444b7c2060c2b0613fe209ceb1 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Tue, 24 Oct 2023 15:44:51 -0700 Subject: [PATCH 34/42] No public description PiperOrigin-RevId: 576308323 --- .../pre_processing/coco_to_tfrecord.ipynb | 134 +++++++----------- 1 file changed, 50 insertions(+), 84 deletions(-) diff --git a/official/projects/waste_identification_ml/pre_processing/coco_to_tfrecord.ipynb b/official/projects/waste_identification_ml/pre_processing/coco_to_tfrecord.ipynb index 4cc32e7cfbb..d0a2ae0e401 100644 --- a/official/projects/waste_identification_ml/pre_processing/coco_to_tfrecord.ipynb +++ b/official/projects/waste_identification_ml/pre_processing/coco_to_tfrecord.ipynb @@ -2,34 +2,34 @@ "cells": [ { "cell_type": "markdown", - "source": [ - "# Conversion of COCO annotation JSON file to TFRecords" - ], "metadata": { "id": "SsIv6LYT84gm" - } + }, + "source": [ + "# Conversion of COCO annotation JSON file to TFRecords" + ] }, { "cell_type": "markdown", + "metadata": { + "id": "zl7o2xEW9IbX" + }, "source": [ "Given a COCO annotated JSON file, your goal is to convert it into a TFRecords file necessary to train with the Mask RCNN model.\n", "\n", "To accomplish this task, you will clone the TensorFlow Model Garden repo. The TensorFlow Model Garden is a repository with a number of different implementations of state-of-the-art (SOTA) models and modeling solutions for TensorFlow users.\n", "\n", "This notebook is an end to end example. When you run the notebook, it will take COCO annotated JSON train and test files as an input and will convert them into TFRecord files. You can also output sharded TFRecord files in case your training and validation data is huge. It makes it easier for the algorithm to read and access the data." - ], - "metadata": { - "id": "zl7o2xEW9IbX" - } + ] }, { "cell_type": "markdown", - "source": [ - "**Note** - In this example, we assume that all our data is saved on Google drive and we will also write our outputs to Google drive. We also assume that the script will be used as a Google Colab notebook. But this can be changed according to the needs of users. They can modify this in case they are working on their local workstation, remote server or any other database. This colab notebook can be changed to a regular jupyter notebook running on a local machine according to the need of the users." - ], "metadata": { "id": "g3OHfWQBpYVB" - } + }, + "source": [ + "**Note** - In this example, we assume that all our data is saved on Google drive and we will also write our outputs to Google drive. We also assume that the script will be used as a Google Colab notebook. But this can be changed according to the needs of users. They can modify this in case they are working on their local workstation, remote server or any other database. This colab notebook can be changed to a regular jupyter notebook running on a local machine according to the need of the users." + ] }, { "cell_type": "markdown", @@ -44,29 +44,12 @@ "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "hdRAEurMA3zi", - "outputId": "7212e558-af5d-4cb2-dd1f-6e634f5fca0a" + "id": "pnsra7Zf0uGe" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting tensorflow-addons\n", - " Downloading tensorflow_addons-0.16.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (1.1 MB)\n", - "\u001b[?25l\r\u001b[K |▎ | 10 kB 22.4 MB/s eta 0:00:01\r\u001b[K |▋ | 20 kB 8.9 MB/s eta 0:00:01\r\u001b[K |▉ | 30 kB 8.3 MB/s eta 0:00:01\r\u001b[K |█▏ | 40 kB 7.7 MB/s eta 0:00:01\r\u001b[K |█▌ | 51 kB 4.1 MB/s eta 0:00:01\r\u001b[K |█▊ | 61 kB 4.9 MB/s eta 0:00:01\r\u001b[K |██ | 71 kB 5.3 MB/s eta 0:00:01\r\u001b[K |██▍ | 81 kB 5.5 MB/s eta 0:00:01\r\u001b[K |██▋ | 92 kB 6.1 MB/s eta 0:00:01\r\u001b[K |███ | 102 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███▏ | 112 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███▌ | 122 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███▉ | 133 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████ | 143 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████▍ | 153 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████▊ | 163 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████ | 174 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████▎ | 184 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████▌ | 194 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████▉ | 204 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████▏ | 215 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████▍ | 225 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████▊ | 235 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████ | 245 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████▎ | 256 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████▋ | 266 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████▉ | 276 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████▏ | 286 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████▌ | 296 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████▊ | 307 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████ | 317 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████▍ | 327 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████▋ | 337 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████ | 348 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████▏ | 358 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████▌ | 368 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████▉ | 378 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████ | 389 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████▍ | 399 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████▊ | 409 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████ | 419 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████▎ | 430 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████▌ | 440 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████▉ | 450 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████▏ | 460 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████▍ | 471 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████▊ | 481 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████ | 491 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████▎ | 501 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████▋ | 512 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████▉ | 522 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████▏ | 532 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████▌ | 542 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████▊ | 552 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████ | 563 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████▍ | 573 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████▋ | 583 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████ | 593 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████▏ | 604 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████▌ | 614 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████▉ | 624 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████ | 634 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████▍ | 645 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████▊ | 655 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████ | 665 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████▎ | 675 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████▌ | 686 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████▉ | 696 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████▏ | 706 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████▍ | 716 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████▊ | 727 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████ | 737 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████▎ | 747 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████▋ | 757 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████▉ | 768 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████▏ | 778 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████▌ | 788 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████▊ | 798 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████ | 808 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████▍ | 819 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████▋ | 829 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████ | 839 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████▏ | 849 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████▌ | 860 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████▉ | 870 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████ | 880 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▍ | 890 kB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▊ | 901 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████ | 911 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████▎ | 921 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████▌ | 931 kB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████▉ | 942 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████▏ | 952 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████▍ | 962 kB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████▊ | 972 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████████ | 983 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████████▎ | 993 kB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████████▋ | 1.0 MB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████████▉ | 1.0 MB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████████▏ | 1.0 MB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████████▌ | 1.0 MB 5.1 MB/s eta 0:00:01\r\u001b[K |█████████████████████████████▊ | 1.0 MB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████ | 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▍ | 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▋ | 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████ | 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▏| 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▌| 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▉| 1.1 MB 5.1 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 1.1 MB 5.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.7/dist-packages (from tensorflow-addons) (2.7.1)\n", - "Installing collected packages: tensorflow-addons\n", - "Successfully installed tensorflow-addons-0.16.1\n" - ] - } - ], + "outputs": [], "source": [ - "!pip install tf-nightly\n", - "!pip install tensorflow-addons" + "!pip install -q tf-nightly\n", + "!pip install -q tensorflow-addons" ] }, { @@ -84,50 +67,33 @@ }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "z5HNdeBp0x3G" + }, + "outputs": [], "source": [ "# \"opencv-python-headless\" version should be same of \"opencv-python\"\n", "import pkg_resources\n", "version_number = pkg_resources.get_distribution(\"opencv-python\").version\n", "\n", - "!pip install opencv-python-headless==$version_number" - ], - "metadata": { - "id": "leap_jk5fq_v", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "b5608bb5-24df-4fb1-9885-649ceca98a26" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting opencv-python-headless==4.1.2.30\n", - " Downloading opencv_python_headless-4.1.2.30-cp37-cp37m-manylinux1_x86_64.whl (21.8 MB)\n", - "\u001b[K |████████████████████████████████| 21.8 MB 62.9 MB/s \n", - "\u001b[?25hRequirement already satisfied: numpy>=1.14.5 in /usr/local/lib/python3.7/dist-packages (from opencv-python-headless==4.1.2.30) (1.21.6)\n", - "Installing collected packages: opencv-python-headless\n", - "Successfully installed opencv-python-headless-4.1.2.30\n" - ] - } + "!pip install -q opencv-python-headless==$version_number" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "id": "i80tEP0pEJif", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "i80tEP0pEJif", "outputId": "cb0d8dde-8852-49eb-e6d7-33653722eee0" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Mounted at /content/gdrive\n", "Successful\n" @@ -158,28 +124,28 @@ }, { "cell_type": "code", - "source": [ - "# clone the Model Garden directory for Tensorflow where all the config files and scripts are located for this project. \n", - "# project folder name is - 'waste_identification_ml'\n", - "!git clone https://github.com/tensorflow/models.git " - ], + "execution_count": null, "metadata": { "id": "Vh42KtozpqeT" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "# clone the Model Garden directory for Tensorflow where all the config files and scripts are located for this project.\n", + "# project folder name is - 'waste_identification_ml'\n", + "!git clone https://github.com/tensorflow/models.git" + ] }, { "cell_type": "code", - "source": [ - "# Go to the model folder\n", - "%cd models" - ], + "execution_count": null, "metadata": { "id": "wm-k6-S4pr_B" }, - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "# Go to the model folder\n", + "%cd models" + ] }, { "cell_type": "markdown", @@ -207,16 +173,16 @@ "cell_type": "code", "execution_count": null, "metadata": { - "id": "mjsai7PDAxgp", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "mjsai7PDAxgp", "outputId": "c78c7eaa-36e0-48e0-ba2c-3e674bdc5402" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "I0422 00:06:23.072771 139705362556800 create_coco_tf_record.py:494] writing to output path: /mydrive/gtech/MRFs/Recykal/Latest_sharing_by_sanket/Google_Recykal/Taxonomy_version_2/train/\n", "I0422 00:06:25.089654 139705362556800 create_coco_tf_record.py:366] Building bounding box index.\n", @@ -293,7 +259,8 @@ "source": [ "# run the script to convert your json file to TFRecord file\n", "# --num_shards (how many TFRecord sharded files you want)\n", - "!python3 -m official.vision.data.create_coco_tf_record --logtostderr \\\n", + "!python3 -m official.vision.data.create_coco_tf_record \\\n", + " --logtostderr \\\n", " --image_dir=$training_images_folder \\\n", " --object_annotations_file=$training_annotation_file \\\n", " --output_file_prefix=$output_folder \\\n", @@ -313,31 +280,31 @@ }, { "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OVQn5DiFBUfv" + }, + "outputs": [], "source": [ "validation_annotation_file = '/mydrive/gtech/total_images/' #@param {type:\"string\"}\n", "validation_data_folder = '/mydrive/gtech/_val.json' #@param {type:\"string\"}\n", "output_folder = '/mydrive/gtech/val/' #@param {type:\"string\"}" - ], - "metadata": { - "id": "OVQn5DiFBUfv" - }, - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "id": "nWbKeLoVwXbi", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "nWbKeLoVwXbi", "outputId": "63f4fc03-43b1-424e-dfb2-200f9bbdf1e5" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "I0421 20:53:39.071351 140304098097024 create_coco_tf_record.py:494] writing to output path: /mydrive/gtech/MRFs/Recykal/Latest_sharing_by_sanket/Google_Recykal/Taxonomy_version_2/val/\n", "I0421 20:53:40.622877 140304098097024 create_coco_tf_record.py:366] Building bounding box index.\n", @@ -380,7 +347,6 @@ "metadata": { "accelerator": "GPU", "colab": { - "collapsed_sections": [], "machine_shape": "hm", "provenance": [] }, @@ -394,4 +360,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 84000f908779829232b7f23ccdfdef41167e460a Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 25 Oct 2023 13:18:59 -0700 Subject: [PATCH 35/42] No public description PiperOrigin-RevId: 576624568 --- official/vision/configs/maskrcnn.py | 5 +++ official/vision/configs/retinanet.py | 1 + .../vision/dataloaders/retinanet_input.py | 10 ++++- official/vision/ops/preprocess_ops.py | 11 +++-- official/vision/ops/preprocess_ops_test.py | 40 +++++++++++++++++++ official/vision/serving/detection.py | 1 + official/vision/tasks/retinanet.py | 1 + 7 files changed, 63 insertions(+), 6 deletions(-) diff --git a/official/vision/configs/maskrcnn.py b/official/vision/configs/maskrcnn.py index d39625d5124..f51f82a3114 100644 --- a/official/vision/configs/maskrcnn.py +++ b/official/vision/configs/maskrcnn.py @@ -47,11 +47,16 @@ class Parser(hyperparams.Config): rpn_fg_fraction: float = 0.5 mask_crop_size: int = 112 pad: bool = True # Only support `pad = True`. + keep_aspect_ratio: bool = True # Only support `keep_aspect_ratio = True`. def __post_init__(self, *args, **kwargs): """Validates the configuration.""" if not self.pad: raise ValueError('`maskrcnn.Parser` only supports `pad = True`.') + if not self.keep_aspect_ratio: + raise ValueError( + '`maskrcnn.Parser` only supports `keep_aspect_ratio = True`.' + ) super().__post_init__(*args, **kwargs) diff --git a/official/vision/configs/retinanet.py b/official/vision/configs/retinanet.py index 7499b157a02..130527e2497 100644 --- a/official/vision/configs/retinanet.py +++ b/official/vision/configs/retinanet.py @@ -60,6 +60,7 @@ class Parser(hyperparams.Config): # Can choose AutoAugment and RandAugment. aug_type: Optional[common.Augmentation] = None pad: bool = True + keep_aspect_ratio: bool = True # Keep for backward compatibility. Not used. aug_policy: Optional[str] = None diff --git a/official/vision/dataloaders/retinanet_input.py b/official/vision/dataloaders/retinanet_input.py index ef2c008afd2..42e81416744 100644 --- a/official/vision/dataloaders/retinanet_input.py +++ b/official/vision/dataloaders/retinanet_input.py @@ -57,7 +57,8 @@ def __init__(self, dtype='bfloat16', resize_first: Optional[bool] = None, mode=None, - pad=True): + pad=True, + keep_aspect_ratio=True): """Initializes parameters for parsing annotations in the dataset. Args: @@ -113,7 +114,8 @@ def __init__(self, size = (384, 384). This is necessary when using FPN as it assumes each lower feature map is 2x size of its higher neighbor. Without padding, such relationship may be invalidated. The backbone may produce 5x5 and - 2x2 consecutive feature maps, which does not work with FPN. + 2x2 consecutive feature maps, which does not work with FPN. + keep_aspect_ratio: `bool`, if True, keep the aspect ratio when resizing. """ self._mode = mode self._max_num_instances = max_num_instances @@ -170,6 +172,8 @@ def __init__(self, # This is needed when using FPN decoder. self._pad = pad + self._keep_aspect_ratio = keep_aspect_ratio + def _resize_and_crop_image_and_boxes(self, image, boxes, pad=True): """Resizes and crops image and boxes, optionally with padding.""" # Resizes and crops image. @@ -183,6 +187,7 @@ def _resize_and_crop_image_and_boxes(self, image, boxes, pad=True): padded_size=padded_size, aug_scale_min=self._aug_scale_min, aug_scale_max=self._aug_scale_max, + keep_aspect_ratio=self._keep_aspect_ratio, ) # Resizes and crops boxes. @@ -345,6 +350,7 @@ def _parse_eval_data(self, data, anchor_labeler=None, input_anchor=None): padded_size=padded_size, aug_scale_min=1.0, aug_scale_max=1.0, + keep_aspect_ratio=self._keep_aspect_ratio, ) image = tf.ensure_shape(image, padded_size + [3]) image_height, image_width, _ = image.get_shape().as_list() diff --git a/official/vision/ops/preprocess_ops.py b/official/vision/ops/preprocess_ops.py index 653638c18cc..9bf0927e898 100644 --- a/official/vision/ops/preprocess_ops.py +++ b/official/vision/ops/preprocess_ops.py @@ -158,7 +158,8 @@ def resize_and_crop_image(image, aug_scale_min=1.0, aug_scale_max=1.0, seed=1, - method=tf.image.ResizeMethod.BILINEAR): + method=tf.image.ResizeMethod.BILINEAR, + keep_aspect_ratio=True): """Resizes the input image to output size (RetinaNet style). Resize and pad images given the desired output size of the image and @@ -184,6 +185,7 @@ def resize_and_crop_image(image, random scale applied to desired_size for training scale jittering. seed: seed for random scale jittering. method: function to resize input image to scaled image. + keep_aspect_ratio: whether or not to keep the aspect ratio when resizing. Returns: output_image: `Tensor` of shape [height, width, 3] where [height, width] @@ -213,9 +215,10 @@ def resize_and_crop_image(image, else: scaled_size = tf.cast(desired_size, tf.float32) - scale = tf.minimum( - scaled_size[0] / image_size[0], scaled_size[1] / image_size[1]) - scaled_size = tf.round(image_size * scale) + if keep_aspect_ratio: + scale = tf.minimum( + scaled_size[0] / image_size[0], scaled_size[1] / image_size[1]) + scaled_size = tf.round(image_size * scale) # Computes 2D image_scale. image_scale = scaled_size / image_size diff --git a/official/vision/ops/preprocess_ops_test.py b/official/vision/ops/preprocess_ops_test.py index cfab812b853..f82744cea78 100644 --- a/official/vision/ops/preprocess_ops_test.py +++ b/official/vision/ops/preprocess_ops_test.py @@ -15,7 +15,9 @@ """Tests for preprocess_ops.py.""" import io + # Import libraries + from absl.testing import parameterized import numpy as np from PIL import Image @@ -57,6 +59,44 @@ def test_pad_to_fixed_size(self, input_shape, output_size): self.assertAllClose(output_size, output_data.shape[0]) self.assertAllClose(expected_outputs, output_data) + @parameterized.named_parameters( + dict( + testcase_name='no_jittering', + input_size=(100, 200), + desired_size=(20, 10), + aug_scale_max=1.0, + output_scales=(20 / 100, 10 / 200), + ), + dict( + testcase_name='with_jittering', + input_size=(100, 200), + desired_size=(20, 10), + aug_scale_max=2.0, + output_scales=(20 / 100, 10 / 200), + ), + ) + def test_resize_and_crop_image_not_keep_aspect_ratio( + self, input_size, desired_size, aug_scale_max, output_scales + ): + image = tf.convert_to_tensor(np.random.rand(*input_size, 3)) + + resized_image, image_info = preprocess_ops.resize_and_crop_image( + image, + desired_size=desired_size, + padded_size=desired_size, + aug_scale_max=aug_scale_max, + keep_aspect_ratio=False, + ) + resized_image_shape = tf.shape(resized_image) + + self.assertAllEqual([*desired_size, 3], resized_image_shape.numpy()) + if aug_scale_max == 1: + self.assertNDArrayNear( + [input_size, desired_size, output_scales, [0.0, 0.0]], + image_info.numpy(), + 1e-5, + ) + @parameterized.parameters( (100, 200, 100, 200, 32, 1.0, 1.0, 128, 224), (100, 256, 128, 256, 32, 1.0, 1.0, 128, 256), diff --git a/official/vision/serving/detection.py b/official/vision/serving/detection.py index b15e294d60d..c26d22a6143 100644 --- a/official/vision/serving/detection.py +++ b/official/vision/serving/detection.py @@ -88,6 +88,7 @@ def _build_inputs(self, image): padded_size=self._padded_size, aug_scale_min=1.0, aug_scale_max=1.0, + keep_aspect_ratio=self.params.task.train_data.parser.keep_aspect_ratio, ) anchor_boxes = self._build_anchor_boxes() diff --git a/official/vision/tasks/retinanet.py b/official/vision/tasks/retinanet.py index 58084dd598b..20ad4b50c24 100644 --- a/official/vision/tasks/retinanet.py +++ b/official/vision/tasks/retinanet.py @@ -137,6 +137,7 @@ def build_inputs(self, skip_crowd_during_training=params.parser.skip_crowd_during_training, max_num_instances=params.parser.max_num_instances, pad=params.parser.pad, + keep_aspect_ratio=params.parser.keep_aspect_ratio, ) reader = input_reader_factory.input_reader_generator( From c828195cac15a30a0612a282e226c738874b907e Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Wed, 1 Nov 2023 11:17:43 -0700 Subject: [PATCH 36/42] No public description PiperOrigin-RevId: 578578985 --- official/projects/volumetric_models/__init__.py | 14 ++++++++++++++ .../projects/volumetric_models/configs/__init__.py | 14 ++++++++++++++ .../volumetric_models/dataloaders/__init__.py | 14 ++++++++++++++ .../volumetric_models/evaluation/__init__.py | 14 ++++++++++++++ .../projects/volumetric_models/losses/__init__.py | 14 ++++++++++++++ .../volumetric_models/modeling/__init__.py | 14 ++++++++++++++ .../volumetric_models/modeling/heads/__init__.py | 14 ++++++++++++++ .../projects/volumetric_models/serving/__init__.py | 14 ++++++++++++++ .../projects/volumetric_models/tasks/__init__.py | 14 ++++++++++++++ 9 files changed, 126 insertions(+) create mode 100644 official/projects/volumetric_models/__init__.py create mode 100644 official/projects/volumetric_models/configs/__init__.py create mode 100644 official/projects/volumetric_models/dataloaders/__init__.py create mode 100644 official/projects/volumetric_models/evaluation/__init__.py create mode 100644 official/projects/volumetric_models/losses/__init__.py create mode 100644 official/projects/volumetric_models/modeling/__init__.py create mode 100644 official/projects/volumetric_models/modeling/heads/__init__.py create mode 100644 official/projects/volumetric_models/serving/__init__.py create mode 100644 official/projects/volumetric_models/tasks/__init__.py diff --git a/official/projects/volumetric_models/__init__.py b/official/projects/volumetric_models/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/configs/__init__.py b/official/projects/volumetric_models/configs/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/configs/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/dataloaders/__init__.py b/official/projects/volumetric_models/dataloaders/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/dataloaders/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/evaluation/__init__.py b/official/projects/volumetric_models/evaluation/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/evaluation/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/losses/__init__.py b/official/projects/volumetric_models/losses/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/losses/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/modeling/__init__.py b/official/projects/volumetric_models/modeling/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/modeling/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/modeling/heads/__init__.py b/official/projects/volumetric_models/modeling/heads/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/modeling/heads/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/serving/__init__.py b/official/projects/volumetric_models/serving/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/serving/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + diff --git a/official/projects/volumetric_models/tasks/__init__.py b/official/projects/volumetric_models/tasks/__init__.py new file mode 100644 index 00000000000..9852eb32912 --- /dev/null +++ b/official/projects/volumetric_models/tasks/__init__.py @@ -0,0 +1,14 @@ +# Copyright 2023 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. + From 560446af7059aaf1904e100a3acba4c576952ba7 Mon Sep 17 00:00:00 2001 From: Hongkun Yu Date: Wed, 1 Nov 2023 14:32:06 -0700 Subject: [PATCH 37/42] Do not use keras.experimental. PiperOrigin-RevId: 578644470 --- official/modeling/optimization/lr_schedule.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/official/modeling/optimization/lr_schedule.py b/official/modeling/optimization/lr_schedule.py index 8c0125a5d08..ad14d93f6c4 100644 --- a/official/modeling/optimization/lr_schedule.py +++ b/official/modeling/optimization/lr_schedule.py @@ -30,11 +30,12 @@ def _make_offset_wrapper(new_class_name: str, base_lr_class): Example: CosineDecayWithOffset = _make_offset_wrapper( - 'CosineDecayWithOffset', tf.keras.experimental.CosineDecay) + 'CosineDecayWithOffset', + tf.keras.optimizers.schedules.CosineDecay) # Use the lr: lr = CosineDecayWithOffset(offset=100, initial_learning_rate=0.1, decay_steps=1000) - lr(101) # equals to tf.keras.experimental.CosineDecay(...)(101-100) + lr(101) # equals to keras.optimizers.schedules.CosineDecay(...)(101-100) Args: new_class_name: the name of the new class. @@ -85,8 +86,10 @@ def offset_learning_rate_call(self, step): ExponentialDecayWithOffset = _make_offset_wrapper( "ExponentialDecayWithOffset", tf.keras.optimizers.schedules.ExponentialDecay) -CosineDecayWithOffset = _make_offset_wrapper("CosineDecayWithOffset", - tf.keras.experimental.CosineDecay) +CosineDecayWithOffset = _make_offset_wrapper( + "CosineDecayWithOffset", + tf.keras.optimizers.schedules.CosineDecay, +) class LinearWarmup(tf.keras.optimizers.schedules.LearningRateSchedule): From e4b757007c8139bac9c2ed27c062e4f1a6efd293 Mon Sep 17 00:00:00 2001 From: Yeqing Li Date: Wed, 1 Nov 2023 19:21:46 -0700 Subject: [PATCH 38/42] No public description PiperOrigin-RevId: 578710502 --- official/common/dataset_fn.py | 2 +- official/common/distribute_utils.py | 2 +- official/common/distribute_utils_test.py | 2 +- official/core/actions.py | 14 +- official/core/actions_test.py | 12 +- official/core/base_task.py | 18 +- official/core/base_trainer.py | 10 +- official/core/base_trainer_test.py | 8 +- official/core/export_base.py | 6 +- official/core/export_base_test.py | 6 +- official/core/file_writers.py | 2 +- official/core/file_writers_test.py | 2 +- official/core/input_reader.py | 2 +- official/core/registry_test.py | 2 +- .../core/savedmodel_checkpoint_manager.py | 2 +- .../savedmodel_checkpoint_manager_test.py | 6 +- official/core/test_utils.py | 8 +- official/core/tf_example_builder.py | 2 +- official/core/tf_example_builder_test.py | 2 +- official/core/train_lib.py | 10 +- official/core/train_lib_test.py | 2 +- official/core/train_utils.py | 10 +- official/core/train_utils_test.py | 2 +- official/legacy/bert/bert_models.py | 62 +++--- official/legacy/bert/bert_models_test.py | 12 +- official/legacy/bert/common_flags.py | 2 +- official/legacy/bert/configs.py | 2 +- official/legacy/bert/export_tfhub.py | 16 +- official/legacy/bert/export_tfhub_test.py | 8 +- official/legacy/bert/input_pipeline.py | 2 +- official/legacy/bert/model_saving_utils.py | 8 +- official/legacy/bert/model_training_utils.py | 10 +- .../legacy/bert/model_training_utils_test.py | 26 +-- official/legacy/bert/run_classifier.py | 16 +- official/legacy/bert/run_pretraining.py | 2 +- official/legacy/bert/run_squad.py | 2 +- official/legacy/bert/run_squad_helper.py | 10 +- official/legacy/bert/serving.py | 4 +- .../legacy/detection/dataloader/anchor.py | 2 +- .../detection/dataloader/input_reader.py | 2 +- .../detection/dataloader/maskrcnn_parser.py | 2 +- .../detection/dataloader/olnmask_parser.py | 2 +- .../detection/dataloader/retinanet_parser.py | 2 +- .../detection/dataloader/shapemask_parser.py | 2 +- .../dataloader/tf_example_decoder.py | 2 +- .../detection/evaluation/coco_evaluator.py | 4 +- .../legacy/detection/evaluation/coco_utils.py | 2 +- .../detection/executor/detection_executor.py | 8 +- .../executor/distributed_executor.py | 28 +-- official/legacy/detection/main.py | 2 +- .../detection/modeling/architecture/fpn.py | 6 +- .../detection/modeling/architecture/heads.py | 120 ++++++------ .../modeling/architecture/nn_blocks.py | 40 ++-- .../detection/modeling/architecture/nn_ops.py | 10 +- .../detection/modeling/architecture/resnet.py | 6 +- .../modeling/architecture/spinenet.py | 14 +- .../legacy/detection/modeling/base_model.py | 2 +- .../detection/modeling/checkpoint_utils.py | 4 +- .../detection/modeling/learning_rates.py | 6 +- official/legacy/detection/modeling/losses.py | 38 ++-- .../detection/modeling/maskrcnn_model.py | 20 +- .../detection/modeling/olnmask_model.py | 20 +- .../legacy/detection/modeling/optimizers.py | 12 +- .../detection/modeling/retinanet_model.py | 8 +- .../detection/modeling/shapemask_model.py | 22 +-- official/legacy/detection/ops/nms.py | 2 +- .../legacy/detection/ops/postprocess_ops.py | 6 +- official/legacy/detection/ops/roi_ops.py | 4 +- .../detection/ops/spatial_transform_ops.py | 2 +- official/legacy/detection/ops/target_ops.py | 6 +- official/legacy/detection/utils/box_utils.py | 2 +- .../detection/utils/dataloader_utils.py | 2 +- .../legacy/detection/utils/input_utils.py | 2 +- .../legacy/image_classification/augment.py | 2 +- .../image_classification/augment_test.py | 2 +- .../legacy/image_classification/callbacks.py | 22 +-- .../classifier_trainer.py | 28 +-- .../classifier_trainer_test.py | 2 +- .../classifier_trainer_util_test.py | 12 +- .../image_classification/dataset_factory.py | 2 +- .../efficientnet/common_modules.py | 18 +- .../efficientnet/efficientnet_model.py | 52 ++--- .../efficientnet/tfhub_export.py | 10 +- .../image_classification/learning_rate.py | 8 +- .../learning_rate_test.py | 4 +- .../legacy/image_classification/mnist_main.py | 30 +-- .../legacy/image_classification/mnist_test.py | 2 +- .../image_classification/optimizer_factory.py | 40 ++-- .../optimizer_factory_test.py | 14 +- .../image_classification/preprocessing.py | 2 +- .../image_classification/resnet/common.py | 12 +- .../resnet/imagenet_preprocessing.py | 8 +- .../resnet/resnet_ctl_imagenet_main.py | 4 +- .../resnet/resnet_model.py | 18 +- .../resnet/resnet_runnable.py | 14 +- .../resnet/tfhub_export.py | 6 +- .../legacy/image_classification/test_utils.py | 16 +- .../image_classification/vgg/vgg_model.py | 12 +- .../legacy/transformer/attention_layer.py | 14 +- official/legacy/transformer/compute_bleu.py | 2 +- .../legacy/transformer/compute_bleu_test.py | 2 +- official/legacy/transformer/data_pipeline.py | 2 +- .../legacy/transformer/embedding_layer.py | 4 +- official/legacy/transformer/ffn_layer.py | 8 +- official/legacy/transformer/metrics.py | 12 +- official/legacy/transformer/misc.py | 4 +- official/legacy/transformer/model_utils.py | 2 +- .../legacy/transformer/model_utils_test.py | 2 +- official/legacy/transformer/optimizer.py | 4 +- official/legacy/transformer/transformer.py | 28 +-- .../transformer/transformer_forward_test.py | 16 +- .../transformer/transformer_layers_test.py | 6 +- .../legacy/transformer/transformer_main.py | 8 +- .../transformer/transformer_main_test.py | 2 +- .../legacy/transformer/transformer_test.py | 2 +- official/legacy/transformer/translate.py | 4 +- .../legacy/transformer/utils/tokenizer.py | 2 +- .../transformer/utils/tokenizer_test.py | 2 +- official/legacy/xlnet/data_utils.py | 4 +- official/legacy/xlnet/optimization.py | 8 +- .../xlnet/preprocess_classification_data.py | 2 +- .../legacy/xlnet/preprocess_pretrain_data.py | 2 +- .../legacy/xlnet/preprocess_squad_data.py | 2 +- official/legacy/xlnet/run_classifier.py | 4 +- official/legacy/xlnet/run_pretrain.py | 2 +- official/legacy/xlnet/run_squad.py | 2 +- official/legacy/xlnet/squad_utils.py | 2 +- official/legacy/xlnet/training_utils.py | 12 +- official/legacy/xlnet/xlnet_config.py | 2 +- official/legacy/xlnet/xlnet_modeling.py | 86 ++++----- official/modeling/activations/gelu.py | 6 +- official/modeling/activations/gelu_test.py | 2 +- official/modeling/activations/mish.py | 4 +- official/modeling/activations/mish_test.py | 2 +- official/modeling/activations/relu.py | 4 +- official/modeling/activations/relu_test.py | 2 +- official/modeling/activations/sigmoid.py | 4 +- official/modeling/activations/sigmoid_test.py | 2 +- official/modeling/activations/swish.py | 8 +- official/modeling/activations/swish_test.py | 2 +- .../experimental/tf2_utils_2x_wide.py | 20 +- .../experimental/tf2_utils_2x_wide_test.py | 24 +-- .../fast_training/progressive/policies.py | 10 +- .../fast_training/progressive/train_lib.py | 6 +- .../progressive/train_lib_test.py | 2 +- .../fast_training/progressive/trainer.py | 6 +- .../fast_training/progressive/trainer_test.py | 10 +- .../fast_training/progressive/utils.py | 2 +- official/modeling/grad_utils.py | 6 +- official/modeling/grad_utils_test.py | 14 +- official/modeling/hyperparams/base_config.py | 2 +- .../modeling/hyperparams/base_config_test.py | 2 +- official/modeling/hyperparams/oneof_test.py | 2 +- official/modeling/hyperparams/params_dict.py | 2 +- .../modeling/hyperparams/params_dict_test.py | 2 +- official/modeling/multitask/base_model.py | 10 +- official/modeling/multitask/base_trainer.py | 8 +- .../modeling/multitask/base_trainer_test.py | 6 +- official/modeling/multitask/evaluator.py | 8 +- official/modeling/multitask/evaluator_test.py | 10 +- .../multitask/interleaving_trainer.py | 10 +- .../multitask/interleaving_trainer_test.py | 6 +- official/modeling/multitask/multitask.py | 4 +- official/modeling/multitask/task_sampler.py | 2 +- .../modeling/multitask/task_sampler_test.py | 2 +- official/modeling/multitask/test_utils.py | 32 ++-- official/modeling/multitask/train_lib.py | 4 +- official/modeling/multitask/train_lib_test.py | 2 +- .../configs/learning_rate_config.py | 2 +- .../configs/optimization_config_test.py | 2 +- .../optimization/configs/optimizer_config.py | 12 +- .../modeling/optimization/ema_optimizer.py | 16 +- official/modeling/optimization/lamb.py | 8 +- official/modeling/optimization/lamb_test.py | 6 +- official/modeling/optimization/lars.py | 4 +- .../modeling/optimization/legacy_adamw.py | 4 +- official/modeling/optimization/lr_schedule.py | 46 ++--- .../modeling/optimization/lr_schedule_test.py | 2 +- .../optimization/optimizer_factory.py | 56 +++--- .../optimization/optimizer_factory_test.py | 4 +- official/modeling/performance.py | 14 +- official/modeling/privacy/configs_test.py | 2 +- official/modeling/privacy/ops.py | 2 +- official/modeling/privacy/ops_test.py | 2 +- official/modeling/tf_utils.py | 58 +++--- official/modeling/tf_utils_test.py | 2 +- official/nlp/configs/encoders.py | 56 +++--- official/nlp/configs/encoders_test.py | 2 +- official/nlp/continuous_finetune_lib.py | 2 +- official/nlp/continuous_finetune_lib_test.py | 2 +- official/nlp/data/classifier_data_lib.py | 2 +- official/nlp/data/classifier_data_lib_test.py | 2 +- official/nlp/data/create_finetuning_data.py | 2 +- official/nlp/data/create_pretraining_data.py | 2 +- .../nlp/data/create_pretraining_data_test.py | 2 +- .../nlp/data/create_xlnet_pretraining_data.py | 2 +- .../create_xlnet_pretraining_data_test.py | 2 +- official/nlp/data/data_loader.py | 2 +- official/nlp/data/data_loader_factory_test.py | 2 +- official/nlp/data/dual_encoder_dataloader.py | 2 +- .../nlp/data/dual_encoder_dataloader_test.py | 2 +- official/nlp/data/pretrain_dataloader.py | 2 +- official/nlp/data/pretrain_dataloader_test.py | 2 +- .../nlp/data/pretrain_dynamic_dataloader.py | 2 +- .../data/pretrain_dynamic_dataloader_test.py | 2 +- official/nlp/data/pretrain_text_dataloader.py | 2 +- .../nlp/data/question_answering_dataloader.py | 2 +- .../question_answering_dataloader_test.py | 2 +- .../data/sentence_prediction_dataloader.py | 2 +- .../sentence_prediction_dataloader_test.py | 2 +- official/nlp/data/squad_lib.py | 2 +- official/nlp/data/squad_lib_sp.py | 2 +- official/nlp/data/tagging_data_lib.py | 2 +- official/nlp/data/tagging_data_lib_test.py | 2 +- official/nlp/data/tagging_dataloader.py | 2 +- official/nlp/data/tagging_dataloader_test.py | 2 +- official/nlp/data/train_sentencepiece.py | 2 +- official/nlp/data/wmt_dataloader.py | 2 +- official/nlp/data/wmt_dataloader_test.py | 2 +- official/nlp/finetuning/binary_helper.py | 2 +- official/nlp/finetuning/glue/run_glue.py | 2 +- .../nlp/finetuning/superglue/run_superglue.py | 2 +- official/nlp/metrics/bleu.py | 2 +- official/nlp/metrics/bleu_test.py | 2 +- official/nlp/modeling/__init__.py | 4 +- official/nlp/modeling/layers/attention.py | 12 +- .../nlp/modeling/layers/attention_test.py | 2 +- .../nlp/modeling/layers/bigbird_attention.py | 8 +- .../modeling/layers/bigbird_attention_test.py | 2 +- .../modeling/layers/block_diag_feedforward.py | 56 +++--- .../layers/block_diag_feedforward_test.py | 14 +- official/nlp/modeling/layers/cls_head.py | 36 ++-- official/nlp/modeling/layers/cls_head_test.py | 2 +- .../modeling/layers/factorized_embedding.py | 6 +- .../layers/factorized_embedding_test.py | 8 +- .../nlp/modeling/layers/gated_feedforward.py | 48 ++--- .../modeling/layers/gated_feedforward_test.py | 14 +- .../nlp/modeling/layers/gaussian_process.py | 28 +-- .../modeling/layers/gaussian_process_test.py | 8 +- .../nlp/modeling/layers/kernel_attention.py | 22 +-- .../modeling/layers/kernel_attention_test.py | 2 +- official/nlp/modeling/layers/masked_lm.py | 12 +- .../nlp/modeling/layers/masked_lm_test.py | 22 +-- .../nlp/modeling/layers/masked_softmax.py | 6 +- .../modeling/layers/masked_softmax_test.py | 28 +-- .../modeling/layers/mat_mul_with_margin.py | 6 +- .../layers/mat_mul_with_margin_test.py | 6 +- official/nlp/modeling/layers/mixing.py | 8 +- official/nlp/modeling/layers/mixing_test.py | 4 +- .../nlp/modeling/layers/mobile_bert_layers.py | 56 +++--- .../layers/mobile_bert_layers_test.py | 30 +-- official/nlp/modeling/layers/moe.py | 54 +++--- official/nlp/modeling/layers/moe_test.py | 22 +-- .../layers/multi_channel_attention.py | 22 +-- .../layers/multi_channel_attention_test.py | 2 +- .../modeling/layers/on_device_embedding.py | 6 +- .../layers/on_device_embedding_test.py | 30 +-- .../nlp/modeling/layers/pack_optimization.py | 12 +- .../modeling/layers/pack_optimization_test.py | 2 +- .../layers/per_dim_scale_attention.py | 6 +- .../layers/per_dim_scale_attention_test.py | 2 +- .../nlp/modeling/layers/position_embedding.py | 26 +-- .../layers/position_embedding_test.py | 16 +- .../nlp/modeling/layers/relative_attention.py | 14 +- .../layers/relative_attention_test.py | 2 +- .../nlp/modeling/layers/reuse_attention.py | 52 ++--- .../modeling/layers/reuse_attention_test.py | 82 ++++---- .../nlp/modeling/layers/reuse_transformer.py | 54 +++--- .../modeling/layers/reuse_transformer_test.py | 62 +++--- .../nlp/modeling/layers/rezero_transformer.py | 54 +++--- .../layers/rezero_transformer_test.py | 22 +-- official/nlp/modeling/layers/routing.py | 12 +- official/nlp/modeling/layers/routing_test.py | 2 +- .../modeling/layers/self_attention_mask.py | 6 +- .../modeling/layers/spectral_normalization.py | 18 +- .../layers/spectral_normalization_test.py | 6 +- .../layers/talking_heads_attention.py | 8 +- .../layers/talking_heads_attention_test.py | 26 +-- official/nlp/modeling/layers/text_layers.py | 10 +- .../nlp/modeling/layers/text_layers_test.py | 18 +- .../nlp/modeling/layers/tn_expand_condense.py | 10 +- .../layers/tn_expand_condense_test.py | 14 +- .../layers/tn_transformer_expand_condense.py | 48 ++--- .../modeling/layers/tn_transformer_test.py | 42 ++--- official/nlp/modeling/layers/transformer.py | 50 ++--- .../layers/transformer_encoder_block.py | 50 ++--- .../layers/transformer_encoder_block_test.py | 60 +++--- .../modeling/layers/transformer_scaffold.py | 38 ++-- .../layers/transformer_scaffold_test.py | 64 +++---- .../nlp/modeling/layers/transformer_test.py | 6 +- .../nlp/modeling/layers/transformer_xl.py | 26 +-- .../modeling/layers/transformer_xl_test.py | 6 +- official/nlp/modeling/layers/util.py | 2 +- ...eighted_sparse_categorical_crossentropy.py | 4 +- ...ed_sparse_categorical_crossentropy_test.py | 14 +- .../nlp/modeling/models/bert_classifier.py | 8 +- .../modeling/models/bert_classifier_test.py | 8 +- .../nlp/modeling/models/bert_pretrainer.py | 20 +- .../modeling/models/bert_pretrainer_test.py | 26 +-- .../nlp/modeling/models/bert_span_labeler.py | 10 +- .../modeling/models/bert_span_labeler_test.py | 8 +- .../modeling/models/bert_token_classifier.py | 12 +- .../models/bert_token_classifier_test.py | 8 +- official/nlp/modeling/models/dual_encoder.py | 30 +-- .../nlp/modeling/models/dual_encoder_test.py | 14 +- .../nlp/modeling/models/electra_pretrainer.py | 10 +- .../models/electra_pretrainer_test.py | 12 +- .../modeling/models/seq2seq_transformer.py | 22 +-- .../models/seq2seq_transformer_test.py | 2 +- official/nlp/modeling/models/t5.py | 16 +- official/nlp/modeling/models/t5_test.py | 42 ++--- official/nlp/modeling/models/xlnet.py | 32 ++-- official/nlp/modeling/models/xlnet_test.py | 50 ++--- .../nlp/modeling/networks/albert_encoder.py | 32 ++-- .../modeling/networks/albert_encoder_test.py | 32 ++-- .../networks/bert_dense_encoder_test.py | 76 ++++---- .../nlp/modeling/networks/bert_encoder.py | 72 +++---- .../modeling/networks/bert_encoder_test.py | 106 +++++------ .../nlp/modeling/networks/classification.py | 14 +- .../modeling/networks/classification_test.py | 38 ++-- .../nlp/modeling/networks/encoder_scaffold.py | 34 ++-- .../networks/encoder_scaffold_test.py | 158 ++++++++-------- official/nlp/modeling/networks/fnet.py | 46 ++--- official/nlp/modeling/networks/fnet_test.py | 18 +- .../modeling/networks/funnel_transformer.py | 48 ++--- .../networks/funnel_transformer_test.py | 72 +++---- .../modeling/networks/mobile_bert_encoder.py | 14 +- .../networks/mobile_bert_encoder_test.py | 36 ++-- .../networks/packed_sequence_embedding.py | 40 ++-- .../packed_sequence_embedding_test.py | 26 +-- .../nlp/modeling/networks/span_labeling.py | 30 +-- .../modeling/networks/span_labeling_test.py | 42 ++--- .../nlp/modeling/networks/sparse_mixer.py | 46 ++--- .../modeling/networks/sparse_mixer_test.py | 18 +- official/nlp/modeling/networks/xlnet_base.py | 12 +- .../nlp/modeling/networks/xlnet_base_test.py | 6 +- official/nlp/modeling/ops/beam_search.py | 2 +- official/nlp/modeling/ops/beam_search_test.py | 2 +- official/nlp/modeling/ops/decoding_module.py | 2 +- .../nlp/modeling/ops/decoding_module_test.py | 2 +- official/nlp/modeling/ops/sampling_module.py | 2 +- .../nlp/modeling/ops/segment_extractor.py | 2 +- .../modeling/ops/segment_extractor_test.py | 2 +- official/nlp/optimization.py | 6 +- .../nlp/serving/export_savedmodel_test.py | 2 +- .../nlp/serving/export_savedmodel_util.py | 2 +- official/nlp/serving/serving_modules.py | 12 +- official/nlp/serving/serving_modules_test.py | 2 +- official/nlp/tasks/dual_encoder.py | 10 +- official/nlp/tasks/dual_encoder_test.py | 6 +- official/nlp/tasks/electra_task.py | 28 +-- official/nlp/tasks/electra_task_test.py | 4 +- official/nlp/tasks/masked_lm.py | 22 +-- .../nlp/tasks/masked_lm_determinism_test.py | 8 +- official/nlp/tasks/masked_lm_test.py | 4 +- official/nlp/tasks/question_answering.py | 22 +-- official/nlp/tasks/question_answering_test.py | 8 +- official/nlp/tasks/sentence_prediction.py | 22 +-- .../nlp/tasks/sentence_prediction_test.py | 14 +- official/nlp/tasks/tagging.py | 12 +- official/nlp/tasks/tagging_test.py | 8 +- official/nlp/tasks/translation.py | 14 +- official/nlp/tasks/translation_test.py | 4 +- official/nlp/tasks/utils.py | 14 +- official/nlp/tools/export_tfhub_lib.py | 24 +-- official/nlp/tools/export_tfhub_lib_test.py | 20 +- ...tf2_albert_encoder_checkpoint_converter.py | 6 +- .../tf2_bert_encoder_checkpoint_converter.py | 6 +- official/nlp/tools/tokenization.py | 2 +- official/nlp/tools/tokenization_test.py | 2 +- official/nlp/train.py | 2 +- .../assemblenet/configs/assemblenet_test.py | 2 +- .../assemblenet/modeling/assemblenet.py | 74 ++++---- .../assemblenet/modeling/assemblenet_plus.py | 56 +++--- .../modeling/assemblenet_plus_test.py | 8 +- .../assemblenet/modeling/rep_flow_2d_layer.py | 16 +- official/projects/assemblenet/train_test.py | 2 +- .../projects/basnet/configs/basnet_test.py | 2 +- .../basnet/evaluation/metrics_test.py | 8 +- .../projects/basnet/losses/basnet_losses.py | 6 +- .../projects/basnet/modeling/basnet_model.py | 54 +++--- .../basnet/modeling/basnet_model_test.py | 4 +- .../projects/basnet/modeling/nn_blocks.py | 38 ++-- official/projects/basnet/modeling/refunet.py | 20 +- official/projects/basnet/serving/basnet.py | 4 +- official/projects/basnet/tasks/basnet.py | 16 +- official/projects/bigbird/encoder.py | 28 +-- official/projects/bigbird/encoder_test.py | 4 +- official/projects/bigbird/recompute_grad.py | 2 +- .../projects/bigbird/recomputing_dropout.py | 10 +- .../projects/bigbird/stateless_dropout.py | 2 +- .../centernet/configs/centernet_test.py | 2 +- .../centernet/dataloaders/centernet_input.py | 2 +- .../centernet/losses/centernet_losses.py | 2 +- .../centernet/losses/centernet_losses_test.py | 2 +- .../centernet/modeling/backbones/hourglass.py | 28 +-- .../modeling/backbones/hourglass_test.py | 4 +- .../centernet/modeling/centernet_model.py | 12 +- .../modeling/centernet_model_test.py | 4 +- .../modeling/heads/centernet_head.py | 6 +- .../modeling/heads/centernet_head_test.py | 6 +- .../centernet/modeling/layers/cn_nn_blocks.py | 32 ++-- .../modeling/layers/cn_nn_blocks_test.py | 16 +- .../modeling/layers/detection_generator.py | 4 +- .../layers/detection_generator_test.py | 2 +- official/projects/centernet/ops/box_list.py | 2 +- .../projects/centernet/ops/box_list_ops.py | 2 +- official/projects/centernet/ops/loss_ops.py | 2 +- official/projects/centernet/ops/nms_ops.py | 2 +- .../projects/centernet/ops/preprocess_ops.py | 2 +- .../projects/centernet/ops/target_assigner.py | 2 +- .../centernet/ops/target_assigner_test.py | 2 +- .../projects/centernet/tasks/centernet.py | 20 +- .../utils/checkpoints/config_classes.py | 6 +- .../utils/checkpoints/read_checkpoints.py | 2 +- .../tf2_centernet_checkpoint_converter.py | 4 +- .../const_cl/configs/backbones_3d_test.py | 2 +- .../const_cl/configs/const_cl_test.py | 2 +- .../projects/const_cl/configs/head_test.py | 2 +- .../const_cl/datasets/video_ssl_inputs.py | 2 +- .../datasets/video_ssl_inputs_test.py | 2 +- official/projects/const_cl/losses/losses.py | 2 +- .../projects/const_cl/losses/losses_test.py | 2 +- .../modeling/backbones/nn_blocks_3d.py | 12 +- .../modeling/backbones/nn_blocks_3d_test.py | 4 +- .../const_cl/modeling/backbones/resnet_3d.py | 32 ++-- .../modeling/backbones/resnet_3d_test.py | 6 +- .../const_cl/modeling/const_cl_model.py | 18 +- .../const_cl/modeling/const_cl_model_test.py | 8 +- .../modeling/heads/instance_reconstructor.py | 14 +- .../heads/instance_reconstructor_test.py | 2 +- .../const_cl/modeling/heads/simple.py | 14 +- .../const_cl/modeling/heads/simple_test.py | 2 +- .../modeling/heads/transformer_decoder.py | 24 +-- .../heads/transformer_decoder_test.py | 2 +- official/projects/const_cl/tasks/const_cl.py | 38 ++-- .../projects/const_cl/tasks/const_cl_test.py | 2 +- .../deep_mask_head_rcnn_config_test.py | 2 +- .../modeling/heads/hourglass_network.py | 36 ++-- .../modeling/heads/instance_heads.py | 34 ++-- .../modeling/heads/instance_heads_test.py | 2 +- .../modeling/maskrcnn_model.py | 32 ++-- .../modeling/maskrcnn_model_test.py | 4 +- .../deepmac_maskrcnn/serving/detection.py | 4 +- .../serving/detection_test.py | 2 +- .../tasks/deep_mask_head_rcnn.py | 14 +- official/projects/detr/configs/detr_test.py | 2 +- official/projects/detr/dataloaders/coco.py | 2 +- .../projects/detr/dataloaders/coco_test.py | 2 +- .../projects/detr/dataloaders/detr_input.py | 2 +- official/projects/detr/modeling/detr.py | 30 +-- official/projects/detr/modeling/detr_test.py | 2 +- .../projects/detr/modeling/transformer.py | 98 +++++----- .../detr/modeling/transformer_test.py | 2 +- official/projects/detr/ops/matchers.py | 2 +- official/projects/detr/ops/matchers_test.py | 2 +- official/projects/detr/optimization.py | 2 +- .../projects/detr/serving/export_module.py | 8 +- .../detr/serving/export_module_test.py | 2 +- official/projects/detr/tasks/detection.py | 12 +- .../projects/detr/tasks/detection_test.py | 2 +- .../edgetpu/nlp/mobilebert_edgetpu_trainer.py | 40 ++-- .../nlp/mobilebert_edgetpu_trainer_test.py | 2 +- .../edgetpu/nlp/modeling/edgetpu_layers.py | 18 +- .../nlp/modeling/edgetpu_layers_test.py | 2 +- .../projects/edgetpu/nlp/modeling/encoder.py | 16 +- .../edgetpu/nlp/modeling/model_builder.py | 10 +- .../nlp/modeling/model_builder_test.py | 4 +- .../edgetpu/nlp/modeling/pretrainer.py | 14 +- .../edgetpu/nlp/modeling/pretrainer_test.py | 18 +- .../nlp/run_mobilebert_edgetpu_train.py | 2 +- .../nlp/serving/export_tflite_squad.py | 20 +- .../nlp/serving/export_tflite_squad_test.py | 4 +- official/projects/edgetpu/nlp/utils/utils.py | 4 +- .../projects/edgetpu/nlp/utils/utils_test.py | 2 +- .../dataloaders/classification_input.py | 2 +- .../dataloaders/classification_input_test.py | 2 +- .../modeling/backbones/mobilenet_edgetpu.py | 10 +- .../backbones/mobilenet_edgetpu_test.py | 4 +- .../edgetpu/vision/modeling/common_modules.py | 16 +- .../edgetpu/vision/modeling/custom_layers.py | 28 +-- .../vision/modeling/custom_layers_test.py | 6 +- .../vision/modeling/heads/bifpn_head.py | 30 +-- .../modeling/mobilenet_edgetpu_v1_model.py | 8 +- .../mobilenet_edgetpu_v1_model_blocks.py | 48 ++--- .../mobilenet_edgetpu_v1_model_test.py | 14 +- .../modeling/mobilenet_edgetpu_v2_model.py | 8 +- .../mobilenet_edgetpu_v2_model_blocks.py | 70 +++---- .../mobilenet_edgetpu_v2_model_blocks_test.py | 28 +-- .../mobilenet_edgetpu_v2_model_test.py | 6 +- .../optimized_multiheadattention_layer.py | 10 +- ...optimized_multiheadattention_layer_test.py | 4 +- .../edgetpu/vision/serving/export_tflite.py | 10 +- .../vision/serving/export_tflite_test.py | 6 +- .../edgetpu/vision/serving/export_util.py | 2 +- .../serving/tflite_imagenet_evaluator.py | 2 +- .../serving/tflite_imagenet_evaluator_run.py | 2 +- .../serving/tflite_imagenet_evaluator_test.py | 2 +- .../vision/tasks/image_classification.py | 46 ++--- .../vision/tasks/image_classification_test.py | 2 +- .../vision/tasks/semantic_segmentation.py | 6 +- .../tasks/semantic_segmentation_test.py | 2 +- official/projects/fffner/fffner.py | 4 +- official/projects/fffner/fffner_classifier.py | 8 +- official/projects/fffner/fffner_dataloader.py | 2 +- official/projects/fffner/fffner_encoder.py | 56 +++--- .../projects/fffner/fffner_encoder_test.py | 2 +- official/projects/fffner/fffner_prediction.py | 14 +- .../utils/convert_checkpoint_huggingface.py | 4 +- .../utils/convert_checkpoint_tensorflow.py | 4 +- official/projects/fffner/utils/create_data.py | 2 +- official/projects/labse/export_tfhub.py | 6 +- official/projects/labse/export_tfhub_test.py | 8 +- official/projects/longformer/longformer.py | 4 +- .../longformer/longformer_attention.py | 22 +-- .../longformer/longformer_attention_test.py | 2 +- .../projects/longformer/longformer_encoder.py | 34 ++-- .../longformer/longformer_encoder_block.py | 56 +++--- .../longformer/longformer_encoder_test.py | 2 +- ...ert_pretrained_pytorch_checkpoint_to_tf.py | 4 +- .../utils/longformer_tokenizer_to_tfrecord.py | 2 +- .../lra/exponential_moving_average.py | 4 +- official/projects/lra/linformer.py | 4 +- official/projects/lra/linformer_encoder.py | 34 ++-- .../projects/lra/linformer_encoder_block.py | 68 +++---- official/projects/lra/lra_dual_encoder.py | 6 +- .../lra/lra_dual_encoder_dataloader.py | 2 +- .../projects/lra/lra_dual_encoder_task.py | 20 +- official/projects/lra/mega.py | 4 +- official/projects/lra/mega_encoder.py | 32 ++-- official/projects/lra/mega_encoder_test.py | 2 +- .../lra/moving_average_gated_attention.py | 62 +++--- official/projects/lra/transformer.py | 4 +- official/projects/lra/transformer_encoder.py | 34 ++-- official/projects/mae/modeling/masked_ae.py | 10 +- official/projects/mae/modeling/utils.py | 2 +- official/projects/mae/modeling/vit.py | 22 +-- official/projects/mae/optimization.py | 2 +- .../mae/tasks/image_classification.py | 10 +- .../mae/tasks/image_classification_test.py | 2 +- official/projects/mae/tasks/linear_probe.py | 10 +- .../projects/mae/tasks/linear_probe_test.py | 2 +- official/projects/mae/tasks/masked_ae.py | 6 +- official/projects/mae/tasks/masked_ae_test.py | 2 +- official/projects/maxvit/configs/backbones.py | 2 +- .../configs/image_classification_test.py | 2 +- official/projects/maxvit/configs/rcnn_test.py | 2 +- .../projects/maxvit/configs/retinanet_test.py | 2 +- .../configs/semantic_segmentation_test.py | 2 +- .../projects/maxvit/modeling/common_ops.py | 6 +- official/projects/maxvit/modeling/layers.py | 52 ++--- official/projects/maxvit/modeling/maxvit.py | 42 ++--- .../projects/maxvit/modeling/maxvit_test.py | 4 +- official/projects/maxvit/train_test.py | 2 +- official/projects/mobilebert/distillation.py | 52 ++--- .../projects/mobilebert/distillation_test.py | 6 +- official/projects/mobilebert/export_tfhub.py | 8 +- official/projects/mobilebert/model_utils.py | 2 +- .../projects/mosaic/modeling/mosaic_blocks.py | 118 ++++++------ .../mosaic/modeling/mosaic_blocks_test.py | 2 +- .../projects/mosaic/modeling/mosaic_head.py | 18 +- .../mosaic/modeling/mosaic_head_test.py | 2 +- .../projects/mosaic/modeling/mosaic_model.py | 26 +-- .../mosaic/modeling/mosaic_model_test.py | 4 +- official/projects/mosaic/mosaic_tasks.py | 10 +- official/projects/mosaic/mosaic_tasks_test.py | 2 +- .../mosaic/qat/configs/mosaic_config_test.py | 2 +- .../projects/mosaic/qat/modeling/factory.py | 10 +- .../mosaic/qat/modeling/factory_test.py | 6 +- .../mosaic/qat/modeling/heads/mosaic_head.py | 14 +- .../qat/modeling/heads/mosaic_head_test.py | 2 +- .../mosaic/qat/modeling/layers/nn_blocks.py | 42 ++--- .../qat/modeling/layers/nn_blocks_test.py | 14 +- .../mosaic/qat/serving/export_module.py | 6 +- .../projects/mosaic/qat/tasks/mosaic_tasks.py | 6 +- .../mosaic/qat/tasks/mosaic_tasks_test.py | 2 +- .../projects/movinet/configs/movinet_test.py | 2 +- official/projects/movinet/modeling/movinet.py | 32 ++-- .../movinet/modeling/movinet_layers.py | 144 +++++++------- .../movinet/modeling/movinet_layers_test.py | 4 +- .../movinet/modeling/movinet_model.py | 46 ++--- .../movinet/modeling/movinet_model_test.py | 22 +-- .../projects/movinet/modeling/movinet_test.py | 16 +- .../movinet/tools/convert_3d_2plus1d.py | 2 +- .../movinet/tools/convert_3d_2plus1d_test.py | 2 +- .../movinet/tools/export_saved_model.py | 12 +- .../movinet/tools/export_saved_model_test.py | 12 +- .../movinet/tools/quantize_movinet.py | 8 +- official/projects/movinet/train_test.py | 2 +- official/projects/nhnet/configs_test.py | 2 +- official/projects/nhnet/decoder.py | 26 +-- official/projects/nhnet/decoder_test.py | 24 +-- official/projects/nhnet/evaluation.py | 8 +- official/projects/nhnet/input_pipeline.py | 2 +- official/projects/nhnet/models.py | 36 ++-- official/projects/nhnet/models_test.py | 4 +- official/projects/nhnet/optimizer.py | 6 +- official/projects/nhnet/raw_data_processor.py | 2 +- official/projects/nhnet/trainer.py | 8 +- official/projects/nhnet/trainer_test.py | 2 +- official/projects/nhnet/utils.py | 6 +- .../dataloaders/panoptic_deeplab_input.py | 2 +- .../dataloaders/panoptic_maskrcnn_input.py | 2 +- .../losses/panoptic_deeplab_losses.py | 2 +- .../projects/panoptic/modeling/factory.py | 24 +-- .../modeling/heads/panoptic_deeplab_heads.py | 62 +++--- .../panoptic/modeling/layers/fusion_layers.py | 28 +-- .../modeling/layers/panoptic_deeplab_merge.py | 6 +- .../layers/panoptic_segmentation_generator.py | 6 +- .../panoptic/modeling/layers/paste_masks.py | 6 +- .../modeling/panoptic_deeplab_model.py | 20 +- .../modeling/panoptic_maskrcnn_model.py | 46 ++--- official/projects/panoptic/ops/mask_ops.py | 2 +- .../panoptic/serving/export_saved_model.py | 4 +- .../panoptic/serving/panoptic_deeplab.py | 6 +- .../panoptic/serving/panoptic_maskrcnn.py | 4 +- .../panoptic/tasks/panoptic_deeplab.py | 26 +-- .../panoptic/tasks/panoptic_maskrcnn.py | 28 +-- .../perceiver/configs/perceiver_test.py | 2 +- .../perceiver/modeling/layers/decoder.py | 8 +- .../perceiver/modeling/layers/decoder_test.py | 20 +- .../perceiver/modeling/layers/encoder.py | 12 +- .../perceiver/modeling/layers/encoder_test.py | 50 ++--- .../perceiver/modeling/layers/utils.py | 20 +- .../perceiver/modeling/layers/utils_test.py | 2 +- .../perceiver/modeling/models/classifier.py | 16 +- .../modeling/models/classifier_test.py | 8 +- .../perceiver/modeling/models/pretrainer.py | 14 +- .../modeling/models/pretrainer_test.py | 10 +- .../modeling/networks/positional_decoder.py | 20 +- .../networks/positional_decoder_test.py | 14 +- .../modeling/networks/sequence_encoder.py | 26 +-- .../networks/sequence_encoder_test.py | 26 +-- official/projects/perceiver/tasks/pretrain.py | 4 +- .../projects/perceiver/tasks/pretrain_test.py | 4 +- .../tasks/sentence_prediction_test.py | 12 +- .../projects/pix2seq/configs/pix2seq_test.py | 2 +- .../pix2seq/dataloaders/pix2seq_input.py | 2 +- .../pix2seq/dataloaders/pix2seq_input_test.py | 2 +- .../pix2seq/modeling/pix2seq_model.py | 28 +-- .../pix2seq/modeling/pix2seq_model_test.py | 2 +- .../projects/pix2seq/modeling/transformer.py | 40 ++-- .../pix2seq/modeling/transformer_test.py | 2 +- .../projects/pix2seq/tasks/pix2seq_task.py | 16 +- official/projects/pix2seq/utils.py | 2 +- official/projects/pixel/data_loader.py | 2 +- official/projects/pixel/modeling/pixel.py | 30 +-- .../projects/pixel/tasks/classification.py | 20 +- .../utils/convert_numpy_weights_to_tf.py | 2 +- .../pointpillars/configs/pointpillars_test.py | 2 +- .../pointpillars/dataloaders/decoders.py | 2 +- .../pointpillars/dataloaders/decoders_test.py | 2 +- .../pointpillars/dataloaders/parsers.py | 2 +- .../pointpillars/dataloaders/parsers_test.py | 2 +- .../pointpillars/modeling/backbones.py | 14 +- .../pointpillars/modeling/backbones_test.py | 4 +- .../pointpillars/modeling/decoders.py | 16 +- .../pointpillars/modeling/decoders_test.py | 4 +- .../projects/pointpillars/modeling/factory.py | 10 +- .../pointpillars/modeling/factory_test.py | 6 +- .../pointpillars/modeling/featurizers.py | 12 +- .../pointpillars/modeling/featurizers_test.py | 14 +- .../projects/pointpillars/modeling/heads.py | 24 +-- .../pointpillars/modeling/heads_test.py | 4 +- .../projects/pointpillars/modeling/layers.py | 24 +-- .../pointpillars/modeling/layers_test.py | 4 +- .../projects/pointpillars/modeling/models.py | 40 ++-- .../pointpillars/modeling/models_test.py | 8 +- .../pointpillars/tasks/pointpillars.py | 34 ++-- .../pointpillars/tasks/pointpillars_test.py | 2 +- .../pointpillars/tools/process_wod.py | 2 +- official/projects/pointpillars/train.py | 2 +- .../pointpillars/utils/model_exporter.py | 12 +- official/projects/pointpillars/utils/utils.py | 4 +- .../projects/pointpillars/utils/utils_test.py | 2 +- .../utils/wod_detection_evaluator.py | 2 +- .../pointpillars/utils/wod_processor.py | 2 +- .../configs/image_classification_test.py | 2 +- .../pruning/tasks/image_classification.py | 14 +- .../tasks/image_classification_test.py | 2 +- .../nlp/modeling/layers/mobile_bert_layers.py | 42 ++--- .../modeling/layers/multi_head_attention.py | 4 +- .../layers/transformer_encoder_block.py | 58 +++--- .../layers/transformer_encoder_block_test.py | 32 ++-- .../nlp/modeling/models/bert_span_labeler.py | 10 +- .../nlp/modeling/networks/span_labeling.py | 14 +- .../nlp/pretrained_checkpoint_converter.py | 2 +- .../projects/qat/nlp/quantization/configs.py | 10 +- .../qat/nlp/quantization/configs_test.py | 16 +- .../projects/qat/nlp/quantization/schemes.py | 2 +- .../qat/nlp/tasks/question_answering.py | 14 +- .../qat/nlp/tasks/question_answering_test.py | 2 +- .../configs/image_classification_test.py | 2 +- .../qat/vision/configs/retinanet_test.py | 2 +- .../configs/semantic_segmentation_test.py | 2 +- .../projects/qat/vision/modeling/factory.py | 48 ++--- .../qat/vision/modeling/factory_test.py | 18 +- .../modeling/heads/dense_prediction_heads.py | 30 +-- .../heads/dense_prediction_heads_test.py | 2 +- .../qat/vision/modeling/layers/nn_blocks.py | 60 +++--- .../vision/modeling/layers/nn_blocks_test.py | 6 +- .../qat/vision/modeling/layers/nn_layers.py | 68 +++---- .../vision/modeling/layers/nn_layers_test.py | 14 +- .../qat/vision/modeling/segmentation_model.py | 18 +- official/projects/qat/vision/n_bit/configs.py | 10 +- .../projects/qat/vision/n_bit/configs_test.py | 14 +- .../projects/qat/vision/n_bit/nn_blocks.py | 74 ++++---- .../qat/vision/n_bit/nn_blocks_test.py | 6 +- .../projects/qat/vision/n_bit/nn_layers.py | 18 +- official/projects/qat/vision/n_bit/schemes.py | 2 +- .../qat/vision/quantization/configs.py | 10 +- .../qat/vision/quantization/configs_test.py | 14 +- .../qat/vision/quantization/helper.py | 38 ++-- .../qat/vision/quantization/helper_test.py | 6 +- .../vision/quantization/layer_transforms.py | 4 +- .../qat/vision/serving/export_module.py | 6 +- .../qat/vision/tasks/image_classification.py | 8 +- .../vision/tasks/image_classification_test.py | 2 +- .../projects/qat/vision/tasks/retinanet.py | 4 +- .../qat/vision/tasks/retinanet_test.py | 2 +- .../qat/vision/tasks/semantic_segmentation.py | 6 +- official/projects/roformer/roformer.py | 4 +- .../projects/roformer/roformer_attention.py | 12 +- .../roformer/roformer_attention_test.py | 2 +- .../projects/roformer/roformer_encoder.py | 34 ++-- .../roformer/roformer_encoder_block.py | 56 +++--- .../roformer/roformer_encoder_block_test.py | 42 ++--- .../roformer/roformer_encoder_test.py | 48 ++--- .../projects/s3d/modeling/inception_utils.py | 60 +++--- .../s3d/modeling/inception_utils_test.py | 6 +- official/projects/s3d/modeling/net_utils.py | 22 +-- .../projects/s3d/modeling/net_utils_test.py | 4 +- official/projects/s3d/modeling/s3d.py | 48 ++--- official/projects/s3d/modeling/s3d_test.py | 10 +- .../simclr/configs/multitask_config_test.py | 2 +- .../projects/simclr/configs/simclr_test.py | 2 +- .../simclr/dataloaders/preprocess_ops.py | 2 +- .../simclr/dataloaders/simclr_input.py | 2 +- official/projects/simclr/heads/simclr_head.py | 18 +- .../projects/simclr/heads/simclr_head_test.py | 6 +- .../simclr/losses/contrastive_losses.py | 2 +- .../simclr/losses/contrastive_losses_test.py | 2 +- .../simclr/modeling/layers/nn_blocks.py | 18 +- .../simclr/modeling/layers/nn_blocks_test.py | 4 +- .../simclr/modeling/multitask_model.py | 8 +- .../simclr/modeling/multitask_model_test.py | 2 +- .../projects/simclr/modeling/simclr_model.py | 14 +- .../simclr/modeling/simclr_model_test.py | 6 +- official/projects/simclr/tasks/simclr.py | 52 ++--- official/projects/teams/teams.py | 8 +- official/projects/teams/teams_pretrainer.py | 20 +- .../projects/teams/teams_pretrainer_test.py | 16 +- official/projects/teams/teams_task.py | 28 +-- official/projects/teams/teams_task_test.py | 4 +- .../classification_data_loader.py | 2 +- .../classification_example.py | 12 +- .../classification_example_test.py | 4 +- official/projects/token_dropping/encoder.py | 46 ++--- .../projects/token_dropping/encoder_config.py | 4 +- .../projects/token_dropping/encoder_test.py | 78 ++++---- official/projects/token_dropping/masked_lm.py | 12 +- .../projects/token_dropping/masked_lm_test.py | 4 +- official/projects/triviaqa/dataset.py | 2 +- official/projects/triviaqa/evaluate.py | 2 +- official/projects/triviaqa/inputs.py | 2 +- official/projects/triviaqa/modeling.py | 26 +-- official/projects/triviaqa/predict.py | 4 +- official/projects/triviaqa/prediction.py | 2 +- official/projects/triviaqa/train.py | 10 +- .../data_conversion/convert.py | 2 +- .../unified_detector/data_conversion/utils.py | 2 +- .../data_loaders/autoaugment.py | 2 +- .../data_loaders/input_reader.py | 2 +- .../data_loaders/tf_example_decoder.py | 2 +- .../universal_detection_parser.py | 2 +- .../external_configurables.py | 4 +- .../modeling/universal_detector.py | 42 ++--- .../unified_detector/run_inference.py | 6 +- .../unified_detector/tasks/ocr_task.py | 14 +- .../projects/unified_detector/utils/typing.py | 2 +- .../unified_detector/utils/utilities.py | 2 +- .../video_ssl/configs/video_ssl_test.py | 2 +- .../video_ssl/dataloaders/video_ssl_input.py | 2 +- .../dataloaders/video_ssl_input_test.py | 2 +- official/projects/video_ssl/losses/losses.py | 2 +- .../video_ssl/modeling/video_ssl_model.py | 32 ++-- .../video_ssl/ops/video_ssl_preprocess_ops.py | 2 +- .../ops/video_ssl_preprocess_ops_test.py | 2 +- .../projects/video_ssl/tasks/linear_eval.py | 8 +- official/projects/video_ssl/tasks/pretrain.py | 14 +- .../projects/video_ssl/tasks/pretrain_test.py | 2 +- .../videoglue/datasets/action_localization.py | 2 +- .../videoglue/datasets/common/processors.py | 2 +- .../videoglue/datasets/common/utils.py | 2 +- .../videoglue/datasets/dataset_factory.py | 2 +- .../datasets/video_classification.py | 2 +- ...otemporal_action_localization_evaluator.py | 2 +- .../videoglue/modeling/backbones/vit_3d.py | 36 ++-- .../modeling/heads/action_transformer.py | 24 +-- .../videoglue/modeling/heads/simple.py | 42 ++--- .../modeling/heads/transformer_decoder.py | 36 ++-- .../video_action_transformer_model.py | 34 ++-- .../modeling/video_classification_model.py | 36 ++-- .../tasks/multihead_video_classification.py | 32 ++-- .../spatiotemporal_action_localization.py | 26 +-- .../videoglue/tools/checkpoint_loader.py | 12 +- .../configs/semantic_segmentation_3d_test.py | 2 +- .../dataloaders/segmentation_input_3d.py | 2 +- .../dataloaders/segmentation_input_3d_test.py | 2 +- .../evaluation/segmentation_metrics.py | 8 +- .../evaluation/segmentation_metrics_test.py | 2 +- .../losses/segmentation_losses.py | 4 +- .../losses/segmentation_losses_test.py | 2 +- .../modeling/backbones/unet_3d.py | 20 +- .../modeling/backbones/unet_3d_test.py | 6 +- .../modeling/decoders/factory.py | 12 +- .../modeling/decoders/factory_test.py | 2 +- .../modeling/decoders/unet_3d_decoder.py | 24 +-- .../modeling/decoders/unet_3d_decoder_test.py | 6 +- .../volumetric_models/modeling/factory.py | 10 +- .../modeling/factory_test.py | 10 +- .../modeling/heads/segmentation_heads_3d.py | 30 +-- .../heads/segmentation_heads_3d_test.py | 2 +- .../modeling/nn_blocks_3d.py | 66 +++---- .../modeling/nn_blocks_3d_test.py | 8 +- .../modeling/segmentation_model_test.py | 4 +- .../serving/semantic_segmentation_3d.py | 6 +- .../serving/semantic_segmentation_3d_test.py | 2 +- .../tasks/semantic_segmentation_3d.py | 38 ++-- .../tasks/semantic_segmentation_3d_test.py | 2 +- .../projects/volumetric_models/train_test.py | 2 +- .../model_inference/postprocessing.py | 2 +- .../model_inference/preprocessing.py | 2 +- .../yolo/dataloaders/classification_input.py | 2 +- .../yolo/dataloaders/tf_example_decoder.py | 2 +- .../projects/yolo/dataloaders/yolo_input.py | 2 +- official/projects/yolo/losses/yolo_loss.py | 8 +- .../projects/yolo/losses/yolo_loss_test.py | 4 +- official/projects/yolo/losses/yolov7_loss.py | 10 +- .../projects/yolo/losses/yolov7_loss_test.py | 2 +- .../yolo/modeling/backbones/darknet.py | 18 +- .../yolo/modeling/backbones/darknet_test.py | 14 +- .../yolo/modeling/backbones/yolov7.py | 24 +-- .../yolo/modeling/backbones/yolov7_test.py | 8 +- .../yolo/modeling/decoders/yolo_decoder.py | 32 ++-- .../modeling/decoders/yolo_decoder_test.py | 10 +- .../projects/yolo/modeling/decoders/yolov7.py | 22 +-- .../yolo/modeling/decoders/yolov7_test.py | 8 +- .../projects/yolo/modeling/factory_test.py | 10 +- .../projects/yolo/modeling/heads/yolo_head.py | 10 +- .../yolo/modeling/heads/yolo_head_test.py | 6 +- .../yolo/modeling/heads/yolov7_head.py | 18 +- .../yolo/modeling/heads/yolov7_head_test.py | 6 +- .../modeling/layers/detection_generator.py | 4 +- .../layers/detection_generator_test.py | 4 +- .../yolo/modeling/layers/nn_blocks.py | 84 ++++----- .../yolo/modeling/layers/nn_blocks_test.py | 50 ++--- official/projects/yolo/modeling/yolo_model.py | 10 +- .../projects/yolo/modeling/yolov7_model.py | 10 +- official/projects/yolo/ops/anchor.py | 2 +- official/projects/yolo/ops/box_ops.py | 2 +- official/projects/yolo/ops/box_ops_test.py | 2 +- official/projects/yolo/ops/initializer_ops.py | 4 +- official/projects/yolo/ops/kmeans_anchors.py | 2 +- .../projects/yolo/ops/kmeans_anchors_test.py | 2 +- official/projects/yolo/ops/loss_utils.py | 8 +- official/projects/yolo/ops/math_ops.py | 2 +- official/projects/yolo/ops/mosaic.py | 2 +- .../projects/yolo/ops/preprocessing_ops.py | 2 +- .../yolo/ops/preprocessing_ops_test.py | 2 +- .../optimization/configs/optimizer_config.py | 2 +- .../yolo/optimization/optimizer_factory.py | 2 +- .../projects/yolo/optimization/sgd_torch.py | 6 +- .../yolo/serving/export_module_factory.py | 10 +- official/projects/yolo/serving/model_fn.py | 2 +- official/projects/yolo/tasks/task_utils.py | 4 +- official/projects/yolo/tasks/yolo.py | 12 +- official/projects/yolo/tasks/yolov7.py | 12 +- official/projects/yt8m/configs/yt8m_test.py | 2 +- official/projects/yt8m/dataloaders/utils.py | 2 +- .../projects/yt8m/dataloaders/yt8m_input.py | 2 +- .../yt8m/dataloaders/yt8m_input_test.py | 2 +- .../projects/yt8m/eval_utils/eval_util.py | 2 +- .../yt8m/eval_utils/eval_util_test.py | 2 +- .../projects/yt8m/modeling/backbones/dbof.py | 16 +- .../yt8m/modeling/backbones/dbof_test.py | 4 +- .../projects/yt8m/modeling/heads/logistic.py | 6 +- official/projects/yt8m/modeling/heads/moe.py | 6 +- official/projects/yt8m/modeling/nn_layers.py | 14 +- .../projects/yt8m/modeling/nn_layers_test.py | 4 +- official/projects/yt8m/modeling/yt8m_model.py | 14 +- .../projects/yt8m/modeling/yt8m_model_test.py | 4 +- .../yt8m/modeling/yt8m_model_utils.py | 2 +- .../yt8m/modeling/yt8m_model_utils_test.py | 2 +- official/projects/yt8m/tasks/yt8m_task.py | 18 +- official/projects/yt8m/train_test.py | 2 +- official/recommendation/create_ncf_data.py | 2 +- official/recommendation/data_pipeline.py | 2 +- official/recommendation/data_preprocessing.py | 2 +- official/recommendation/data_test.py | 2 +- official/recommendation/movielens.py | 2 +- official/recommendation/ncf_common.py | 2 +- official/recommendation/ncf_input_pipeline.py | 2 +- official/recommendation/ncf_keras_main.py | 42 ++--- official/recommendation/ncf_test.py | 2 +- official/recommendation/neumf_model.py | 38 ++-- official/recommendation/ranking/common.py | 6 +- .../ranking/configs/config_test.py | 2 +- .../ranking/data/data_pipeline.py | 2 +- .../ranking/data/data_pipeline_test.py | 2 +- .../preprocessing/criteo_preprocess.py | 2 +- .../ranking/preprocessing/shard_rebalancer.py | 2 +- official/recommendation/ranking/task.py | 22 +-- official/recommendation/ranking/task_test.py | 2 +- official/recommendation/ranking/train.py | 4 +- official/recommendation/ranking/train_test.py | 2 +- official/requirements.txt | 1 + official/utils/docs/build_orbit_api_docs.py | 6 +- official/utils/docs/build_tfm_api_docs.py | 6 +- official/utils/flags/_base.py | 2 +- official/utils/flags/_distribution.py | 2 +- official/utils/flags/_performance.py | 4 +- official/utils/flags/flags_test.py | 2 +- official/utils/misc/keras_utils.py | 6 +- official/utils/misc/model_helpers.py | 2 +- official/utils/misc/model_helpers_test.py | 2 +- official/utils/testing/mock_task.py | 16 +- .../configs/image_classification_test.py | 2 +- official/vision/configs/maskrcnn_test.py | 2 +- official/vision/configs/retinanet_test.py | 2 +- .../configs/semantic_segmentation_test.py | 2 +- .../configs/video_classification_test.py | 2 +- official/vision/data/create_coco_tf_record.py | 2 +- official/vision/data/image_utils_test.py | 2 +- .../data/process_coco_few_shot_json_files.py | 2 +- .../vision/data/tf_example_builder_test.py | 2 +- official/vision/data/tfrecord_lib.py | 2 +- official/vision/data/tfrecord_lib_test.py | 4 +- .../dataloaders/classification_input.py | 2 +- official/vision/dataloaders/input_reader.py | 2 +- official/vision/dataloaders/maskrcnn_input.py | 2 +- .../vision/dataloaders/retinanet_input.py | 2 +- .../vision/dataloaders/segmentation_input.py | 2 +- .../vision/dataloaders/tf_example_decoder.py | 2 +- .../dataloaders/tf_example_decoder_test.py | 2 +- .../tf_example_label_map_decoder.py | 2 +- .../tf_example_label_map_decoder_test.py | 2 +- .../tfds_classification_decoders.py | 2 +- .../dataloaders/tfds_detection_decoders.py | 2 +- .../vision/dataloaders/tfds_factory_test.py | 2 +- .../dataloaders/tfds_segmentation_decoders.py | 2 +- .../vision/dataloaders/tfexample_utils.py | 2 +- official/vision/dataloaders/utils.py | 2 +- official/vision/dataloaders/utils_test.py | 2 +- official/vision/dataloaders/video_input.py | 2 +- .../vision/dataloaders/video_input_test.py | 2 +- official/vision/evaluation/coco_evaluator.py | 2 +- official/vision/evaluation/coco_utils.py | 2 +- official/vision/evaluation/coco_utils_test.py | 2 +- .../vision/evaluation/instance_metrics.py | 8 +- .../evaluation/instance_metrics_test.py | 2 +- official/vision/evaluation/iou.py | 8 +- official/vision/evaluation/iou_test.py | 2 +- .../vision/evaluation/panoptic_quality.py | 4 +- .../evaluation/panoptic_quality_evaluator.py | 2 +- .../panoptic_quality_evaluator_test.py | 2 +- .../evaluation/panoptic_quality_test.py | 2 +- .../vision/evaluation/segmentation_metrics.py | 6 +- .../evaluation/segmentation_metrics_test.py | 2 +- .../evaluation/wod_detection_evaluator.py | 2 +- .../vision/examples/starter/example_input.py | 2 +- .../vision/examples/starter/example_model.py | 30 +-- .../vision/examples/starter/example_task.py | 36 ++-- official/vision/losses/focal_loss.py | 8 +- official/vision/losses/loss_utils.py | 2 +- official/vision/losses/maskrcnn_losses.py | 18 +- .../vision/losses/maskrcnn_losses_test.py | 2 +- official/vision/losses/retinanet_losses.py | 18 +- official/vision/losses/segmentation_losses.py | 6 +- .../vision/losses/segmentation_losses_test.py | 2 +- .../vision/modeling/backbones/efficientnet.py | 30 +-- .../modeling/backbones/efficientnet_test.py | 16 +- official/vision/modeling/backbones/factory.py | 18 +- .../vision/modeling/backbones/factory_test.py | 16 +- .../vision/modeling/backbones/mobiledet.py | 30 +-- .../modeling/backbones/mobiledet_test.py | 12 +- .../vision/modeling/backbones/mobilenet.py | 50 ++--- .../modeling/backbones/mobilenet_test.py | 22 +-- official/vision/modeling/backbones/resnet.py | 32 ++-- .../vision/modeling/backbones/resnet_3d.py | 38 ++-- .../modeling/backbones/resnet_3d_test.py | 6 +- .../modeling/backbones/resnet_deeplab.py | 30 +-- .../modeling/backbones/resnet_deeplab_test.py | 18 +- .../vision/modeling/backbones/resnet_test.py | 18 +- official/vision/modeling/backbones/revnet.py | 32 ++-- .../vision/modeling/backbones/revnet_test.py | 12 +- .../vision/modeling/backbones/spinenet.py | 28 +-- .../modeling/backbones/spinenet_mobile.py | 30 +-- .../backbones/spinenet_mobile_test.py | 8 +- .../modeling/backbones/spinenet_test.py | 12 +- official/vision/modeling/backbones/vit.py | 16 +- .../vision/modeling/backbones/vit_test.py | 20 +- .../vision/modeling/classification_model.py | 40 ++-- .../modeling/classification_model_test.py | 20 +- official/vision/modeling/decoders/aspp.py | 18 +- .../vision/modeling/decoders/aspp_test.py | 6 +- official/vision/modeling/decoders/factory.py | 14 +- .../vision/modeling/decoders/factory_test.py | 2 +- official/vision/modeling/decoders/fpn.py | 36 ++-- official/vision/modeling/decoders/fpn_test.py | 10 +- official/vision/modeling/decoders/nasfpn.py | 42 ++--- .../vision/modeling/decoders/nasfpn_test.py | 6 +- official/vision/modeling/factory.py | 40 ++-- official/vision/modeling/factory_3d.py | 18 +- official/vision/modeling/factory_test.py | 18 +- .../modeling/heads/dense_prediction_heads.py | 60 +++--- .../heads/dense_prediction_heads_test.py | 2 +- .../vision/modeling/heads/instance_heads.py | 76 ++++---- .../modeling/heads/instance_heads_test.py | 2 +- .../modeling/heads/segmentation_heads.py | 62 +++--- .../modeling/heads/segmentation_heads_test.py | 2 +- .../vision/modeling/layers/box_sampler.py | 6 +- official/vision/modeling/layers/deeplab.py | 58 +++--- .../vision/modeling/layers/deeplab_test.py | 6 +- .../modeling/layers/detection_generator.py | 10 +- .../layers/detection_generator_test.py | 2 +- official/vision/modeling/layers/edgetpu.py | 2 +- .../vision/modeling/layers/edgetpu_test.py | 8 +- .../vision/modeling/layers/mask_sampler.py | 6 +- official/vision/modeling/layers/nn_blocks.py | 178 +++++++++--------- .../vision/modeling/layers/nn_blocks_3d.py | 34 ++-- .../modeling/layers/nn_blocks_3d_test.py | 4 +- .../vision/modeling/layers/nn_blocks_test.py | 82 ++++---- official/vision/modeling/layers/nn_layers.py | 140 +++++++------- .../vision/modeling/layers/nn_layers_test.py | 16 +- .../vision/modeling/layers/roi_aligner.py | 6 +- .../modeling/layers/roi_aligner_test.py | 2 +- .../vision/modeling/layers/roi_generator.py | 6 +- .../vision/modeling/layers/roi_sampler.py | 6 +- official/vision/modeling/maskrcnn_model.py | 38 ++-- .../vision/modeling/maskrcnn_model_test.py | 8 +- official/vision/modeling/retinanet_model.py | 28 +-- .../vision/modeling/retinanet_model_test.py | 4 +- .../vision/modeling/segmentation_model.py | 16 +- .../modeling/segmentation_model_test.py | 4 +- .../modeling/video_classification_model.py | 38 ++-- .../video_classification_model_test.py | 6 +- official/vision/ops/anchor.py | 2 +- official/vision/ops/anchor_generator.py | 2 +- official/vision/ops/anchor_generator_test.py | 2 +- official/vision/ops/anchor_test.py | 2 +- official/vision/ops/augment.py | 2 +- official/vision/ops/augment_test.py | 2 +- official/vision/ops/box_matcher.py | 2 +- official/vision/ops/box_matcher_test.py | 2 +- official/vision/ops/box_ops.py | 2 +- official/vision/ops/iou_similarity.py | 2 +- official/vision/ops/iou_similarity_test.py | 2 +- official/vision/ops/mask_ops.py | 2 +- official/vision/ops/mask_ops_test.py | 2 +- official/vision/ops/nms.py | 2 +- official/vision/ops/preprocess_ops.py | 2 +- official/vision/ops/preprocess_ops_3d.py | 2 +- official/vision/ops/preprocess_ops_3d_test.py | 2 +- official/vision/ops/preprocess_ops_test.py | 2 +- official/vision/ops/sampling_ops.py | 2 +- official/vision/ops/spatial_transform_ops.py | 4 +- official/vision/ops/target_gather.py | 2 +- official/vision/ops/target_gather_test.py | 2 +- official/vision/serving/detection.py | 4 +- official/vision/serving/detection_test.py | 2 +- official/vision/serving/export_base.py | 6 +- official/vision/serving/export_base_v2.py | 6 +- .../vision/serving/export_base_v2_test.py | 6 +- .../vision/serving/export_module_factory.py | 4 +- .../serving/export_module_factory_test.py | 4 +- .../vision/serving/export_saved_model_lib.py | 2 +- .../serving/export_saved_model_lib_test.py | 2 +- .../serving/export_saved_model_lib_v2.py | 2 +- official/vision/serving/export_tfhub_lib.py | 8 +- official/vision/serving/export_tflite.py | 2 +- official/vision/serving/export_tflite_lib.py | 4 +- official/vision/serving/export_utils.py | 2 +- .../vision/serving/image_classification.py | 4 +- .../serving/image_classification_test.py | 4 +- .../vision/serving/semantic_segmentation.py | 4 +- .../serving/semantic_segmentation_test.py | 2 +- .../vision/serving/video_classification.py | 2 +- .../serving/video_classification_test.py | 2 +- official/vision/tasks/image_classification.py | 56 +++--- official/vision/tasks/maskrcnn.py | 24 +-- official/vision/tasks/retinanet.py | 32 ++-- .../vision/tasks/semantic_segmentation.py | 26 +-- official/vision/tasks/video_classification.py | 46 ++--- official/vision/train.py | 2 +- official/vision/train_spatial_partitioning.py | 2 +- .../utils/object_detection/argmax_matcher.py | 2 +- .../balanced_positive_negative_sampler.py | 2 +- .../utils/object_detection/box_coder.py | 2 +- .../vision/utils/object_detection/box_list.py | 2 +- .../utils/object_detection/box_list_ops.py | 2 +- .../object_detection/faster_rcnn_box_coder.py | 2 +- .../vision/utils/object_detection/matcher.py | 2 +- .../object_detection/minibatch_sampler.py | 2 +- official/vision/utils/object_detection/ops.py | 2 +- .../utils/object_detection/preprocessor.py | 2 +- .../region_similarity_calculator.py | 2 +- .../utils/object_detection/shape_utils.py | 2 +- .../utils/object_detection/target_assigner.py | 2 +- .../object_detection/visualization_utils.py | 2 +- official/vision/utils/ops_test.py | 2 +- official/vision/utils/summary_manager.py | 2 +- orbit/actions/conditional_action.py | 2 +- orbit/actions/conditional_action_test.py | 2 +- orbit/actions/export_saved_model.py | 2 +- orbit/actions/export_saved_model_test.py | 2 +- orbit/actions/new_best_metric.py | 2 +- orbit/actions/new_best_metric_test.py | 2 +- orbit/actions/save_checkpoint_if_preempted.py | 2 +- orbit/controller.py | 2 +- orbit/controller_test.py | 36 ++-- .../single_task/single_task_evaluator.py | 8 +- .../single_task/single_task_evaluator_test.py | 18 +- .../single_task/single_task_trainer.py | 18 +- .../single_task/single_task_trainer_test.py | 18 +- orbit/runner.py | 2 +- orbit/standard_runner.py | 2 +- orbit/standard_runner_test.py | 2 +- orbit/utils/common.py | 2 +- orbit/utils/common_test.py | 2 +- orbit/utils/epoch_helper.py | 2 +- orbit/utils/loop_fns.py | 2 +- orbit/utils/summary_manager.py | 2 +- orbit/utils/tpu_summaries.py | 2 +- orbit/utils/tpu_summaries_test.py | 2 +- tensorflow_models/tensorflow_models_test.py | 2 +- 1136 files changed, 7221 insertions(+), 7220 deletions(-) diff --git a/official/common/dataset_fn.py b/official/common/dataset_fn.py index 5d9fec97340..420099abd37 100644 --- a/official/common/dataset_fn.py +++ b/official/common/dataset_fn.py @@ -31,7 +31,7 @@ import functools from typing import Any, Callable, Type, Union -import tensorflow as tf +import tensorflow as tf, tf_keras PossibleDatasetType = Union[Type[tf.data.Dataset], Callable[[tf.Tensor], Any]] diff --git a/official/common/distribute_utils.py b/official/common/distribute_utils.py index 58d63038853..35841ff4587 100644 --- a/official/common/distribute_utils.py +++ b/official/common/distribute_utils.py @@ -16,7 +16,7 @@ import json import os -import tensorflow as tf +import tensorflow as tf, tf_keras def _collective_communication(all_reduce_alg): diff --git a/official/common/distribute_utils_test.py b/official/common/distribute_utils_test.py index 50df03579ae..1f510f808c2 100644 --- a/official/common/distribute_utils_test.py +++ b/official/common/distribute_utils_test.py @@ -15,7 +15,7 @@ """Tests for distribution util functions.""" import sys -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils diff --git a/official/core/actions.py b/official/core/actions.py index 5a092b8a46a..d5555614f77 100644 --- a/official/core/actions.py +++ b/official/core/actions.py @@ -20,7 +20,7 @@ import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_trainer from official.core import config_definitions @@ -39,16 +39,16 @@ class PruningAction: def __init__( self, export_dir: str, - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, ): """Initializes the instance. Args: export_dir: `str` for the export directory of the pruning summaries. - model: `tf.keras.Model` model instance used for training. This will be + model: `tf_keras.Model` model instance used for training. This will be used to assign a pruning step to each prunable weight. - optimizer: `tf.keras.optimizers.Optimizer` optimizer instance used for + optimizer: `tf_keras.optimizers.Optimizer` optimizer instance used for training. This will be used to find the current training steps. """ # TODO(b/221490190): Avoid local import when the bug is fixed. @@ -84,14 +84,14 @@ class EMACheckpointing: def __init__(self, export_dir: str, - optimizer: tf.keras.optimizers.Optimizer, + optimizer: tf_keras.optimizers.Optimizer, checkpoint: tf.train.Checkpoint, max_to_keep: int = 1): """Initializes the instance. Args: export_dir: `str` for the export directory of the EMA average weights. - optimizer: `tf.keras.optimizers.Optimizer` optimizer instance used for + optimizer: `tf_keras.optimizers.Optimizer` optimizer instance used for training. This will be used to swap the model weights with the average weigths. checkpoint: `tf.train.Checkpoint` instance. diff --git a/official/core/actions_test.py b/official/core/actions_test.py index bfba63bd72c..6d5ee54501f 100644 --- a/official/core/actions_test.py +++ b/official/core/actions_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import numpy as np import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -27,12 +27,12 @@ from official.modeling import optimization -class TestModel(tf.keras.Model): +class TestModel(tf_keras.Model): def __init__(self): super().__init__() self.value = tf.Variable(0.0) - self.dense = tf.keras.layers.Dense(2) + self.dense = tf_keras.layers.Dense(2) _ = self.dense(tf.zeros((2, 2), tf.float32)) def call(self, x, training=None): @@ -51,7 +51,7 @@ def test_ema_checkpointing(self, distribution): with distribution.scope(): directory = self.create_tempdir() model = TestModel() - optimizer = tf.keras.optimizers.SGD() + optimizer = tf_keras.optimizers.SGD() optimizer = optimization.ExponentialMovingAverage( optimizer, trainable_weights_only=False) @@ -81,7 +81,7 @@ def test_ema_checkpointing(self, distribution): # Raises an error for a normal optimizer. with self.assertRaisesRegex(ValueError, 'Optimizer has to be instance of.*'): - _ = actions.EMACheckpointing(directory, tf.keras.optimizers.SGD(), + _ = actions.EMACheckpointing(directory, tf_keras.optimizers.SGD(), checkpoint) @combinations.generate( @@ -121,7 +121,7 @@ def test_pruning(self, distribution): with distribution.scope(): directory = self.get_temp_dir() model = TestModel() - optimizer = tf.keras.optimizers.SGD() + optimizer = tf_keras.optimizers.SGD() pruning = actions.PruningAction(directory, model, optimizer) pruning({}) diff --git a/official/core/base_task.py b/official/core/base_task.py index a88df37afe0..fb95b1f3ca0 100644 --- a/official/core/base_task.py +++ b/official/core/base_task.py @@ -18,7 +18,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions from official.modeling import optimization @@ -110,7 +110,7 @@ def create_optimizer(cls, optimizer_config: OptimizationConfig, return optimizer - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """[Optional] A callback function used as CheckpointManager's init_fn. This function will be called when no checkpoint is found for the model. @@ -141,7 +141,7 @@ def initialize(self, model: tf.keras.Model): logging.info("Finished loading pretrained checkpoint from %s", ckpt_dir_or_file) - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """[Optional] Creates model architecture. Returns: @@ -222,8 +222,8 @@ def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): def train_step(self, inputs, - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics=None): """Does forward and backward. @@ -260,14 +260,14 @@ def train_step(self, # For mixed precision, when a LossScaleOptimizer is used, the loss is # scaled to avoid numeric underflow. if isinstance(optimizer, - tf.keras.mixed_precision.LossScaleOptimizer): + tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) if isinstance(optimizer, - tf.keras.mixed_precision.LossScaleOptimizer): + tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) logs = {self.loss: loss} @@ -279,7 +279,7 @@ def train_step(self, logs.update({m.name: m.result() for m in model.metrics}) return logs - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): """Validation step. With distribution strategies, this method runs on devices. @@ -308,7 +308,7 @@ def validation_step(self, inputs, model: tf.keras.Model, metrics=None): logs.update({m.name: m.result() for m in model.metrics}) return logs - def inference_step(self, inputs, model: tf.keras.Model): + def inference_step(self, inputs, model: tf_keras.Model): """Performs the forward step. With distribution strategies, this method runs on devices. diff --git a/official/core/base_trainer.py b/official/core/base_trainer.py index ba436fd85c6..0d8c7821700 100644 --- a/official/core/base_trainer.py +++ b/official/core/base_trainer.py @@ -23,7 +23,7 @@ from absl import logging import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions @@ -142,7 +142,7 @@ def __init__( self, config: ExperimentConfig, task: base_task.Task, - model: tf.keras.Model, + model: tf_keras.Model, optimizer: tf.optimizers.Optimizer, train: bool = True, evaluate: bool = True, @@ -156,7 +156,7 @@ def __init__( Args: config: An `ExperimentConfig` instance specifying experiment config. task: A base_task.Task instance. - model: The model instance, e.g. a tf.keras.Model instance. + model: The model instance, e.g. a tf_keras.Model instance. optimizer: tf.optimizers.Optimizer instance. train: bool, whether or not this trainer will be used for training. default to True. @@ -207,8 +207,8 @@ def __init__( optimizer=self.optimizer, **checkpoint_items) - self._train_loss = tf.keras.metrics.Mean("training_loss", dtype=tf.float32) - self._validation_loss = tf.keras.metrics.Mean( + self._train_loss = tf_keras.metrics.Mean("training_loss", dtype=tf.float32) + self._validation_loss = tf_keras.metrics.Mean( "validation_loss", dtype=tf.float32) model_metrics = model.metrics if hasattr(model, "metrics") else [] diff --git a/official/core/base_trainer_test.py b/official/core/base_trainer_test.py index 9d3316ea3f7..1290cb4880c 100644 --- a/official/core/base_trainer_test.py +++ b/official/core/base_trainer_test.py @@ -22,7 +22,7 @@ from absl.testing import parameterized import orbit import portpicker -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -312,7 +312,7 @@ def test_configure_optimizer(self, mixed_precision_dtype, loss_scale): trainer = self.create_test_trainer(config) if mixed_precision_dtype == 'float16': self.assertIsInstance(trainer.optimizer, - tf.keras.mixed_precision.LossScaleOptimizer) + tf_keras.mixed_precision.LossScaleOptimizer) if loss_scale in (None, 'dynamic'): self.assertTrue(trainer.optimizer.dynamic) else: @@ -321,7 +321,7 @@ def test_configure_optimizer(self, mixed_precision_dtype, loss_scale): else: self.assertIsInstance( trainer.optimizer, - (tf.keras.optimizers.SGD, tf.keras.optimizers.legacy.SGD)) + (tf_keras.optimizers.SGD, tf_keras.optimizers.legacy.SGD)) metrics = trainer.train(tf.convert_to_tensor(5, dtype=tf.int32)) self.assertIn('training_loss', metrics) @@ -349,7 +349,7 @@ def test_export_best_ckpt(self): def test_model_with_compiled_loss(self): task = mock_task.MockTask() model = task.build_model() - model.compile(loss=tf.keras.losses.CategoricalCrossentropy()) + model.compile(loss=tf_keras.losses.CategoricalCrossentropy()) trainer = trainer_lib.Trainer( self._config, task, diff --git a/official/core/export_base.py b/official/core/export_base.py index 194f9b08d5a..b6166878cd8 100644 --- a/official/core/export_base.py +++ b/official/core/export_base.py @@ -20,7 +20,7 @@ from typing import Any, Callable, Dict, Mapping, List, Optional, Text, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras MAX_DIRECTORY_CREATION_ATTEMPTS = 10 @@ -30,7 +30,7 @@ class ExportModule(tf.Module, metaclass=abc.ABCMeta): def __init__(self, params, - model: Union[tf.Module, tf.keras.Model], + model: Union[tf.Module, tf_keras.Model], inference_step: Optional[Callable[..., Any]] = None, *, preprocessor: Optional[Callable[..., Any]] = None, @@ -68,7 +68,7 @@ def _inference_step(inputs, model=None): if inference_step is not None: self.inference_step = functools.partial(inference_step, model=self.model) else: - if issubclass(type(model), tf.keras.Model): + if issubclass(type(model), tf_keras.Model): # Default to self.model.call instead of self.model.__call__ to avoid # keras tracing logic designed for training. # Since most of Model Garden's call doesn't not have training kwargs diff --git a/official/core/export_base_test.py b/official/core/export_base_test.py index 3f9dc06a3ce..f968735614f 100644 --- a/official/core/export_base_test.py +++ b/official/core/export_base_test.py @@ -16,7 +16,7 @@ import os from typing import Any, Dict, Mapping, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import export_base @@ -41,7 +41,7 @@ class ExportBaseTest(tf.test.TestCase): def test_export_module(self): tmp_dir = self.get_temp_dir() - model = tf.keras.layers.Dense(2) + model = tf_keras.layers.Dense(2) inputs = tf.ones([2, 4], tf.float32) expected_output = model(inputs, training=False) module = TestModule(params=None, model=model) @@ -67,7 +67,7 @@ def test_export_module(self): def test_custom_inference_step(self): tmp_dir = self.get_temp_dir() - model = tf.keras.layers.Dense(2) + model = tf_keras.layers.Dense(2) inputs = tf.ones([2, 4], tf.float32) def _inference_step(inputs, model): diff --git a/official/core/file_writers.py b/official/core/file_writers.py index 7dc1bb47282..a23d5d2e8ad 100644 --- a/official/core/file_writers.py +++ b/official/core/file_writers.py @@ -17,7 +17,7 @@ import io from typing import Optional, Sequence, Union -import tensorflow as tf +import tensorflow as tf, tf_keras def write_small_dataset(examples: Sequence[Union[tf.train.Example, diff --git a/official/core/file_writers_test.py b/official/core/file_writers_test.py index fa32f1aaaf1..50c472bbd5c 100644 --- a/official/core/file_writers_test.py +++ b/official/core/file_writers_test.py @@ -16,7 +16,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import file_writers from official.core import tf_example_builder diff --git a/official/core/input_reader.py b/official/core/input_reader.py index 25a0ff19008..356779e5e5a 100644 --- a/official/core/input_reader.py +++ b/official/core/input_reader.py @@ -18,7 +18,7 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Text, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.core import config_definitions as cfg diff --git a/official/core/registry_test.py b/official/core/registry_test.py index dfe7a6ddc25..cbae9dc3232 100644 --- a/official/core/registry_test.py +++ b/official/core/registry_test.py @@ -14,7 +14,7 @@ """Tests for registry.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import registry diff --git a/official/core/savedmodel_checkpoint_manager.py b/official/core/savedmodel_checkpoint_manager.py index d8a675687cc..b3b958b83f9 100644 --- a/official/core/savedmodel_checkpoint_manager.py +++ b/official/core/savedmodel_checkpoint_manager.py @@ -20,7 +20,7 @@ from typing import Callable, List, Mapping, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras SAVED_MODULES_PATH_SUFFIX = 'saved_modules' diff --git a/official/core/savedmodel_checkpoint_manager_test.py b/official/core/savedmodel_checkpoint_manager_test.py index 77a59e4962e..56ca19d7950 100644 --- a/official/core/savedmodel_checkpoint_manager_test.py +++ b/official/core/savedmodel_checkpoint_manager_test.py @@ -16,7 +16,7 @@ import time from typing import Iterable -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import savedmodel_checkpoint_manager @@ -31,10 +31,10 @@ def _models_exist(checkpoint_path: str, models: Iterable[str]) -> bool: return True -class _ModelForTest(tf.keras.Model): +class _ModelForTest(tf_keras.Model): def __init__(self, hidden_size: int = 8): super().__init__() - self.dense = tf.keras.layers.Dense(hidden_size) + self.dense = tf_keras.layers.Dense(hidden_size) @tf.function(input_signature=[tf.TensorSpec([None, 16])]) def call(self, inputs): diff --git a/official/core/test_utils.py b/official/core/test_utils.py index 0552a6a393a..266702e69fb 100644 --- a/official/core/test_utils.py +++ b/official/core/test_utils.py @@ -14,16 +14,16 @@ """Utils for testing.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -class FakeKerasModel(tf.keras.Model): +class FakeKerasModel(tf_keras.Model): """Fake keras model for testing.""" def __init__(self): super().__init__() - self.dense = tf.keras.layers.Dense(4, activation=tf.nn.relu) - self.dense2 = tf.keras.layers.Dense(4, activation=tf.nn.relu) + self.dense = tf_keras.layers.Dense(4, activation=tf.nn.relu) + self.dense2 = tf_keras.layers.Dense(4, activation=tf.nn.relu) def call(self, inputs): # pytype: disable=signature-mismatch # overriding-parameter-count-checks return self.dense2(self.dense(inputs)) diff --git a/official/core/tf_example_builder.py b/official/core/tf_example_builder.py index a2e7be134e9..2be1ca2b9c3 100644 --- a/official/core/tf_example_builder.py +++ b/official/core/tf_example_builder.py @@ -20,7 +20,7 @@ from typing import Mapping, Sequence, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras BytesValueType = Union[bytes, Sequence[bytes], str, Sequence[str]] diff --git a/official/core/tf_example_builder_test.py b/official/core/tf_example_builder_test.py index 2617de60d99..b26ef544373 100644 --- a/official/core/tf_example_builder_test.py +++ b/official/core/tf_example_builder_test.py @@ -19,7 +19,7 @@ """ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import tf_example_builder diff --git a/official/core/train_lib.py b/official/core/train_lib.py index c03af327145..37bc051e8bf 100644 --- a/official/core/train_lib.py +++ b/official/core/train_lib.py @@ -22,7 +22,7 @@ from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import actions from official.core import base_task @@ -252,12 +252,12 @@ def _build_controller( ) return controller - def run(self) -> Tuple[tf.keras.Model, Mapping[str, Any]]: + def run(self) -> Tuple[tf_keras.Model, Mapping[str, Any]]: """Run experiments by mode. Returns: A 2-tuple of (model, eval_logs). - model: `tf.keras.Model` instance. + model: `tf_keras.Model` instance. eval_logs: returns eval metrics logs when run_post_eval is set to True, otherwise, returns {}. """ @@ -321,7 +321,7 @@ def run_experiment( summary_manager: Optional[orbit.utils.SummaryManager] = None, eval_summary_manager: Optional[orbit.utils.SummaryManager] = None, enable_async_checkpointing: bool = False, -) -> Tuple[tf.keras.Model, Mapping[str, Any]]: +) -> Tuple[tf_keras.Model, Mapping[str, Any]]: """Runs train/eval configured by the experiment params. Args: @@ -349,7 +349,7 @@ def run_experiment( Returns: A 2-tuple of (model, eval_logs). - model: `tf.keras.Model` instance. + model: `tf_keras.Model` instance. eval_logs: returns eval metrics logs when run_post_eval is set to True, otherwise, returns {}. """ diff --git a/official/core/train_lib_test.py b/official/core/train_lib_test.py index eebac1a6079..b77fde2ca69 100644 --- a/official/core/train_lib_test.py +++ b/official/core/train_lib_test.py @@ -20,7 +20,7 @@ from absl.testing import flagsaver from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/core/train_utils.py b/official/core/train_utils.py index cd4c501c36c..984ac319d50 100644 --- a/official/core/train_utils.py +++ b/official/core/train_utils.py @@ -25,7 +25,7 @@ import gin import numpy as np import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import from tensorflow.python.framework import ops @@ -243,7 +243,7 @@ def best_ckpt_path(self): def create_optimizer(task: base_task.Task, params: config_definitions.ExperimentConfig - ) -> tf.keras.optimizers.Optimizer: + ) -> tf_keras.optimizers.Optimizer: """A create optimizer util to be backward compatability with new args.""" if 'dp_config' in inspect.signature(task.create_optimizer).parameters: dp_config = None @@ -471,7 +471,7 @@ def remove_ckpts(model_dir): tf.io.gfile.remove(file_to_remove) -def write_model_params(model: Union[tf.Module, tf.keras.Model], +def write_model_params(model: Union[tf.Module, tf_keras.Model], output_path: str) -> None: """Writes the model parameters and shapes to a file. @@ -489,7 +489,7 @@ def write_model_params(model: Union[tf.Module, tf.keras.Model], def try_count_params( - model: Union[tf.Module, tf.keras.Model], + model: Union[tf.Module, tf_keras.Model], trainable_only: bool = False): """Count the number of parameters if model is possible. @@ -519,7 +519,7 @@ def try_count_params( return total_params -def try_count_flops(model: Union[tf.Module, tf.keras.Model], +def try_count_flops(model: Union[tf.Module, tf_keras.Model], inputs_kwargs: Optional[Dict[str, Any]] = None, output_path: Optional[str] = None): """Counts and returns model FLOPs. diff --git a/official/core/train_utils_test.py b/official/core/train_utils_test.py index 1be26e668c7..807e95cbf24 100644 --- a/official/core/train_utils_test.py +++ b/official/core/train_utils_test.py @@ -18,7 +18,7 @@ import pprint import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.core import test_utils diff --git a/official/legacy/bert/bert_models.py b/official/legacy/bert/bert_models.py index 75e33b07edf..59560d8412e 100644 --- a/official/legacy/bert/bert_models.py +++ b/official/legacy/bert/bert_models.py @@ -15,7 +15,7 @@ """BERT models that are compatible with TF 2.0.""" import gin -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.legacy.albert import configs as albert_configs from official.legacy.bert import configs @@ -24,7 +24,7 @@ from official.nlp.modeling import networks -class BertPretrainLossAndMetricLayer(tf.keras.layers.Layer): +class BertPretrainLossAndMetricLayer(tf_keras.layers.Layer): """Returns layer that computes custom loss and metrics for pretraining.""" def __init__(self, vocab_size, **kwargs): @@ -38,7 +38,7 @@ def _add_metrics(self, lm_output, lm_labels, lm_label_weights, lm_example_loss, sentence_output, sentence_labels, next_sentence_loss): """Adds metrics.""" - masked_lm_accuracy = tf.keras.metrics.sparse_categorical_accuracy( + masked_lm_accuracy = tf_keras.metrics.sparse_categorical_accuracy( lm_labels, lm_output) numerator = tf.reduce_sum(masked_lm_accuracy * lm_label_weights) denominator = tf.reduce_sum(lm_label_weights) + 1e-5 @@ -49,7 +49,7 @@ def _add_metrics(self, lm_output, lm_labels, lm_label_weights, self.add_metric(lm_example_loss, name='lm_example_loss', aggregation='mean') if sentence_labels is not None: - next_sentence_accuracy = tf.keras.metrics.sparse_categorical_accuracy( + next_sentence_accuracy = tf_keras.metrics.sparse_categorical_accuracy( sentence_labels, sentence_output) self.add_metric( next_sentence_accuracy, @@ -70,7 +70,7 @@ def call(self, lm_label_weights = tf.cast(lm_label_weights, tf.float32) lm_output_logits = tf.cast(lm_output_logits, tf.float32) - lm_prediction_losses = tf.keras.losses.sparse_categorical_crossentropy( + lm_prediction_losses = tf_keras.losses.sparse_categorical_crossentropy( lm_label_ids, lm_output_logits, from_logits=True) lm_numerator_loss = tf.reduce_sum(lm_prediction_losses * lm_label_weights) lm_denominator_loss = tf.reduce_sum(lm_label_weights) @@ -79,7 +79,7 @@ def call(self, if sentence_labels is not None: sentence_output_logits = tf.cast(sentence_output_logits, tf.float32) - sentence_loss = tf.keras.losses.sparse_categorical_crossentropy( + sentence_loss = tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_output_logits, from_logits=True) sentence_loss = tf.reduce_mean(sentence_loss) loss = mask_label_loss + sentence_loss @@ -123,7 +123,7 @@ def get_transformer_encoder(bert_config, type_vocab_size=bert_config.type_vocab_size, hidden_size=bert_config.hidden_size, max_seq_length=bert_config.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), dropout_rate=bert_config.hidden_dropout_prob, ) @@ -133,7 +133,7 @@ def get_transformer_encoder(bert_config, intermediate_activation=tf_utils.get_activation(bert_config.hidden_act), dropout_rate=bert_config.hidden_dropout_prob, attention_dropout_rate=bert_config.attention_probs_dropout_prob, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), ) kwargs = dict( @@ -141,7 +141,7 @@ def get_transformer_encoder(bert_config, hidden_cfg=hidden_cfg, num_hidden_instances=bert_config.num_hidden_layers, pooled_output_dim=bert_config.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range)) # Relies on gin configuration to define the Transformer encoder arguments. @@ -159,7 +159,7 @@ def get_transformer_encoder(bert_config, max_sequence_length=bert_config.max_position_embeddings, type_vocab_size=bert_config.type_vocab_size, embedding_width=bert_config.embedding_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range)) if isinstance(bert_config, albert_configs.AlbertConfig): return networks.AlbertEncoder(**kwargs) @@ -192,32 +192,32 @@ def pretrain_model(bert_config, save weights after pretraining, and (3) optional core `BertPretrainer` object if argument `return_core_pretrainer_model` is True. """ - input_word_ids = tf.keras.layers.Input( + input_word_ids = tf_keras.layers.Input( shape=(seq_length,), name='input_word_ids', dtype=tf.int32) - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(seq_length,), name='input_mask', dtype=tf.int32) - input_type_ids = tf.keras.layers.Input( + input_type_ids = tf_keras.layers.Input( shape=(seq_length,), name='input_type_ids', dtype=tf.int32) - masked_lm_positions = tf.keras.layers.Input( + masked_lm_positions = tf_keras.layers.Input( shape=(max_predictions_per_seq,), name='masked_lm_positions', dtype=tf.int32) - masked_lm_ids = tf.keras.layers.Input( + masked_lm_ids = tf_keras.layers.Input( shape=(max_predictions_per_seq,), name='masked_lm_ids', dtype=tf.int32) - masked_lm_weights = tf.keras.layers.Input( + masked_lm_weights = tf_keras.layers.Input( shape=(max_predictions_per_seq,), name='masked_lm_weights', dtype=tf.int32) if use_next_sentence_label: - next_sentence_labels = tf.keras.layers.Input( + next_sentence_labels = tf_keras.layers.Input( shape=(1,), name='next_sentence_labels', dtype=tf.int32) else: next_sentence_labels = None transformer_encoder = get_transformer_encoder(bert_config, seq_length) if initializer is None: - initializer = tf.keras.initializers.TruncatedNormal( + initializer = tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range) pretrainer_model = models.BertPretrainer( network=transformer_encoder, @@ -247,7 +247,7 @@ def pretrain_model(bert_config, if use_next_sentence_label: inputs['next_sentence_labels'] = next_sentence_labels - keras_model = tf.keras.Model(inputs=inputs, outputs=output_loss) + keras_model = tf_keras.Model(inputs=inputs, outputs=output_loss) if return_core_pretrainer_model: return keras_model, transformer_encoder, pretrainer_model else: @@ -274,23 +274,23 @@ def squad_model(bert_config, (2) the core BERT transformer encoder. """ if initializer is None: - initializer = tf.keras.initializers.TruncatedNormal( + initializer = tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range) if not hub_module_url: bert_encoder = get_transformer_encoder(bert_config, max_seq_length) return models.BertSpanLabeler( network=bert_encoder, initializer=initializer), bert_encoder - input_word_ids = tf.keras.layers.Input( + input_word_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_word_ids') - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_mask') - input_type_ids = tf.keras.layers.Input( + input_type_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_type_ids') core_model = hub.KerasLayer(hub_module_url, trainable=hub_module_trainable) pooled_output, sequence_output = core_model( [input_word_ids, input_mask, input_type_ids]) - bert_encoder = tf.keras.Model( + bert_encoder = tf_keras.Model( inputs={ 'input_word_ids': input_word_ids, 'input_mask': input_mask, @@ -330,7 +330,7 @@ def classifier_model(bert_config, if final_layer_initializer is not None: initializer = final_layer_initializer else: - initializer = tf.keras.initializers.TruncatedNormal( + initializer = tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range) if not hub_module_url: @@ -342,21 +342,21 @@ def classifier_model(bert_config, dropout_rate=bert_config.hidden_dropout_prob, initializer=initializer), bert_encoder - input_word_ids = tf.keras.layers.Input( + input_word_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_word_ids') - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_mask') - input_type_ids = tf.keras.layers.Input( + input_type_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_type_ids') bert_model = hub.KerasLayer(hub_module_url, trainable=hub_module_trainable) pooled_output, _ = bert_model([input_word_ids, input_mask, input_type_ids]) - output = tf.keras.layers.Dropout(rate=bert_config.hidden_dropout_prob)( + output = tf_keras.layers.Dropout(rate=bert_config.hidden_dropout_prob)( pooled_output) - output = tf.keras.layers.Dense( + output = tf_keras.layers.Dense( num_labels, kernel_initializer=initializer, name='output')( output) - return tf.keras.Model( + return tf_keras.Model( inputs={ 'input_word_ids': input_word_ids, 'input_mask': input_mask, diff --git a/official/legacy/bert/bert_models_test.py b/official/legacy/bert/bert_models_test.py index 7cd1e0b05da..20ebd8926e2 100644 --- a/official/legacy/bert/bert_models_test.py +++ b/official/legacy/bert/bert_models_test.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import bert_models from official.legacy.bert import configs as bert_configs @@ -43,7 +43,7 @@ def test_pretrain_model(self): max_predictions_per_seq=2, initializer=None, use_next_sentence_label=True) - self.assertIsInstance(model, tf.keras.Model) + self.assertIsInstance(model, tf_keras.Model) self.assertIsInstance(encoder, networks.BertEncoder) # model has one scalar output: loss value. @@ -64,8 +64,8 @@ def test_squad_model(self): initializer=None, hub_module_url=None, hub_module_trainable=None) - self.assertIsInstance(model, tf.keras.Model) - self.assertIsInstance(core_model, tf.keras.Model) + self.assertIsInstance(model, tf_keras.Model) + self.assertIsInstance(core_model, tf_keras.Model) # Expect two output from model: start positions and end positions self.assertIsInstance(model.output, list) @@ -87,8 +87,8 @@ def test_classifier_model(self): final_layer_initializer=None, hub_module_url=None, hub_module_trainable=None) - self.assertIsInstance(model, tf.keras.Model) - self.assertIsInstance(core_model, tf.keras.Model) + self.assertIsInstance(model, tf_keras.Model) + self.assertIsInstance(core_model, tf_keras.Model) # model has one classification output with num_labels=3. self.assertEqual(model.output.shape.as_list(), [None, 3]) diff --git a/official/legacy/bert/common_flags.py b/official/legacy/bert/common_flags.py index dafe415e7a4..4f21a3f59e6 100644 --- a/official/legacy/bert/common_flags.py +++ b/official/legacy/bert/common_flags.py @@ -15,7 +15,7 @@ """Defining common flags used across all BERT models/applications.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.utils import hyperparams_flags from official.utils.flags import core as flags_core diff --git a/official/legacy/bert/configs.py b/official/legacy/bert/configs.py index 6f91bc94a40..402f7de7a22 100644 --- a/official/legacy/bert/configs.py +++ b/official/legacy/bert/configs.py @@ -18,7 +18,7 @@ import json import six -import tensorflow as tf +import tensorflow as tf, tf_keras class BertConfig(object): diff --git a/official/legacy/bert/export_tfhub.py b/official/legacy/bert/export_tfhub.py index 091a92a22bd..3cee3fdfcc5 100644 --- a/official/legacy/bert/export_tfhub.py +++ b/official/legacy/bert/export_tfhub.py @@ -24,7 +24,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import bert_models from official.legacy.bert import configs @@ -45,7 +45,7 @@ "What kind of BERT model to export.") -def create_bert_model(bert_config: configs.BertConfig) -> tf.keras.Model: +def create_bert_model(bert_config: configs.BertConfig) -> tf_keras.Model: """Creates a BERT keras core model from BERT configuration. Args: @@ -55,11 +55,11 @@ def create_bert_model(bert_config: configs.BertConfig) -> tf.keras.Model: A keras model. """ # Adds input layers just as placeholders. - input_word_ids = tf.keras.layers.Input( + input_word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name="input_word_ids") - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name="input_mask") - input_type_ids = tf.keras.layers.Input( + input_type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name="input_type_ids") transformer_encoder = bert_models.get_transformer_encoder( bert_config, sequence_length=None) @@ -67,7 +67,7 @@ def create_bert_model(bert_config: configs.BertConfig) -> tf.keras.Model: [input_word_ids, input_mask, input_type_ids]) # To keep consistent with legacy hub modules, the outputs are # "pooled_output" and "sequence_output". - return tf.keras.Model( + return tf_keras.Model( inputs=[input_word_ids, input_mask, input_type_ids], outputs=[pooled_output, sequence_output]), transformer_encoder @@ -77,7 +77,7 @@ def export_bert_tfhub(bert_config: configs.BertConfig, hub_destination: Text, vocab_file: Text, do_lower_case: bool = None): - """Restores a tf.keras.Model and saves for TF-Hub.""" + """Restores a tf_keras.Model and saves for TF-Hub.""" # If do_lower_case is not explicit, default to checking whether "uncased" is # in the vocab file name if do_lower_case is None: @@ -99,7 +99,7 @@ def export_bert_squad_tfhub(bert_config: configs.BertConfig, hub_destination: Text, vocab_file: Text, do_lower_case: bool = None): - """Restores a tf.keras.Model for BERT with SQuAD and saves for TF-Hub.""" + """Restores a tf_keras.Model for BERT with SQuAD and saves for TF-Hub.""" # If do_lower_case is not explicit, default to checking whether "uncased" is # in the vocab file name if do_lower_case is None: diff --git a/official/legacy/bert/export_tfhub_test.py b/official/legacy/bert/export_tfhub_test.py index ee9cafcb133..fa8cf2d6735 100644 --- a/official/legacy/bert/export_tfhub_test.py +++ b/official/legacy/bert/export_tfhub_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.legacy.bert import configs @@ -94,9 +94,9 @@ def _dropout_mean_stddev(training, num_runs=20): self.assertGreater(_dropout_mean_stddev(training=True), 1e-3) # Test propagation of seq_length in shape inference. - input_word_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_mask = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_type_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_word_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_mask = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_type_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) pooled_output, sequence_output = hub_layer( [input_word_ids, input_mask, input_type_ids]) self.assertEqual(pooled_output.shape.as_list(), [None, hidden_size]) diff --git a/official/legacy/bert/input_pipeline.py b/official/legacy/bert/input_pipeline.py index 49842b11f8f..fc6ba48ded1 100644 --- a/official/legacy/bert/input_pipeline.py +++ b/official/legacy/bert/input_pipeline.py @@ -14,7 +14,7 @@ """BERT model input pipelines.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def decode_record(record, name_to_features): diff --git a/official/legacy/bert/model_saving_utils.py b/official/legacy/bert/model_saving_utils.py index d669f6626b8..7f833e5ea8f 100644 --- a/official/legacy/bert/model_saving_utils.py +++ b/official/legacy/bert/model_saving_utils.py @@ -17,11 +17,11 @@ import os import typing from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def export_bert_model(model_export_path: typing.Text, - model: tf.keras.Model, + model: tf_keras.Model, checkpoint_dir: typing.Optional[typing.Text] = None, restore_model_using_load_weights: bool = False) -> None: """Export BERT model for serving which does not include the optimizer. @@ -45,8 +45,8 @@ def export_bert_model(model_export_path: typing.Text, """ if not model_export_path: raise ValueError('model_export_path must be specified.') - if not isinstance(model, tf.keras.Model): - raise ValueError('model must be a tf.keras.Model object.') + if not isinstance(model, tf_keras.Model): + raise ValueError('model must be a tf_keras.Model object.') if checkpoint_dir: if restore_model_using_load_weights: diff --git a/official/legacy/bert/model_training_utils.py b/official/legacy/bert/model_training_utils.py index 46cf44f0cda..2a6bb589c7e 100644 --- a/official/legacy/bert/model_training_utils.py +++ b/official/legacy/bert/model_training_utils.py @@ -19,7 +19,7 @@ import tempfile from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.util import deprecation from official.common import distribute_utils from official.modeling import grad_utils @@ -261,7 +261,7 @@ def run_customized_training_loop( total_training_steps = steps_per_epoch * epochs train_iterator = _get_input_iterator(train_input_fn, strategy) - eval_loss_metric = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) + eval_loss_metric = tf_keras.metrics.Mean('training_loss', dtype=tf.float32) with distribute_utils.get_strategy_scope(strategy): # To correctly place the model weights on accelerators, @@ -274,7 +274,7 @@ def run_customized_training_loop( raise ValueError('sub_model_export_name is specified as %s, but ' 'sub_model is None.' % sub_model_export_name) - callback_list = tf.keras.callbacks.CallbackList( + callback_list = tf_keras.callbacks.CallbackList( callbacks=custom_callbacks, model=model) optimizer = model.optimizer @@ -287,7 +287,7 @@ def run_customized_training_loop( checkpoint.read(init_checkpoint).assert_existing_objects_matched() logging.info('Loading from checkpoint file completed') - train_loss_metric = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) + train_loss_metric = tf_keras.metrics.Mean('training_loss', dtype=tf.float32) eval_metrics = metric_fn() if metric_fn else [] if not isinstance(eval_metrics, list): eval_metrics = [eval_metrics] @@ -340,7 +340,7 @@ def _replicated_step(inputs): post_allreduce_callbacks, allreduce_bytes_per_pack) else: - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): with tape: scaled_loss = optimizer.get_scaled_loss(loss) scaled_grads = tape.gradient(scaled_loss, training_vars) diff --git a/official/legacy/bert/model_training_utils_test.py b/official/legacy/bert/model_training_utils_test.py index 998cc09400f..4d44ea785ca 100644 --- a/official/legacy/bert/model_training_utils_test.py +++ b/official/legacy/bert/model_training_utils_test.py @@ -21,7 +21,7 @@ from absl.testing import parameterized from absl.testing.absltest import mock import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -94,16 +94,16 @@ def create_model_fn(input_shape, num_classes, use_float16=False): def _model_fn(): """A one-layer softmax model suitable for testing.""" - input_layer = tf.keras.layers.Input(shape=input_shape) - x = tf.keras.layers.Dense(num_classes, activation='relu')(input_layer) - output_layer = tf.keras.layers.Dense(num_classes, activation='softmax')(x) - sub_model = tf.keras.models.Model(input_layer, x, name='sub_model') - model = tf.keras.models.Model(input_layer, output_layer, name='model') + input_layer = tf_keras.layers.Input(shape=input_shape) + x = tf_keras.layers.Dense(num_classes, activation='relu')(input_layer) + output_layer = tf_keras.layers.Dense(num_classes, activation='softmax')(x) + sub_model = tf_keras.models.Model(input_layer, x, name='sub_model') + model = tf_keras.models.Model(input_layer, output_layer, name='model') model.add_metric( tf.reduce_mean(input_layer), name='mean_input', aggregation='mean') - model.optimizer = tf.keras.optimizers.SGD(learning_rate=0.1, momentum=0.9) + model.optimizer = tf_keras.optimizers.SGD(learning_rate=0.1, momentum=0.9) if use_float16: - model.optimizer = tf.keras.mixed_precision.LossScaleOptimizer( + model.optimizer = tf_keras.mixed_precision.LossScaleOptimizer( model.optimizer) return model, sub_model @@ -112,7 +112,7 @@ def _model_fn(): def metric_fn(): """Gets a tf.keras metric object.""" - return tf.keras.metrics.CategoricalAccuracy(name='accuracy', dtype=tf.float32) + return tf_keras.metrics.CategoricalAccuracy(name='accuracy', dtype=tf.float32) def summaries_with_matching_keyword(keyword, summary_dir): @@ -131,7 +131,7 @@ def check_eventfile_for_keyword(keyword, summary_dir): return any(summaries_with_matching_keyword(keyword, summary_dir)) -class RecordingCallback(tf.keras.callbacks.Callback): +class RecordingCallback(tf_keras.callbacks.Callback): def __init__(self): self.batch_begin = [] # (batch, logs) @@ -165,7 +165,7 @@ def run_training(self, strategy, model_dir, steps_per_loop, run_eagerly): model_training_utils.run_customized_training_loop( strategy=strategy, model_fn=self._model_fn, - loss_fn=tf.keras.losses.categorical_crossentropy, + loss_fn=tf_keras.losses.categorical_crossentropy, model_dir=model_dir, steps_per_epoch=20, steps_per_loop=steps_per_loop, @@ -195,7 +195,7 @@ def test_train_eager_single_step(self, distribution): @combinations.generate(eager_gpu_strategy_combinations()) def test_train_eager_mixed_precision(self, distribution): model_dir = self.create_tempdir().full_path - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') self._model_fn = create_model_fn( input_shape=[128], num_classes=3, use_float16=True) self.run_training( @@ -255,7 +255,7 @@ def test_train_check_callbacks(self, distribution): model_training_utils.run_customized_training_loop( strategy=distribution, model_fn=self._model_fn, - loss_fn=tf.keras.losses.categorical_crossentropy, + loss_fn=tf_keras.losses.categorical_crossentropy, model_dir=model_dir, steps_per_epoch=20, num_eval_per_epoch=4, diff --git a/official/legacy/bert/run_classifier.py b/official/legacy/bert/run_classifier.py index a2a2f29e5b4..125675b2746 100644 --- a/official/legacy/bert/run_classifier.py +++ b/official/legacy/bert/run_classifier.py @@ -24,7 +24,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.bert import bert_models from official.legacy.bert import common_flags @@ -153,11 +153,11 @@ def _get_classifier_model(): use_float16=common_flags.use_float16()) return classifier_model, core_model - # tf.keras.losses objects accept optional sample_weight arguments (eg. coming + # tf_keras.losses objects accept optional sample_weight arguments (eg. coming # from the dataset) to compute weighted loss, as used for the regression # tasks. The classification tasks, using the custom get_loss_fn don't accept # sample weights though. - loss_fn = (tf.keras.losses.MeanSquaredError() if is_regression + loss_fn = (tf_keras.losses.MeanSquaredError() if is_regression else get_loss_fn(num_classes)) # Defines evaluation metrics function, which will create metrics in the @@ -166,12 +166,12 @@ def _get_classifier_model(): metric_fn = custom_metrics elif is_regression: metric_fn = functools.partial( - tf.keras.metrics.MeanSquaredError, + tf_keras.metrics.MeanSquaredError, 'mean_squared_error', dtype=tf.float32) else: metric_fn = functools.partial( - tf.keras.metrics.SparseCategoricalAccuracy, + tf_keras.metrics.SparseCategoricalAccuracy, 'accuracy', dtype=tf.float32) @@ -230,7 +230,7 @@ def run_keras_compile_fit(model_dir, steps_per_execution=steps_per_loop) summary_dir = os.path.join(model_dir, 'summaries') - summary_callback = tf.keras.callbacks.TensorBoard(summary_dir) + summary_callback = tf_keras.callbacks.TensorBoard(summary_dir) checkpoint = tf.train.Checkpoint(model=bert_model, optimizer=optimizer) checkpoint_manager = tf.train.CheckpointManager( checkpoint, @@ -347,7 +347,7 @@ def export_classifier(model_export_path, input_meta_data, bert_config, raise ValueError('Export path is not specified: %s' % model_dir) # Export uses float32 for now, even if training uses mixed precision. - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') classifier_model = bert_models.classifier_model( bert_config, input_meta_data.get('num_labels', 1), @@ -422,7 +422,7 @@ def custom_main(custom_callbacks=None, custom_metrics=None): """Run classification or regression. Args: - custom_callbacks: list of tf.keras.Callbacks passed to training loop. + custom_callbacks: list of tf_keras.Callbacks passed to training loop. custom_metrics: list of metrics passed to the training loop. """ gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_param) diff --git a/official/legacy/bert/run_pretraining.py b/official/legacy/bert/run_pretraining.py index b0c22ed1a14..d385a0ed76e 100644 --- a/official/legacy/bert/run_pretraining.py +++ b/official/legacy/bert/run_pretraining.py @@ -19,7 +19,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.bert import bert_models from official.legacy.bert import common_flags diff --git a/official/legacy/bert/run_squad.py b/official/legacy/bert/run_squad.py index ea7facac5a0..3620b42831c 100644 --- a/official/legacy/bert/run_squad.py +++ b/official/legacy/bert/run_squad.py @@ -23,7 +23,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.bert import configs as bert_configs from official.legacy.bert import run_squad_helper diff --git a/official/legacy/bert/run_squad_helper.py b/official/legacy/bert/run_squad_helper.py index 014c8eae66d..ba56596c957 100644 --- a/official/legacy/bert/run_squad_helper.py +++ b/official/legacy/bert/run_squad_helper.py @@ -20,7 +20,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import bert_models from official.legacy.bert import common_flags from official.legacy.bert import input_pipeline @@ -97,9 +97,9 @@ def define_common_squad_flags(): def squad_loss_fn(start_positions, end_positions, start_logits, end_logits): """Returns sparse categorical crossentropy for start/end logits.""" - start_loss = tf.keras.losses.sparse_categorical_crossentropy( + start_loss = tf_keras.losses.sparse_categorical_crossentropy( start_positions, start_logits, from_logits=True) - end_loss = tf.keras.losses.sparse_categorical_crossentropy( + end_loss = tf_keras.losses.sparse_categorical_crossentropy( end_positions, end_logits, from_logits=True) total_loss = (tf.reduce_mean(start_loss) + tf.reduce_mean(end_loss)) / 2 @@ -160,7 +160,7 @@ def get_squad_model_to_predict(strategy, bert_config, checkpoint_path, """Gets a squad model to make predictions.""" with strategy.scope(): # Prediction always uses float32, even if training uses mixed precision. - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') squad_model, _ = bert_models.squad_model( bert_config, input_meta_data['max_seq_length'], @@ -464,7 +464,7 @@ def export_squad(model_export_path, input_meta_data, bert_config): if not model_export_path: raise ValueError('Export path is not specified: %s' % model_export_path) # Export uses float32 for now, even if training uses mixed precision. - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') squad_model, _ = bert_models.squad_model(bert_config, input_meta_data['max_seq_length']) model_saving_utils.export_bert_model( diff --git a/official/legacy/bert/serving.py b/official/legacy/bert/serving.py index 6b77b86369d..60893e21383 100644 --- a/official/legacy/bert/serving.py +++ b/official/legacy/bert/serving.py @@ -16,7 +16,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import bert_models from official.legacy.bert import configs @@ -36,7 +36,7 @@ FLAGS = flags.FLAGS -class BertServing(tf.keras.Model): +class BertServing(tf_keras.Model): """Bert transformer encoder model for serving.""" def __init__(self, bert_config, name_to_features=None, name="serving_model"): diff --git a/official/legacy/detection/dataloader/anchor.py b/official/legacy/detection/dataloader/anchor.py index 1249f43beb4..bb36ad53a0a 100644 --- a/official/legacy/detection/dataloader/anchor.py +++ b/official/legacy/detection/dataloader/anchor.py @@ -20,7 +20,7 @@ import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.utils import box_utils from official.vision.ops import iou_similarity from official.vision.utils.object_detection import argmax_matcher diff --git a/official/legacy/detection/dataloader/input_reader.py b/official/legacy/detection/dataloader/input_reader.py index 3c9fa5ef1fc..c114f8a8067 100644 --- a/official/legacy/detection/dataloader/input_reader.py +++ b/official/legacy/detection/dataloader/input_reader.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function from typing import Optional, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import factory from official.legacy.detection.dataloader import mode_keys as ModeKeys from official.modeling.hyperparams import params_dict diff --git a/official/legacy/detection/dataloader/maskrcnn_parser.py b/official/legacy/detection/dataloader/maskrcnn_parser.py index ad558c40156..d37e3f86435 100644 --- a/official/legacy/detection/dataloader/maskrcnn_parser.py +++ b/official/legacy/detection/dataloader/maskrcnn_parser.py @@ -14,7 +14,7 @@ """Data parser and processing for Mask R-CNN.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys as ModeKeys diff --git a/official/legacy/detection/dataloader/olnmask_parser.py b/official/legacy/detection/dataloader/olnmask_parser.py index 782bb01d991..7b8e9bcebcb 100644 --- a/official/legacy/detection/dataloader/olnmask_parser.py +++ b/official/legacy/detection/dataloader/olnmask_parser.py @@ -14,7 +14,7 @@ """Data parser and processing for Mask R-CNN.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader.maskrcnn_parser import Parser as MaskrcnnParser diff --git a/official/legacy/detection/dataloader/retinanet_parser.py b/official/legacy/detection/dataloader/retinanet_parser.py index e64e5e82e34..adcd53a5b72 100644 --- a/official/legacy/detection/dataloader/retinanet_parser.py +++ b/official/legacy/detection/dataloader/retinanet_parser.py @@ -21,7 +21,7 @@ Focal Loss for Dense Object Detection. arXiv:1708.02002 """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys as ModeKeys diff --git a/official/legacy/detection/dataloader/shapemask_parser.py b/official/legacy/detection/dataloader/shapemask_parser.py index 66e0d286a10..3e1e82777fd 100644 --- a/official/legacy/detection/dataloader/shapemask_parser.py +++ b/official/legacy/detection/dataloader/shapemask_parser.py @@ -21,7 +21,7 @@ ShapeMask: Learning to Segment Novel Objects by Refining Shape Priors. arXiv:1904.03239. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys as ModeKeys diff --git a/official/legacy/detection/dataloader/tf_example_decoder.py b/official/legacy/detection/dataloader/tf_example_decoder.py index 1163d23304a..0d0dbbb6c53 100644 --- a/official/legacy/detection/dataloader/tf_example_decoder.py +++ b/official/legacy/detection/dataloader/tf_example_decoder.py @@ -18,7 +18,7 @@ A decoder to decode string tensors containing serialized tensorflow.Example protos for object detection. """ -import tensorflow as tf +import tensorflow as tf, tf_keras class TfExampleDecoder(object): diff --git a/official/legacy/detection/evaluation/coco_evaluator.py b/official/legacy/detection/evaluation/coco_evaluator.py index 441a5b19e58..83f3013585d 100644 --- a/official/legacy/detection/evaluation/coco_evaluator.py +++ b/official/legacy/detection/evaluation/coco_evaluator.py @@ -38,7 +38,7 @@ import numpy as np from pycocotools import cocoeval import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.evaluation import coco_utils from official.legacy.detection.utils import class_utils @@ -277,7 +277,7 @@ def evaluateImg(self, img_id, cat_id, a_rng, max_det): class MetricWrapper(object): """Metric Wrapper of the COCO evaluator.""" # This is only a wrapper for COCO metric and works on for numpy array. So it - # doesn't inherit from tf.keras.layers.Layer or tf.keras.metrics.Metric. + # doesn't inherit from tf_keras.layers.Layer or tf_keras.metrics.Metric. def __init__(self, evaluator): self._evaluator = evaluator diff --git a/official/legacy/detection/evaluation/coco_utils.py b/official/legacy/detection/evaluation/coco_utils.py index 32b5e914b66..d25814a3a51 100644 --- a/official/legacy/detection/evaluation/coco_utils.py +++ b/official/legacy/detection/evaluation/coco_utils.py @@ -27,7 +27,7 @@ from pycocotools import coco from pycocotools import mask as mask_api import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import tf_example_decoder from official.legacy.detection.utils import box_utils diff --git a/official/legacy/detection/executor/detection_executor.py b/official/legacy/detection/executor/detection_executor.py index b135240057c..506a2947213 100644 --- a/official/legacy/detection/executor/detection_executor.py +++ b/official/legacy/detection/executor/detection_executor.py @@ -20,7 +20,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.executor import distributed_executor as executor from official.vision.utils.object_detection import visualization_utils @@ -63,11 +63,11 @@ def _create_replicated_step(self, logging.info('Filter trainable variables from %d to %d', len(model.trainable_variables), len(trainable_variables)) update_state_fn = lambda labels, outputs: None - if isinstance(metric, tf.keras.metrics.Metric): + if isinstance(metric, tf_keras.metrics.Metric): update_state_fn = metric.update_state else: logging.error('Detection: train metric is not an instance of ' - 'tf.keras.metrics.Metric.') + 'tf_keras.metrics.Metric.') def _replicated_step(inputs): """Replicated training step.""" @@ -151,7 +151,7 @@ def _run_evaluation(self, test_step, current_training_step, metric, break metric_result = metric.result() - if isinstance(metric, tf.keras.metrics.Metric): + if isinstance(metric, tf_keras.metrics.Metric): metric_result = tf.nest.map_structure(lambda x: x.numpy().astype(float), metric_result) logging.info('Step: [%d] Validation metric = %s', current_training_step, diff --git a/official/legacy/detection/executor/distributed_executor.py b/official/legacy/detection/executor/distributed_executor.py index 7c9a9d7b4a5..19fcf07113e 100644 --- a/official/legacy/detection/executor/distributed_executor.py +++ b/official/legacy/detection/executor/distributed_executor.py @@ -25,7 +25,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import,g-import-not-at-top,redefined-outer-name,reimported from official.common import distribute_utils @@ -63,12 +63,12 @@ def metrics_as_dict(metric): Args: metric: metric(s) to be put into the list. `metric` could be an object, a - list, or a dict of tf.keras.metrics.Metric or has the `required_method`. + list, or a dict of tf_keras.metrics.Metric or has the `required_method`. Returns: A dictionary of valid metrics. """ - if isinstance(metric, tf.keras.metrics.Metric): + if isinstance(metric, tf_keras.metrics.Metric): metrics = {metric.name: metric} elif isinstance(metric, list): metrics = {m.name: m for m in metric} @@ -141,7 +141,7 @@ def __init__(self, strategy, params, model_fn, loss_fn, is_multi_host=False): strategy: an instance of tf.distribute.Strategy. params: Model configuration needed to run distribution strategy. model_fn: Keras model function. Signature: - (params: ParamsDict) -> tf.keras.models.Model. + (params: ParamsDict) -> tf_keras.models.Model. loss_fn: loss function. Signature: (y_true: Tensor, y_pred: Tensor) -> Tensor is_multi_host: Set to True when using multi hosts for training, like multi @@ -223,8 +223,8 @@ def _create_replicated_step(self, strategy: an instance of tf.distribute.Strategy. model: (Tensor, bool) -> Tensor. model function. loss_fn: (y_true: Tensor, y_pred: Tensor) -> Tensor. - optimizer: tf.keras.optimizers.Optimizer. - metric: tf.keras.metrics.Metric subclass. + optimizer: tf_keras.optimizers.Optimizer. + metric: tf_keras.metrics.Metric subclass. Returns: The training step callable. @@ -261,8 +261,8 @@ def _create_train_step(self, strategy: an instance of tf.distribute.Strategy. model: (Tensor, bool) -> Tensor. model function. loss_fn: (y_true: Tensor, y_pred: Tensor) -> Tensor. - optimizer: tf.keras.optimizers.Optimizer. - metric: tf.keras.metrics.Metric subclass. + optimizer: tf_keras.optimizers.Optimizer. + metric: tf_keras.metrics.Metric subclass. Returns: The training step callable. @@ -332,8 +332,8 @@ def train( train_metric_fn: Optional[Callable[[], Any]] = None, eval_metric_fn: Optional[Callable[[], Any]] = None, summary_writer_fn: Callable[[Text, Text], SummaryWriter] = SummaryWriter, - init_checkpoint: Optional[Callable[[tf.keras.Model], Any]] = None, - custom_callbacks: Optional[List[tf.keras.callbacks.Callback]] = None, + init_checkpoint: Optional[Callable[[tf_keras.Model], Any]] = None, + custom_callbacks: Optional[List[tf_keras.callbacks.Callback]] = None, continuous_eval: bool = False, save_config: bool = True): """Runs distributed training. @@ -412,7 +412,7 @@ def _run_callbacks_on_batch_end(batch): train_loss = None train_metric_result = None eval_metric_result = None - tf.keras.backend.set_learning_phase(1) + tf_keras.backend.set_learning_phase(1) with strategy.scope(): # To correctly place the model weights on accelerators, # model and optimizer should be created in scope. @@ -662,8 +662,8 @@ def evaluate_checkpoint(self, raise ValueError('if `eval_metric_fn` is specified, ' 'eval_metric_fn must be a callable.') - old_phase = tf.keras.backend.learning_phase() - tf.keras.backend.set_learning_phase(0) + old_phase = tf_keras.backend.learning_phase() + tf_keras.backend.set_learning_phase(0) params = self._params strategy = self._strategy # To reduce unnecessary send/receive input pipeline operation, we place @@ -705,7 +705,7 @@ def evaluate_checkpoint(self, summary_writer(metrics=eval_metric_result, step=current_step) reset_states(eval_metric) - tf.keras.backend.set_learning_phase(old_phase) + tf_keras.backend.set_learning_phase(old_phase) return eval_metric_result, current_step def predict(self): diff --git a/official/legacy/detection/main.py b/official/legacy/detection/main.py index 9c9560983b1..6e0274ed2dd 100644 --- a/official/legacy/detection/main.py +++ b/official/legacy/detection/main.py @@ -20,7 +20,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.detection.configs import factory as config_factory diff --git a/official/legacy/detection/modeling/architecture/fpn.py b/official/legacy/detection/modeling/architecture/fpn.py index 804e5f5bf03..6d14626b271 100644 --- a/official/legacy/detection/modeling/architecture/fpn.py +++ b/official/legacy/detection/modeling/architecture/fpn.py @@ -26,7 +26,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.modeling.architecture import nn_ops from official.legacy.detection.ops import spatial_transform_ops @@ -62,9 +62,9 @@ def __init__(self, self._fpn_feat_dims = fpn_feat_dims if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, depth_multiplier=1) + tf_keras.layers.SeparableConv2D, depth_multiplier=1) else: - self._conv2d_op = tf.keras.layers.Conv2D + self._conv2d_op = tf_keras.layers.Conv2D if activation == 'relu': self._activation_op = tf.nn.relu elif activation == 'swish': diff --git a/official/legacy/detection/modeling/architecture/heads.py b/official/legacy/detection/modeling/architecture/heads.py index 0589ad0adb8..cf410b1bd3a 100644 --- a/official/legacy/detection/modeling/architecture/heads.py +++ b/official/legacy/detection/modeling/architecture/heads.py @@ -21,13 +21,13 @@ import functools import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.modeling.architecture import nn_ops from official.legacy.detection.ops import spatial_transform_ops -class RpnHead(tf.keras.layers.Layer): +class RpnHead(tf_keras.layers.Layer): """Region Proposal Network head.""" def __init__( @@ -74,13 +74,13 @@ def __init__( if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, bias_initializer=tf.zeros_initializer()) else: self._conv2d_op = functools.partial( - tf.keras.layers.Conv2D, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + tf_keras.layers.Conv2D, + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer()) self._rpn_conv = self._conv2d_op( @@ -138,7 +138,7 @@ def call(self, features, is_training=None): return scores_outputs, box_outputs -class OlnRpnHead(tf.keras.layers.Layer): +class OlnRpnHead(tf_keras.layers.Layer): """Region Proposal Network for Object Localization Network (OLN).""" def __init__( @@ -183,13 +183,13 @@ def __init__( if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, bias_initializer=tf.zeros_initializer()) else: self._conv2d_op = functools.partial( - tf.keras.layers.Conv2D, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + tf_keras.layers.Conv2D, + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer()) self._rpn_conv = self._conv2d_op( @@ -262,7 +262,7 @@ def __call__(self, features, is_training=None): return scores_outputs, box_outputs, center_outputs -class FastrcnnHead(tf.keras.layers.Layer): +class FastrcnnHead(tf_keras.layers.Layer): """Fast R-CNN box head.""" def __init__( @@ -303,13 +303,13 @@ def __init__( self._num_filters = num_filters if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, bias_initializer=tf.zeros_initializer()) else: self._conv2d_op = functools.partial( - tf.keras.layers.Conv2D, - kernel_initializer=tf.keras.initializers.VarianceScaling( + tf_keras.layers.Conv2D, + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer()) @@ -344,7 +344,7 @@ def __init__( self._fc_bn_ops = [] for i in range(self._num_fcs): self._fc_ops.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self._fc_dims, activation=(None if self._use_batch_norm else self._activation_op), @@ -352,14 +352,14 @@ def __init__( if self._use_batch_norm: self._fc_bn_ops.append(self._norm_activation(fused=False)) - self._class_predict = tf.keras.layers.Dense( + self._class_predict = tf_keras.layers.Dense( self._num_classes, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), name='class-predict') - self._box_predict = tf.keras.layers.Dense( + self._box_predict = tf_keras.layers.Dense( self._num_classes * 4, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.001), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.001), bias_initializer=tf.zeros_initializer(), name='box-predict') @@ -403,7 +403,7 @@ def call(self, roi_features, is_training=None): return class_outputs, box_outputs -class OlnBoxScoreHead(tf.keras.layers.Layer): +class OlnBoxScoreHead(tf_keras.layers.Layer): """Box head of Object Localization Network (OLN).""" def __init__( @@ -442,13 +442,13 @@ def __init__( self._num_filters = num_filters if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, bias_initializer=tf.zeros_initializer()) else: self._conv2d_op = functools.partial( - tf.keras.layers.Conv2D, - kernel_initializer=tf.keras.initializers.VarianceScaling( + tf_keras.layers.Conv2D, + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer()) @@ -483,7 +483,7 @@ def __init__( self._fc_bn_ops = [] for i in range(self._num_fcs): self._fc_ops.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self._fc_dims, activation=(None if self._use_batch_norm else self._activation_op), @@ -491,19 +491,19 @@ def __init__( if self._use_batch_norm: self._fc_bn_ops.append(self._norm_activation(fused=False)) - self._class_predict = tf.keras.layers.Dense( + self._class_predict = tf_keras.layers.Dense( self._num_classes, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), name='class-predict') - self._box_predict = tf.keras.layers.Dense( + self._box_predict = tf_keras.layers.Dense( self._num_classes * 4, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.001), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.001), bias_initializer=tf.zeros_initializer(), name='box-predict') - self._score_predict = tf.keras.layers.Dense( + self._score_predict = tf_keras.layers.Dense( 1, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), name='score-predict') @@ -547,7 +547,7 @@ def __call__(self, roi_features, is_training=None): return class_outputs, box_outputs, score_outputs -class MaskrcnnHead(tf.keras.layers.Layer): +class MaskrcnnHead(tf_keras.layers.Layer): """Mask R-CNN head.""" def __init__( @@ -584,13 +584,13 @@ def __init__( self._num_filters = num_filters if use_separable_conv: self._conv2d_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, bias_initializer=tf.zeros_initializer()) else: self._conv2d_op = functools.partial( - tf.keras.layers.Conv2D, - kernel_initializer=tf.keras.initializers.VarianceScaling( + tf_keras.layers.Conv2D, + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer()) if activation == 'relu': @@ -613,13 +613,13 @@ def __init__( activation=(None if self._use_batch_norm else self._activation_op), name='mask-conv-l%d' % i)) - self._mask_conv_transpose = tf.keras.layers.Conv2DTranspose( + self._mask_conv_transpose = tf_keras.layers.Conv2DTranspose( self._num_filters, kernel_size=(2, 2), strides=(2, 2), padding='valid', activation=(None if self._use_batch_norm else self._activation_op), - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer(), name='conv5-mask') @@ -735,18 +735,18 @@ def _box_net_batch_norm_name(self, i, level): def _build_class_net_layers(self, norm_activation): """Build re-usable layers for class prediction network.""" if self._use_separable_conv: - self._class_predict = tf.keras.layers.SeparableConv2D( + self._class_predict = tf_keras.layers.SeparableConv2D( self._num_classes * self._anchors_per_location, kernel_size=(3, 3), bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01)), padding='same', name='class-predict') else: - self._class_predict = tf.keras.layers.Conv2D( + self._class_predict = tf_keras.layers.Conv2D( self._num_classes * self._anchors_per_location, kernel_size=(3, 3), bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01)), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-5), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=1e-5), padding='same', name='class-predict') self._class_conv = [] @@ -754,7 +754,7 @@ def _build_class_net_layers(self, norm_activation): for i in range(self._num_convs): if self._use_separable_conv: self._class_conv.append( - tf.keras.layers.SeparableConv2D( + tf_keras.layers.SeparableConv2D( self._num_filters, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), @@ -763,11 +763,11 @@ def _build_class_net_layers(self, norm_activation): name='class-' + str(i))) else: self._class_conv.append( - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( self._num_filters, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal( + kernel_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), activation=None, padding='same', @@ -779,18 +779,18 @@ def _build_class_net_layers(self, norm_activation): def _build_box_net_layers(self, norm_activation): """Build re-usable layers for box prediction network.""" if self._use_separable_conv: - self._box_predict = tf.keras.layers.SeparableConv2D( + self._box_predict = tf_keras.layers.SeparableConv2D( 4 * self._anchors_per_location, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), padding='same', name='box-predict') else: - self._box_predict = tf.keras.layers.Conv2D( + self._box_predict = tf_keras.layers.Conv2D( 4 * self._anchors_per_location, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-5), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=1e-5), padding='same', name='box-predict') self._box_conv = [] @@ -798,7 +798,7 @@ def _build_box_net_layers(self, norm_activation): for i in range(self._num_convs): if self._use_separable_conv: self._box_conv.append( - tf.keras.layers.SeparableConv2D( + tf_keras.layers.SeparableConv2D( self._num_filters, kernel_size=(3, 3), activation=None, @@ -807,12 +807,12 @@ def _build_box_net_layers(self, norm_activation): name='box-' + str(i))) else: self._box_conv.append( - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( self._num_filters, kernel_size=(3, 3), activation=None, bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal( + kernel_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), padding='same', name='box-' + str(i))) @@ -886,7 +886,7 @@ def __init__(self, num_classes, num_downsample_channels, mask_crop_size, self._shape_prior_path = shape_prior_path self._use_category_for_mask = use_category_for_mask - self._shape_prior_fc = tf.keras.layers.Dense( + self._shape_prior_fc = tf_keras.layers.Dense( self._num_downsample_channels, name='shape-prior-fc') def __call__(self, fpn_features, boxes, outer_boxes, classes, is_training): @@ -986,7 +986,7 @@ class ids. # Reduce spatial dimension of features. The features have shape # [batch_size, num_instances, num_channels]. features = tf.reduce_mean(features, axis=(2, 3)) - logits = tf.keras.layers.Dense( + logits = tf_keras.layers.Dense( self._mask_num_classes * self._num_clusters, kernel_initializer=tf.random_normal_initializer(stddev=0.01), name='classify-shape-prior-fc')(features) @@ -1032,7 +1032,7 @@ def __init__(self, self._num_convs = num_convs self._norm_activation = norm_activation - self._coarse_mask_fc = tf.keras.layers.Dense( + self._coarse_mask_fc = tf_keras.layers.Dense( self._num_downsample_channels, name='coarse-mask-fc') self._class_conv = [] @@ -1040,11 +1040,11 @@ def __init__(self, for i in range(self._num_convs): self._class_conv.append( - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( self._num_downsample_channels, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal( + kernel_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), padding='same', name='coarse-mask-class-%d' % i)) @@ -1052,12 +1052,12 @@ def __init__(self, self._class_norm_activation.append( norm_activation(name='coarse-mask-class-%d-bn' % i)) - self._class_predict = tf.keras.layers.Conv2D( + self._class_predict = tf_keras.layers.Conv2D( self._mask_num_classes, kernel_size=(1, 1), # Focal loss bias initialization to have foreground 0.01 probability. bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01)), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), padding='same', name='coarse-mask-class-predict') @@ -1158,10 +1158,10 @@ def __init__(self, self._num_convs = num_convs self.up_sample_factor = upsample_factor - self._fine_mask_fc = tf.keras.layers.Dense( + self._fine_mask_fc = tf_keras.layers.Dense( self._num_downsample_channels, name='fine-mask-fc') - self._upsample_conv = tf.keras.layers.Conv2DTranspose( + self._upsample_conv = tf_keras.layers.Conv2DTranspose( self._num_downsample_channels, (self.up_sample_factor, self.up_sample_factor), (self.up_sample_factor, self.up_sample_factor), @@ -1171,11 +1171,11 @@ def __init__(self, self._fine_class_bn = [] for i in range(self._num_convs): self._fine_class_conv.append( - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( self._num_downsample_channels, kernel_size=(3, 3), bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal( + kernel_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), activation=None, padding='same', @@ -1183,12 +1183,12 @@ def __init__(self, self._fine_class_bn.append( norm_activation(name='fine-mask-class-%d-bn' % i)) - self._class_predict_conv = tf.keras.layers.Conv2D( + self._class_predict_conv = tf_keras.layers.Conv2D( self._mask_num_classes, kernel_size=(1, 1), # Focal loss bias initialization to have foreground 0.01 probability. bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01)), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), padding='same', name='fine-mask-class-predict') diff --git a/official/legacy/detection/modeling/architecture/nn_blocks.py b/official/legacy/detection/modeling/architecture/nn_blocks.py index 5f37b779d53..8c0cd87d09c 100644 --- a/official/legacy/detection/modeling/architecture/nn_blocks.py +++ b/official/legacy/detection/modeling/architecture/nn_blocks.py @@ -18,12 +18,12 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class ResidualBlock(tf.keras.layers.Layer): +class ResidualBlock(tf_keras.layers.Layer): """A residual block.""" def __init__(self, @@ -50,9 +50,9 @@ def __init__(self, for the first block of a block group, which may change the number of filters and the resolution. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + 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. @@ -75,10 +75,10 @@ def __init__(self, self._bias_regularizer = bias_regularizer if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -86,7 +86,7 @@ def __init__(self, def build(self, input_shape): if self._use_projection: - self._shortcut = tf.keras.layers.Conv2D( + self._shortcut = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=1, strides=self._strides, @@ -99,7 +99,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -113,7 +113,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=1, @@ -162,7 +162,7 @@ def call(self, inputs): return self._activation_fn(x + shortcut) -class BottleneckBlock(tf.keras.layers.Layer): +class BottleneckBlock(tf_keras.layers.Layer): """A standard bottleneck block.""" def __init__(self, @@ -189,9 +189,9 @@ def __init__(self, for the first block of a block group, which may change the number of filters and the resolution. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + 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. @@ -213,10 +213,10 @@ def __init__(self, self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -224,7 +224,7 @@ def __init__(self, def build(self, input_shape): if self._use_projection: - self._shortcut = tf.keras.layers.Conv2D( + self._shortcut = tf_keras.layers.Conv2D( filters=self._filters * 4, kernel_size=1, strides=self._strides, @@ -237,7 +237,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=1, strides=1, @@ -250,7 +250,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -264,7 +264,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv3 = tf.keras.layers.Conv2D( + self._conv3 = tf_keras.layers.Conv2D( filters=self._filters * 4, kernel_size=1, strides=1, diff --git a/official/legacy/detection/modeling/architecture/nn_ops.py b/official/legacy/detection/modeling/architecture/nn_ops.py index c8e2f5b534a..eb4890bf4d0 100644 --- a/official/legacy/detection/modeling/architecture/nn_ops.py +++ b/official/legacy/detection/modeling/architecture/nn_ops.py @@ -20,10 +20,10 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras -class NormActivation(tf.keras.layers.Layer): +class NormActivation(tf_keras.layers.Layer): """Combined Normalization and Activation layers.""" def __init__(self, @@ -54,10 +54,10 @@ def __init__(self, """ super(NormActivation, self).__init__(trainable=trainable) if init_zero: - gamma_initializer = tf.keras.initializers.Zeros() + gamma_initializer = tf_keras.initializers.Zeros() else: - gamma_initializer = tf.keras.initializers.Ones() - self._normalization_op = tf.keras.layers.BatchNormalization( + gamma_initializer = tf_keras.initializers.Ones() + self._normalization_op = tf_keras.layers.BatchNormalization( momentum=momentum, epsilon=epsilon, center=True, diff --git a/official/legacy/detection/modeling/architecture/resnet.py b/official/legacy/detection/modeling/architecture/resnet.py index 43dad4307ab..4938b99ff9d 100644 --- a/official/legacy/detection/modeling/architecture/resnet.py +++ b/official/legacy/detection/modeling/architecture/resnet.py @@ -23,7 +23,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.modeling.architecture import nn_ops @@ -159,7 +159,7 @@ def conv2d_fixed_padding(self, inputs, filters, kernel_size, strides): if strides > 1: inputs = self.fixed_padding(inputs, kernel_size) - return tf.keras.layers.Conv2D( + return tf_keras.layers.Conv2D( filters=filters, kernel_size=kernel_size, strides=strides, @@ -309,7 +309,7 @@ def model(inputs, is_training=None): inputs = tf.identity(inputs, 'initial_conv') inputs = self._norm_activation()(inputs, is_training=is_training) - inputs = tf.keras.layers.MaxPool2D( + inputs = tf_keras.layers.MaxPool2D( pool_size=3, strides=2, padding='SAME', data_format=self._data_format)( inputs) diff --git a/official/legacy/detection/modeling/architecture/spinenet.py b/official/legacy/detection/modeling/architecture/spinenet.py index 3be8efbb76b..b04481e21ee 100644 --- a/official/legacy/detection/modeling/architecture/spinenet.py +++ b/official/legacy/detection/modeling/architecture/spinenet.py @@ -22,11 +22,11 @@ import math from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.modeling.architecture import nn_blocks from official.modeling import tf_utils -layers = tf.keras.layers +layers = tf_keras.layers FILTER_SIZE_MAP = { 1: 32, @@ -111,11 +111,11 @@ def build_block_specs(block_specs=None): return [BlockSpec(*b) for b in block_specs] -class SpineNet(tf.keras.Model): +class SpineNet(tf_keras.Model): """Class to build SpineNet models.""" def __init__(self, - input_specs=tf.keras.layers.InputSpec(shape=[None, 640, 640, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, 640, 640, 3]), min_level=3, max_level=7, block_specs=None, @@ -161,13 +161,13 @@ def __init__(self, else: self._norm = layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build SpineNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) net = self._build_stem(inputs=inputs) net = self._build_scale_permuted_network( @@ -453,7 +453,7 @@ class SpineNetBuilder(object): def __init__(self, model_id, - input_specs=tf.keras.layers.InputSpec(shape=[None, 640, 640, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, 640, 640, 3]), min_level=3, max_level=7, block_specs=None, diff --git a/official/legacy/detection/modeling/base_model.py b/official/legacy/detection/modeling/base_model.py index ed9109a459a..8d92bc4518b 100644 --- a/official/legacy/detection/modeling/base_model.py +++ b/official/legacy/detection/modeling/base_model.py @@ -21,7 +21,7 @@ import abc import re -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.modeling import checkpoint_utils from official.legacy.detection.modeling import learning_rates from official.legacy.detection.modeling import optimizers diff --git a/official/legacy/detection/modeling/checkpoint_utils.py b/official/legacy/detection/modeling/checkpoint_utils.py index 723642417d8..6e50a9a289f 100644 --- a/official/legacy/detection/modeling/checkpoint_utils.py +++ b/official/legacy/detection/modeling/checkpoint_utils.py @@ -26,7 +26,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def _build_assignment_map(keras_model, @@ -40,7 +40,7 @@ def _build_assignment_map(keras_model, the new Keras name. Args: - keras_model: tf.keras.Model object to provide variables to assign. + keras_model: tf_keras.Model object to provide variables to assign. prefix: prefix in the variable name to be remove for alignment with names in the checkpoint. skip_variables_regex: regular expression to math the names of variables that diff --git a/official/legacy/detection/modeling/learning_rates.py b/official/legacy/detection/modeling/learning_rates.py index 672cc7d5548..8ef242b89cb 100644 --- a/official/legacy/detection/modeling/learning_rates.py +++ b/official/legacy/detection/modeling/learning_rates.py @@ -19,12 +19,12 @@ from __future__ import print_function import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.hyperparams import params_dict class StepLearningRateWithLinearWarmup( - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): """Class to generate learning rate tensor.""" def __init__(self, total_steps, params): @@ -57,7 +57,7 @@ def get_config(self): class CosineLearningRateWithLinearWarmup( - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): """Class to generate learning rate tensor.""" def __init__(self, total_steps, params): diff --git a/official/legacy/detection/modeling/losses.py b/official/legacy/detection/modeling/losses.py index 2d2b0dd0d41..110cd795178 100644 --- a/official/legacy/detection/modeling/losses.py +++ b/official/legacy/detection/modeling/losses.py @@ -19,7 +19,7 @@ from __future__ import print_function from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def focal_loss(logits, targets, alpha, gamma, normalizer): @@ -90,8 +90,8 @@ class RpnScoreLoss(object): def __init__(self, params): self._rpn_batch_size_per_im = params.rpn_batch_size_per_im - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, score_outputs, labels): """Computes total RPN detection loss. @@ -153,8 +153,8 @@ def __init__(self, params): # The delta is typically around the mean value of regression target. # for instances, the regression targets of 512x512 input with 6 anchors on # P2-P6 pyramid is about [0.1, 0.1, 0.2, 0.2]. - self._huber_loss = tf.keras.losses.Huber( - delta=params.huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + self._huber_loss = tf_keras.losses.Huber( + delta=params.huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) def __call__(self, box_outputs, labels): """Computes total RPN detection loss. @@ -199,8 +199,8 @@ class OlnRpnCenterLoss(object): """Object Localization Network RPN centerness regression loss function.""" def __init__(self): - self._l1_loss = tf.keras.losses.MeanAbsoluteError( - reduction=tf.keras.losses.Reduction.SUM) + self._l1_loss = tf_keras.losses.MeanAbsoluteError( + reduction=tf_keras.losses.Reduction.SUM) def __call__(self, center_outputs, labels): """Computes total RPN centerness regression loss. @@ -342,8 +342,8 @@ class FastrcnnClassLoss(object): """Fast R-CNN classification loss function.""" def __init__(self): - self._categorical_crossentropy = tf.keras.losses.CategoricalCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._categorical_crossentropy = tf_keras.losses.CategoricalCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, class_outputs, class_targets): """Computes the class loss (Fast-RCNN branch) of Mask-RCNN. @@ -388,8 +388,8 @@ def __init__(self, params): # The delta is typically around the mean value of regression target. # for instances, the regression targets of 512x512 input with 6 anchors on # P2-P6 pyramid is about [0.1, 0.1, 0.2, 0.2]. - self._huber_loss = tf.keras.losses.Huber( - delta=params.huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + self._huber_loss = tf_keras.losses.Huber( + delta=params.huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) def __call__(self, box_outputs, class_targets, box_targets): """Computes the box loss (Fast-RCNN branch) of Mask-RCNN. @@ -465,8 +465,8 @@ class OlnBoxScoreLoss(object): def __init__(self, params): self._ignore_threshold = params.ignore_threshold - self._l1_loss = tf.keras.losses.MeanAbsoluteError( - reduction=tf.keras.losses.Reduction.SUM) + self._l1_loss = tf_keras.losses.MeanAbsoluteError( + reduction=tf_keras.losses.Reduction.SUM) def __call__(self, score_outputs, score_targets): """Computes the class loss (Fast-RCNN branch) of Mask-RCNN. @@ -505,8 +505,8 @@ class MaskrcnnLoss(object): """Mask R-CNN instance segmentation mask loss function.""" def __init__(self): - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, mask_outputs, mask_targets, select_class_targets): """Computes the mask loss of Mask-RCNN. @@ -616,8 +616,8 @@ class RetinanetBoxLoss(object): """RetinaNet box loss.""" def __init__(self, params): - self._huber_loss = tf.keras.losses.Huber( - delta=params.huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + self._huber_loss = tf_keras.losses.Huber( + delta=params.huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) def __call__(self, box_outputs, labels, num_positives): """Computes box detection loss. @@ -695,8 +695,8 @@ class ShapemaskLoss(object): """ShapeMask mask loss function wrapper.""" def __init__(self): - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, logits, labels, valid_mask): """ShapeMask mask cross entropy loss function wrapper. diff --git a/official/legacy/detection/modeling/maskrcnn_model.py b/official/legacy/detection/modeling/maskrcnn_model.py index 3ebe885466b..79ae5696773 100644 --- a/official/legacy/detection/modeling/maskrcnn_model.py +++ b/official/legacy/detection/modeling/maskrcnn_model.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys @@ -239,31 +239,31 @@ def build_input_layers(self, params, mode): batch_size = params.train.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info', ), 'gt_boxes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.maskrcnn_parser.max_num_instances, 4], batch_size=batch_size, name='gt_boxes'), 'gt_classes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.maskrcnn_parser.max_num_instances], batch_size=batch_size, name='gt_classes', dtype=tf.int64), } if self._include_mask: - input_layer['gt_masks'] = tf.keras.layers.Input( + input_layer['gt_masks'] = tf_keras.layers.Input( shape=[ params.maskrcnn_parser.max_num_instances, params.maskrcnn_parser.mask_crop_size, @@ -275,13 +275,13 @@ def build_input_layers(self, params, mode): batch_size = params.eval.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info', @@ -294,9 +294,9 @@ def build_model(self, params, mode): input_layers = self.build_input_layers(self._params, mode) outputs = self.model_outputs(input_layers, mode) - model = tf.keras.models.Model( + model = tf_keras.models.Model( inputs=input_layers, outputs=outputs, name='maskrcnn') - assert model is not None, 'Fail to build tf.keras.Model.' + assert model is not None, 'Fail to build tf_keras.Model.' model.optimizer = self.build_optimizer() self._keras_model = model diff --git a/official/legacy/detection/modeling/olnmask_model.py b/official/legacy/detection/modeling/olnmask_model.py index 379afcd9139..7c362289f65 100644 --- a/official/legacy/detection/modeling/olnmask_model.py +++ b/official/legacy/detection/modeling/olnmask_model.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys @@ -368,31 +368,31 @@ def build_input_layers(self, params, mode): batch_size = params.train.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info', ), 'gt_boxes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.olnmask_parser.max_num_instances, 4], batch_size=batch_size, name='gt_boxes'), 'gt_classes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.olnmask_parser.max_num_instances], batch_size=batch_size, name='gt_classes', dtype=tf.int64), } if self._include_mask: - input_layer['gt_masks'] = tf.keras.layers.Input( + input_layer['gt_masks'] = tf_keras.layers.Input( shape=[ params.olnmask_parser.max_num_instances, params.olnmask_parser.mask_crop_size, @@ -404,13 +404,13 @@ def build_input_layers(self, params, mode): batch_size = params.eval.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info', @@ -423,9 +423,9 @@ def build_model(self, params, mode): input_layers = self.build_input_layers(self._params, mode) outputs = self.model_outputs(input_layers, mode) - model = tf.keras.models.Model( + model = tf_keras.models.Model( inputs=input_layers, outputs=outputs, name='olnmask') - assert model is not None, 'Fail to build tf.keras.Model.' + assert model is not None, 'Fail to build tf_keras.Model.' model.optimizer = self.build_optimizer() self._keras_model = model diff --git a/official/legacy/detection/modeling/optimizers.py b/official/legacy/detection/modeling/optimizers.py index 359abb86b7a..ad3258bd3fb 100644 --- a/official/legacy/detection/modeling/optimizers.py +++ b/official/legacy/detection/modeling/optimizers.py @@ -20,7 +20,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras class OptimizerFactory(object): @@ -30,18 +30,18 @@ def __init__(self, params): """Creates optimized based on the specified flags.""" if params.type == 'momentum': self._optimizer = functools.partial( - tf.keras.optimizers.SGD, + tf_keras.optimizers.SGD, momentum=params.momentum, nesterov=params.nesterov) elif params.type == 'adam': - self._optimizer = tf.keras.optimizers.Adam + self._optimizer = tf_keras.optimizers.Adam elif params.type == 'adadelta': - self._optimizer = tf.keras.optimizers.Adadelta + self._optimizer = tf_keras.optimizers.Adadelta elif params.type == 'adagrad': - self._optimizer = tf.keras.optimizers.Adagrad + self._optimizer = tf_keras.optimizers.Adagrad elif params.type == 'rmsprop': self._optimizer = functools.partial( - tf.keras.optimizers.RMSprop, momentum=params.momentum) + tf_keras.optimizers.RMSprop, momentum=params.momentum) else: raise ValueError('Unsupported optimizer type `{}`.'.format(params.type)) diff --git a/official/legacy/detection/modeling/retinanet_model.py b/official/legacy/detection/modeling/retinanet_model.py index 6f467d4ef43..249dbd5938d 100644 --- a/official/legacy/detection/modeling/retinanet_model.py +++ b/official/legacy/detection/modeling/retinanet_model.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import mode_keys from official.legacy.detection.evaluation import factory as eval_factory @@ -57,7 +57,7 @@ def __init__(self, params): self._transpose_input = params.train.transpose_input assert not self._transpose_input, 'Transpose input is not supported.' # Input layer. - self._input_layer = tf.keras.layers.Input( + self._input_layer = tf_keras.layers.Input( shape=(None, None, params.retinanet_parser.num_channels), name='', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32) @@ -118,9 +118,9 @@ def build_model(self, params, mode=None): if self._keras_model is None: outputs = self.model_outputs(self._input_layer, mode) - model = tf.keras.models.Model( + model = tf_keras.models.Model( inputs=self._input_layer, outputs=outputs, name='retinanet') - assert model is not None, 'Fail to build tf.keras.Model.' + assert model is not None, 'Fail to build tf_keras.Model.' model.optimizer = self.build_optimizer() self._keras_model = model diff --git a/official/legacy/detection/modeling/shapemask_model.py b/official/legacy/detection/modeling/shapemask_model.py index 80521b1f287..e698a5a5941 100644 --- a/official/legacy/detection/modeling/shapemask_model.py +++ b/official/legacy/detection/modeling/shapemask_model.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.dataloader import anchor from official.legacy.detection.dataloader import mode_keys @@ -103,7 +103,7 @@ def build_outputs(self, inputs, mode): # Wrapping if else code paths into a layer to make the checkpoint loadable # in prediction mode. - class SampledBoxesLayer(tf.keras.layers.Layer): + class SampledBoxesLayer(tf_keras.layers.Layer): """ShapeMask model function.""" def call(self, inputs, val_boxes, val_classes, val_outer_boxes, training): @@ -210,28 +210,28 @@ def build_input_layers(self, params, mode): batch_size = params.train.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info'), 'mask_classes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.shapemask_parser.num_sampled_masks], batch_size=batch_size, name='mask_classes', dtype=tf.int64), 'mask_outer_boxes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.shapemask_parser.num_sampled_masks, 4], batch_size=batch_size, name='mask_outer_boxes', dtype=tf.float32), 'mask_boxes': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[params.shapemask_parser.num_sampled_masks, 4], batch_size=batch_size, name='mask_boxes', @@ -241,13 +241,13 @@ def build_input_layers(self, params, mode): batch_size = params.eval.batch_size input_layer = { 'image': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=input_shape, batch_size=batch_size, name='image', dtype=tf.bfloat16 if self._use_bfloat16 else tf.float32), 'image_info': - tf.keras.layers.Input( + tf_keras.layers.Input( shape=[4, 2], batch_size=batch_size, name='image_info'), } return input_layer @@ -257,9 +257,9 @@ def build_model(self, params, mode): input_layers = self.build_input_layers(self._params, mode) outputs = self.model_outputs(input_layers, mode) - model = tf.keras.models.Model( + model = tf_keras.models.Model( inputs=input_layers, outputs=outputs, name='shapemask') - assert model is not None, 'Fail to build tf.keras.Model.' + assert model is not None, 'Fail to build tf_keras.Model.' model.optimizer = self.build_optimizer() self._keras_model = model diff --git a/official/legacy/detection/ops/nms.py b/official/legacy/detection/ops/nms.py index 9167aa816cc..551771181b3 100644 --- a/official/legacy/detection/ops/nms.py +++ b/official/legacy/detection/ops/nms.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.utils import box_utils diff --git a/official/legacy/detection/ops/postprocess_ops.py b/official/legacy/detection/ops/postprocess_ops.py index e6528e72dfd..bb29d391295 100644 --- a/official/legacy/detection/ops/postprocess_ops.py +++ b/official/legacy/detection/ops/postprocess_ops.py @@ -20,7 +20,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.ops import nms from official.legacy.detection.utils import box_utils @@ -291,7 +291,7 @@ def _generate_detections_batched(boxes, scores, max_total_size, return nmsed_boxes, nmsed_scores, nmsed_classes, valid_detections -class MultilevelDetectionGenerator(tf.keras.layers.Layer): +class MultilevelDetectionGenerator(tf_keras.layers.Layer): """Generates detected boxes with scores and classes for one-stage detector.""" def __init__(self, min_level, max_level, params): @@ -338,7 +338,7 @@ def call(self, box_outputs, class_outputs, anchor_boxes, image_shape): return nmsed_boxes, nmsed_scores, nmsed_classes, valid_detections -class GenericDetectionGenerator(tf.keras.layers.Layer): +class GenericDetectionGenerator(tf_keras.layers.Layer): """Generates the final detected boxes with scores and classes.""" def __init__(self, params): diff --git a/official/legacy/detection/ops/roi_ops.py b/official/legacy/detection/ops/roi_ops.py index 109e2105b25..94a192810ef 100644 --- a/official/legacy/detection/ops/roi_ops.py +++ b/official/legacy/detection/ops/roi_ops.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.ops import nms from official.legacy.detection.utils import box_utils @@ -170,7 +170,7 @@ def multilevel_propose_rois(rpn_boxes, return selected_rois, selected_roi_scores -class ROIGenerator(tf.keras.layers.Layer): +class ROIGenerator(tf_keras.layers.Layer): """Proposes RoIs for the second stage processing.""" def __init__(self, params): diff --git a/official/legacy/detection/ops/spatial_transform_ops.py b/official/legacy/detection/ops/spatial_transform_ops.py index e9549d58620..70d3fac496c 100644 --- a/official/legacy/detection/ops/spatial_transform_ops.py +++ b/official/legacy/detection/ops/spatial_transform_ops.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras _EPSILON = 1e-8 diff --git a/official/legacy/detection/ops/target_ops.py b/official/legacy/detection/ops/target_ops.py index 086d76ad07c..689e6c3f65c 100644 --- a/official/legacy/detection/ops/target_ops.py +++ b/official/legacy/detection/ops/target_ops.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.ops import spatial_transform_ops from official.legacy.detection.utils import box_utils @@ -292,7 +292,7 @@ def sample_and_crop_foreground_masks(candidate_rois, return foreground_rois, foreground_classes, cropped_foreground_masks -class ROISampler(tf.keras.layers.Layer): +class ROISampler(tf_keras.layers.Layer): """Samples RoIs and creates training targets.""" def __init__(self, params): @@ -517,7 +517,7 @@ def assign_and_sample_proposals_and_scores(self, sampled_gt_classes, sampled_gt_indices) -class MaskSampler(tf.keras.layers.Layer): +class MaskSampler(tf_keras.layers.Layer): """Samples and creates mask training targets.""" def __init__(self, mask_target_size, num_mask_samples_per_image): diff --git a/official/legacy/detection/utils/box_utils.py b/official/legacy/detection/utils/box_utils.py index 11ea64bd76f..04695e2d2b9 100644 --- a/official/legacy/detection/utils/box_utils.py +++ b/official/legacy/detection/utils/box_utils.py @@ -19,7 +19,7 @@ from __future__ import print_function import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras EPSILON = 1e-8 BBOX_XFORM_CLIP = np.log(1000. / 16.) diff --git a/official/legacy/detection/utils/dataloader_utils.py b/official/legacy/detection/utils/dataloader_utils.py index e826e23eb4d..06c2659b830 100644 --- a/official/legacy/detection/utils/dataloader_utils.py +++ b/official/legacy/detection/utils/dataloader_utils.py @@ -14,7 +14,7 @@ """Utility functions for dataloader.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.utils import input_utils diff --git a/official/legacy/detection/utils/input_utils.py b/official/legacy/detection/utils/input_utils.py index 380ae234029..67ce114600f 100644 --- a/official/legacy/detection/utils/input_utils.py +++ b/official/legacy/detection/utils/input_utils.py @@ -16,7 +16,7 @@ import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.detection.utils import box_utils from official.vision.utils.object_detection import preprocessor diff --git a/official/legacy/image_classification/augment.py b/official/legacy/image_classification/augment.py index a917ef85100..9b677b08209 100644 --- a/official/legacy/image_classification/augment.py +++ b/official/legacy/image_classification/augment.py @@ -25,7 +25,7 @@ import math from typing import Any, Dict, List, Optional, Text, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras # This signifies the max integer that the controller RNN could predict for the diff --git a/official/legacy/image_classification/augment_test.py b/official/legacy/image_classification/augment_test.py index bfec9d11847..85cb2a3fdf0 100644 --- a/official/legacy/image_classification/augment_test.py +++ b/official/legacy/image_classification/augment_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import augment diff --git a/official/legacy/image_classification/callbacks.py b/official/legacy/image_classification/callbacks.py index 9360a72be0f..a0301fcc9be 100644 --- a/official/legacy/image_classification/callbacks.py +++ b/official/legacy/image_classification/callbacks.py @@ -21,7 +21,7 @@ from typing import Any, List, MutableMapping, Optional, Text from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import optimization from official.utils.misc import keras_utils @@ -38,19 +38,19 @@ def get_callbacks( batch_size: int = 0, log_steps: int = 0, model_dir: Optional[str] = None, - backup_and_restore: bool = False) -> List[tf.keras.callbacks.Callback]: + backup_and_restore: bool = False) -> List[tf_keras.callbacks.Callback]: """Get all callbacks.""" model_dir = model_dir or '' callbacks = [] if model_checkpoint: ckpt_full_path = os.path.join(model_dir, 'model.ckpt-{epoch:04d}') callbacks.append( - tf.keras.callbacks.ModelCheckpoint( + tf_keras.callbacks.ModelCheckpoint( ckpt_full_path, save_weights_only=True, verbose=1)) if backup_and_restore: backup_dir = os.path.join(model_dir, 'tmp') callbacks.append( - tf.keras.callbacks.experimental.BackupAndRestore(backup_dir)) + tf_keras.callbacks.experimental.BackupAndRestore(backup_dir)) if include_tensorboard: callbacks.append( CustomTensorBoard( @@ -82,14 +82,14 @@ def get_callbacks( def get_scalar_from_tensor(t: tf.Tensor) -> int: """Utility function to convert a Tensor to a scalar.""" - t = tf.keras.backend.get_value(t) + t = tf_keras.backend.get_value(t) if callable(t): return t() else: return t -class CustomTensorBoard(tf.keras.callbacks.TensorBoard): +class CustomTensorBoard(tf_keras.callbacks.TensorBoard): """A customized TensorBoard callback that tracks additional datapoints. Metrics tracked: @@ -157,7 +157,7 @@ def _calculate_lr(self) -> int: return get_scalar_from_tensor( self._get_base_optimizer()._decayed_lr(var_dtype=tf.float32)) # pylint:disable=protected-access - def _get_base_optimizer(self) -> tf.keras.optimizers.Optimizer: + def _get_base_optimizer(self) -> tf_keras.optimizers.Optimizer: """Get the base optimizer used by the current model.""" optimizer = self.model.optimizer @@ -169,7 +169,7 @@ def _get_base_optimizer(self) -> tf.keras.optimizers.Optimizer: return optimizer -class MovingAverageCallback(tf.keras.callbacks.Callback): +class MovingAverageCallback(tf_keras.callbacks.Callback): """A Callback to be used with a `ExponentialMovingAverage` optimizer. Applies moving average weights to the model during validation time to test @@ -187,7 +187,7 @@ def __init__(self, overwrite_weights_on_train_end: bool = False, **kwargs): super(MovingAverageCallback, self).__init__(**kwargs) self.overwrite_weights_on_train_end = overwrite_weights_on_train_end - def set_model(self, model: tf.keras.Model): + def set_model(self, model: tf_keras.Model): super(MovingAverageCallback, self).set_model(model) assert isinstance(self.model.optimizer, optimization.ExponentialMovingAverage) @@ -204,7 +204,7 @@ def on_train_end(self, logs: Optional[MutableMapping[Text, Any]] = None): self.model.optimizer.assign_average_vars(self.model.variables) -class AverageModelCheckpoint(tf.keras.callbacks.ModelCheckpoint): +class AverageModelCheckpoint(tf_keras.callbacks.ModelCheckpoint): """Saves and, optionally, assigns the averaged weights. Taken from tfa.callbacks.AverageModelCheckpoint. @@ -212,7 +212,7 @@ class AverageModelCheckpoint(tf.keras.callbacks.ModelCheckpoint): Attributes: update_weights: If True, assign the moving average weights to the model, and save them. If False, keep the old non-averaged weights, but the saved - model uses the average weights. See `tf.keras.callbacks.ModelCheckpoint` + model uses the average weights. See `tf_keras.callbacks.ModelCheckpoint` for the other args. """ diff --git a/official/legacy/image_classification/classifier_trainer.py b/official/legacy/image_classification/classifier_trainer.py index 8f1d2e6b6f8..ea432ca1501 100644 --- a/official/legacy/image_classification/classifier_trainer.py +++ b/official/legacy/image_classification/classifier_trainer.py @@ -21,7 +21,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.image_classification import callbacks as custom_callbacks from official.legacy.image_classification import dataset_factory @@ -38,7 +38,7 @@ from official.utils.misc import keras_utils -def get_models() -> Mapping[str, tf.keras.Model]: +def get_models() -> Mapping[str, tf_keras.Model]: """Returns the mapping from model type name to Keras model.""" return { 'efficientnet': efficientnet_model.EfficientNet.from_name, @@ -64,26 +64,26 @@ def _get_metrics(one_hot: bool) -> Mapping[Text, Any]: return { # (name, metric_fn) 'acc': - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), 'accuracy': - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), 'top_1': - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), 'top_5': - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.TopKCategoricalAccuracy( k=5, name='top_5_accuracy'), } else: return { # (name, metric_fn) 'acc': - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), 'accuracy': - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), 'top_1': - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), 'top_5': - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=5, name='top_5_accuracy'), } @@ -192,7 +192,7 @@ def _get_params_from_flags(flags_obj: flags.FlagValues): return params -def resume_from_checkpoint(model: tf.keras.Model, model_dir: str, +def resume_from_checkpoint(model: tf_keras.Model, model_dir: str, train_steps: int) -> int: """Resumes from the latest checkpoint, if possible. @@ -233,7 +233,7 @@ def initialize(params: base_configs.ExperimentConfig, data_format = 'channels_first' else: data_format = 'channels_last' - tf.keras.backend.set_image_data_format(data_format) + tf_keras.backend.set_image_data_format(data_format) if params.runtime.run_eagerly: # Enable eager execution to allow step-by-step debugging tf.config.experimental_run_functions_eagerly(True) @@ -348,10 +348,10 @@ def train_and_eval( steps_per_loop = train_steps if params.train.set_epoch_loop else 1 if one_hot: - loss_obj = tf.keras.losses.CategoricalCrossentropy( + loss_obj = tf_keras.losses.CategoricalCrossentropy( label_smoothing=params.model.loss.label_smoothing) else: - loss_obj = tf.keras.losses.SparseCategoricalCrossentropy() + loss_obj = tf_keras.losses.SparseCategoricalCrossentropy() model.compile( optimizer=optimizer, loss=loss_obj, diff --git a/official/legacy/image_classification/classifier_trainer_test.py b/official/legacy/image_classification/classifier_trainer_test.py index be7a73db22d..21a21cee845 100644 --- a/official/legacy/image_classification/classifier_trainer_test.py +++ b/official/legacy/image_classification/classifier_trainer_test.py @@ -25,7 +25,7 @@ from absl import flags from absl.testing import flagsaver from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/legacy/image_classification/classifier_trainer_util_test.py b/official/legacy/image_classification/classifier_trainer_util_test.py index ad722e9f5ef..09fdd65bf37 100644 --- a/official/legacy/image_classification/classifier_trainer_util_test.py +++ b/official/legacy/image_classification/classifier_trainer_util_test.py @@ -22,7 +22,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import classifier_trainer from official.legacy.image_classification import dataset_factory @@ -30,12 +30,12 @@ from official.legacy.image_classification.configs import base_configs -def get_trivial_model(num_classes: int) -> tf.keras.Model: +def get_trivial_model(num_classes: int) -> tf_keras.Model: """Creates and compiles trivial model for ImageNet dataset.""" model = test_utils.trivial_model(num_classes=num_classes) lr = 0.01 - optimizer = tf.keras.optimizers.SGD(learning_rate=lr) - loss_obj = tf.keras.losses.SparseCategoricalCrossentropy() + optimizer = tf_keras.optimizers.SGD(learning_rate=lr) + loss_obj = tf_keras.losses.SparseCategoricalCrossentropy() model.compile(optimizer=optimizer, loss=loss_obj, run_eagerly=True) return model @@ -120,7 +120,7 @@ class EmptyClass: def test_resume_from_checkpoint(self): """Tests functionality for resuming from checkpoint.""" # Set the keras policy - tf.keras.mixed_precision.set_global_policy('mixed_bfloat16') + tf_keras.mixed_precision.set_global_policy('mixed_bfloat16') # Get the model, datasets, and compile it. model = get_trivial_model(10) @@ -131,7 +131,7 @@ def test_resume_from_checkpoint(self): train_steps = 10 ds = get_trivial_data() callbacks = [ - tf.keras.callbacks.ModelCheckpoint( + tf_keras.callbacks.ModelCheckpoint( os.path.join(model_dir, 'model.ckpt-{epoch:04d}'), save_weights_only=True) ] diff --git a/official/legacy/image_classification/dataset_factory.py b/official/legacy/image_classification/dataset_factory.py index b0bd931e61a..e414ed6f19c 100644 --- a/official/legacy/image_classification/dataset_factory.py +++ b/official/legacy/image_classification/dataset_factory.py @@ -21,7 +21,7 @@ from typing import Any, List, Mapping, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.legacy.image_classification import augment from official.legacy.image_classification import preprocessing diff --git a/official/legacy/image_classification/efficientnet/common_modules.py b/official/legacy/image_classification/efficientnet/common_modules.py index 7f2b6067c44..f7d07b11c79 100644 --- a/official/legacy/image_classification/efficientnet/common_modules.py +++ b/official/legacy/image_classification/efficientnet/common_modules.py @@ -18,13 +18,13 @@ from __future__ import print_function from typing import Optional, Text import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow.compat.v1 as tf1 from tensorflow.python.tpu import tpu_function -@tf.keras.utils.register_keras_serializable(package='Vision') -class TpuBatchNormalization(tf.keras.layers.BatchNormalization): +@tf_keras.utils.register_keras_serializable(package='Vision') +class TpuBatchNormalization(tf_keras.layers.BatchNormalization): """Cross replica batch normalization.""" def __init__(self, fused: Optional[bool] = False, **kwargs): @@ -71,7 +71,7 @@ def _moments(self, inputs: tf.Tensor, reduction_axes: int, keep_dims: int): return (shard_mean, shard_variance) -def get_batch_norm(batch_norm_type: Text) -> tf.keras.layers.BatchNormalization: +def get_batch_norm(batch_norm_type: Text) -> tf_keras.layers.BatchNormalization: """A helper to create a batch normalization getter. Args: @@ -79,12 +79,12 @@ def get_batch_norm(batch_norm_type: Text) -> tf.keras.layers.BatchNormalization: will use `TpuBatchNormalization`. Returns: - An instance of `tf.keras.layers.BatchNormalization`. + An instance of `tf_keras.layers.BatchNormalization`. """ if batch_norm_type == 'tpu': return TpuBatchNormalization - return tf.keras.layers.BatchNormalization # pytype: disable=bad-return-type # typed-keras + return tf_keras.layers.BatchNormalization # pytype: disable=bad-return-type # typed-keras def count_params(model, trainable_only=True): @@ -94,11 +94,11 @@ def count_params(model, trainable_only=True): else: return int( np.sum([ - tf.keras.backend.count_params(p) for p in model.trainable_weights + tf_keras.backend.count_params(p) for p in model.trainable_weights ])) -def load_weights(model: tf.keras.Model, +def load_weights(model: tf_keras.Model, model_weights_path: Text, weights_format: Text = 'saved_model'): """Load model weights from the given file path. @@ -110,7 +110,7 @@ def load_weights(model: tf.keras.Model, 'checkpoint'. """ if weights_format == 'saved_model': - loaded_model = tf.keras.models.load_model(model_weights_path) + loaded_model = tf_keras.models.load_model(model_weights_path) model.set_weights(loaded_model.get_weights()) else: model.load_weights(model_weights_path) diff --git a/official/legacy/image_classification/efficientnet/efficientnet_model.py b/official/legacy/image_classification/efficientnet/efficientnet_model.py index 03c1dcb2919..6d060df016c 100644 --- a/official/legacy/image_classification/efficientnet/efficientnet_model.py +++ b/official/legacy/image_classification/efficientnet/efficientnet_model.py @@ -27,7 +27,7 @@ from typing import Any, Dict, Optional, Text, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import preprocessing from official.legacy.image_classification.efficientnet import common_modules from official.modeling import tf_utils @@ -163,7 +163,7 @@ def conv2d_block(inputs: tf.Tensor, batch_norm = common_modules.get_batch_norm(config.batch_norm) bn_momentum = config.bn_momentum bn_epsilon = config.bn_epsilon - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() weight_decay = config.weight_decay name = name or '' @@ -175,15 +175,15 @@ def conv2d_block(inputs: tf.Tensor, 'use_bias': use_bias, 'padding': 'same', 'name': name + '_conv2d', - 'kernel_regularizer': tf.keras.regularizers.l2(weight_decay), - 'bias_regularizer': tf.keras.regularizers.l2(weight_decay), + 'kernel_regularizer': tf_keras.regularizers.l2(weight_decay), + 'bias_regularizer': tf_keras.regularizers.l2(weight_decay), } if depthwise: - conv2d = tf.keras.layers.DepthwiseConv2D + conv2d = tf_keras.layers.DepthwiseConv2D init_kwargs.update({'depthwise_initializer': CONV_KERNEL_INITIALIZER}) else: - conv2d = tf.keras.layers.Conv2D + conv2d = tf_keras.layers.Conv2D init_kwargs.update({ 'filters': conv_filters, 'kernel_initializer': CONV_KERNEL_INITIALIZER @@ -201,7 +201,7 @@ def conv2d_block(inputs: tf.Tensor, x) if activation is not None: - x = tf.keras.layers.Activation(activation, name=name + '_activation')(x) + x = tf_keras.layers.Activation(activation, name=name + '_activation')(x) return x @@ -223,7 +223,7 @@ def mb_conv_block(inputs: tf.Tensor, use_se = config.use_se activation = tf_utils.get_activation(config.activation) drop_connect_rate = config.drop_connect_rate - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() use_depthwise = block.conv_type != 'no_depthwise' prefix = prefix or '' @@ -276,8 +276,8 @@ def mb_conv_block(inputs: tf.Tensor, else: se_shape = (1, 1, filters) - se = tf.keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x) - se = tf.keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')(se) + se = tf_keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x) + se = tf_keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')(se) se = conv2d_block( se, @@ -295,7 +295,7 @@ def mb_conv_block(inputs: tf.Tensor, use_batch_norm=False, activation='sigmoid', name=prefix + 'se_expand') - x = tf.keras.layers.multiply([x, se], name=prefix + 'se_excite') + x = tf_keras.layers.multiply([x, se], name=prefix + 'se_excite') # Output phase x = conv2d_block( @@ -303,7 +303,7 @@ def mb_conv_block(inputs: tf.Tensor, # Add identity so that quantization-aware training can insert quantization # ops correctly. - x = tf.keras.layers.Activation( + x = tf_keras.layers.Activation( tf_utils.get_activation('identity'), name=prefix + 'id')( x) @@ -314,19 +314,19 @@ def mb_conv_block(inputs: tf.Tensor, # The only difference between dropout and dropconnect in TF is scaling by # drop_connect_rate during training. See: # https://github.com/keras-team/keras/pull/9898#issuecomment-380577612 - x = tf.keras.layers.Dropout( + x = tf_keras.layers.Dropout( drop_connect_rate, noise_shape=(None, 1, 1, 1), name=prefix + 'drop')( x) - x = tf.keras.layers.add([x, inputs], name=prefix + 'add') + x = tf_keras.layers.add([x, inputs], name=prefix + 'add') return x -def efficientnet(image_input: tf.keras.layers.Input, config: ModelConfig): # pytype: disable=invalid-annotation # typed-keras +def efficientnet(image_input: tf_keras.layers.Input, config: ModelConfig): # pytype: disable=invalid-annotation # typed-keras """Creates an EfficientNet graph given the model parameters. - This function is wrapped by the `EfficientNet` class to make a tf.keras.Model. + This function is wrapped by the `EfficientNet` class to make a tf_keras.Model. Args: image_input: the input batch of images @@ -345,14 +345,14 @@ def efficientnet(image_input: tf.keras.layers.Input, config: ModelConfig): # py num_classes = config.num_classes input_channels = config.input_channels rescale_input = config.rescale_input - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() dtype = config.dtype weight_decay = config.weight_decay x = image_input if data_format == 'channels_first': # Happens on GPU/TPU if available. - x = tf.keras.layers.Permute((3, 1, 2))(x) + x = tf_keras.layers.Permute((3, 1, 2))(x) if rescale_input: x = preprocessing.normalize_images( x, num_channels=input_channels, dtype=dtype, data_format=data_format) @@ -405,22 +405,22 @@ def efficientnet(image_input: tf.keras.layers.Input, config: ModelConfig): # py name='top') # Build classifier - x = tf.keras.layers.GlobalAveragePooling2D(name='top_pool')(x) + x = tf_keras.layers.GlobalAveragePooling2D(name='top_pool')(x) if dropout_rate and dropout_rate > 0: - x = tf.keras.layers.Dropout(dropout_rate, name='top_dropout')(x) - x = tf.keras.layers.Dense( + x = tf_keras.layers.Dropout(dropout_rate, name='top_dropout')(x) + x = tf_keras.layers.Dense( num_classes, kernel_initializer=DENSE_KERNEL_INITIALIZER, - kernel_regularizer=tf.keras.regularizers.l2(weight_decay), - bias_regularizer=tf.keras.regularizers.l2(weight_decay), + kernel_regularizer=tf_keras.regularizers.l2(weight_decay), + bias_regularizer=tf_keras.regularizers.l2(weight_decay), name='logits')( x) - x = tf.keras.layers.Activation('softmax', name='probs')(x) + x = tf_keras.layers.Activation('softmax', name='probs')(x) return x -class EfficientNet(tf.keras.Model): +class EfficientNet(tf_keras.Model): """Wrapper class for an EfficientNet Keras model. Contains helper methods to build, manage, and save metadata about the model. @@ -443,7 +443,7 @@ def __init__(self, input_channels = self.config.input_channels model_name = self.config.model_name input_shape = (None, None, input_channels) # Should handle any size image - image_input = tf.keras.layers.Input(shape=input_shape) + image_input = tf_keras.layers.Input(shape=input_shape) output = efficientnet(image_input, self.config) diff --git a/official/legacy/image_classification/efficientnet/tfhub_export.py b/official/legacy/image_classification/efficientnet/tfhub_export.py index edab776b230..38f8c6b7378 100644 --- a/official/legacy/image_classification/efficientnet/tfhub_export.py +++ b/official/legacy/image_classification/efficientnet/tfhub_export.py @@ -23,7 +23,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification.efficientnet import efficientnet_model @@ -36,22 +36,22 @@ def export_tfhub(model_path, hub_destination, model_name): - """Restores a tf.keras.Model and saves for TF-Hub.""" + """Restores a tf_keras.Model and saves for TF-Hub.""" model_configs = dict(efficientnet_model.MODEL_CONFIGS) config = model_configs[model_name] - image_input = tf.keras.layers.Input( + image_input = tf_keras.layers.Input( shape=(None, None, 3), name="image_input", dtype=tf.float32) x = image_input * 255.0 outputs = efficientnet_model.efficientnet(x, config) - hub_model = tf.keras.Model(image_input, outputs) + hub_model = tf_keras.Model(image_input, outputs) ckpt = tf.train.Checkpoint(model=hub_model) ckpt.restore(model_path).assert_existing_objects_matched() hub_model.save( os.path.join(hub_destination, "classification"), include_optimizer=False) feature_vector_output = hub_model.get_layer(name="top_pool").get_output_at(0) - hub_model2 = tf.keras.Model(image_input, feature_vector_output) + hub_model2 = tf_keras.Model(image_input, feature_vector_output) hub_model2.save( os.path.join(hub_destination, "feature-vector"), include_optimizer=False) diff --git a/official/legacy/image_classification/learning_rate.py b/official/legacy/image_classification/learning_rate.py index 94b3a914386..7d5a06fd199 100644 --- a/official/legacy/image_classification/learning_rate.py +++ b/official/legacy/image_classification/learning_rate.py @@ -20,16 +20,16 @@ from typing import Any, Mapping, Optional import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras BASE_LEARNING_RATE = 0.1 -class WarmupDecaySchedule(tf.keras.optimizers.schedules.LearningRateSchedule): +class WarmupDecaySchedule(tf_keras.optimizers.schedules.LearningRateSchedule): """A wrapper for LearningRateSchedule that includes warmup steps.""" def __init__(self, - lr_schedule: tf.keras.optimizers.schedules.LearningRateSchedule, + lr_schedule: tf_keras.optimizers.schedules.LearningRateSchedule, warmup_steps: int, warmup_lr: Optional[float] = None): """Add warmup decay to a learning rate schedule. @@ -73,7 +73,7 @@ def get_config(self) -> Mapping[str, Any]: return config -class CosineDecayWithWarmup(tf.keras.optimizers.schedules.LearningRateSchedule): +class CosineDecayWithWarmup(tf_keras.optimizers.schedules.LearningRateSchedule): """Class to generate learning rate tensor.""" def __init__(self, batch_size: int, total_steps: int, warmup_steps: int): diff --git a/official/legacy/image_classification/learning_rate_test.py b/official/legacy/image_classification/learning_rate_test.py index 0670b2ac6c1..5fbb1e11681 100644 --- a/official/legacy/image_classification/learning_rate_test.py +++ b/official/legacy/image_classification/learning_rate_test.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import learning_rate @@ -32,7 +32,7 @@ def test_warmup_decay(self): decay_rate = 0.01 warmup_steps = 10 - base_lr = tf.keras.optimizers.schedules.ExponentialDecay( + base_lr = tf_keras.optimizers.schedules.ExponentialDecay( initial_learning_rate=initial_lr, decay_steps=decay_steps, decay_rate=decay_rate) diff --git a/official/legacy/image_classification/mnist_main.py b/official/legacy/image_classification/mnist_main.py index 822ccc2197e..c62b6ab3f42 100644 --- a/official/legacy/image_classification/mnist_main.py +++ b/official/legacy/image_classification/mnist_main.py @@ -23,7 +23,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.common import distribute_utils from official.legacy.image_classification.resnet import common @@ -36,29 +36,29 @@ def build_model(): """Constructs the ML model used to predict handwritten digits.""" - image = tf.keras.layers.Input(shape=(28, 28, 1)) + image = tf_keras.layers.Input(shape=(28, 28, 1)) - y = tf.keras.layers.Conv2D(filters=32, + y = tf_keras.layers.Conv2D(filters=32, kernel_size=5, padding='same', activation='relu')(image) - y = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), + y = tf_keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(y) - y = tf.keras.layers.Conv2D(filters=32, + y = tf_keras.layers.Conv2D(filters=32, kernel_size=5, padding='same', activation='relu')(y) - y = tf.keras.layers.MaxPooling2D(pool_size=(2, 2), + y = tf_keras.layers.MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')(y) - y = tf.keras.layers.Flatten()(y) - y = tf.keras.layers.Dense(1024, activation='relu')(y) - y = tf.keras.layers.Dropout(0.4)(y) + y = tf_keras.layers.Flatten()(y) + y = tf_keras.layers.Dense(1024, activation='relu')(y) + y = tf_keras.layers.Dropout(0.4)(y) - probs = tf.keras.layers.Dense(10, activation='softmax')(y) + probs = tf_keras.layers.Dense(10, activation='softmax')(y) - model = tf.keras.models.Model(image, probs, name='mnist') + model = tf_keras.models.Model(image, probs, name='mnist') return model @@ -104,9 +104,9 @@ def run(flags_obj, datasets_override=None, strategy_override=None): eval_input_dataset = mnist_test.cache().repeat().batch(flags_obj.batch_size) with strategy_scope: - lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( + lr_schedule = tf_keras.optimizers.schedules.ExponentialDecay( 0.05, decay_steps=100000, decay_rate=0.96) - optimizer = tf.keras.optimizers.SGD(learning_rate=lr_schedule) + optimizer = tf_keras.optimizers.SGD(learning_rate=lr_schedule) model = build_model() model.compile( @@ -120,9 +120,9 @@ def run(flags_obj, datasets_override=None, strategy_override=None): ckpt_full_path = os.path.join(flags_obj.model_dir, 'model.ckpt-{epoch:04d}') callbacks = [ - tf.keras.callbacks.ModelCheckpoint( + tf_keras.callbacks.ModelCheckpoint( ckpt_full_path, save_weights_only=True), - tf.keras.callbacks.TensorBoard(log_dir=flags_obj.model_dir), + tf_keras.callbacks.TensorBoard(log_dir=flags_obj.model_dir), ] num_eval_examples = mnist.info.splits['test'].num_examples diff --git a/official/legacy/image_classification/mnist_test.py b/official/legacy/image_classification/mnist_test.py index 4538adf2553..495d52b3a2b 100644 --- a/official/legacy/image_classification/mnist_test.py +++ b/official/legacy/image_classification/mnist_test.py @@ -21,7 +21,7 @@ import functools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/legacy/image_classification/optimizer_factory.py b/official/legacy/image_classification/optimizer_factory.py index 2ba0ed050e9..e57e398a03d 100644 --- a/official/legacy/image_classification/optimizer_factory.py +++ b/official/legacy/image_classification/optimizer_factory.py @@ -21,7 +21,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import learning_rate from official.legacy.image_classification.configs import base_configs @@ -33,7 +33,7 @@ FloatTensorLike = Union[tf.Tensor, float, np.float16, np.float32, np.float64] -class Lookahead(tf.keras.optimizers.legacy.Optimizer): +class Lookahead(tf_keras.optimizers.legacy.Optimizer): """This class allows to extend optimizers with the lookahead mechanism. The mechanism is proposed by Michael R. Zhang et.al in the paper [Lookahead @@ -47,14 +47,14 @@ class Lookahead(tf.keras.optimizers.legacy.Optimizer): Example of usage: ```python - opt = tf.keras.optimizers.SGD(learning_rate) opt = + opt = tf_keras.optimizers.SGD(learning_rate) opt = tfa.optimizers.Lookahead(opt) ``` """ def __init__( self, - optimizer: tf.keras.optimizers.Optimizer, + optimizer: tf_keras.optimizers.Optimizer, sync_period: int = 6, slow_step_size: FloatTensorLike = 0.5, name: str = 'Lookahead', @@ -80,13 +80,13 @@ def __init__( super().__init__(name, **kwargs) if isinstance(optimizer, str): - optimizer = tf.keras.optimizers.get(optimizer) + optimizer = tf_keras.optimizers.get(optimizer) if not isinstance( optimizer, - (tf.keras.optimizers.Optimizer, tf.keras.optimizers.legacy.Optimizer), + (tf_keras.optimizers.Optimizer, tf_keras.optimizers.legacy.Optimizer), ): raise TypeError( - 'optimizer is not an object of tf.keras.optimizers.Optimizer' + 'optimizer is not an object of tf_keras.optimizers.Optimizer' ) self._optimizer = optimizer @@ -152,7 +152,7 @@ def _resource_apply_sparse(self, grad, var, indices): def get_config(self): config = { - 'optimizer': tf.keras.optimizers.serialize(self._optimizer), + 'optimizer': tf_keras.optimizers.serialize(self._optimizer), 'sync_period': self._serialize_hyperparameter('sync_period'), 'slow_step_size': self._serialize_hyperparameter('slow_step_size'), } @@ -177,7 +177,7 @@ def lr(self, lr): @classmethod def from_config(cls, config, custom_objects=None): - optimizer = tf.keras.optimizers.deserialize( + optimizer = tf_keras.optimizers.deserialize( config.pop('optimizer'), custom_objects=custom_objects ) return cls(optimizer, **config) @@ -185,24 +185,24 @@ def from_config(cls, config, custom_objects=None): def build_optimizer( optimizer_name: Text, - base_learning_rate: tf.keras.optimizers.schedules.LearningRateSchedule, + base_learning_rate: tf_keras.optimizers.schedules.LearningRateSchedule, params: Dict[Text, Any], - model: Optional[tf.keras.Model] = None): + model: Optional[tf_keras.Model] = None): """Build the optimizer based on name. Args: optimizer_name: String representation of the optimizer name. Examples: sgd, momentum, rmsprop. - base_learning_rate: `tf.keras.optimizers.schedules.LearningRateSchedule` + base_learning_rate: `tf_keras.optimizers.schedules.LearningRateSchedule` base learning rate. params: String -> Any dictionary representing the optimizer params. This should contain optimizer specific parameters such as `base_learning_rate`, `decay`, etc. - model: The `tf.keras.Model`. This is used for the shadow copy if using + model: The `tf_keras.Model`. This is used for the shadow copy if using `ExponentialMovingAverage`. Returns: - A tf.keras.optimizers.legacy.Optimizer. + A tf_keras.optimizers.legacy.Optimizer. Raises: ValueError if the provided optimizer_name is not supported. @@ -214,12 +214,12 @@ def build_optimizer( if optimizer_name == 'sgd': logging.info('Using SGD optimizer') nesterov = params.get('nesterov', False) - optimizer = tf.keras.optimizers.legacy.SGD( + optimizer = tf_keras.optimizers.legacy.SGD( learning_rate=base_learning_rate, nesterov=nesterov) elif optimizer_name == 'momentum': logging.info('Using momentum optimizer') nesterov = params.get('nesterov', False) - optimizer = tf.keras.optimizers.legacy.SGD( + optimizer = tf_keras.optimizers.legacy.SGD( learning_rate=base_learning_rate, momentum=params['momentum'], nesterov=nesterov) @@ -228,7 +228,7 @@ def build_optimizer( rho = params.get('decay', None) or params.get('rho', 0.9) momentum = params.get('momentum', 0.9) epsilon = params.get('epsilon', 1e-07) - optimizer = tf.keras.optimizers.legacy.RMSprop( + optimizer = tf_keras.optimizers.legacy.RMSprop( learning_rate=base_learning_rate, rho=rho, momentum=momentum, @@ -238,7 +238,7 @@ def build_optimizer( beta_1 = params.get('beta_1', 0.9) beta_2 = params.get('beta_2', 0.999) epsilon = params.get('epsilon', 1e-07) - optimizer = tf.keras.optimizers.legacy.Adam( + optimizer = tf_keras.optimizers.legacy.Adam( learning_rate=base_learning_rate, beta_1=beta_1, beta_2=beta_2, @@ -307,7 +307,7 @@ def build_learning_rate(params: base_configs.LearningRateConfig, 'Using exponential learning rate with: ' 'initial_learning_rate: %f, decay_steps: %d, ' 'decay_rate: %f', base_lr, decay_steps, decay_rate) - lr = tf.keras.optimizers.schedules.ExponentialDecay( + lr = tf_keras.optimizers.schedules.ExponentialDecay( initial_learning_rate=base_lr, decay_steps=decay_steps, decay_rate=decay_rate, @@ -319,7 +319,7 @@ def build_learning_rate(params: base_configs.LearningRateConfig, logging.info( 'Using stepwise learning rate. Parameters: ' 'boundaries: %s, values: %s', boundaries, multipliers) - lr = tf.keras.optimizers.schedules.PiecewiseConstantDecay( + lr = tf_keras.optimizers.schedules.PiecewiseConstantDecay( boundaries=boundaries, values=multipliers) elif decay_type == 'cosine_with_warmup': lr = learning_rate.CosineDecayWithWarmup( diff --git a/official/legacy/image_classification/optimizer_factory_test.py b/official/legacy/image_classification/optimizer_factory_test.py index 828be58549c..f96d6da9936 100644 --- a/official/legacy/image_classification/optimizer_factory_test.py +++ b/official/legacy/image_classification/optimizer_factory_test.py @@ -20,17 +20,17 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import optimizer_factory from official.legacy.image_classification.configs import base_configs class OptimizerFactoryTest(tf.test.TestCase, parameterized.TestCase): - def build_toy_model(self) -> tf.keras.Model: + def build_toy_model(self) -> tf_keras.Model: """Creates a toy `tf.Keras.Model`.""" - model = tf.keras.Sequential() - model.add(tf.keras.layers.Dense(1, input_shape=(1,))) + model = tf_keras.Sequential() + model.add(tf_keras.layers.Dense(1, input_shape=(1,))) return model @parameterized.named_parameters( @@ -58,7 +58,7 @@ def test_optimizer(self, optimizer_name, moving_average_decay, lookahead): params=params, model=model) self.assertTrue( - issubclass(type(optimizer), tf.keras.optimizers.legacy.Optimizer) + issubclass(type(optimizer), tf_keras.optimizers.legacy.Optimizer) ) def test_unknown_optimizer(self): @@ -86,7 +86,7 @@ def test_learning_rate_without_decay_or_warmups(self): params=params, batch_size=batch_size, train_steps=train_steps) self.assertTrue( issubclass( - type(lr), tf.keras.optimizers.schedules.LearningRateSchedule)) + type(lr), tf_keras.optimizers.schedules.LearningRateSchedule)) @parameterized.named_parameters(('exponential', 'exponential'), ('cosine_with_warmup', 'cosine_with_warmup')) @@ -113,7 +113,7 @@ def test_learning_rate_with_decay_and_warmup(self, lr_decay_type): train_steps=train_steps) self.assertTrue( issubclass( - type(lr), tf.keras.optimizers.schedules.LearningRateSchedule)) + type(lr), tf_keras.optimizers.schedules.LearningRateSchedule)) if __name__ == '__main__': diff --git a/official/legacy/image_classification/preprocessing.py b/official/legacy/image_classification/preprocessing.py index 4884f89f90d..dc73cc93fa0 100644 --- a/official/legacy/image_classification/preprocessing.py +++ b/official/legacy/image_classification/preprocessing.py @@ -18,7 +18,7 @@ from __future__ import division from __future__ import print_function from typing import List, Optional, Text, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import augment diff --git a/official/legacy/image_classification/resnet/common.py b/official/legacy/image_classification/resnet/common.py index fa44f9d0419..b97721fb556 100644 --- a/official/legacy/image_classification/resnet/common.py +++ b/official/legacy/image_classification/resnet/common.py @@ -20,7 +20,7 @@ import os from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.utils.flags import core as flags_core @@ -35,7 +35,7 @@ class PiecewiseConstantDecayWithWarmup( - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): """Piecewise constant decay with warmup schedule.""" def __init__(self, @@ -110,10 +110,10 @@ def get_optimizer(learning_rate=0.1, use_legacy_optimizer=True): """Returns optimizer to use.""" # The learning_rate is overwritten at the beginning of each step by callback. if use_legacy_optimizer: - return tf.keras.optimizers.legacy.SGD( + return tf_keras.optimizers.legacy.SGD( learning_rate=learning_rate, momentum=0.9) else: - return tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9) + return tf_keras.optimizers.SGD(learning_rate=learning_rate, momentum=0.9) def get_callbacks(pruning_method=None, @@ -127,7 +127,7 @@ def get_callbacks(pruning_method=None, callbacks = [time_callback] if FLAGS.enable_tensorboard: - tensorboard_callback = tf.keras.callbacks.TensorBoard( + tensorboard_callback = tf_keras.callbacks.TensorBoard( log_dir=FLAGS.model_dir, profile_batch=FLAGS.profile_steps) callbacks.append(tensorboard_callback) @@ -143,7 +143,7 @@ def get_callbacks(pruning_method=None, if model_dir is not None: ckpt_full_path = os.path.join(model_dir, 'model.ckpt-{epoch:04d}') callbacks.append( - tf.keras.callbacks.ModelCheckpoint( + tf_keras.callbacks.ModelCheckpoint( ckpt_full_path, save_weights_only=True)) return callbacks diff --git a/official/legacy/image_classification/resnet/imagenet_preprocessing.py b/official/legacy/image_classification/resnet/imagenet_preprocessing.py index 5eab9259670..00ad8e61c76 100644 --- a/official/legacy/image_classification/resnet/imagenet_preprocessing.py +++ b/official/legacy/image_classification/resnet/imagenet_preprocessing.py @@ -38,7 +38,7 @@ import os from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras DEFAULT_IMAGE_SIZE = 224 NUM_CHANNELS = 3 @@ -257,13 +257,13 @@ def get_parse_record_fn(use_keras_image_data_format=False): This is useful by handling different types of Keras models. For instance, the current resnet_model.resnet50 input format is always channel-last, whereas the keras_applications mobilenet input format depends on - tf.keras.backend.image_data_format(). We should set + tf_keras.backend.image_data_format(). We should set use_keras_image_data_format=False for the former and True for the latter. Args: use_keras_image_data_format: A boolean denoting whether data format is keras backend image data format. If False, the image format is channel-last. If - True, the image format matches tf.keras.backend.image_data_format(). + True, the image format matches tf_keras.backend.image_data_format(). Returns: Function to use for parsing the records. @@ -272,7 +272,7 @@ def get_parse_record_fn(use_keras_image_data_format=False): def parse_record_fn(raw_record, is_training, dtype): image, label = parse_record(raw_record, is_training, dtype) if use_keras_image_data_format: - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': image = tf.transpose(image, perm=[2, 0, 1]) return image, label diff --git a/official/legacy/image_classification/resnet/resnet_ctl_imagenet_main.py b/official/legacy/image_classification/resnet/resnet_ctl_imagenet_main.py index 504fd0bc9fd..d0f1696aa0d 100644 --- a/official/legacy/image_classification/resnet/resnet_ctl_imagenet_main.py +++ b/official/legacy/image_classification/resnet/resnet_ctl_imagenet_main.py @@ -22,7 +22,7 @@ from absl import flags from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.image_classification.resnet import common from official.legacy.image_classification.resnet import imagenet_preprocessing @@ -113,7 +113,7 @@ def run(flags_obj): if data_format is None: data_format = ('channels_first' if tf.config.list_physical_devices('GPU') else 'channels_last') - tf.keras.backend.set_image_data_format(data_format) + tf_keras.backend.set_image_data_format(data_format) strategy = distribute_utils.get_distribution_strategy( distribution_strategy=flags_obj.distribution_strategy, diff --git a/official/legacy/image_classification/resnet/resnet_model.py b/official/legacy/image_classification/resnet/resnet_model.py index ac8a0fd4a8d..6ee17ae693d 100644 --- a/official/legacy/image_classification/resnet/resnet_model.py +++ b/official/legacy/image_classification/resnet/resnet_model.py @@ -14,7 +14,7 @@ """ResNet50 model for Keras. -Adapted from tf.keras.applications.resnet50.ResNet50(). +Adapted from tf_keras.applications.resnet50.ResNet50(). This is ResNet model version 1.5. Related papers/blogs: @@ -27,14 +27,14 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification.resnet import imagenet_preprocessing -layers = tf.keras.layers +layers = tf_keras.layers def _gen_l2_regularizer(use_l2_regularizer=True, l2_weight_decay=1e-4): - return tf.keras.regularizers.L2( + return tf_keras.regularizers.L2( l2_weight_decay) if use_l2_regularizer else None @@ -62,7 +62,7 @@ def identity_block(input_tensor, Output tensor for the block. """ filters1, filters2, filters3 = filters - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 @@ -150,7 +150,7 @@ def conv_block(input_tensor, Output tensor for the block. """ filters1, filters2, filters3 = filters - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 @@ -249,7 +249,7 @@ def resnet50(num_classes, # Hub image modules expect inputs in the range [0, 1]. This rescales these # inputs to the range expected by the trained model. x = layers.Lambda( - lambda x: x * 255.0 - tf.keras.backend.constant( # pylint: disable=g-long-lambda + lambda x: x * 255.0 - tf_keras.backend.constant( # pylint: disable=g-long-lambda imagenet_preprocessing.CHANNEL_MEANS, shape=[1, 1, 3], dtype=x.dtype), @@ -258,7 +258,7 @@ def resnet50(num_classes, else: x = img_input - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': x = layers.Permute((3, 1, 2))(x) bn_axis = 1 else: # channels_last @@ -322,4 +322,4 @@ def resnet50(num_classes, x = layers.Activation('softmax', dtype='float32')(x) # Create model. - return tf.keras.Model(img_input, x, name='resnet50') + return tf_keras.Model(img_input, x, name='resnet50') diff --git a/official/legacy/image_classification/resnet/resnet_runnable.py b/official/legacy/image_classification/resnet/resnet_runnable.py index e37851564e0..101a663533b 100644 --- a/official/legacy/image_classification/resnet/resnet_runnable.py +++ b/official/legacy/image_classification/resnet/resnet_runnable.py @@ -15,7 +15,7 @@ """Runs a ResNet model on the ImageNet dataset using custom training loops.""" import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification.resnet import common from official.legacy.image_classification.resnet import imagenet_preprocessing from official.legacy.image_classification.resnet import resnet_model @@ -76,11 +76,11 @@ def __init__(self, flags_obj, time_callback, epoch_steps): use_float16=self.dtype == tf.float16, loss_scale=flags_core.get_loss_scale(flags_obj, default_for_fp16=128)) - self.train_loss = tf.keras.metrics.Mean('train_loss', dtype=tf.float32) - self.train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( + self.train_loss = tf_keras.metrics.Mean('train_loss', dtype=tf.float32) + self.train_accuracy = tf_keras.metrics.SparseCategoricalAccuracy( 'train_accuracy', dtype=tf.float32) - self.test_loss = tf.keras.metrics.Mean('test_loss', dtype=tf.float32) - self.test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy( + self.test_loss = tf_keras.metrics.Mean('test_loss', dtype=tf.float32) + self.test_accuracy = tf_keras.metrics.SparseCategoricalAccuracy( 'test_accuracy', dtype=tf.float32) self.checkpoint = tf.train.Checkpoint( @@ -140,7 +140,7 @@ def step_fn(inputs): with tf.GradientTape() as tape: logits = self.model(images, training=True) - prediction_loss = tf.keras.losses.sparse_categorical_crossentropy( + prediction_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, logits) loss = tf.reduce_sum(prediction_loss) * (1.0 / self.flags_obj.batch_size) @@ -187,7 +187,7 @@ def step_fn(inputs): """Function to run on the device.""" images, labels = inputs logits = self.model(images, training=False) - loss = tf.keras.losses.sparse_categorical_crossentropy(labels, logits) + loss = tf_keras.losses.sparse_categorical_crossentropy(labels, logits) loss = tf.reduce_sum(loss) * (1.0 / self.flags_obj.batch_size) self.test_loss.update_state(loss) self.test_accuracy.update_state(labels, logits) diff --git a/official/legacy/image_classification/resnet/tfhub_export.py b/official/legacy/image_classification/resnet/tfhub_export.py index c98be645e7e..2c319da3589 100644 --- a/official/legacy/image_classification/resnet/tfhub_export.py +++ b/official/legacy/image_classification/resnet/tfhub_export.py @@ -24,7 +24,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification.resnet import imagenet_preprocessing from official.legacy.image_classification.resnet import resnet_model @@ -38,7 +38,7 @@ def export_tfhub(model_path, hub_destination): - """Restores a tf.keras.Model and saves for TF-Hub.""" + """Restores a tf_keras.Model and saves for TF-Hub.""" model = resnet_model.resnet50( num_classes=imagenet_preprocessing.NUM_CLASSES, rescale_inputs=True) model.load_weights(model_path) @@ -48,7 +48,7 @@ def export_tfhub(model_path, hub_destination): # Extracts a sub-model to use pooling feature vector as model output. image_input = model.get_layer(index=0).get_output_at(0) feature_vector_output = model.get_layer(name="reduce_mean").get_output_at(0) - hub_model = tf.keras.Model(image_input, feature_vector_output) + hub_model = tf_keras.Model(image_input, feature_vector_output) # Exports a SavedModel. hub_model.save( diff --git a/official/legacy/image_classification/test_utils.py b/official/legacy/image_classification/test_utils.py index 762e18061ce..1b3cabd5f09 100644 --- a/official/legacy/image_classification/test_utils.py +++ b/official/legacy/image_classification/test_utils.py @@ -18,20 +18,20 @@ from __future__ import division from __future__ import print_function -import tensorflow as tf +import tensorflow as tf, tf_keras def trivial_model(num_classes): """Trivial model for ImageNet dataset.""" input_shape = (224, 224, 3) - img_input = tf.keras.layers.Input(shape=input_shape) + img_input = tf_keras.layers.Input(shape=input_shape) - x = tf.keras.layers.Lambda( - lambda x: tf.keras.backend.reshape(x, [-1, 224 * 224 * 3]), + x = tf_keras.layers.Lambda( + lambda x: tf_keras.backend.reshape(x, [-1, 224 * 224 * 3]), name='reshape')(img_input) - x = tf.keras.layers.Dense(1, name='fc1')(x) - x = tf.keras.layers.Dense(num_classes, name='fc1000')(x) - x = tf.keras.layers.Activation('softmax', dtype='float32')(x) + x = tf_keras.layers.Dense(1, name='fc1')(x) + x = tf_keras.layers.Dense(num_classes, name='fc1000')(x) + x = tf_keras.layers.Activation('softmax', dtype='float32')(x) - return tf.keras.models.Model(img_input, x, name='trivial') + return tf_keras.models.Model(img_input, x, name='trivial') diff --git a/official/legacy/image_classification/vgg/vgg_model.py b/official/legacy/image_classification/vgg/vgg_model.py index ac59afc5c81..f48cf08a1f7 100644 --- a/official/legacy/image_classification/vgg/vgg_model.py +++ b/official/legacy/image_classification/vgg/vgg_model.py @@ -14,19 +14,19 @@ """VGG16 model for Keras. -Adapted from tf.keras.applications.vgg16.VGG16(). +Adapted from tf_keras.applications.vgg16.VGG16(). Related papers/blogs: - https://arxiv.org/abs/1409.1556 """ -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers def _gen_l2_regularizer(use_l2_regularizer=True, l2_weight_decay=1e-4): - return tf.keras.regularizers.L2( + return tf_keras.regularizers.L2( l2_weight_decay) if use_l2_regularizer else None @@ -53,7 +53,7 @@ def vgg16(num_classes, x = img_input - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': x = layers.Permute((3, 1, 2))(x) bn_axis = 1 else: # channels_last @@ -266,4 +266,4 @@ def vgg16(num_classes, x = layers.Activation('softmax', dtype='float32')(x) # Create model. - return tf.keras.Model(img_input, x, name='vgg16') + return tf_keras.Model(img_input, x, name='vgg16') diff --git a/official/legacy/transformer/attention_layer.py b/official/legacy/transformer/attention_layer.py index fcdce774b03..50e11253afe 100644 --- a/official/legacy/transformer/attention_layer.py +++ b/official/legacy/transformer/attention_layer.py @@ -15,12 +15,12 @@ """Implementation of multiheaded attention and self-attention layers.""" import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class Attention(tf.keras.layers.Layer): +class Attention(tf_keras.layers.Layer): """Multi-headed attention layer.""" def __init__(self, hidden_size, num_heads, attention_dropout): @@ -48,23 +48,23 @@ def build(self, input_shape): def _glorot_initializer(fan_in, fan_out): limit = math.sqrt(6.0 / (fan_in + fan_out)) - return tf.keras.initializers.RandomUniform(minval=-limit, maxval=limit) + return tf_keras.initializers.RandomUniform(minval=-limit, maxval=limit) attention_initializer = _glorot_initializer(input_shape.as_list()[-1], self.hidden_size) - self.query_dense_layer = tf.keras.layers.EinsumDense( + self.query_dense_layer = tf_keras.layers.EinsumDense( "BTE,ENH->BTNH", output_shape=(None, self.num_heads, size_per_head), kernel_initializer=tf_utils.clone_initializer(attention_initializer), bias_axes=None, name="query") - self.key_dense_layer = tf.keras.layers.EinsumDense( + self.key_dense_layer = tf_keras.layers.EinsumDense( "BTE,ENH->BTNH", output_shape=(None, self.num_heads, size_per_head), kernel_initializer=tf_utils.clone_initializer(attention_initializer), bias_axes=None, name="key") - self.value_dense_layer = tf.keras.layers.EinsumDense( + self.value_dense_layer = tf_keras.layers.EinsumDense( "BTE,ENH->BTNH", output_shape=(None, self.num_heads, size_per_head), kernel_initializer=tf_utils.clone_initializer(attention_initializer), @@ -72,7 +72,7 @@ def _glorot_initializer(fan_in, fan_out): name="value") output_initializer = _glorot_initializer(self.hidden_size, self.hidden_size) - self.output_dense_layer = tf.keras.layers.EinsumDense( + self.output_dense_layer = tf_keras.layers.EinsumDense( "BTNH,NHE->BTE", output_shape=(None, self.hidden_size), kernel_initializer=output_initializer, diff --git a/official/legacy/transformer/compute_bleu.py b/official/legacy/transformer/compute_bleu.py index ed14d191994..2df04fb6d02 100644 --- a/official/legacy/transformer/compute_bleu.py +++ b/official/legacy/transformer/compute_bleu.py @@ -27,7 +27,7 @@ from absl import logging import six from six.moves import range -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer.utils import metrics from official.legacy.transformer.utils import tokenizer diff --git a/official/legacy/transformer/compute_bleu_test.py b/official/legacy/transformer/compute_bleu_test.py index 38e528ca9bf..c9ae2716a13 100644 --- a/official/legacy/transformer/compute_bleu_test.py +++ b/official/legacy/transformer/compute_bleu_test.py @@ -16,7 +16,7 @@ import tempfile -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import compute_bleu diff --git a/official/legacy/transformer/data_pipeline.py b/official/legacy/transformer/data_pipeline.py index da89b014693..fbcf8694047 100644 --- a/official/legacy/transformer/data_pipeline.py +++ b/official/legacy/transformer/data_pipeline.py @@ -50,7 +50,7 @@ import os from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.utils.misc import model_helpers diff --git a/official/legacy/transformer/embedding_layer.py b/official/legacy/transformer/embedding_layer.py index 75a769322c8..2dbc285552d 100644 --- a/official/legacy/transformer/embedding_layer.py +++ b/official/legacy/transformer/embedding_layer.py @@ -14,10 +14,10 @@ """Implementation of embedding layer with shared weights.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -class EmbeddingSharedWeights(tf.keras.layers.Layer): +class EmbeddingSharedWeights(tf_keras.layers.Layer): """Calculates input embeddings and pre-softmax linear with shared weights.""" def __init__(self, vocab_size, hidden_size): diff --git a/official/legacy/transformer/ffn_layer.py b/official/legacy/transformer/ffn_layer.py index 42be6a117a6..772eb694df6 100644 --- a/official/legacy/transformer/ffn_layer.py +++ b/official/legacy/transformer/ffn_layer.py @@ -14,10 +14,10 @@ """Implementation of fully connected network.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -class FeedForwardNetwork(tf.keras.layers.Layer): +class FeedForwardNetwork(tf_keras.layers.Layer): """Fully connected feedforward network.""" def __init__(self, hidden_size, filter_size, relu_dropout): @@ -34,12 +34,12 @@ def __init__(self, hidden_size, filter_size, relu_dropout): self.relu_dropout = relu_dropout def build(self, input_shape): - self.filter_dense_layer = tf.keras.layers.Dense( + self.filter_dense_layer = tf_keras.layers.Dense( self.filter_size, use_bias=True, activation=tf.nn.relu, name="filter_layer") - self.output_dense_layer = tf.keras.layers.Dense( + self.output_dense_layer = tf_keras.layers.Dense( self.hidden_size, use_bias=True, name="output_layer") super(FeedForwardNetwork, self).build(input_shape) diff --git a/official/legacy/transformer/metrics.py b/official/legacy/transformer/metrics.py index 6d0c73cd0be..e70060207c6 100644 --- a/official/legacy/transformer/metrics.py +++ b/official/legacy/transformer/metrics.py @@ -25,7 +25,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras def _pad_tensors_to_same_length(x, y): @@ -131,7 +131,7 @@ def padded_neg_log_perplexity(logits, labels, vocab_size): return -num, den -class MetricLayer(tf.keras.layers.Layer): +class MetricLayer(tf_keras.layers.Layer): """Custom a layer of metrics for Transformer model.""" def __init__(self, vocab_size): @@ -144,11 +144,11 @@ def build(self, input_shape): neg_log_perplexity = functools.partial( padded_neg_log_perplexity, vocab_size=self.vocab_size) self.metric_mean_fns = [ - (tf.keras.metrics.Mean("accuracy"), padded_accuracy), - (tf.keras.metrics.Mean("accuracy_top5"), padded_accuracy_top5), - (tf.keras.metrics.Mean("accuracy_per_sequence"), + (tf_keras.metrics.Mean("accuracy"), padded_accuracy), + (tf_keras.metrics.Mean("accuracy_top5"), padded_accuracy_top5), + (tf_keras.metrics.Mean("accuracy_per_sequence"), padded_sequence_accuracy), - (tf.keras.metrics.Mean("neg_log_perplexity"), neg_log_perplexity), + (tf_keras.metrics.Mean("neg_log_perplexity"), neg_log_perplexity), ] super(MetricLayer, self).build(input_shape) diff --git a/official/legacy/transformer/misc.py b/official/legacy/transformer/misc.py index 969176dd98f..66f2e059d37 100644 --- a/official/legacy/transformer/misc.py +++ b/official/legacy/transformer/misc.py @@ -17,7 +17,7 @@ # pylint: disable=g-bad-import-order from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import model_params from official.utils.flags import core as flags_core @@ -250,7 +250,7 @@ def get_callbacks(): callbacks.append(time_callback) if FLAGS.enable_tensorboard: - tensorboard_callback = tf.keras.callbacks.TensorBoard( + tensorboard_callback = tf_keras.callbacks.TensorBoard( log_dir=FLAGS.model_dir) callbacks.append(tensorboard_callback) diff --git a/official/legacy/transformer/model_utils.py b/official/legacy/transformer/model_utils.py index 10502306b94..5867a603783 100644 --- a/official/legacy/transformer/model_utils.py +++ b/official/legacy/transformer/model_utils.py @@ -17,7 +17,7 @@ import math import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # Very low numbers to represent -infinity. We do not actually use -Inf, since we # want to be able to multiply these values by zero to get zero. (-Inf * 0 = NaN) diff --git a/official/legacy/transformer/model_utils_test.py b/official/legacy/transformer/model_utils_test.py index d274ced53c2..195fa8f3599 100644 --- a/official/legacy/transformer/model_utils_test.py +++ b/official/legacy/transformer/model_utils_test.py @@ -14,7 +14,7 @@ """Test Transformer model helper methods.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import model_utils diff --git a/official/legacy/transformer/optimizer.py b/official/legacy/transformer/optimizer.py index 533908ee861..dd186e3458e 100644 --- a/official/legacy/transformer/optimizer.py +++ b/official/legacy/transformer/optimizer.py @@ -14,10 +14,10 @@ """Optimizer from addons and learning rate scheduler.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -class LearningRateSchedule(tf.keras.optimizers.schedules.LearningRateSchedule): +class LearningRateSchedule(tf_keras.optimizers.schedules.LearningRateSchedule): """Learning rate schedule.""" def __init__(self, initial_learning_rate, hidden_size, warmup_steps): diff --git a/official/legacy/transformer/transformer.py b/official/legacy/transformer/transformer.py index 5223e4f2acd..cc38b898969 100644 --- a/official/legacy/transformer/transformer.py +++ b/official/legacy/transformer/transformer.py @@ -18,7 +18,7 @@ Transformer model code source: https://github.com/tensorflow/tensor2tensor """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import attention_layer from official.legacy.transformer import embedding_layer @@ -38,32 +38,32 @@ def create_model(params, is_train): """Creates transformer model.""" with tf.name_scope("model"): if is_train: - inputs = tf.keras.layers.Input((None,), dtype="int64", name="inputs") - targets = tf.keras.layers.Input((None,), dtype="int64", name="targets") + inputs = tf_keras.layers.Input((None,), dtype="int64", name="inputs") + targets = tf_keras.layers.Input((None,), dtype="int64", name="targets") internal_model = Transformer(params, name="transformer_v2") logits = internal_model([inputs, targets], training=is_train) vocab_size = params["vocab_size"] label_smoothing = params["label_smoothing"] if params["enable_metrics_in_training"]: logits = metrics.MetricLayer(vocab_size)([logits, targets]) - logits = tf.keras.layers.Lambda( + logits = tf_keras.layers.Lambda( lambda x: x, name="logits", dtype=tf.float32)( logits) - model = tf.keras.Model([inputs, targets], logits) + model = tf_keras.Model([inputs, targets], logits) loss = metrics.transformer_loss(logits, targets, label_smoothing, vocab_size) model.add_loss(loss) return model else: - inputs = tf.keras.layers.Input((None,), dtype="int64", name="inputs") + inputs = tf_keras.layers.Input((None,), dtype="int64", name="inputs") internal_model = Transformer(params, name="transformer_v2") ret = internal_model([inputs], training=is_train) outputs, scores = ret["outputs"], ret["scores"] - return tf.keras.Model(inputs, [outputs, scores]) + return tf_keras.Model(inputs, [outputs, scores]) -class Transformer(tf.keras.Model): +class Transformer(tf_keras.Model): """Transformer model with Keras. Implemented as described in: https://arxiv.org/pdf/1706.03762.pdf @@ -339,7 +339,7 @@ def predict(self, encoder_outputs, encoder_decoder_attention_bias, training): return {"outputs": top_decoded_ids, "scores": top_scores} -class PrePostProcessingWrapper(tf.keras.layers.Layer): +class PrePostProcessingWrapper(tf_keras.layers.Layer): """Wrapper class that applies layer pre-processing and post-processing.""" def __init__(self, layer, params): @@ -350,7 +350,7 @@ def __init__(self, layer, params): def build(self, input_shape): # Create normalization layer - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( epsilon=1e-6, dtype="float32") super(PrePostProcessingWrapper, self).build(input_shape) @@ -375,7 +375,7 @@ def call(self, x, *args, **kwargs): return x + y -class EncoderStack(tf.keras.layers.Layer): +class EncoderStack(tf_keras.layers.Layer): """Transformer encoder stack. The encoder stack is made up of N identical layers. Each layer is composed @@ -406,7 +406,7 @@ def build(self, input_shape): ]) # Create final layer normalization layer. - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=1e-6, dtype="float32") super(EncoderStack, self).build(input_shape) @@ -446,7 +446,7 @@ def call(self, encoder_inputs, attention_bias, inputs_padding, training): return self.output_normalization(encoder_inputs) -class DecoderStack(tf.keras.layers.Layer): +class DecoderStack(tf_keras.layers.Layer): """Transformer decoder stack. Like the encoder stack, the decoder stack is made up of N identical layers. @@ -480,7 +480,7 @@ def build(self, input_shape): PrePostProcessingWrapper(enc_dec_attention_layer, params), PrePostProcessingWrapper(feed_forward_network, params) ]) - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=1e-6, dtype="float32") super(DecoderStack, self).build(input_shape) diff --git a/official/legacy/transformer/transformer_forward_test.py b/official/legacy/transformer/transformer_forward_test.py index af134a98700..20796a93b62 100644 --- a/official/legacy/transformer/transformer_forward_test.py +++ b/official/legacy/transformer/transformer_forward_test.py @@ -15,7 +15,7 @@ """Forward pass test for Transformer model refactoring.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import metrics from official.legacy.transformer import model_params @@ -30,7 +30,7 @@ def _count_params(layer, trainable_only=True): else: return int( np.sum([ - tf.keras.backend.count_params(p) for p in layer.trainable_weights + tf_keras.backend.count_params(p) for p in layer.trainable_weights ])) @@ -66,8 +66,8 @@ def _create_model(params, is_train): name="transformer_v2") if is_train: - inputs = tf.keras.layers.Input((None,), dtype="int64", name="inputs") - targets = tf.keras.layers.Input((None,), dtype="int64", name="targets") + inputs = tf_keras.layers.Input((None,), dtype="int64", name="inputs") + targets = tf_keras.layers.Input((None,), dtype="int64", name="targets") internal_model = models.Seq2SeqTransformer(**model_kwargs) logits = internal_model( dict(inputs=inputs, targets=targets), training=is_train) @@ -75,24 +75,24 @@ def _create_model(params, is_train): label_smoothing = params["label_smoothing"] if params["enable_metrics_in_training"]: logits = metrics.MetricLayer(vocab_size)([logits, targets]) - logits = tf.keras.layers.Lambda( + logits = tf_keras.layers.Lambda( lambda x: x, name="logits", dtype=tf.float32)( logits) - model = tf.keras.Model([inputs, targets], logits) + model = tf_keras.Model([inputs, targets], logits) loss = metrics.transformer_loss(logits, targets, label_smoothing, vocab_size) model.add_loss(loss) return model batch_size = params["decode_batch_size"] if params["padded_decode"] else None - inputs = tf.keras.layers.Input((None,), + inputs = tf_keras.layers.Input((None,), batch_size=batch_size, dtype="int64", name="inputs") internal_model = models.Seq2SeqTransformer(**model_kwargs) ret = internal_model(dict(inputs=inputs), training=is_train) outputs, scores = ret["outputs"], ret["scores"] - return tf.keras.Model(inputs, [outputs, scores]) + return tf_keras.Model(inputs, [outputs, scores]) class TransformerForwardTest(tf.test.TestCase): diff --git a/official/legacy/transformer/transformer_layers_test.py b/official/legacy/transformer/transformer_layers_test.py index b939f59216b..c07c51d749d 100644 --- a/official/legacy/transformer/transformer_layers_test.py +++ b/official/legacy/transformer/transformer_layers_test.py @@ -14,7 +14,7 @@ """Tests for layers in Transformer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import attention_layer from official.legacy.transformer import embedding_layer @@ -109,10 +109,10 @@ def test_feed_forward_network(self): def test_metric_layer(self): vocab_size = 50 - logits = tf.keras.layers.Input((None, vocab_size), + logits = tf_keras.layers.Input((None, vocab_size), dtype="float32", name="logits") - targets = tf.keras.layers.Input((None,), dtype="int64", name="targets") + targets = tf_keras.layers.Input((None,), dtype="int64", name="targets") output_logits = metrics.MetricLayer(vocab_size)([logits, targets]) self.assertEqual(output_logits.shape.as_list(), [ None, diff --git a/official/legacy/transformer/transformer_main.py b/official/legacy/transformer/transformer_main.py index 7300fa4e849..0c3e4a93bd2 100644 --- a/official/legacy/transformer/transformer_main.py +++ b/official/legacy/transformer/transformer_main.py @@ -26,7 +26,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.transformer import compute_bleu @@ -208,7 +208,7 @@ def train(self): current_step = opt.iterations.numpy() if params["use_ctl"]: - train_loss_metric = tf.keras.metrics.Mean( + train_loss_metric = tf_keras.metrics.Mean( "training_loss", dtype=tf.float32) if params["enable_tensorboard"]: summary_writer = tf.summary.create_file_writer( @@ -411,7 +411,7 @@ def _create_callbacks(self, cur_log_dir, params): if params["enable_checkpointing"]: ckpt_full_path = os.path.join(cur_log_dir, "cp-{epoch:04d}.ckpt") callbacks.append( - tf.keras.callbacks.ModelCheckpoint( + tf_keras.callbacks.ModelCheckpoint( ckpt_full_path, save_weights_only=params["save_weights_only"])) return callbacks @@ -434,7 +434,7 @@ def _create_optimizer(self): lr_schedule = optimizer.LearningRateSchedule( params["learning_rate"], params["hidden_size"], params["learning_rate_warmup_steps"]) - opt = tf.keras.optimizers.Adam( + opt = tf_keras.optimizers.Adam( lr_schedule, params["optimizer_adam_beta1"], params["optimizer_adam_beta2"], diff --git a/official/legacy/transformer/transformer_main_test.py b/official/legacy/transformer/transformer_main_test.py index 4bf5ccb2b6a..6a669eba095 100644 --- a/official/legacy/transformer/transformer_main_test.py +++ b/official/legacy/transformer/transformer_main_test.py @@ -21,7 +21,7 @@ from absl import flags from absl.testing import flagsaver -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.eager import context # pylint: disable=ungrouped-imports from official.legacy.transformer import misc from official.legacy.transformer import transformer_main diff --git a/official/legacy/transformer/transformer_test.py b/official/legacy/transformer/transformer_test.py index 654fb210a87..51807359255 100644 --- a/official/legacy/transformer/transformer_test.py +++ b/official/legacy/transformer/transformer_test.py @@ -14,7 +14,7 @@ """Test Transformer model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import model_params from official.legacy.transformer import transformer diff --git a/official/legacy/transformer/translate.py b/official/legacy/transformer/translate.py index 1bc56b29186..d99c5a73189 100644 --- a/official/legacy/transformer/translate.py +++ b/official/legacy/transformer/translate.py @@ -17,7 +17,7 @@ # Import libraries from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer.utils import tokenizer @@ -110,7 +110,7 @@ def input_generator(): if distribution_strategy: for j in range(batch_size - len(lines)): lines.append([tokenizer.EOS_ID]) - batch = tf.keras.preprocessing.sequence.pad_sequences( + batch = tf_keras.preprocessing.sequence.pad_sequences( lines, maxlen=params["decode_max_length"], dtype="int32", diff --git a/official/legacy/transformer/utils/tokenizer.py b/official/legacy/transformer/utils/tokenizer.py index f9e960c526f..dfb3bd52dd6 100644 --- a/official/legacy/transformer/utils/tokenizer.py +++ b/official/legacy/transformer/utils/tokenizer.py @@ -28,7 +28,7 @@ import numpy as np import six from six.moves import xrange # pylint: disable=redefined-builtin -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-complex-comprehension PAD = "" diff --git a/official/legacy/transformer/utils/tokenizer_test.py b/official/legacy/transformer/utils/tokenizer_test.py index 8a50693729e..2101ec97043 100644 --- a/official/legacy/transformer/utils/tokenizer_test.py +++ b/official/legacy/transformer/utils/tokenizer_test.py @@ -17,7 +17,7 @@ import collections import tempfile -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer.utils import tokenizer diff --git a/official/legacy/xlnet/data_utils.py b/official/legacy/xlnet/data_utils.py index bb45d06b177..5258ff98bc9 100644 --- a/official/legacy/xlnet/data_utils.py +++ b/official/legacy/xlnet/data_utils.py @@ -21,7 +21,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras special_symbols = { "": 0, @@ -529,7 +529,7 @@ def parser(record): for key in list(example.keys()): val = example[key] - if tf.keras.backend.is_sparse(val): + if tf_keras.backend.is_sparse(val): val = tf.sparse.to_dense(val) if val.dtype == tf.int64: val = tf.cast(val, tf.int32) diff --git a/official/legacy/xlnet/optimization.py b/official/legacy/xlnet/optimization.py index 0d77c9cda50..f731ad6807e 100644 --- a/official/legacy/xlnet/optimization.py +++ b/official/legacy/xlnet/optimization.py @@ -15,11 +15,11 @@ """Functions and classes related to optimization (weight updates).""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp import optimization -class WarmUp(tf.keras.optimizers.schedules.LearningRateSchedule): +class WarmUp(tf_keras.optimizers.schedules.LearningRateSchedule): """Applys a warmup schedule on a given learning rate decay schedule.""" def __init__(self, @@ -69,7 +69,7 @@ def create_optimizer(init_lr, weight_decay_rate=0.0): """Creates an optimizer with learning rate schedule.""" # Implements linear decay of the learning rate. - learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay( + learning_rate_fn = tf_keras.optimizers.schedules.PolynomialDecay( initial_learning_rate=init_lr, decay_steps=num_train_steps - num_warmup_steps, end_learning_rate=init_lr * min_lr_ratio) @@ -92,7 +92,7 @@ def create_optimizer(init_lr, include_in_weight_decay=["r_s_bias", "r_r_bias", "r_w_bias"]) else: logging.info("Using Adam with adam_epsilon=%.9f", (adam_epsilon)) - optimizer = tf.keras.optimizers.legacy.Adam( + optimizer = tf_keras.optimizers.legacy.Adam( learning_rate=learning_rate_fn, epsilon=adam_epsilon) return optimizer, learning_rate_fn diff --git a/official/legacy/xlnet/preprocess_classification_data.py b/official/legacy/xlnet/preprocess_classification_data.py index 29e1df03ecc..c3a28f7fef2 100644 --- a/official/legacy/xlnet/preprocess_classification_data.py +++ b/official/legacy/xlnet/preprocess_classification_data.py @@ -23,7 +23,7 @@ from absl import flags from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import sentencepiece as spm from official.legacy.xlnet import classifier_utils diff --git a/official/legacy/xlnet/preprocess_pretrain_data.py b/official/legacy/xlnet/preprocess_pretrain_data.py index f2d4c5195ac..88b875d3fec 100644 --- a/official/legacy/xlnet/preprocess_pretrain_data.py +++ b/official/legacy/xlnet/preprocess_pretrain_data.py @@ -614,7 +614,7 @@ def _convert_example(example, use_bfloat16): """Cast int64 into int32 and float32 to bfloat16 if use_bfloat16.""" for key in list(example.keys()): val = example[key] - if tf.keras.backend.is_sparse(val): + if tf_keras.backend.is_sparse(val): val = tf.sparse.to_dense(val) if val.dtype == tf.int64: val = tf.cast(val, tf.int32) diff --git a/official/legacy/xlnet/preprocess_squad_data.py b/official/legacy/xlnet/preprocess_squad_data.py index db359c88ba4..867be798efe 100644 --- a/official/legacy/xlnet/preprocess_squad_data.py +++ b/official/legacy/xlnet/preprocess_squad_data.py @@ -22,7 +22,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import sentencepiece as spm from official.legacy.xlnet import squad_utils diff --git a/official/legacy/xlnet/run_classifier.py b/official/legacy/xlnet/run_classifier.py index adfee2c7d15..c9147c9dc8a 100644 --- a/official/legacy/xlnet/run_classifier.py +++ b/official/legacy/xlnet/run_classifier.py @@ -21,7 +21,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.common import distribute_utils from official.legacy.xlnet import common_flags @@ -123,7 +123,7 @@ def _run_evaluation(test_iterator): def get_metric_fn(): - train_acc_metric = tf.keras.metrics.SparseCategoricalAccuracy( + train_acc_metric = tf_keras.metrics.SparseCategoricalAccuracy( "acc", dtype=tf.float32) return train_acc_metric diff --git a/official/legacy/xlnet/run_pretrain.py b/official/legacy/xlnet/run_pretrain.py index cb96174f773..cbb3dce3b3b 100644 --- a/official/legacy/xlnet/run_pretrain.py +++ b/official/legacy/xlnet/run_pretrain.py @@ -21,7 +21,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.common import distribute_utils from official.legacy.xlnet import common_flags diff --git a/official/legacy/xlnet/run_squad.py b/official/legacy/xlnet/run_squad.py index 4e36eae8b28..78dfd361d3f 100644 --- a/official/legacy/xlnet/run_squad.py +++ b/official/legacy/xlnet/run_squad.py @@ -24,7 +24,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import import sentencepiece as spm from official.common import distribute_utils diff --git a/official/legacy/xlnet/squad_utils.py b/official/legacy/xlnet/squad_utils.py index dbee8c5d347..98e9af557b3 100644 --- a/official/legacy/xlnet/squad_utils.py +++ b/official/legacy/xlnet/squad_utils.py @@ -30,7 +30,7 @@ from absl import logging import numpy as np import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.xlnet import data_utils from official.legacy.xlnet import preprocess_utils diff --git a/official/legacy/xlnet/training_utils.py b/official/legacy/xlnet/training_utils.py index 5d683506058..bf19f0b2e15 100644 --- a/official/legacy/xlnet/training_utils.py +++ b/official/legacy/xlnet/training_utils.py @@ -19,7 +19,7 @@ from typing import Any, Callable, Dict, Optional, Text from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import model_training_utils from official.legacy.xlnet import data_utils @@ -51,11 +51,11 @@ def train( train_input_fn: Callable, total_training_steps: int, steps_per_loop: int, - optimizer: tf.keras.optimizers.Optimizer, - learning_rate_fn: tf.keras.optimizers.schedules.LearningRateSchedule, - eval_fn: Optional[Callable[[tf.keras.Model, int, tf.summary.SummaryWriter], + optimizer: tf_keras.optimizers.Optimizer, + learning_rate_fn: tf_keras.optimizers.schedules.LearningRateSchedule, + eval_fn: Optional[Callable[[tf_keras.Model, int, tf.summary.SummaryWriter], Any]] = None, - metric_fn: Optional[Callable[[], tf.keras.metrics.Metric]] = None, + metric_fn: Optional[Callable[[], tf_keras.metrics.Metric]] = None, init_checkpoint: Optional[Text] = None, init_from_transformerxl: Optional[bool] = False, model_dir: Optional[Text] = None, @@ -140,7 +140,7 @@ def train( if not hasattr(model, "optimizer"): raise ValueError("User should set optimizer attribute to model.") - train_loss_metric = tf.keras.metrics.Mean("training_loss", dtype=tf.float32) + train_loss_metric = tf_keras.metrics.Mean("training_loss", dtype=tf.float32) train_metric = None if metric_fn: train_metric = metric_fn() diff --git a/official/legacy/xlnet/xlnet_config.py b/official/legacy/xlnet/xlnet_config.py index 2f5d562a301..35b7e979af9 100644 --- a/official/legacy/xlnet/xlnet_config.py +++ b/official/legacy/xlnet/xlnet_config.py @@ -17,7 +17,7 @@ import json import os -import tensorflow as tf +import tensorflow as tf, tf_keras def create_run_config(is_training, is_finetune, flags): diff --git a/official/legacy/xlnet/xlnet_modeling.py b/official/legacy/xlnet/xlnet_modeling.py index cff83cf353a..29c3f4f0463 100644 --- a/official/legacy/xlnet/xlnet_modeling.py +++ b/official/legacy/xlnet/xlnet_modeling.py @@ -17,22 +17,22 @@ import copy import warnings -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.xlnet import data_utils from official.nlp.modeling import networks def gelu(x): - return tf.keras.activations.gelu(x, approximate=True) + return tf_keras.activations.gelu(x, approximate=True) def _get_initializer(flags): """Get variable initializer.""" if flags.init_method == "uniform": - initializer = tf.keras.initializers.RandomUniform( + initializer = tf_keras.initializers.RandomUniform( minval=-flags.init_range, maxval=flags.init_range) elif flags.init_method == "normal": - initializer = tf.keras.initializers.RandomNormal(stddev=flags.init_std) + initializer = tf_keras.initializers.RandomNormal(stddev=flags.init_std) else: raise ValueError("Initializer {} not supported".format(flags.init_method)) return initializer @@ -78,7 +78,7 @@ def _cache_mem(curr_out, prev_mem, mem_len, reuse_len=None): else: new_mem = tf.concat([prev_mem, curr_out], 0)[-mem_len:] - return tf.keras.backend.stop_gradient(new_mem) + return tf_keras.backend.stop_gradient(new_mem) def is_special_none_tensor(tensor): @@ -86,8 +86,8 @@ def is_special_none_tensor(tensor): return tensor.shape.ndims == 0 and tensor.dtype == tf.int32 -@tf.keras.utils.register_keras_serializable(package="Text") -class RelativePositionEncoding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class RelativePositionEncoding(tf_keras.layers.Layer): """Creates a relative positional encoding. This layer creates a relative positional encoding as described in @@ -132,7 +132,7 @@ def call(self, pos_seq, batch_size=None): return pos_emb -class RelativeAttention(tf.keras.layers.Layer): +class RelativeAttention(tf_keras.layers.Layer): """Core calculations for relative attention.""" def __init__(self, dropout_att, scale): @@ -143,7 +143,7 @@ def __init__(self, dropout_att, scale): def build(self, unused_input_shapes): """Implements build() for the layer.""" - self.attention_probs_dropout = tf.keras.layers.Dropout( + self.attention_probs_dropout = tf_keras.layers.Dropout( rate=self.dropout_att) super(RelativeAttention, self).build(unused_input_shapes) @@ -185,7 +185,7 @@ def call(self, q_head, k_head_h, v_head_h, k_head_r, seg_embed, seg_mat, return attn_vec -class PositionwiseFF(tf.keras.layers.Layer): +class PositionwiseFF(tf_keras.layers.Layer): """Positionwise feed-forward layer.""" def __init__(self, d_model, d_inner, dropout, kernel_initializer, @@ -207,20 +207,20 @@ def build(self, unused_input_shapes): raise (ValueError("Unsupported activation type {}".format( self.activation_type))) self.inner_projection_layer = ( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self.d_inner, activation=activation, kernel_initializer=self.kernel_initializer, name="layer_1")) self.output_projection_layer = ( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self.d_model, kernel_initializer=self.kernel_initializer, name="layer_2")) - self.output_dropout = tf.keras.layers.Dropout( + self.output_dropout = tf_keras.layers.Dropout( rate=self.dropout, name="drop_2") self.output_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="LayerNorm", axis=-1, epsilon=1e-12)) super(PositionwiseFF, self).build(unused_input_shapes) @@ -234,7 +234,7 @@ def call(self, inp): return output -class EmbeddingLookup(tf.keras.layers.Layer): +class EmbeddingLookup(tf_keras.layers.Layer): """Looks up words embeddings for id tensor.""" def __init__(self, n_token, d_embed, initializer, **kwargs): @@ -257,7 +257,7 @@ def call(self, inputs): return tf.nn.embedding_lookup(self.lookup_table, inputs) -class RelativeMultiheadAttention(tf.keras.layers.Layer): +class RelativeMultiheadAttention(tf_keras.layers.Layer): """Multi-head attention with relative embedding.""" def __init__(self, d_model, n_head, d_head, dropout, dropout_att, @@ -274,7 +274,7 @@ def build(self, unused_input_shapes): """Implements build() for the layer.""" self.scale = 1.0 / (self.d_head**0.5) - self.output_layer_norm = tf.keras.layers.LayerNormalization( + self.output_layer_norm = tf_keras.layers.LayerNormalization( name="LayerNorm", axis=-1, epsilon=1e-12) self.kh_projection_layer = self.add_weight( @@ -302,7 +302,7 @@ def build(self, unused_input_shapes): shape=[self.d_model, self.n_head, self.d_head], initializer=self.initializer) - self.attention_dropout = tf.keras.layers.Dropout(rate=self.dropout) + self.attention_dropout = tf_keras.layers.Dropout(rate=self.dropout) super(RelativeMultiheadAttention, self).build(unused_input_shapes) @@ -360,7 +360,7 @@ def call(self, h, g, r, r_w_bias, r_r_bias, seg_mat, r_s_bias, seg_embed, return (output_h, output_g) -class TransformerXLModel(tf.keras.layers.Layer): +class TransformerXLModel(tf_keras.layers.Layer): """Defines a Transformer-XL computation graph with additional support for XLNet.""" def __init__(self, @@ -452,8 +452,8 @@ def build(self, unused_input_shapes): dtype=self.tf_float, name="word_embedding") - self.h_dropout = tf.keras.layers.Dropout(rate=self.dropout) - self.g_dropout = tf.keras.layers.Dropout(rate=self.dropout) + self.h_dropout = tf_keras.layers.Dropout(rate=self.dropout) + self.g_dropout = tf_keras.layers.Dropout(rate=self.dropout) if self.untie_r: self.r_w_bias = ( @@ -501,7 +501,7 @@ def build(self, unused_input_shapes): self.mask_emb = self.add_weight( "mask_emb/mask_emb", shape=[1, 1, self.d_model], dtype=self.tf_float) - self.emb_dropout = tf.keras.layers.Dropout(rate=self.dropout) + self.emb_dropout = tf_keras.layers.Dropout(rate=self.dropout) self.fwd_position_embedding = RelativePositionEncoding(self.d_model) self.bwd_position_embedding = RelativePositionEncoding(self.d_model) @@ -526,7 +526,7 @@ def build(self, unused_input_shapes): activation_type=self.ff_activation, name="layer_%d/ff" % (i))) - self.output_dropout = tf.keras.layers.Dropout(rate=self.dropout) + self.output_dropout = tf_keras.layers.Dropout(rate=self.dropout) super(TransformerXLModel, self).build(unused_input_shapes) @@ -741,7 +741,7 @@ def call(self, inputs): return output, new_mems, None -class PretrainingXLNetModel(tf.keras.Model): +class PretrainingXLNetModel(tf_keras.Model): """XLNet keras model combined with pretraining LM loss layer. See the original paper: https://arxiv.org/pdf/1906.08237.pdf @@ -826,7 +826,7 @@ def call(self, features): return self.new_mems, model_output -class ClassificationXLNetModel(tf.keras.Model): +class ClassificationXLNetModel(tf_keras.Model): """XLNet keras model combined with classification loss layer. See the original paper: https://arxiv.org/pdf/1906.08237.pdf @@ -901,11 +901,11 @@ def call(self, features): summary = self.summarization_layer(attention_output) per_example_loss, logits = self.cl_loss_layer(hidden=summary, labels=label) - self.add_loss(tf.keras.backend.mean(per_example_loss)) + self.add_loss(tf_keras.backend.mean(per_example_loss)) return new_mems, logits -class LMLossLayer(tf.keras.layers.Layer): +class LMLossLayer(tf_keras.layers.Layer): """Layer computing cross entropy loss for language modeling.""" def __init__(self, @@ -945,12 +945,12 @@ def __init__(self, def build(self, unused_input_shapes): """Implements build() for the layer.""" if self.use_proj: - self.proj_layer = tf.keras.layers.Dense( + self.proj_layer = tf_keras.layers.Dense( units=self.hidden_size, kernel_initializer=self.initializer, activation=gelu, name="lm_projection/dense") - self.proj_layer_norm = tf.keras.layers.LayerNormalization( + self.proj_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name="lm_projection/LayerNorm") if not self.tie_weight: self.softmax_w = self.add_weight( @@ -984,7 +984,7 @@ def call(self, hidden, target, lookup_table, target_mask): return total_loss, logits -class Summarization(tf.keras.layers.Layer): +class Summarization(tf_keras.layers.Layer): """The layer to pool the output from XLNet model into a vector.""" def __init__(self, @@ -1024,12 +1024,12 @@ def __init__(self, def build(self, unused_input_shapes): """Implements build() for the layer.""" if self.use_proj: - self.proj_layer = tf.keras.layers.Dense( + self.proj_layer = tf_keras.layers.Dense( units=self.hidden_size, kernel_initializer=self.initializer, activation=tf.nn.tanh, name="summary") - self.dropout_layer = tf.keras.layers.Dropout(rate=self.dropout_rate) + self.dropout_layer = tf_keras.layers.Dropout(rate=self.dropout_rate) super(Summarization, self).build(unused_input_shapes) @@ -1047,7 +1047,7 @@ def call(self, inputs): return summary -class ClassificationLossLayer(tf.keras.layers.Layer): +class ClassificationLossLayer(tf_keras.layers.Layer): """Layer computing cross entropy loss for classification task.""" def __init__(self, n_class, initializer, **kwargs): @@ -1065,7 +1065,7 @@ def __init__(self, n_class, initializer, **kwargs): def build(self, unused_input_shapes): """Implements build() for the layer.""" - self.proj_layer = tf.keras.layers.Dense( + self.proj_layer = tf_keras.layers.Dense( units=self.n_class, kernel_initializer=self.initializer, name="logit") super(ClassificationLossLayer, self).build(unused_input_shapes) @@ -1080,7 +1080,7 @@ def call(self, hidden, labels): return loss, logits -class QAXLNetModel(tf.keras.Model): +class QAXLNetModel(tf_keras.Model): """XLNet keras model combined with question answering loss layer. See the original paper: https://arxiv.org/pdf/1906.08237.pdf @@ -1161,7 +1161,7 @@ def call(self, features, training=False): return results -class QALossLayer(tf.keras.layers.Layer): +class QALossLayer(tf_keras.layers.Layer): """Layer computing position and regression loss for question answering task.""" def __init__(self, hidden_size, start_n_top, end_n_top, initializer, @@ -1185,28 +1185,28 @@ def __init__(self, hidden_size, start_n_top, end_n_top, initializer, def build(self, unused_input_shapes): """Implements build() for the layer.""" - self.start_logits_proj_layer = tf.keras.layers.Dense( + self.start_logits_proj_layer = tf_keras.layers.Dense( units=1, kernel_initializer=self.initializer, name="start_logits/dense") - self.end_logits_proj_layer0 = tf.keras.layers.Dense( + self.end_logits_proj_layer0 = tf_keras.layers.Dense( units=self.hidden_size, kernel_initializer=self.initializer, activation=tf.nn.tanh, name="end_logits/dense_0") - self.end_logits_proj_layer1 = tf.keras.layers.Dense( + self.end_logits_proj_layer1 = tf_keras.layers.Dense( units=1, kernel_initializer=self.initializer, name="end_logits/dense_1") - self.end_logits_layer_norm = tf.keras.layers.LayerNormalization( + self.end_logits_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name="end_logits/LayerNorm") - self.answer_class_proj_layer0 = tf.keras.layers.Dense( + self.answer_class_proj_layer0 = tf_keras.layers.Dense( units=self.hidden_size, kernel_initializer=self.initializer, activation=tf.nn.tanh, name="answer_class/dense_0") - self.answer_class_proj_layer1 = tf.keras.layers.Dense( + self.answer_class_proj_layer1 = tf_keras.layers.Dense( units=1, kernel_initializer=self.initializer, use_bias=False, name="answer_class/dense_1") - self.ans_feature_dropout = tf.keras.layers.Dropout(rate=self.dropout_rate) + self.ans_feature_dropout = tf_keras.layers.Dropout(rate=self.dropout_rate) super(QALossLayer, self).build(unused_input_shapes) def __call__(self, hidden, p_mask, cls_index, **kwargs): diff --git a/official/modeling/activations/gelu.py b/official/modeling/activations/gelu.py index 05a06cd6ca4..50e39e40787 100644 --- a/official/modeling/activations/gelu.py +++ b/official/modeling/activations/gelu.py @@ -14,10 +14,10 @@ """Gaussian error linear unit.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def gelu(x): """Gaussian Error Linear Unit. @@ -29,4 +29,4 @@ def gelu(x): Returns: `x` with the GELU activation applied. """ - return tf.keras.activations.gelu(x, approximate=True) + return tf_keras.activations.gelu(x, approximate=True) diff --git a/official/modeling/activations/gelu_test.py b/official/modeling/activations/gelu_test.py index 7712e6688fa..aca4d8b5561 100644 --- a/official/modeling/activations/gelu_test.py +++ b/official/modeling/activations/gelu_test.py @@ -14,7 +14,7 @@ """Tests for the Gaussian error linear unit.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations diff --git a/official/modeling/activations/mish.py b/official/modeling/activations/mish.py index 07be320899b..ea8c72f8a14 100644 --- a/official/modeling/activations/mish.py +++ b/official/modeling/activations/mish.py @@ -14,10 +14,10 @@ """Self Regularized Non-Monotonic Activation Function.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def mish(x) -> tf.Tensor: """Mish activation function. diff --git a/official/modeling/activations/mish_test.py b/official/modeling/activations/mish_test.py index 011abf6ee5f..0a51f270a2c 100644 --- a/official/modeling/activations/mish_test.py +++ b/official/modeling/activations/mish_test.py @@ -14,7 +14,7 @@ """Tests for the customized Mish activation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations diff --git a/official/modeling/activations/relu.py b/official/modeling/activations/relu.py index 02fdb232e83..b6de54b3e22 100644 --- a/official/modeling/activations/relu.py +++ b/official/modeling/activations/relu.py @@ -14,10 +14,10 @@ """Customized Relu activation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def relu6(features): """Computes the Relu6 activation function. diff --git a/official/modeling/activations/relu_test.py b/official/modeling/activations/relu_test.py index 423a4d23916..b97a1cdcb9c 100644 --- a/official/modeling/activations/relu_test.py +++ b/official/modeling/activations/relu_test.py @@ -14,7 +14,7 @@ """Tests for the customized Relu activation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations diff --git a/official/modeling/activations/sigmoid.py b/official/modeling/activations/sigmoid.py index f8c5437c404..ee2464ab275 100644 --- a/official/modeling/activations/sigmoid.py +++ b/official/modeling/activations/sigmoid.py @@ -14,10 +14,10 @@ """Customized Sigmoid activation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def hard_sigmoid(features): """Computes the hard sigmoid activation function. diff --git a/official/modeling/activations/sigmoid_test.py b/official/modeling/activations/sigmoid_test.py index 87b19635fe6..9813e17e989 100644 --- a/official/modeling/activations/sigmoid_test.py +++ b/official/modeling/activations/sigmoid_test.py @@ -15,7 +15,7 @@ """Tests for the customized Sigmoid activation.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations diff --git a/official/modeling/activations/swish.py b/official/modeling/activations/swish.py index c996ac1bcdf..dc0f311bcb6 100644 --- a/official/modeling/activations/swish.py +++ b/official/modeling/activations/swish.py @@ -14,10 +14,10 @@ """Customized Swish activation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def simple_swish(features): """Computes the Swish activation function. @@ -38,7 +38,7 @@ def simple_swish(features): return features * tf.nn.sigmoid(features) -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def hard_swish(features): """Computes a hard version of the swish function. @@ -56,7 +56,7 @@ def hard_swish(features): return features * tf.nn.relu6(features + tf.cast(3., fdtype)) * (1. / 6.) -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') def identity(features): """Computes the identity function. diff --git a/official/modeling/activations/swish_test.py b/official/modeling/activations/swish_test.py index 0374699d22f..b1fbfc0e417 100644 --- a/official/modeling/activations/swish_test.py +++ b/official/modeling/activations/swish_test.py @@ -14,7 +14,7 @@ """Tests for the customized Swish activation.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations diff --git a/official/modeling/fast_training/experimental/tf2_utils_2x_wide.py b/official/modeling/fast_training/experimental/tf2_utils_2x_wide.py index 79b4d7f072b..26355bf3d16 100644 --- a/official/modeling/fast_training/experimental/tf2_utils_2x_wide.py +++ b/official/modeling/fast_training/experimental/tf2_utils_2x_wide.py @@ -16,7 +16,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras def expand_vector(v: np.ndarray) -> np.ndarray: @@ -156,15 +156,15 @@ def model_to_model_2x_wide(model_from: tf.Module, Also makes sure that the output of the model is not changed after expanding. For example: ``` - model_narrow = tf.keras.Sequential() - model_narrow.add(tf.keras.Input(shape=(3,))) - model_narrow.add(tf.keras.layers.Dense(4)) - model_narrow.add(tf.keras.layers.Dense(1)) - - model_wide = tf.keras.Sequential() - model_wide.add(tf.keras.Input(shape=(6,))) - model_wide.add(tf.keras.layers.Dense(8)) - model_wide.add(tf.keras.layers.Dense(1)) + model_narrow = tf_keras.Sequential() + model_narrow.add(tf_keras.Input(shape=(3,))) + model_narrow.add(tf_keras.layers.Dense(4)) + model_narrow.add(tf_keras.layers.Dense(1)) + + model_wide = tf_keras.Sequential() + model_wide.add(tf_keras.Input(shape=(6,))) + model_wide.add(tf_keras.layers.Dense(8)) + model_wide.add(tf_keras.layers.Dense(1)) model_to_model_2x_wide(model_narrow, model_wide) assert model_narrow([[1, 2, 3]]) == model_wide([[1, 1, 2, 2, 3, 3]]) diff --git a/official/modeling/fast_training/experimental/tf2_utils_2x_wide_test.py b/official/modeling/fast_training/experimental/tf2_utils_2x_wide_test.py index a92e0862b16..59ad118cc6b 100644 --- a/official/modeling/fast_training/experimental/tf2_utils_2x_wide_test.py +++ b/official/modeling/fast_training/experimental/tf2_utils_2x_wide_test.py @@ -15,7 +15,7 @@ """Tests for tf2_utils_2x_wide.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.fast_training.experimental import tf2_utils_2x_wide @@ -73,17 +73,17 @@ def test_expand_3d_tensor_axis_2(self): def test_end_to_end(self): """Covers expand_vector, expand_2_axes, and expand_1_axis.""" - model_narrow = tf.keras.Sequential() - model_narrow.add(tf.keras.Input(shape=(3,))) - model_narrow.add(tf.keras.layers.Dense(4)) - model_narrow.add(tf.keras.layers.Dense(4)) - model_narrow.add(tf.keras.layers.Dense(1)) - - model_wide = tf.keras.Sequential() - model_wide.add(tf.keras.Input(shape=(6,))) - model_wide.add(tf.keras.layers.Dense(8)) - model_wide.add(tf.keras.layers.Dense(8)) - model_wide.add(tf.keras.layers.Dense(1)) + model_narrow = tf_keras.Sequential() + model_narrow.add(tf_keras.Input(shape=(3,))) + model_narrow.add(tf_keras.layers.Dense(4)) + model_narrow.add(tf_keras.layers.Dense(4)) + model_narrow.add(tf_keras.layers.Dense(1)) + + model_wide = tf_keras.Sequential() + model_wide.add(tf_keras.Input(shape=(6,))) + model_wide.add(tf_keras.layers.Dense(8)) + model_wide.add(tf_keras.layers.Dense(8)) + model_wide.add(tf_keras.layers.Dense(1)) x0 = np.array([[1, 2, 3]]) x1 = np.array([[1, 1, 2, 2, 3, 3]]) diff --git a/official/modeling/fast_training/progressive/policies.py b/official/modeling/fast_training/progressive/policies.py index 7b1e4c36fad..b5b94368d8d 100644 --- a/official/modeling/fast_training/progressive/policies.py +++ b/official/modeling/fast_training/progressive/policies.py @@ -23,7 +23,7 @@ from typing import Any, Mapping from absl import logging import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import streamz_counters from official.modeling.fast_training.progressive import utils @@ -96,12 +96,12 @@ def num_steps(self, stage_id: int) -> int: @abc.abstractmethod def get_model(self, stage_id: int, - old_model: tf.keras.Model = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + old_model: tf_keras.Model = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Return model for this stage. For initialization, `old_model` = None.""" pass @abc.abstractmethod - def get_optimizer(self, stage_id: int) -> tf.keras.optimizers.Optimizer: + def get_optimizer(self, stage_id: int) -> tf_keras.optimizers.Optimizer: """Return optimizer for this stage.""" pass @@ -116,7 +116,7 @@ def get_eval_dataset(self, stage_id: int) -> tf.data.Dataset: pass @property - def cur_model(self) -> tf.keras.Model: + def cur_model(self) -> tf_keras.Model: return self._volatiles.model @property @@ -132,7 +132,7 @@ def cur_eval_dataset(self) -> tf.data.Dataset: return self._cur_eval_dataset @property - def cur_optimizer(self) -> tf.keras.optimizers.Optimizer: + def cur_optimizer(self) -> tf_keras.optimizers.Optimizer: return self._volatiles.optimizer @property diff --git a/official/modeling/fast_training/progressive/train_lib.py b/official/modeling/fast_training/progressive/train_lib.py index a7885b5b775..47c42549ff0 100644 --- a/official/modeling/fast_training/progressive/train_lib.py +++ b/official/modeling/fast_training/progressive/train_lib.py @@ -25,7 +25,7 @@ # Import libraries from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions from official.core import train_lib as base_train_lib @@ -39,7 +39,7 @@ def run_experiment(distribution_strategy: tf.distribute.Strategy, model_dir: str, run_post_eval: bool = False, save_summary: bool = True) \ --> Tuple[tf.keras.Model, Mapping[str, Any]]: +-> Tuple[tf_keras.Model, Mapping[str, Any]]: """Runs train/eval configured by the experiment params. Args: @@ -55,7 +55,7 @@ def run_experiment(distribution_strategy: tf.distribute.Strategy, Returns: A 2-tuple of (model, eval_logs). - model: `tf.keras.Model` instance. + model: `tf_keras.Model` instance. eval_logs: returns eval metrics logs when run_post_eval is set to True, otherwise, returns {}. """ diff --git a/official/modeling/fast_training/progressive/train_lib_test.py b/official/modeling/fast_training/progressive/train_lib_test.py index cdc7f911589..4cc64c6adbb 100644 --- a/official/modeling/fast_training/progressive/train_lib_test.py +++ b/official/modeling/fast_training/progressive/train_lib_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import dataclasses import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/modeling/fast_training/progressive/trainer.py b/official/modeling/fast_training/progressive/trainer.py index f49d2a31dd8..8d562e100bc 100644 --- a/official/modeling/fast_training/progressive/trainer.py +++ b/official/modeling/fast_training/progressive/trainer.py @@ -27,7 +27,7 @@ from absl import logging import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import base_trainer as trainer_lib from official.core import config_definitions @@ -116,8 +116,8 @@ def __init__( global_step=self.global_step, **self._task.cur_checkpoint_items) - self._train_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) - self._validation_loss = tf.keras.metrics.Mean( + self._train_loss = tf_keras.metrics.Mean('training_loss', dtype=tf.float32) + self._validation_loss = tf_keras.metrics.Mean( 'validation_loss', dtype=tf.float32) self._train_metrics = self.task.build_metrics( training=True) + self.model.metrics diff --git a/official/modeling/fast_training/progressive/trainer_test.py b/official/modeling/fast_training/progressive/trainer_test.py index ff78764e2a4..a5377105d02 100644 --- a/official/modeling/fast_training/progressive/trainer_test.py +++ b/official/modeling/fast_training/progressive/trainer_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -67,11 +67,11 @@ def num_steps(self, stage_id: int) -> int: def get_model(self, stage_id: int, - old_model: tf.keras.Model) -> tf.keras.Model: + old_model: tf_keras.Model) -> tf_keras.Model: del stage_id, old_model return self.build_model() - def get_optimizer(self, stage_id: int) -> tf.keras.optimizers.Optimizer: + def get_optimizer(self, stage_id: int) -> tf_keras.optimizers.Optimizer: optimizer_type = 'sgd' if stage_id == 0 else 'adamw' optimizer_config = cfg.OptimizationConfig({ 'optimizer': {'type': optimizer_type}, @@ -228,11 +228,11 @@ def test_configure_optimizer(self, mixed_precision_dtype, loss_scale): if mixed_precision_dtype != 'float16': self.assertIsInstance( trainer.optimizer, - (tf.keras.optimizers.SGD, tf.keras.optimizers.legacy.SGD)) + (tf_keras.optimizers.SGD, tf_keras.optimizers.legacy.SGD)) elif mixed_precision_dtype == 'float16' and loss_scale is None: self.assertIsInstance( trainer.optimizer, - (tf.keras.optimizers.SGD, tf.keras.optimizers.legacy.SGD)) + (tf_keras.optimizers.SGD, tf_keras.optimizers.legacy.SGD)) metrics = trainer.train(tf.convert_to_tensor(5, dtype=tf.int32)) self.assertIn('training_loss', metrics) diff --git a/official/modeling/fast_training/progressive/utils.py b/official/modeling/fast_training/progressive/utils.py index 35ab383b7d4..ca360348a71 100644 --- a/official/modeling/fast_training/progressive/utils.py +++ b/official/modeling/fast_training/progressive/utils.py @@ -15,7 +15,7 @@ """Util classes and functions.""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import from tensorflow.python.trackable import autotrackable diff --git a/official/modeling/grad_utils.py b/official/modeling/grad_utils.py index 23338785ee6..8ccce40d79a 100644 --- a/official/modeling/grad_utils.py +++ b/official/modeling/grad_utils.py @@ -16,7 +16,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def _filter_grads(grads_and_vars): @@ -98,7 +98,7 @@ def minimize_using_explicit_allreduce(tape, Args: tape: An instance of `tf.GradientTape`. - optimizer: An instance of `tf.keras.optimizers.Optimizer`. + optimizer: An instance of `tf_keras.optimizers.Optimizer`. loss: the loss tensor. trainable_variables: A list of model Variables. pre_allreduce_callbacks: A list of callback functions that takes gradients @@ -117,7 +117,7 @@ def minimize_using_explicit_allreduce(tape, in one pack. """ if isinstance(optimizer, - tf.keras.mixed_precision.LossScaleOptimizer): + tf_keras.mixed_precision.LossScaleOptimizer): # FP16 GPU code path with tape: scaled_loss = optimizer.get_scaled_loss(loss) diff --git a/official/modeling/grad_utils_test.py b/official/modeling/grad_utils_test.py index 9fd132dd62b..2f9fc08a831 100644 --- a/official/modeling/grad_utils_test.py +++ b/official/modeling/grad_utils_test.py @@ -14,7 +14,7 @@ """Tests for grad_utils.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import grad_utils from official.modeling import performance @@ -23,9 +23,9 @@ class GradUtilsTest(tf.test.TestCase): def test_minimize(self): - optimizer = tf.keras.optimizers.SGD(0.1) + optimizer = tf_keras.optimizers.SGD(0.1) with tf.GradientTape() as tape: - model = tf.keras.layers.Dense(2) + model = tf_keras.layers.Dense(2) outputs = model(tf.zeros((2, 2), tf.float32)) loss = tf.reduce_mean(outputs) @@ -35,10 +35,10 @@ def test_minimize(self): def test_minimize_fp16(self): optimizer = performance.configure_optimizer( - tf.keras.optimizers.SGD(0.1), use_float16=True) + tf_keras.optimizers.SGD(0.1), use_float16=True) performance.set_mixed_precision_policy(tf.float16) with tf.GradientTape() as tape: - model = tf.keras.layers.Dense(2) + model = tf_keras.layers.Dense(2) outputs = model(tf.zeros((2, 2), tf.float16)) loss = tf.reduce_mean(outputs) @@ -51,11 +51,11 @@ def _clip_by_global_norm(grads_and_vars): (grads, _) = tf.clip_by_global_norm(grads, clip_norm=1.0) return zip(grads, tvars) with tf.GradientTape() as tape: - model = tf.keras.layers.Dense(2) + model = tf_keras.layers.Dense(2) outputs = model(tf.zeros((2, 2), tf.float16)) loss = tf.reduce_mean(outputs) optimizer = performance.configure_optimizer( - tf.keras.optimizers.SGD(0.1), use_float16=True, loss_scale=128) + tf_keras.optimizers.SGD(0.1), use_float16=True, loss_scale=128) grad_utils.minimize_using_explicit_allreduce( tape, optimizer, diff --git a/official/modeling/hyperparams/base_config.py b/official/modeling/hyperparams/base_config.py index 5999f181689..9e1a57995f0 100644 --- a/official/modeling/hyperparams/base_config.py +++ b/official/modeling/hyperparams/base_config.py @@ -22,7 +22,7 @@ from typing import Any, List, Mapping, Optional, Type, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import yaml 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 39e77192940..efd976f9e35 100644 --- a/official/modeling/hyperparams/base_config_test.py +++ b/official/modeling/hyperparams/base_config_test.py @@ -17,7 +17,7 @@ from typing import List, Optional, Tuple from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.hyperparams import base_config diff --git a/official/modeling/hyperparams/oneof_test.py b/official/modeling/hyperparams/oneof_test.py index 902c467a553..019af49112a 100644 --- a/official/modeling/hyperparams/oneof_test.py +++ b/official/modeling/hyperparams/oneof_test.py @@ -13,7 +13,7 @@ # limitations under the License. import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.hyperparams import base_config from official.modeling.hyperparams import oneof diff --git a/official/modeling/hyperparams/params_dict.py b/official/modeling/hyperparams/params_dict.py index b1c51a19df7..f66da0c3ed9 100644 --- a/official/modeling/hyperparams/params_dict.py +++ b/official/modeling/hyperparams/params_dict.py @@ -19,7 +19,7 @@ import re import six -import tensorflow as tf +import tensorflow as tf, tf_keras import yaml # regex pattern that matches on key-value pairs in a comma-separated diff --git a/official/modeling/hyperparams/params_dict_test.py b/official/modeling/hyperparams/params_dict_test.py index d6859262c01..1967d292722 100644 --- a/official/modeling/hyperparams/params_dict_test.py +++ b/official/modeling/hyperparams/params_dict_test.py @@ -16,7 +16,7 @@ import os -import tensorflow as tf +import tensorflow as tf, tf_keras import yaml from official.modeling.hyperparams import params_dict diff --git a/official/modeling/multitask/base_model.py b/official/modeling/multitask/base_model.py index 0d7946e29a5..262eec3deb6 100644 --- a/official/modeling/multitask/base_model.py +++ b/official/modeling/multitask/base_model.py @@ -15,7 +15,7 @@ """Abstraction of multi-task model.""" from typing import Text, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras class MultiTaskBaseModel(tf.Module): @@ -25,11 +25,11 @@ def __init__(self, **kwargs): super().__init__(**kwargs) self._sub_tasks = self._instantiate_sub_tasks() - def _instantiate_sub_tasks(self) -> Dict[Text, tf.keras.Model]: + def _instantiate_sub_tasks(self) -> Dict[Text, tf_keras.Model]: """Abstract function that sets up the computation for each sub-task. Returns: - A map from task name (as string) to a tf.keras.Model object that + A map from task name (as string) to a tf_keras.Model object that represents the sub-task in the multi-task pool. """ raise NotImplementedError( @@ -37,7 +37,7 @@ def _instantiate_sub_tasks(self) -> Dict[Text, tf.keras.Model]: @property def sub_tasks(self): - """Fetch a map of task name (string) to task model (tf.keras.Model).""" + """Fetch a map of task name (string) to task model (tf_keras.Model).""" return self._sub_tasks def initialize(self): @@ -50,5 +50,5 @@ def build(self): for task_model in self._sub_tasks.values(): # Assumes all the tf.Module models are built because we don't have any # way to check them. - if isinstance(task_model, tf.keras.Model) and not task_model.built: + if isinstance(task_model, tf_keras.Model) and not task_model.built: _ = task_model(task_model.inputs) diff --git a/official/modeling/multitask/base_trainer.py b/official/modeling/multitask/base_trainer.py index 745aaf37497..1ac812f2b1f 100644 --- a/official/modeling/multitask/base_trainer.py +++ b/official/modeling/multitask/base_trainer.py @@ -20,7 +20,7 @@ import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import optimization from official.modeling.multitask import base_model @@ -33,7 +33,7 @@ class MultiTaskBaseTrainer(orbit.StandardTrainer): def __init__(self, multi_task: multitask.MultiTask, - multi_task_model: Union[tf.keras.Model, + multi_task_model: Union[tf_keras.Model, base_model.MultiTaskBaseModel], optimizer: tf.optimizers.Optimizer, trainer_options=None, @@ -113,9 +113,9 @@ def training_losses(self): # Builds the per-task metrics and losses. # This the total summed training loss of tasks in the joint training. self._training_losses = dict( - total_loss=tf.keras.metrics.Mean("training_loss", dtype=tf.float32)) + total_loss=tf_keras.metrics.Mean("training_loss", dtype=tf.float32)) for name in self.multi_task.tasks: - self._training_losses[name] = tf.keras.metrics.Mean( + self._training_losses[name] = tf_keras.metrics.Mean( "training_loss", dtype=tf.float32) return self._training_losses diff --git a/official/modeling/multitask/base_trainer_test.py b/official/modeling/multitask/base_trainer_test.py index 528b05997e7..039bdb01213 100644 --- a/official/modeling/multitask/base_trainer_test.py +++ b/official/modeling/multitask/base_trainer_test.py @@ -14,7 +14,7 @@ """Tests for multitask.base_trainer.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -47,7 +47,7 @@ def test_multitask_joint_trainer(self, distribution): task_weights = {"foo": 1.0, "bar": 1.0} test_multitask = multitask.MultiTask( tasks=tasks, task_weights=task_weights) - test_optimizer = tf.keras.optimizers.SGD(0.1) + test_optimizer = tf_keras.optimizers.SGD(0.1) model = test_utils.MockMultiTaskModel() test_trainer = base_trainer.MultiTaskBaseTrainer( multi_task=test_multitask, @@ -70,7 +70,7 @@ def test_trainer_with_configs(self): task_config=test_utils.BarConfig(), task_weight=0.5))) test_multitask = multitask.MultiTask.from_config(config) - test_optimizer = tf.keras.optimizers.SGD(0.1) + test_optimizer = tf_keras.optimizers.SGD(0.1) model = test_utils.MockMultiTaskModel() test_trainer = base_trainer.MultiTaskBaseTrainer( multi_task=test_multitask, diff --git a/official/modeling/multitask/evaluator.py b/official/modeling/multitask/evaluator.py index f0317bcbc9b..6e0ddb54682 100644 --- a/official/modeling/multitask/evaluator.py +++ b/official/modeling/multitask/evaluator.py @@ -19,7 +19,7 @@ from typing import Dict, List, Optional, Union import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import train_utils @@ -33,7 +33,7 @@ class MultiTaskEvaluator(orbit.AbstractEvaluator): def __init__( self, eval_tasks: List[base_task.Task], - model: Union[tf.keras.Model, base_model.MultiTaskBaseModel], + model: Union[tf_keras.Model, base_model.MultiTaskBaseModel], global_step: Optional[tf.Variable] = None, eval_steps: Optional[Dict[str, int]] = None, checkpoint_exporter: Optional[train_utils.BestCheckpointExporter] = None): @@ -41,7 +41,7 @@ def __init__( Args: eval_tasks: A list of tasks to evaluate. - model: tf.keras.Model instance. + model: tf_keras.Model instance. global_step: the global step variable. eval_steps: a dictionary of steps to run eval keyed by task names. checkpoint_exporter: an object that has the `maybe_export_checkpoint` @@ -124,7 +124,7 @@ def validation_losses(self): # Builds the per-task metrics and losses. self._validation_losses = {} for task in self.tasks: - self._validation_losses[task.name] = tf.keras.metrics.Mean( + self._validation_losses[task.name] = tf_keras.metrics.Mean( "validation_loss", dtype=tf.float32) return self._validation_losses diff --git a/official/modeling/multitask/evaluator_test.py b/official/modeling/multitask/evaluator_test.py index 55235c1f822..2e37b12116e 100644 --- a/official/modeling/multitask/evaluator_test.py +++ b/official/modeling/multitask/evaluator_test.py @@ -15,7 +15,7 @@ """Tests for multitask.evaluator.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -35,11 +35,11 @@ def all_strategy_combinations(): ) -class MockModel(tf.keras.Model): +class MockModel(tf_keras.Model): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) - self.dense = tf.keras.layers.Dense(1) + self.dense = tf_keras.layers.Dense(1) def call(self, inputs): print(inputs, type(inputs)) @@ -55,7 +55,7 @@ class MockTask(base_task.Task): def build_metrics(self, training: bool = True): del training - return [tf.keras.metrics.Accuracy(name="acc")] + return [tf_keras.metrics.Accuracy(name="acc")] def build_inputs(self, params): @@ -73,7 +73,7 @@ def generate_data(_): generate_data, num_parallel_calls=tf.data.experimental.AUTOTUNE) return dataset.prefetch(buffer_size=1).batch(2, drop_remainder=True) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): logs = super().validation_step(inputs, model, metrics) logs["counter"] = tf.ones((1,), dtype=tf.float32) return logs diff --git a/official/modeling/multitask/interleaving_trainer.py b/official/modeling/multitask/interleaving_trainer.py index d4597cbe352..6347e98e178 100644 --- a/official/modeling/multitask/interleaving_trainer.py +++ b/official/modeling/multitask/interleaving_trainer.py @@ -16,7 +16,7 @@ from typing import Union import gin import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.multitask import base_model from official.modeling.multitask import base_trainer from official.modeling.multitask import multitask @@ -29,11 +29,11 @@ class MultiTaskInterleavingTrainer(base_trainer.MultiTaskBaseTrainer): def __init__(self, multi_task: multitask.MultiTask, - multi_task_model: Union[tf.keras.Model, + multi_task_model: Union[tf_keras.Model, base_model.MultiTaskBaseModel], optimizer: Union[tf.optimizers.Optimizer, - tf.keras.optimizers.experimental.Optimizer, - tf.keras.optimizers.legacy.Optimizer], + tf_keras.optimizers.experimental.Optimizer, + tf_keras.optimizers.legacy.Optimizer], task_sampler: sampler.TaskSampler, trainer_options=None): super().__init__( @@ -74,7 +74,7 @@ def step_fn(inputs): # If the new Keras optimizer is used, we require all model variables are # created before the training and let the optimizer to create the slot # variable all together. - if isinstance(optimizer, tf.keras.optimizers.experimental.Optimizer): + if isinstance(optimizer, tf_keras.optimizers.experimental.Optimizer): multi_task_model.build() optimizer.build(multi_task_model.trainable_variables) diff --git a/official/modeling/multitask/interleaving_trainer_test.py b/official/modeling/multitask/interleaving_trainer_test.py index 12601ec53fb..6e47c05376c 100644 --- a/official/modeling/multitask/interleaving_trainer_test.py +++ b/official/modeling/multitask/interleaving_trainer_test.py @@ -14,7 +14,7 @@ """Tests for multitask.interleaving_trainer.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -46,7 +46,7 @@ def test_multitask_interleaving_trainer(self, distribution): test_utils.MockBarTask(params=test_utils.BarConfig(), name="bar") ] test_multitask = multitask.MultiTask(tasks=tasks) - test_optimizer = tf.keras.optimizers.SGD(0.1) + test_optimizer = tf_keras.optimizers.SGD(0.1) model = test_utils.MockMultiTaskModel() sampler = task_sampler.UniformTaskSampler( task_weights=test_multitask.task_weights) @@ -75,7 +75,7 @@ def test_trainer_with_configs(self, distribution): task_weight=1.0))) with distribution.scope(): test_multitask = multitask.MultiTask.from_config(config) - test_optimizer = tf.keras.optimizers.SGD(0.1) + test_optimizer = tf_keras.optimizers.SGD(0.1) model = test_utils.MockMultiTaskModel() num_step = 1000 sampler = task_sampler.AnnealingTaskSampler( diff --git a/official/modeling/multitask/multitask.py b/official/modeling/multitask/multitask.py index fed11923a0f..ded8aa65113 100644 --- a/official/modeling/multitask/multitask.py +++ b/official/modeling/multitask/multitask.py @@ -16,7 +16,7 @@ import abc from typing import Dict, List, Optional, Text, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions from official.core import task_factory @@ -103,7 +103,7 @@ def create_optimizer(cls, def joint_train_step(self, task_inputs, multi_task_model: base_model.MultiTaskBaseModel, - optimizer: tf.keras.optimizers.Optimizer, task_metrics, + optimizer: tf_keras.optimizers.Optimizer, task_metrics, **kwargs): """The joint train step. diff --git a/official/modeling/multitask/task_sampler.py b/official/modeling/multitask/task_sampler.py index 56186924700..620ebce3ddd 100644 --- a/official/modeling/multitask/task_sampler.py +++ b/official/modeling/multitask/task_sampler.py @@ -15,7 +15,7 @@ """Utils to sample tasks for interleaved optimization.""" import abc from typing import Union, Dict, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.multitask import configs diff --git a/official/modeling/multitask/task_sampler_test.py b/official/modeling/multitask/task_sampler_test.py index c756ae2dce9..a6d0746914b 100644 --- a/official/modeling/multitask/task_sampler_test.py +++ b/official/modeling/multitask/task_sampler_test.py @@ -13,7 +13,7 @@ # limitations under the License. """Tests for multitask.task_sampler.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.multitask import configs from official.modeling.multitask import task_sampler as sampler diff --git a/official/modeling/multitask/test_utils.py b/official/modeling/multitask/test_utils.py index 788fabf455a..747e88f26f8 100644 --- a/official/modeling/multitask/test_utils.py +++ b/official/modeling/multitask/test_utils.py @@ -14,22 +14,22 @@ """Testing utils for mock models and tasks.""" from typing import Dict, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg from official.core import task_factory from official.modeling.multitask import base_model -class MockFooModel(tf.keras.Model): +class MockFooModel(tf_keras.Model): """A mock model can consume 'foo' and 'bar' inputs.""" def __init__(self, shared_layer, *args, **kwargs): super().__init__(*args, **kwargs) self._share_layer = shared_layer - self._foo_specific_layer = tf.keras.layers.Dense(1) - self.inputs = {"foo": tf.keras.Input(shape=(2,), dtype=tf.float32), - "bar": tf.keras.Input(shape=(2,), dtype=tf.float32)} + self._foo_specific_layer = tf_keras.layers.Dense(1) + self.inputs = {"foo": tf_keras.Input(shape=(2,), dtype=tf.float32), + "bar": tf_keras.Input(shape=(2,), dtype=tf.float32)} def call(self, inputs): # pytype: disable=signature-mismatch # overriding-parameter-count-checks self.add_loss(tf.zeros((1,), dtype=tf.float32)) @@ -40,14 +40,14 @@ def call(self, inputs): # pytype: disable=signature-mismatch # overriding-para return self._foo_specific_layer(self._share_layer(input_tensor)) -class MockBarModel(tf.keras.Model): +class MockBarModel(tf_keras.Model): """A mock model can only consume 'bar' inputs.""" def __init__(self, shared_layer, *args, **kwargs): super().__init__(*args, **kwargs) self._share_layer = shared_layer - self._bar_specific_layer = tf.keras.layers.Dense(1) - self.inputs = {"bar": tf.keras.Input(shape=(2,), dtype=tf.float32)} + self._bar_specific_layer = tf_keras.layers.Dense(1) + self.inputs = {"bar": tf_keras.Input(shape=(2,), dtype=tf.float32)} def call(self, inputs): # pytype: disable=signature-mismatch # overriding-parameter-count-checks self.add_loss(tf.zeros((2,), dtype=tf.float32)) @@ -57,10 +57,10 @@ def call(self, inputs): # pytype: disable=signature-mismatch # overriding-para class MockMultiTaskModel(base_model.MultiTaskBaseModel): def __init__(self, *args, **kwargs): - self._shared_dense = tf.keras.layers.Dense(1) + self._shared_dense = tf_keras.layers.Dense(1) super().__init__(*args, **kwargs) - def _instantiate_sub_tasks(self) -> Dict[Text, tf.keras.Model]: + def _instantiate_sub_tasks(self) -> Dict[Text, tf_keras.Model]: return { "foo": MockFooModel(self._shared_dense), "bar": MockBarModel(self._shared_dense) @@ -96,16 +96,16 @@ class MockFooTask(base_task.Task): def build_metrics(self, training: bool = True): del training - return [tf.keras.metrics.Accuracy(name="foo_acc")] + return [tf_keras.metrics.Accuracy(name="foo_acc")] def build_inputs(self, params): return mock_data("foo") - def build_model(self) -> tf.keras.Model: - return MockFooModel(shared_layer=tf.keras.layers.Dense(1)) + def build_model(self) -> tf_keras.Model: + return MockFooModel(shared_layer=tf_keras.layers.Dense(1)) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - loss = tf.keras.losses.mean_squared_error(labels, model_outputs) + loss = tf_keras.losses.mean_squared_error(labels, model_outputs) if aux_losses: loss += tf.add_n(aux_losses) return tf.reduce_mean(loss) @@ -117,13 +117,13 @@ class MockBarTask(base_task.Task): def build_metrics(self, training: bool = True): del training - return [tf.keras.metrics.Accuracy(name="bar_acc")] + return [tf_keras.metrics.Accuracy(name="bar_acc")] def build_inputs(self, params): return mock_data("bar") def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - loss = tf.keras.losses.mean_squared_error(labels, model_outputs) + loss = tf_keras.losses.mean_squared_error(labels, model_outputs) if aux_losses: loss += tf.add_n(aux_losses) return tf.reduce_mean(loss) diff --git a/official/modeling/multitask/train_lib.py b/official/modeling/multitask/train_lib.py index 3dd3da7aab3..dd190bd7293 100644 --- a/official/modeling/multitask/train_lib.py +++ b/official/modeling/multitask/train_lib.py @@ -18,7 +18,7 @@ from typing import Any, List, Mapping, Optional, Tuple, Union from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import base_trainer as core_lib from official.core import train_utils @@ -195,7 +195,7 @@ def run_experiment_with_multitask_eval( best_ckpt_exporter_creator: A functor for creating best checkpoint exporter. Returns: - model: `tf.keras.Model` instance. + model: `tf_keras.Model` instance. """ is_training = 'train' in mode diff --git a/official/modeling/multitask/train_lib_test.py b/official/modeling/multitask/train_lib_test.py index 1b0b8ef9017..f6471baec66 100644 --- a/official/modeling/multitask/train_lib_test.py +++ b/official/modeling/multitask/train_lib_test.py @@ -14,7 +14,7 @@ """Tests for multitask.train_lib.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/modeling/optimization/configs/learning_rate_config.py b/official/modeling/optimization/configs/learning_rate_config.py index 655dbbe32c1..f37ed3713bb 100644 --- a/official/modeling/optimization/configs/learning_rate_config.py +++ b/official/modeling/optimization/configs/learning_rate_config.py @@ -119,7 +119,7 @@ class CosineLrConfig(base_config.Config): """Configuration for Cosine learning rate decay. This class is a containers for the cosine learning rate decay configs, - tf.keras.experimental.CosineDecay. + tf_keras.experimental.CosineDecay. Attributes: name: The name of the learning rate schedule. Defaults to CosineDecay. diff --git a/official/modeling/optimization/configs/optimization_config_test.py b/official/modeling/optimization/configs/optimization_config_test.py index 266d16207bd..902dbcd4dad 100644 --- a/official/modeling/optimization/configs/optimization_config_test.py +++ b/official/modeling/optimization/configs/optimization_config_test.py @@ -14,7 +14,7 @@ """Tests for optimization_config.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization.configs import learning_rate_config as lr_cfg from official.modeling.optimization.configs import optimization_config diff --git a/official/modeling/optimization/configs/optimizer_config.py b/official/modeling/optimization/configs/optimizer_config.py index fab35b031df..304213b3da0 100644 --- a/official/modeling/optimization/configs/optimizer_config.py +++ b/official/modeling/optimization/configs/optimizer_config.py @@ -40,7 +40,7 @@ class BaseOptimizerConfig(base_config.Config): class SGDConfig(BaseOptimizerConfig): """Configuration for SGD optimizer. - The attributes for this class matches the arguments of tf.keras.optimizer.SGD. + The attributes for this class matches the arguments of tf_keras.optimizer.SGD. Attributes: name: name of the optimizer. @@ -61,7 +61,7 @@ class SGDExperimentalConfig(BaseOptimizerConfig): """Configuration for SGD optimizer. The attributes for this class matches the arguments of - `tf.keras.optimizer.experimental.SGD`. + `tf_keras.optimizer.experimental.SGD`. Attributes: name: name of the optimizer. @@ -80,7 +80,7 @@ class RMSPropConfig(BaseOptimizerConfig): """Configuration for RMSProp optimizer. The attributes for this class matches the arguments of - tf.keras.optimizers.RMSprop. + tf_keras.optimizers.RMSprop. Attributes: name: name of the optimizer. @@ -101,7 +101,7 @@ class AdagradConfig(BaseOptimizerConfig): """Configuration for Adagrad optimizer. The attributes of this class match the arguments of - tf.keras.optimizer.Adagrad. + tf_keras.optimizer.Adagrad. Attributes: name: name of the optimizer. @@ -119,7 +119,7 @@ class AdamConfig(BaseOptimizerConfig): """Configuration for Adam optimizer. The attributes for this class matches the arguments of - tf.keras.optimizer.Adam. + tf_keras.optimizer.Adam. Attributes: name: name of the optimizer. @@ -141,7 +141,7 @@ class AdamExperimentalConfig(BaseOptimizerConfig): """Configuration for experimental Adam optimizer. The attributes for this class matches the arguments of - `tf.keras.optimizer.experimental.Adam`. + `tf_keras.optimizer.experimental.Adam`. Attributes: name: name of the optimizer. diff --git a/official/modeling/optimization/ema_optimizer.py b/official/modeling/optimization/ema_optimizer.py index 41ecf4fad91..5f88842aea8 100644 --- a/official/modeling/optimization/ema_optimizer.py +++ b/official/modeling/optimization/ema_optimizer.py @@ -16,7 +16,7 @@ from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=protected-access @@ -48,7 +48,7 @@ def maybe_merge_call(fn, strategy, *args, **kwargs): return fn(strategy, *args, **kwargs) -class ExponentialMovingAverage(tf.keras.optimizers.legacy.Optimizer): +class ExponentialMovingAverage(tf_keras.optimizers.legacy.Optimizer): """Optimizer that computes an exponential moving average of the variables. Empirically it has been found that using the moving average of the trained @@ -59,7 +59,7 @@ class ExponentialMovingAverage(tf.keras.optimizers.legacy.Optimizer): Example of usage for training: ```python - opt = tf.keras.optimizers.SGD(learning_rate) + opt = tf_keras.optimizers.SGD(learning_rate) opt = ExponentialMovingAverage(opt) opt.shadow_copy(model) @@ -74,7 +74,7 @@ class ExponentialMovingAverage(tf.keras.optimizers.legacy.Optimizer): """ def __init__(self, - optimizer: tf.keras.optimizers.Optimizer, + optimizer: tf_keras.optimizers.Optimizer, trainable_weights_only: bool = True, average_decay: float = 0.99, start_step: int = 0, @@ -84,7 +84,7 @@ def __init__(self, """Construct a new ExponentialMovingAverage optimizer. Args: - optimizer: `tf.keras.optimizers.Optimizer` that will be + optimizer: `tf_keras.optimizers.Optimizer` that will be used to compute and apply gradients. trainable_weights_only: 'bool', if True, only model trainable weights will be updated. Otherwise, all model weights will be updated. This mainly @@ -111,7 +111,7 @@ def __init__(self, self._average_weights = None self._model_weights = None - def shadow_copy(self, model: tf.keras.Model): + def shadow_copy(self, model: tf_keras.Model): """Creates shadow variables for the given model weights.""" if self._trainable_weights_only: @@ -279,7 +279,7 @@ def _resource_apply_sparse_duplicate_indices(self, grad, var, indices): def get_config(self): config = { - 'optimizer': tf.keras.optimizers.serialize(self._optimizer), + 'optimizer': tf_keras.optimizers.serialize(self._optimizer), 'average_decay': self._average_decay, 'start_step': self._start_step, 'dynamic_decay': self._dynamic_decay, @@ -289,7 +289,7 @@ def get_config(self): @classmethod def from_config(cls, config, custom_objects=None): - optimizer = tf.keras.optimizers.deserialize( + optimizer = tf_keras.optimizers.deserialize( config.pop('optimizer'), custom_objects=custom_objects, ) diff --git a/official/modeling/optimization/lamb.py b/official/modeling/optimization/lamb.py index de352c46b03..9524026478d 100644 --- a/official/modeling/optimization/lamb.py +++ b/official/modeling/optimization/lamb.py @@ -21,13 +21,13 @@ from typing import Optional, Union, Callable, List import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras FloatTensorLike = Union[tf.Tensor, float, np.float16, np.float32] -@tf.keras.utils.register_keras_serializable(package="Addons") -class LAMB(tf.keras.optimizers.legacy.Optimizer): +@tf_keras.utils.register_keras_serializable(package="Addons") +class LAMB(tf_keras.optimizers.legacy.Optimizer): """Optimizer that implements the Layer-wise Adaptive Moments (LAMB). See paper [Large Batch Optimization for Deep Learning: Training BERT @@ -50,7 +50,7 @@ def __init__( Args: learning_rate: A `Tensor` or a floating point value. or a schedule that - is a `tf.keras.optimizers.schedules.LearningRateSchedule` The learning + is a `tf_keras.optimizers.schedules.LearningRateSchedule` The learning rate. beta_1: A `float` value or a constant `float` tensor. The exponential decay rate for the 1st moment estimates. diff --git a/official/modeling/optimization/lamb_test.py b/official/modeling/optimization/lamb_test.py index f6c41ce12ec..56fa513649c 100644 --- a/official/modeling/optimization/lamb_test.py +++ b/official/modeling/optimization/lamb_test.py @@ -16,7 +16,7 @@ import numpy as np from numpy import linalg -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization import lamb @@ -166,8 +166,8 @@ def test_exclude_layer_adaptation(self): def test_serialization(self): optimizer = lamb.LAMB(1e-4) - config = tf.keras.optimizers.serialize(optimizer, use_legacy_format=True) - new_optimizer = tf.keras.optimizers.deserialize( + config = tf_keras.optimizers.serialize(optimizer, use_legacy_format=True) + new_optimizer = tf_keras.optimizers.deserialize( config, use_legacy_format=True ) assert new_optimizer.get_config() == optimizer.get_config() diff --git a/official/modeling/optimization/lars.py b/official/modeling/optimization/lars.py index d1fd9b85fff..de083b62543 100644 --- a/official/modeling/optimization/lars.py +++ b/official/modeling/optimization/lars.py @@ -16,13 +16,13 @@ import re from typing import Text, List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=protected-access -class LARS(tf.keras.optimizers.legacy.Optimizer): +class LARS(tf_keras.optimizers.legacy.Optimizer): """Layer-wise Adaptive Rate Scaling for large batch training. Introduced by "Large Batch Training of Convolutional Networks" by Y. You, diff --git a/official/modeling/optimization/legacy_adamw.py b/official/modeling/optimization/legacy_adamw.py index 69eebc29cf1..16bd640cbef 100644 --- a/official/modeling/optimization/legacy_adamw.py +++ b/official/modeling/optimization/legacy_adamw.py @@ -17,10 +17,10 @@ import re from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras -class AdamWeightDecay(tf.keras.optimizers.legacy.Adam): +class AdamWeightDecay(tf_keras.optimizers.legacy.Adam): """Adam enables L2 weight decay and clip_by_global_norm on gradients. [Warning!]: Keras optimizer supports gradient clipping and has an AdamW diff --git a/official/modeling/optimization/lr_schedule.py b/official/modeling/optimization/lr_schedule.py index ad14d93f6c4..03f0c0da097 100644 --- a/official/modeling/optimization/lr_schedule.py +++ b/official/modeling/optimization/lr_schedule.py @@ -17,7 +17,7 @@ import math from typing import Mapping, Any, Union, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras def _make_offset_wrapper(new_class_name: str, base_lr_class): @@ -31,7 +31,7 @@ def _make_offset_wrapper(new_class_name: str, base_lr_class): Example: CosineDecayWithOffset = _make_offset_wrapper( 'CosineDecayWithOffset', - tf.keras.optimizers.schedules.CosineDecay) + tf_keras.optimizers.schedules.CosineDecay) # Use the lr: lr = CosineDecayWithOffset(offset=100, initial_learning_rate=0.1, decay_steps=1000) @@ -40,13 +40,13 @@ def _make_offset_wrapper(new_class_name: str, base_lr_class): Args: new_class_name: the name of the new class. base_lr_class: the base learning rate schedule class. Should be subclass of - tf.keras.optimizers.schedules.LearningRateSchedule + tf_keras.optimizers.schedules.LearningRateSchedule Returns: A new class (subclass of the base_lr_class) that can take an offset. """ assert issubclass(base_lr_class, - tf.keras.optimizers.schedules.LearningRateSchedule), ( + tf_keras.optimizers.schedules.LearningRateSchedule), ( "base_lr_class should be subclass of keras " f"LearningRateSchedule, got {base_lr_class}") @@ -80,24 +80,24 @@ def offset_learning_rate_call(self, step): PiecewiseConstantDecayWithOffset = _make_offset_wrapper( "PiecewiseConstantDecayWithOffset", - tf.keras.optimizers.schedules.PiecewiseConstantDecay) + tf_keras.optimizers.schedules.PiecewiseConstantDecay) PolynomialDecayWithOffset = _make_offset_wrapper( - "PolynomialDecayWithOffset", tf.keras.optimizers.schedules.PolynomialDecay) + "PolynomialDecayWithOffset", tf_keras.optimizers.schedules.PolynomialDecay) ExponentialDecayWithOffset = _make_offset_wrapper( "ExponentialDecayWithOffset", - tf.keras.optimizers.schedules.ExponentialDecay) + tf_keras.optimizers.schedules.ExponentialDecay) CosineDecayWithOffset = _make_offset_wrapper( "CosineDecayWithOffset", - tf.keras.optimizers.schedules.CosineDecay, + tf_keras.optimizers.schedules.CosineDecay, ) -class LinearWarmup(tf.keras.optimizers.schedules.LearningRateSchedule): +class LinearWarmup(tf_keras.optimizers.schedules.LearningRateSchedule): """Linear warmup schedule.""" def __init__(self, after_warmup_lr_sched: Union[ - tf.keras.optimizers.schedules.LearningRateSchedule, float], + tf_keras.optimizers.schedules.LearningRateSchedule, float], warmup_steps: int, warmup_learning_rate: float, name: Optional[str] = None): @@ -113,7 +113,7 @@ def __init__(self, steps. Args: - after_warmup_lr_sched: tf.keras.optimizers.schedules .LearningRateSchedule + after_warmup_lr_sched: tf_keras.optimizers.schedules .LearningRateSchedule or a constant. warmup_steps: Number of the warmup steps. warmup_learning_rate: Initial learning rate for the warmup. @@ -125,7 +125,7 @@ def __init__(self, self._warmup_steps = warmup_steps self._init_warmup_lr = warmup_learning_rate if isinstance(after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): self._final_warmup_lr = after_warmup_lr_sched(warmup_steps) else: self._final_warmup_lr = tf.cast(after_warmup_lr_sched, dtype=tf.float32) @@ -139,7 +139,7 @@ def __call__(self, step: int): (self._final_warmup_lr - self._init_warmup_lr)) if isinstance(self._after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): after_warmup_lr = self._after_warmup_lr_sched(step) else: after_warmup_lr = tf.cast(self._after_warmup_lr_sched, dtype=tf.float32) @@ -151,7 +151,7 @@ def __call__(self, step: int): def get_config(self) -> Mapping[str, Any]: if isinstance(self._after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): config = { "after_warmup_lr_sched": self._after_warmup_lr_sched.get_config()} # pytype: disable=attribute-error else: @@ -165,18 +165,18 @@ def get_config(self) -> Mapping[str, Any]: return config -class PolynomialWarmUp(tf.keras.optimizers.schedules.LearningRateSchedule): +class PolynomialWarmUp(tf_keras.optimizers.schedules.LearningRateSchedule): """Applies polynomial warmup schedule on a given learning rate decay schedule.""" def __init__(self, after_warmup_lr_sched: Union[ - tf.keras.optimizers.schedules.LearningRateSchedule, float], + tf_keras.optimizers.schedules.LearningRateSchedule, float], warmup_steps: int, power: float = 1.0, name: str = "PolynomialWarmup"): super().__init__() if isinstance(after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): self._initial_learning_rate = after_warmup_lr_sched(warmup_steps) else: self._initial_learning_rate = tf.cast( @@ -206,7 +206,7 @@ def __call__(self, step): tf.math.pow(warmup_percent_done, self._power)) if isinstance(self._after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): after_warmup_lr = self._after_warmup_lr_sched(step) else: after_warmup_lr = tf.cast(self._after_warmup_lr_sched, dtype=tf.float32) @@ -219,7 +219,7 @@ def __call__(self, step): def get_config(self) -> Mapping[str, Any]: if isinstance(self._after_warmup_lr_sched, - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): config = { "after_warmup_lr_sched": self._after_warmup_lr_sched.get_config()} # pytype: disable=attribute-error else: @@ -233,7 +233,7 @@ def get_config(self) -> Mapping[str, Any]: return config -class DirectPowerDecay(tf.keras.optimizers.schedules.LearningRateSchedule): +class DirectPowerDecay(tf_keras.optimizers.schedules.LearningRateSchedule): """Learning rate schedule follows lr * (step)^power.""" def __init__(self, @@ -270,7 +270,7 @@ def get_config(self): } -class PowerAndLinearDecay(tf.keras.optimizers.schedules.LearningRateSchedule): +class PowerAndLinearDecay(tf_keras.optimizers.schedules.LearningRateSchedule): """Learning rate schedule with multiplied by linear decay at the end. The schedule has the following behavoir. @@ -337,7 +337,7 @@ def get_config(self): } -class PowerDecayWithOffset(tf.keras.optimizers.schedules.LearningRateSchedule): +class PowerDecayWithOffset(tf_keras.optimizers.schedules.LearningRateSchedule): """Power learning rate decay with offset. Learning rate equals to `pre_offset_learning_rate` if `step` < `offset`. @@ -390,7 +390,7 @@ def get_config(self): class StepCosineDecayWithOffset( - tf.keras.optimizers.schedules.LearningRateSchedule): + tf_keras.optimizers.schedules.LearningRateSchedule): """Stepwise cosine learning rate decay with offset. Learning rate is equivalent to one or more cosine decay(s) starting and diff --git a/official/modeling/optimization/lr_schedule_test.py b/official/modeling/optimization/lr_schedule_test.py index bd92aefb29d..0b8f3b50da7 100644 --- a/official/modeling/optimization/lr_schedule_test.py +++ b/official/modeling/optimization/lr_schedule_test.py @@ -14,7 +14,7 @@ """Tests for lr_schedule.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization import lr_schedule diff --git a/official/modeling/optimization/optimizer_factory.py b/official/modeling/optimization/optimizer_factory.py index ca866b9e383..3618641cf75 100644 --- a/official/modeling/optimization/optimizer_factory.py +++ b/official/modeling/optimization/optimizer_factory.py @@ -16,7 +16,7 @@ from typing import Callable, List, Optional, Tuple, Union import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization import slide_optimizer from official.modeling.optimization import adafactor_optimizer @@ -29,10 +29,10 @@ # Optimizer CLS to be used in both legacy and new path. SHARED_OPTIMIZERS = { - 'sgd_experimental': tf.keras.optimizers.experimental.SGD, - 'adam_experimental': tf.keras.optimizers.experimental.Adam, + 'sgd_experimental': tf_keras.optimizers.experimental.SGD, + 'adam_experimental': tf_keras.optimizers.experimental.Adam, 'adamw': legacy_adamw.AdamWeightDecay, - 'adamw_experimental': tf.keras.optimizers.experimental.AdamW, + 'adamw_experimental': tf_keras.optimizers.experimental.AdamW, 'lamb': lamb.LAMB, 'lars': lars.LARS, 'slide': slide_optimizer.SLIDE, @@ -40,18 +40,18 @@ } LEGACY_OPTIMIZERS_CLS = { - 'sgd': tf.keras.optimizers.legacy.SGD, - 'adam': tf.keras.optimizers.legacy.Adam, - 'rmsprop': tf.keras.optimizers.legacy.RMSprop, - 'adagrad': tf.keras.optimizers.legacy.Adagrad, + 'sgd': tf_keras.optimizers.legacy.SGD, + 'adam': tf_keras.optimizers.legacy.Adam, + 'rmsprop': tf_keras.optimizers.legacy.RMSprop, + 'adagrad': tf_keras.optimizers.legacy.Adagrad, } LEGACY_OPTIMIZERS_CLS.update(SHARED_OPTIMIZERS) NEW_OPTIMIZERS_CLS = { - 'sgd': tf.keras.optimizers.experimental.SGD, - 'adam': tf.keras.optimizers.experimental.Adam, - 'rmsprop': tf.keras.optimizers.experimental.RMSprop, - 'adagrad': tf.keras.optimizers.experimental.Adagrad, + 'sgd': tf_keras.optimizers.experimental.SGD, + 'adam': tf_keras.optimizers.experimental.Adam, + 'rmsprop': tf_keras.optimizers.experimental.RMSprop, + 'adagrad': tf_keras.optimizers.experimental.Adagrad, } NEW_OPTIMIZERS_CLS.update(SHARED_OPTIMIZERS) @@ -74,9 +74,9 @@ def register_optimizer_cls(key: str, optimizer_config_cls: Union[ - tf.keras.optimizers.Optimizer, - tf.keras.optimizers.legacy.Optimizer, - tf.keras.optimizers.experimental.Optimizer + tf_keras.optimizers.Optimizer, + tf_keras.optimizers.legacy.Optimizer, + tf_keras.optimizers.experimental.Optimizer ], use_legacy_optimizer: bool = True): """Register customize optimizer cls. @@ -86,7 +86,7 @@ def register_optimizer_cls(key: str, Args: key: A string to that the optimizer_config_cls is registered with. - optimizer_config_cls: A class which inherits tf.keras.optimizers.Optimizer. + optimizer_config_cls: A class which inherits tf_keras.optimizers.Optimizer. use_legacy_optimizer: A boolean that indicates if using legacy optimizers. """ if use_legacy_optimizer: @@ -168,7 +168,7 @@ def build_learning_rate(self): lr_config.learning_rate is returned. Returns: - tf.keras.optimizers.schedules.LearningRateSchedule instance. If + tf_keras.optimizers.schedules.LearningRateSchedule instance. If learning rate type is consant, lr_config.learning_rate is returned. """ if self._lr_type == 'constant': @@ -184,15 +184,15 @@ def build_learning_rate(self): @gin.configurable def build_optimizer( self, - lr: Union[tf.keras.optimizers.schedules.LearningRateSchedule, float], + lr: Union[tf_keras.optimizers.schedules.LearningRateSchedule, float], gradient_aggregator: Optional[Callable[ [List[Tuple[tf.Tensor, tf.Tensor]]], List[Tuple[tf.Tensor, tf.Tensor]]]] = None, gradient_transformers: Optional[List[Callable[ [List[Tuple[tf.Tensor, tf.Tensor]]], List[Tuple[tf.Tensor, tf.Tensor]]]]] = None, - postprocessor: Optional[Callable[[tf.keras.optimizers.Optimizer], - tf.keras.optimizers.Optimizer]] = None, + postprocessor: Optional[Callable[[tf_keras.optimizers.Optimizer], + tf_keras.optimizers.Optimizer]] = None, use_legacy_optimizer: bool = True): """Build optimizer. @@ -202,7 +202,7 @@ def build_optimizer( Args: lr: A floating point value, or a - tf.keras.optimizers.schedules.LearningRateSchedule instance. + tf_keras.optimizers.schedules.LearningRateSchedule instance. gradient_aggregator: Optional function to overwrite gradient aggregation. gradient_transformers: Optional list of functions to use to transform gradients before applying updates to Variables. The functions are @@ -214,8 +214,8 @@ def build_optimizer( use_legacy_optimizer: A boolean that indicates if using legacy optimizers. Returns: - `tf.keras.optimizers.legacy.Optimizer` or - `tf.keras.optimizers.experimental.Optimizer` instance. + `tf_keras.optimizers.legacy.Optimizer` or + `tf_keras.optimizers.experimental.Optimizer` instance. """ optimizer_dict = self._optimizer_config.as_dict() @@ -252,15 +252,15 @@ def build_optimizer( optimizer, **self._ema_config.as_dict()) if postprocessor: optimizer = postprocessor(optimizer) - if isinstance(optimizer, tf.keras.optimizers.Optimizer): + if isinstance(optimizer, tf_keras.optimizers.Optimizer): return optimizer # The following check makes sure the function won't break in older TF # version because of missing the experimental/legacy package. - if hasattr(tf.keras.optimizers, 'experimental'): - if isinstance(optimizer, tf.keras.optimizers.experimental.Optimizer): + if hasattr(tf_keras.optimizers, 'experimental'): + if isinstance(optimizer, tf_keras.optimizers.experimental.Optimizer): return optimizer - if hasattr(tf.keras.optimizers, 'legacy'): - if isinstance(optimizer, tf.keras.optimizers.legacy.Optimizer): + if hasattr(tf_keras.optimizers, 'legacy'): + if isinstance(optimizer, tf_keras.optimizers.legacy.Optimizer): return optimizer raise TypeError('OptimizerFactory.build_optimizer returning a ' 'non-optimizer object: {}'.format(optimizer)) diff --git a/official/modeling/optimization/optimizer_factory_test.py b/official/modeling/optimization/optimizer_factory_test.py index 7176351a8c6..95422fafc42 100644 --- a/official/modeling/optimization/optimizer_factory_test.py +++ b/official/modeling/optimization/optimizer_factory_test.py @@ -15,7 +15,7 @@ """Tests for optimizer_factory.py.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization import optimizer_factory from official.modeling.optimization.configs import optimization_config @@ -99,7 +99,7 @@ def test_gradient_aggregator(self): zero_grads = lambda gv: [(tf.zeros_like(g), v) for g, v in gv] optimizer = opt_factory.build_optimizer(lr, gradient_aggregator=zero_grads) - if isinstance(optimizer, tf.keras.optimizers.experimental.Optimizer): + if isinstance(optimizer, tf_keras.optimizers.experimental.Optimizer): self.skipTest('New Keras optimizer does not support ' '`gradient_aggregator` arg.') diff --git a/official/modeling/performance.py b/official/modeling/performance.py index 9a45ec926df..821001a7069 100644 --- a/official/modeling/performance.py +++ b/official/modeling/performance.py @@ -15,7 +15,7 @@ """Functions and classes related to training performance.""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def configure_optimizer(optimizer, @@ -29,25 +29,25 @@ def configure_optimizer(optimizer, del use_graph_rewrite if use_float16: if loss_scale in (None, 'dynamic'): - optimizer = tf.keras.mixed_precision.LossScaleOptimizer(optimizer) + optimizer = tf_keras.mixed_precision.LossScaleOptimizer(optimizer) else: # loss_scale is a number. We interpret that as a fixed loss scale. - optimizer = tf.keras.mixed_precision.LossScaleOptimizer( + optimizer = tf_keras.mixed_precision.LossScaleOptimizer( optimizer, dynamic=False, initial_scale=loss_scale) return optimizer def set_mixed_precision_policy(dtype, loss_scale=None): - """Sets the global `tf.keras.mixed_precision.Policy`.""" + """Sets the global `tf_keras.mixed_precision.Policy`.""" # TODO(b/191894773): Remove loss_scale argument assert loss_scale is None, ( 'The loss_scale argument must be None. The argument exists for ' 'historical reasons and will be removed soon.') if dtype == tf.float16: - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') elif dtype == tf.bfloat16: - tf.keras.mixed_precision.set_global_policy('mixed_bfloat16') + tf_keras.mixed_precision.set_global_policy('mixed_bfloat16') elif dtype == tf.float32: - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') else: raise ValueError('Unexpected dtype: %s' % dtype) diff --git a/official/modeling/privacy/configs_test.py b/official/modeling/privacy/configs_test.py index 40cdaf727b8..dad44dc2a3e 100644 --- a/official/modeling/privacy/configs_test.py +++ b/official/modeling/privacy/configs_test.py @@ -14,7 +14,7 @@ """Tests for configs.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.privacy import configs diff --git a/official/modeling/privacy/ops.py b/official/modeling/privacy/ops.py index 732dff9b2e4..85656bf1057 100644 --- a/official/modeling/privacy/ops.py +++ b/official/modeling/privacy/ops.py @@ -17,7 +17,7 @@ from typing import List, Tuple import warnings -import tensorflow as tf +import tensorflow as tf, tf_keras def clip_l2_norm(grads_vars: List[Tuple[tf.Tensor, tf.Tensor]], diff --git a/official/modeling/privacy/ops_test.py b/official/modeling/privacy/ops_test.py index e88df9ed339..f52386366d9 100644 --- a/official/modeling/privacy/ops_test.py +++ b/official/modeling/privacy/ops_test.py @@ -16,7 +16,7 @@ from unittest import mock -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.privacy import ops diff --git a/official/modeling/tf_utils.py b/official/modeling/tf_utils.py index 8a9c0730da3..6c0bd9c8964 100644 --- a/official/modeling/tf_utils.py +++ b/official/modeling/tf_utils.py @@ -17,7 +17,7 @@ import functools import inspect import six -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.util import deprecation from official.modeling import activations @@ -25,7 +25,7 @@ @deprecation.deprecated( None, - "tf.keras.layers.Layer supports multiple positional args and kwargs as " + "tf_keras.layers.Layer supports multiple positional args and kwargs as " "input tensors. pack/unpack inputs to override __call__ is no longer " "needed.") def pack_inputs(inputs): @@ -50,7 +50,7 @@ def pack_inputs(inputs): @deprecation.deprecated( None, - "tf.keras.layers.Layer supports multiple positional args and kwargs as " + "tf_keras.layers.Layer supports multiple positional args and kwargs as " "input tensors. pack/unpack inputs to override __call__ is no longer " "needed.") def unpack_inputs(inputs): @@ -89,7 +89,7 @@ def get_activation(identifier, use_keras_layer=False, **kwargs): It checks string first and if it is one of customized activation not in TF, the corresponding activation will be returned. For non-customized activation - names and callable identifiers, always fallback to tf.keras.activations.get. + names and callable identifiers, always fallback to tf_keras.activations.get. Prefers using keras layers when use_keras_layer=True. Now it only supports 'relu', 'linear', 'identity', 'swish', 'mish', 'leaky_relu', and 'gelu'. @@ -122,7 +122,7 @@ def get_activation(identifier, use_keras_layer=False, **kwargs): "gelu": functools.partial(tf.nn.gelu, **kwargs), } if identifier in keras_layer_allowlist: - return tf.keras.layers.Activation(keras_layer_allowlist[identifier]) + return tf_keras.layers.Activation(keras_layer_allowlist[identifier]) name_to_fn = { "gelu": activations.gelu, "simple_swish": activations.simple_swish, @@ -133,8 +133,8 @@ def get_activation(identifier, use_keras_layer=False, **kwargs): "mish": activations.mish, } if identifier in name_to_fn: - return tf.keras.activations.get(name_to_fn[identifier]) - return tf.keras.activations.get(identifier) + return tf_keras.activations.get(name_to_fn[identifier]) + return tf_keras.activations.get(identifier) def get_shape_list(tensor, expected_rank=None, name=None): @@ -286,7 +286,7 @@ def cross_replica_concat(value, axis, name="cross_replica_concat"): def clone_initializer(initializer): # Keras initializer is going to be stateless, which mean reusing the same # initializer will produce same init value when the shapes are the same. - if isinstance(initializer, tf.keras.initializers.Initializer): + if isinstance(initializer, tf_keras.initializers.Initializer): return initializer.__class__.from_config(initializer.get_config()) # When the input is string/dict or other serialized configs, caller will # create a new keras Initializer instance based on that, and we don't need to @@ -295,21 +295,21 @@ def clone_initializer(initializer): def serialize_keras_object(obj): - if hasattr(tf.keras.utils, "legacy"): - return tf.keras.utils.legacy.serialize_keras_object(obj) + if hasattr(tf_keras.utils, "legacy"): + return tf_keras.utils.legacy.serialize_keras_object(obj) else: - return tf.keras.utils.serialize_keras_object(obj) + return tf_keras.utils.serialize_keras_object(obj) def deserialize_keras_object( config, module_objects=None, custom_objects=None, printable_module_name=None ): - if hasattr(tf.keras.utils, "legacy"): - return tf.keras.utils.legacy.deserialize_keras_object( + if hasattr(tf_keras.utils, "legacy"): + return tf_keras.utils.legacy.deserialize_keras_object( config, custom_objects, module_objects, printable_module_name ) else: - return tf.keras.utils.deserialize_keras_object( + return tf_keras.utils.deserialize_keras_object( config, custom_objects, module_objects, printable_module_name ) @@ -317,56 +317,56 @@ def deserialize_keras_object( def serialize_layer(layer, use_legacy_format=False): if ( "use_legacy_format" - in inspect.getfullargspec(tf.keras.layers.serialize).args + in inspect.getfullargspec(tf_keras.layers.serialize).args ): - return tf.keras.layers.serialize(layer, use_legacy_format=use_legacy_format) + return tf_keras.layers.serialize(layer, use_legacy_format=use_legacy_format) else: - return tf.keras.layers.serialize(layer) + return tf_keras.layers.serialize(layer) def serialize_initializer(initializer, use_legacy_format=False): if ( "use_legacy_format" - in inspect.getfullargspec(tf.keras.initializers.serialize).args + in inspect.getfullargspec(tf_keras.initializers.serialize).args ): - return tf.keras.initializers.serialize( + return tf_keras.initializers.serialize( initializer, use_legacy_format=use_legacy_format ) else: - return tf.keras.initializers.serialize(initializer) + return tf_keras.initializers.serialize(initializer) def serialize_regularizer(regularizer, use_legacy_format=False): if ( "use_legacy_format" - in inspect.getfullargspec(tf.keras.regularizers.serialize).args + in inspect.getfullargspec(tf_keras.regularizers.serialize).args ): - return tf.keras.regularizers.serialize( + return tf_keras.regularizers.serialize( regularizer, use_legacy_format=use_legacy_format ) else: - return tf.keras.regularizers.serialize(regularizer) + return tf_keras.regularizers.serialize(regularizer) def serialize_constraint(constraint, use_legacy_format=False): if ( "use_legacy_format" - in inspect.getfullargspec(tf.keras.constraints.serialize).args + in inspect.getfullargspec(tf_keras.constraints.serialize).args ): - return tf.keras.constraints.serialize( + return tf_keras.constraints.serialize( constraint, use_legacy_format=use_legacy_format ) else: - return tf.keras.constraints.serialize(constraint) + return tf_keras.constraints.serialize(constraint) def serialize_activation(activation, use_legacy_format=False): if ( "use_legacy_format" - in inspect.getfullargspec(tf.keras.activations.serialize).args + in inspect.getfullargspec(tf_keras.activations.serialize).args ): - return tf.keras.activations.serialize( + return tf_keras.activations.serialize( activation, use_legacy_format=use_legacy_format ) else: - return tf.keras.activations.serialize(activation) + return tf_keras.activations.serialize(activation) diff --git a/official/modeling/tf_utils_test.py b/official/modeling/tf_utils_test.py index ba1ab6d05e9..45a3e4fbbc8 100644 --- a/official/modeling/tf_utils_test.py +++ b/official/modeling/tf_utils_test.py @@ -15,7 +15,7 @@ """Tests for tf_utils.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/nlp/configs/encoders.py b/official/nlp/configs/encoders.py index 0bc1deff256..5bf4e665f42 100644 --- a/official/nlp/configs/encoders.py +++ b/official/nlp/configs/encoders.py @@ -20,7 +20,7 @@ from typing import Optional, Sequence, Union import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -71,7 +71,7 @@ class FunnelEncoderConfig(hyperparams.Config): initializer_range: float = 0.02 output_range: Optional[int] = None embedding_width: Optional[int] = None - embedding_layer: Optional[tf.keras.layers.Layer] = None + embedding_layer: Optional[tf_keras.layers.Layer] = None norm_first: bool = False share_rezero: bool = False append_dense_inputs: bool = False @@ -362,7 +362,7 @@ class EncoderConfig(hyperparams.OneOfConfig): @gin.configurable def build_encoder(config: EncoderConfig, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, encoder_cls=None, bypass_config: bool = False): """Instantiate a Transformer encoder network from EncoderConfig. @@ -389,7 +389,7 @@ def build_encoder(config: EncoderConfig, type_vocab_size=encoder_cfg.type_vocab_size, hidden_size=encoder_cfg.hidden_size, max_seq_length=encoder_cfg.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), dropout_rate=encoder_cfg.dropout_rate, ) @@ -400,7 +400,7 @@ def build_encoder(config: EncoderConfig, encoder_cfg.hidden_activation), dropout_rate=encoder_cfg.dropout_rate, attention_dropout_rate=encoder_cfg.attention_dropout_rate, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), ) kwargs = dict( @@ -408,7 +408,7 @@ def build_encoder(config: EncoderConfig, hidden_cfg=hidden_cfg, num_hidden_instances=encoder_cfg.num_layers, pooled_output_dim=encoder_cfg.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), return_all_layer_outputs=encoder_cfg.return_all_encoder_outputs, dict_outputs=True) @@ -417,10 +417,10 @@ def build_encoder(config: EncoderConfig, if encoder_type == "any": encoder = encoder_cfg.BUILDER(encoder_cfg) if not isinstance(encoder, - (tf.Module, tf.keras.Model, tf.keras.layers.Layer)): + (tf.Module, tf_keras.Model, tf_keras.layers.Layer)): raise ValueError("The BUILDER returns an unexpected instance. The " "`build_encoder` should returns a tf.Module, " - "tf.keras.Model or tf.keras.layers.Layer. However, " + "tf_keras.Model or tf_keras.layers.Layer. However, " f"we get {encoder.__class__}") return encoder @@ -459,7 +459,7 @@ def build_encoder(config: EncoderConfig, activation=tf_utils.get_activation(encoder_cfg.hidden_activation), dropout_rate=encoder_cfg.dropout_rate, attention_dropout_rate=encoder_cfg.attention_dropout_rate, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), dict_outputs=True) @@ -480,7 +480,7 @@ def build_encoder(config: EncoderConfig, block_size=encoder_cfg.block_size, max_position_embeddings=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), embedding_width=encoder_cfg.embedding_width, use_gradient_checkpointing=encoder_cfg.use_gradient_checkpointing) @@ -489,13 +489,13 @@ def build_encoder(config: EncoderConfig, type_vocab_size=encoder_cfg.type_vocab_size, hidden_size=encoder_cfg.hidden_size, max_seq_length=encoder_cfg.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), dropout_rate=encoder_cfg.dropout_rate) attention_cfg = dict( num_heads=encoder_cfg.num_attention_heads, key_dim=int(encoder_cfg.hidden_size // encoder_cfg.num_attention_heads), - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), max_rand_mask_length=encoder_cfg.max_position_embeddings, num_rand_blocks=encoder_cfg.num_rand_blocks, @@ -510,7 +510,7 @@ def build_encoder(config: EncoderConfig, dropout_rate=encoder_cfg.dropout_rate, attention_dropout_rate=encoder_cfg.attention_dropout_rate, norm_first=encoder_cfg.norm_first, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), attention_cls=layers.BigBirdAttention, attention_cfg=attention_cfg) @@ -522,7 +522,7 @@ def build_encoder(config: EncoderConfig, mask_cls=layers.BigBirdMasks, mask_cfg=dict(block_size=encoder_cfg.block_size), pooled_output_dim=encoder_cfg.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), return_all_layer_outputs=False, dict_outputs=True, @@ -552,7 +552,7 @@ def build_encoder(config: EncoderConfig, pool_type=encoder_cfg.pool_type, pool_stride=encoder_cfg.pool_stride, unpool_length=encoder_cfg.unpool_length, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_width, @@ -569,13 +569,13 @@ def build_encoder(config: EncoderConfig, type_vocab_size=encoder_cfg.type_vocab_size, hidden_size=encoder_cfg.hidden_size, max_seq_length=encoder_cfg.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), dropout_rate=encoder_cfg.dropout_rate) attention_cfg = dict( num_heads=encoder_cfg.num_attention_heads, key_dim=int(encoder_cfg.hidden_size // encoder_cfg.num_attention_heads), - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), feature_transform=encoder_cfg.feature_transform, num_random_features=encoder_cfg.num_random_features, @@ -592,7 +592,7 @@ def build_encoder(config: EncoderConfig, dropout_rate=encoder_cfg.dropout_rate, attention_dropout_rate=encoder_cfg.attention_dropout_rate, norm_first=encoder_cfg.norm_first, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), attention_cls=layers.KernelAttention, attention_cfg=attention_cfg) @@ -603,7 +603,7 @@ def build_encoder(config: EncoderConfig, num_hidden_instances=encoder_cfg.num_layers, mask_cls=layers.KernelMask, pooled_output_dim=encoder_cfg.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), return_all_layer_outputs=False, dict_outputs=True, @@ -630,7 +630,7 @@ def build_encoder(config: EncoderConfig, inner_activation=encoder_cfg.inner_activation, use_cls_mask=encoder_cfg.use_cls_mask, embedding_width=encoder_cfg.embedding_width, - initializer=tf.keras.initializers.RandomNormal( + initializer=tf_keras.initializers.RandomNormal( stddev=encoder_cfg.initializer_range)) if encoder_type == "reuse": @@ -639,7 +639,7 @@ def build_encoder(config: EncoderConfig, type_vocab_size=encoder_cfg.type_vocab_size, hidden_size=encoder_cfg.hidden_size, max_seq_length=encoder_cfg.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), dropout_rate=encoder_cfg.dropout_rate) hidden_cfg = dict( @@ -650,7 +650,7 @@ def build_encoder(config: EncoderConfig, output_dropout=encoder_cfg.dropout_rate, attention_dropout=encoder_cfg.attention_dropout_rate, norm_first=encoder_cfg.norm_first, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), reuse_attention=encoder_cfg.reuse_attention, use_relative_pe=encoder_cfg.use_relative_pe, @@ -662,7 +662,7 @@ def build_encoder(config: EncoderConfig, hidden_cfg=hidden_cfg, num_hidden_instances=encoder_cfg.num_layers, pooled_output_dim=encoder_cfg.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), return_all_layer_outputs=False, dict_outputs=True, @@ -675,7 +675,7 @@ def build_encoder(config: EncoderConfig, vocab_size=encoder_cfg.vocab_size, embedding_width=encoder_cfg.embedding_size, output_dim=encoder_cfg.hidden_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), name="word_embeddings") return networks.BertEncoderV2( @@ -689,7 +689,7 @@ def build_encoder(config: EncoderConfig, attention_dropout_rate=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_layer=embedding_layer, @@ -710,7 +710,7 @@ def build_encoder(config: EncoderConfig, attention_dropout=encoder_cfg.attention_dropout, max_sequence_length=encoder_cfg.max_sequence_length, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_width, @@ -738,7 +738,7 @@ def build_encoder(config: EncoderConfig, inner_activation=tf_utils.get_activation(encoder_cfg.inner_activation), output_dropout=encoder_cfg.output_dropout, attention_dropout=encoder_cfg.attention_dropout, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_width, @@ -762,7 +762,7 @@ def build_encoder(config: EncoderConfig, attention_dropout_rate=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/nlp/configs/encoders_test.py b/official/nlp/configs/encoders_test.py index 507b31d883d..e6cc1c36c38 100644 --- a/official/nlp/configs/encoders_test.py +++ b/official/nlp/configs/encoders_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.configs.encoders.""" import os -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.nlp.configs import encoders diff --git a/official/nlp/continuous_finetune_lib.py b/official/nlp/continuous_finetune_lib.py index 4de250c6f16..9ad706e2e8e 100644 --- a/official/nlp/continuous_finetune_lib.py +++ b/official/nlp/continuous_finetune_lib.py @@ -19,7 +19,7 @@ from typing import Any, Mapping, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.core import config_definitions diff --git a/official/nlp/continuous_finetune_lib_test.py b/official/nlp/continuous_finetune_lib_test.py index 4715d9ac66b..cc4108c7b3f 100644 --- a/official/nlp/continuous_finetune_lib_test.py +++ b/official/nlp/continuous_finetune_lib_test.py @@ -17,7 +17,7 @@ from absl import flags from absl.testing import flagsaver from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.common import registry_imports diff --git a/official/nlp/data/classifier_data_lib.py b/official/nlp/data/classifier_data_lib.py index 938facd974c..eb9e6822570 100644 --- a/official/nlp/data/classifier_data_lib.py +++ b/official/nlp/data/classifier_data_lib.py @@ -21,7 +21,7 @@ import os from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.nlp.tools import tokenization diff --git a/official/nlp/data/classifier_data_lib_test.py b/official/nlp/data/classifier_data_lib_test.py index 3f1d4f12505..ef54a6742b1 100644 --- a/official/nlp/data/classifier_data_lib_test.py +++ b/official/nlp/data/classifier_data_lib_test.py @@ -18,7 +18,7 @@ import tempfile from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.nlp.data import classifier_data_lib diff --git a/official/nlp/data/create_finetuning_data.py b/official/nlp/data/create_finetuning_data.py index 1b6fc64624f..631a7e48044 100644 --- a/official/nlp/data/create_finetuning_data.py +++ b/official/nlp/data/create_finetuning_data.py @@ -21,7 +21,7 @@ # Import libraries from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import classifier_data_lib from official.nlp.data import sentence_retrieval_lib # word-piece tokenizer based squad_lib diff --git a/official/nlp/data/create_pretraining_data.py b/official/nlp/data/create_pretraining_data.py index fa557c9ecfb..55a4b8489a8 100644 --- a/official/nlp/data/create_pretraining_data.py +++ b/official/nlp/data/create_pretraining_data.py @@ -22,7 +22,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.tools import tokenization diff --git a/official/nlp/data/create_pretraining_data_test.py b/official/nlp/data/create_pretraining_data_test.py index c2ff2affd37..2ae8b86ca22 100644 --- a/official/nlp/data/create_pretraining_data_test.py +++ b/official/nlp/data/create_pretraining_data_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.data.create_pretraining_data.""" import random -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import create_pretraining_data as cpd diff --git a/official/nlp/data/create_xlnet_pretraining_data.py b/official/nlp/data/create_xlnet_pretraining_data.py index 9342188022a..d5e142b9bd0 100644 --- a/official/nlp/data/create_xlnet_pretraining_data.py +++ b/official/nlp/data/create_xlnet_pretraining_data.py @@ -30,7 +30,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.tools import tokenization diff --git a/official/nlp/data/create_xlnet_pretraining_data_test.py b/official/nlp/data/create_xlnet_pretraining_data_test.py index 57e6c3c59a8..b5a9176e91f 100644 --- a/official/nlp/data/create_xlnet_pretraining_data_test.py +++ b/official/nlp/data/create_xlnet_pretraining_data_test.py @@ -21,7 +21,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import create_xlnet_pretraining_data as cpd diff --git a/official/nlp/data/data_loader.py b/official/nlp/data/data_loader.py index ba571af6a8b..e59b4650c6f 100644 --- a/official/nlp/data/data_loader.py +++ b/official/nlp/data/data_loader.py @@ -17,7 +17,7 @@ import abc from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras class DataLoader(metaclass=abc.ABCMeta): diff --git a/official/nlp/data/data_loader_factory_test.py b/official/nlp/data/data_loader_factory_test.py index fd0a7cb6cb3..41b2c37d108 100644 --- a/official/nlp/data/data_loader_factory_test.py +++ b/official/nlp/data/data_loader_factory_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.data.data_loader_factory.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.nlp.data import data_loader_factory diff --git a/official/nlp/data/dual_encoder_dataloader.py b/official/nlp/data/dual_encoder_dataloader.py index 00ceac045e0..0f4e8adb2d4 100644 --- a/official/nlp/data/dual_encoder_dataloader.py +++ b/official/nlp/data/dual_encoder_dataloader.py @@ -18,7 +18,7 @@ import itertools from typing import Iterable, Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.common import dataset_fn diff --git a/official/nlp/data/dual_encoder_dataloader_test.py b/official/nlp/data/dual_encoder_dataloader_test.py index f96463d55c0..f74c01c81a3 100644 --- a/official/nlp/data/dual_encoder_dataloader_test.py +++ b/official/nlp/data/dual_encoder_dataloader_test.py @@ -16,7 +16,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import dual_encoder_dataloader diff --git a/official/nlp/data/pretrain_dataloader.py b/official/nlp/data/pretrain_dataloader.py index b4ab476ea7e..51e268b1b33 100644 --- a/official/nlp/data/pretrain_dataloader.py +++ b/official/nlp/data/pretrain_dataloader.py @@ -19,7 +19,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/nlp/data/pretrain_dataloader_test.py b/official/nlp/data/pretrain_dataloader_test.py index ce1d1100ff8..ebefbfb2fbf 100644 --- a/official/nlp/data/pretrain_dataloader_test.py +++ b/official/nlp/data/pretrain_dataloader_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import pretrain_dataloader diff --git a/official/nlp/data/pretrain_dynamic_dataloader.py b/official/nlp/data/pretrain_dynamic_dataloader.py index e02cd5d99f2..2168c34f36f 100644 --- a/official/nlp/data/pretrain_dynamic_dataloader.py +++ b/official/nlp/data/pretrain_dynamic_dataloader.py @@ -16,7 +16,7 @@ from typing import Optional, Tuple import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/nlp/data/pretrain_dynamic_dataloader_test.py b/official/nlp/data/pretrain_dynamic_dataloader_test.py index 408a12ad6f0..7e559ea7e36 100644 --- a/official/nlp/data/pretrain_dynamic_dataloader_test.py +++ b/official/nlp/data/pretrain_dynamic_dataloader_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import numpy as np import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/nlp/data/pretrain_text_dataloader.py b/official/nlp/data/pretrain_text_dataloader.py index b0ff5b8c154..0c826b2ef15 100644 --- a/official/nlp/data/pretrain_text_dataloader.py +++ b/official/nlp/data/pretrain_text_dataloader.py @@ -16,7 +16,7 @@ import dataclasses from typing import List, Mapping, Optional, Text -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_text as tf_text from official.common import dataset_fn diff --git a/official/nlp/data/question_answering_dataloader.py b/official/nlp/data/question_answering_dataloader.py index 7c76b0275bd..a0d7df3774a 100644 --- a/official/nlp/data/question_answering_dataloader.py +++ b/official/nlp/data/question_answering_dataloader.py @@ -16,7 +16,7 @@ import dataclasses from typing import Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/nlp/data/question_answering_dataloader_test.py b/official/nlp/data/question_answering_dataloader_test.py index 3f074d7b585..80b47ef3c71 100644 --- a/official/nlp/data/question_answering_dataloader_test.py +++ b/official/nlp/data/question_answering_dataloader_test.py @@ -16,7 +16,7 @@ import os import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import question_answering_dataloader diff --git a/official/nlp/data/sentence_prediction_dataloader.py b/official/nlp/data/sentence_prediction_dataloader.py index 7bea8e7ff64..e153a064562 100644 --- a/official/nlp/data/sentence_prediction_dataloader.py +++ b/official/nlp/data/sentence_prediction_dataloader.py @@ -17,7 +17,7 @@ import functools from typing import List, Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.common import dataset_fn diff --git a/official/nlp/data/sentence_prediction_dataloader_test.py b/official/nlp/data/sentence_prediction_dataloader_test.py index d032ab8056b..4fe19167577 100644 --- a/official/nlp/data/sentence_prediction_dataloader_test.py +++ b/official/nlp/data/sentence_prediction_dataloader_test.py @@ -17,7 +17,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from sentencepiece import SentencePieceTrainer from official.nlp.data import sentence_prediction_dataloader as loader diff --git a/official/nlp/data/squad_lib.py b/official/nlp/data/squad_lib.py index f0a1b1f9db2..4bf05f478ab 100644 --- a/official/nlp/data/squad_lib.py +++ b/official/nlp/data/squad_lib.py @@ -23,7 +23,7 @@ import six from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.tools import tokenization diff --git a/official/nlp/data/squad_lib_sp.py b/official/nlp/data/squad_lib_sp.py index 04c53c67eb6..55394c38a1b 100644 --- a/official/nlp/data/squad_lib_sp.py +++ b/official/nlp/data/squad_lib_sp.py @@ -26,7 +26,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.tools import tokenization diff --git a/official/nlp/data/tagging_data_lib.py b/official/nlp/data/tagging_data_lib.py index 716cd11f7b3..5bc109dce6c 100644 --- a/official/nlp/data/tagging_data_lib.py +++ b/official/nlp/data/tagging_data_lib.py @@ -17,7 +17,7 @@ import os from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import classifier_data_lib from official.nlp.tools import tokenization diff --git a/official/nlp/data/tagging_data_lib_test.py b/official/nlp/data/tagging_data_lib_test.py index 7323833daf4..5fc5ea03f83 100644 --- a/official/nlp/data/tagging_data_lib_test.py +++ b/official/nlp/data/tagging_data_lib_test.py @@ -17,7 +17,7 @@ import random from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import tagging_data_lib from official.nlp.tools import tokenization diff --git a/official/nlp/data/tagging_dataloader.py b/official/nlp/data/tagging_dataloader.py index 467e2893f41..83a0a922b30 100644 --- a/official/nlp/data/tagging_dataloader.py +++ b/official/nlp/data/tagging_dataloader.py @@ -16,7 +16,7 @@ import dataclasses from typing import Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/nlp/data/tagging_dataloader_test.py b/official/nlp/data/tagging_dataloader_test.py index 12bebe52d2e..1b2c66f20ca 100644 --- a/official/nlp/data/tagging_dataloader_test.py +++ b/official/nlp/data/tagging_dataloader_test.py @@ -17,7 +17,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import tagging_dataloader diff --git a/official/nlp/data/train_sentencepiece.py b/official/nlp/data/train_sentencepiece.py index 26b05d5a829..3f058421903 100644 --- a/official/nlp/data/train_sentencepiece.py +++ b/official/nlp/data/train_sentencepiece.py @@ -28,7 +28,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from sentencepiece import SentencePieceTrainer diff --git a/official/nlp/data/wmt_dataloader.py b/official/nlp/data/wmt_dataloader.py index 89106f90508..b7062ef25b2 100644 --- a/official/nlp/data/wmt_dataloader.py +++ b/official/nlp/data/wmt_dataloader.py @@ -34,7 +34,7 @@ from typing import Dict, Optional import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_text as tftxt from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/nlp/data/wmt_dataloader_test.py b/official/nlp/data/wmt_dataloader_test.py index 523af7eb77e..83ea5a139a9 100644 --- a/official/nlp/data/wmt_dataloader_test.py +++ b/official/nlp/data/wmt_dataloader_test.py @@ -16,7 +16,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from sentencepiece import SentencePieceTrainer from official.nlp.data import wmt_dataloader diff --git a/official/nlp/finetuning/binary_helper.py b/official/nlp/finetuning/binary_helper.py index 172acfb3c8d..cacb9a6fcbe 100644 --- a/official/nlp/finetuning/binary_helper.py +++ b/official/nlp/finetuning/binary_helper.py @@ -19,7 +19,7 @@ from typing import Any, Dict, List, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.modeling import hyperparams diff --git a/official/nlp/finetuning/glue/run_glue.py b/official/nlp/finetuning/glue/run_glue.py index b178ad1c8c1..968a8675008 100644 --- a/official/nlp/finetuning/glue/run_glue.py +++ b/official/nlp/finetuning/glue/run_glue.py @@ -23,7 +23,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils # Imports registered experiment configs. diff --git a/official/nlp/finetuning/superglue/run_superglue.py b/official/nlp/finetuning/superglue/run_superglue.py index 5f5752c901c..c6077cbee3e 100644 --- a/official/nlp/finetuning/superglue/run_superglue.py +++ b/official/nlp/finetuning/superglue/run_superglue.py @@ -23,7 +23,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils # Imports registered experiment configs. diff --git a/official/nlp/metrics/bleu.py b/official/nlp/metrics/bleu.py index 8df4e4ff24f..1e9ab9b9ec6 100644 --- a/official/nlp/metrics/bleu.py +++ b/official/nlp/metrics/bleu.py @@ -25,7 +25,7 @@ import unicodedata import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras class UnicodeRegex(object): diff --git a/official/nlp/metrics/bleu_test.py b/official/nlp/metrics/bleu_test.py index 22fe8624390..b4f89233109 100644 --- a/official/nlp/metrics/bleu_test.py +++ b/official/nlp/metrics/bleu_test.py @@ -16,7 +16,7 @@ import tempfile -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.metrics import bleu diff --git a/official/nlp/modeling/__init__.py b/official/nlp/modeling/__init__.py index c3a29642dec..5e6bc931e7c 100644 --- a/official/nlp/modeling/__init__.py +++ b/official/nlp/modeling/__init__.py @@ -14,8 +14,8 @@ """NLP Modeling Library. -This library provides a set of Keras primitives (`tf.keras.Layer` and -`tf.keras.Model`) that can be assembled into transformer-based models. +This library provides a set of Keras primitives (`tf_keras.Layer` and +`tf_keras.Model`) that can be assembled into transformer-based models. They are flexible, validated, interoperable, and both TF1 and TF2 compatible. """ from official.nlp.modeling import layers diff --git a/official/nlp/modeling/layers/attention.py b/official/nlp/modeling/layers/attention.py index c0dd2dfa93f..0522313661f 100644 --- a/official/nlp/modeling/layers/attention.py +++ b/official/nlp/modeling/layers/attention.py @@ -16,17 +16,17 @@ # pylint: disable=g-classes-have-attributes import math -import tensorflow as tf +import tensorflow as tf, tf_keras -EinsumDense = tf.keras.layers.EinsumDense -MultiHeadAttention = tf.keras.layers.MultiHeadAttention +EinsumDense = tf_keras.layers.EinsumDense +MultiHeadAttention = tf_keras.layers.MultiHeadAttention -@tf.keras.utils.register_keras_serializable(package="Text") -class CachedAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package="Text") +class CachedAttention(tf_keras.layers.MultiHeadAttention): """Attention layer with cache used for autoregressive decoding. - Arguments are the same as `tf.keras.layers.MultiHeadAttention` layer. + Arguments are the same as `tf_keras.layers.MultiHeadAttention` layer. """ def _update_cache(self, key, value, cache, decode_loop_step): diff --git a/official/nlp/modeling/layers/attention_test.py b/official/nlp/modeling/layers/attention_test.py index 833c812a048..d0b436b0c85 100644 --- a/official/nlp/modeling/layers/attention_test.py +++ b/official/nlp/modeling/layers/attention_test.py @@ -15,7 +15,7 @@ """Tests for the attention layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import attention diff --git a/official/nlp/modeling/layers/bigbird_attention.py b/official/nlp/modeling/layers/bigbird_attention.py index 96df1247924..b667e5ff113 100644 --- a/official/nlp/modeling/layers/bigbird_attention.py +++ b/official/nlp/modeling/layers/bigbird_attention.py @@ -15,7 +15,7 @@ """Keras-based bigbird attention layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras MAX_SEQ_LEN = 4096 @@ -368,7 +368,7 @@ def bigbird_block_sparse_attention( return context_layer -class BigBirdMasks(tf.keras.layers.Layer): +class BigBirdMasks(tf_keras.layers.Layer): """Creates bigbird attention masks.""" def __init__(self, block_size, **kwargs): @@ -390,8 +390,8 @@ def call(self, inputs, mask): return [band_mask, encoder_from_mask, encoder_to_mask, blocked_encoder_mask] -@tf.keras.utils.register_keras_serializable(package="Text") -class BigBirdAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package="Text") +class BigBirdAttention(tf_keras.layers.MultiHeadAttention): """BigBird, a sparse attention mechanism. This layer follows the paper "Big Bird: Transformers for Longer Sequences" diff --git a/official/nlp/modeling/layers/bigbird_attention_test.py b/official/nlp/modeling/layers/bigbird_attention_test.py index b6548bf2169..294356f18a4 100644 --- a/official/nlp/modeling/layers/bigbird_attention_test.py +++ b/official/nlp/modeling/layers/bigbird_attention_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.projects.bigbird.attention.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import bigbird_attention as attention diff --git a/official/nlp/modeling/layers/block_diag_feedforward.py b/official/nlp/modeling/layers/block_diag_feedforward.py index 7e4f763493a..ff1a86a9092 100644 --- a/official/nlp/modeling/layers/block_diag_feedforward.py +++ b/official/nlp/modeling/layers/block_diag_feedforward.py @@ -16,12 +16,12 @@ # pylint: disable=g-classes-have-attributes from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class BlockDiagFeedforward(tf.keras.layers.Layer): +class BlockDiagFeedforward(tf_keras.layers.Layer): """Block diagonal feedforward layer. This layer replaces the weight matrix of the output_dense layer with a block @@ -53,11 +53,11 @@ def __init__( apply_mixing: bool = True, kernel_initializer: str = "glorot_uniform", bias_initializer: str = "zeros", - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - activity_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - kernel_constraint: Optional[tf.keras.constraints.Constraint] = None, - bias_constraint: Optional[tf.keras.constraints.Constraint] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + activity_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + kernel_constraint: Optional[tf_keras.constraints.Constraint] = None, + bias_constraint: Optional[tf_keras.constraints.Constraint] = None, **kwargs): # pylint: disable=g-doc-args super().__init__(**kwargs) self._intermediate_size = intermediate_size @@ -70,13 +70,13 @@ def __init__( raise ValueError("Intermediate_size (%d) isn't a multiple of num_blocks " "(%d)." % (intermediate_size, num_blocks)) - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) def build(self, input_shape): hidden_size = input_shape.as_list()[-1] @@ -88,7 +88,7 @@ def build(self, input_shape): kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( "abc,cde->abde", output_shape=(None, self._num_blocks, self._intermediate_size // self._num_blocks), @@ -98,15 +98,15 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._intermediate_activation, dtype=policy) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( "abde,deo->abdo", output_shape=(None, self._num_blocks, hidden_size // self._num_blocks), bias_axes="do", @@ -116,7 +116,7 @@ def build(self, input_shape): **common_kwargs) if self._apply_mixing: - self._output_mixing = tf.keras.layers.EinsumDense( + self._output_mixing = tf_keras.layers.EinsumDense( "abdo,de->abeo", output_shape=(None, self._num_blocks, hidden_size // self._num_blocks), @@ -125,9 +125,9 @@ def build(self, input_shape): self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._output_reshape = tf.keras.layers.Reshape((-1, hidden_size)) + self._output_reshape = tf_keras.layers.Reshape((-1, hidden_size)) - self._output_dropout = tf.keras.layers.Dropout(rate=self._dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._dropout) def get_config(self): config = { @@ -142,19 +142,19 @@ def get_config(self): "apply_mixing": self._apply_mixing, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint) + tf_keras.constraints.serialize(self._bias_constraint) } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/nlp/modeling/layers/block_diag_feedforward_test.py b/official/nlp/modeling/layers/block_diag_feedforward_test.py index 52249a8013d..d8f22f88e3b 100644 --- a/official/nlp/modeling/layers/block_diag_feedforward_test.py +++ b/official/nlp/modeling/layers/block_diag_feedforward_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import block_diag_feedforward @@ -27,7 +27,7 @@ class BlockDiagFeedforwardTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(BlockDiagFeedforwardTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.parameters( (1, True, "float32"), @@ -40,7 +40,7 @@ def tearDown(self): (2, False, "mixed_float16"), ) def test_layer_creation(self, num_blocks, apply_mixing, dtype): - tf.keras.mixed_precision.set_global_policy(dtype) + tf_keras.mixed_precision.set_global_policy(dtype) kwargs = dict( intermediate_size=128, intermediate_activation="relu", @@ -54,7 +54,7 @@ def test_layer_creation(self, num_blocks, apply_mixing, dtype): sequence_length = 64 width = 128 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -70,7 +70,7 @@ def test_layer_creation(self, num_blocks, apply_mixing, dtype): (2, False, "mixed_float16"), ) def test_layer_invocation(self, num_blocks, apply_mixing, dtype): - tf.keras.mixed_precision.set_global_policy(dtype) + tf_keras.mixed_precision.set_global_policy(dtype) kwargs = dict( intermediate_size=16, intermediate_activation="relu", @@ -84,11 +84,11 @@ def test_layer_invocation(self, num_blocks, apply_mixing, dtype): sequence_length = 16 width = 32 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. batch_size = 6 diff --git a/official/nlp/modeling/layers/cls_head.py b/official/nlp/modeling/layers/cls_head.py index 987d491c3aa..74d234ef590 100644 --- a/official/nlp/modeling/layers/cls_head.py +++ b/official/nlp/modeling/layers/cls_head.py @@ -14,7 +14,7 @@ """A Classification head layer which is common used with sequence encoders.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -22,7 +22,7 @@ from official.nlp.modeling.layers import spectral_normalization -class ClassificationHead(tf.keras.layers.Layer): +class ClassificationHead(tf_keras.layers.Layer): """Pooling head for sentence-level classification tasks.""" def __init__(self, @@ -50,18 +50,18 @@ def __init__(self, self.inner_dim = inner_dim self.num_classes = num_classes self.activation = tf_utils.get_activation(activation) - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) self.cls_token_idx = cls_token_idx if self.inner_dim: - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( units=self.inner_dim, activation=self.activation, kernel_initializer=tf_utils.clone_initializer(self.initializer), name="pooler_dense") - self.dropout = tf.keras.layers.Dropout(rate=self.dropout_rate) + self.dropout = tf_keras.layers.Dropout(rate=self.dropout_rate) - self.out_proj = tf.keras.layers.Dense( + self.out_proj = tf_keras.layers.Dense( units=num_classes, kernel_initializer=tf_utils.clone_initializer(self.initializer), name="logits") @@ -97,8 +97,8 @@ def get_config(self): "dropout_rate": self.dropout_rate, "num_classes": self.num_classes, "inner_dim": self.inner_dim, - "activation": tf.keras.activations.serialize(self.activation), - "initializer": tf.keras.initializers.serialize(self.initializer), + "activation": tf_keras.activations.serialize(self.activation), + "initializer": tf_keras.initializers.serialize(self.initializer), } config.update(super(ClassificationHead, self).get_config()) return config @@ -112,7 +112,7 @@ def checkpoint_items(self): return {self.dense.name: self.dense} -class MultiClsHeads(tf.keras.layers.Layer): +class MultiClsHeads(tf_keras.layers.Layer): """Pooling heads sharing the same pooling stem.""" def __init__(self, @@ -141,20 +141,20 @@ def __init__(self, self.inner_dim = inner_dim self.cls_list = cls_list self.activation = tf_utils.get_activation(activation) - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) self.cls_token_idx = cls_token_idx if self.inner_dim: - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( units=inner_dim, activation=self.activation, kernel_initializer=tf_utils.clone_initializer(self.initializer), name="pooler_dense") - self.dropout = tf.keras.layers.Dropout(rate=self.dropout_rate) + self.dropout = tf_keras.layers.Dropout(rate=self.dropout_rate) self.out_projs = [] for name, num_classes in cls_list: self.out_projs.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=num_classes, kernel_initializer=tf_utils.clone_initializer(self.initializer), name=name)) @@ -193,8 +193,8 @@ def get_config(self): "cls_token_idx": self.cls_token_idx, "cls_list": self.cls_list, "inner_dim": self.inner_dim, - "activation": tf.keras.activations.serialize(self.activation), - "initializer": tf.keras.initializers.serialize(self.initializer), + "activation": tf_keras.activations.serialize(self.activation), + "initializer": tf_keras.initializers.serialize(self.initializer), } config.update(super().get_config()) return config @@ -366,7 +366,7 @@ def extract_spec_norm_kwargs(kwargs): norm_multiplier=kwargs.pop("norm_multiplier", .99)) -class PerQueryDenseHead(tf.keras.layers.Layer): +class PerQueryDenseHead(tf_keras.layers.Layer): """Pooling head used for EncT5 style models. This module projects each query to use a different projection. @@ -402,7 +402,7 @@ def __init__(self, self.features = features self.use_bias = use_bias - self.kernel_initializer = tf.keras.initializers.get(kernel_initializer) + self.kernel_initializer = tf_keras.initializers.get(kernel_initializer) def build(self, input_shape): input_shape = tf.TensorShape(input_shape) @@ -450,7 +450,7 @@ def get_config(self): "features": self.features, "kernel_initializer": - tf.keras.activations.serialize(self.kernel_initializer), + tf_keras.activations.serialize(self.kernel_initializer), } config.update(super(PerQueryDenseHead, self).get_config()) return config diff --git a/official/nlp/modeling/layers/cls_head_test.py b/official/nlp/modeling/layers/cls_head_test.py index 5ca666d9754..391026ceb87 100644 --- a/official/nlp/modeling/layers/cls_head_test.py +++ b/official/nlp/modeling/layers/cls_head_test.py @@ -15,7 +15,7 @@ """Tests for cls_head.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import cls_head diff --git a/official/nlp/modeling/layers/factorized_embedding.py b/official/nlp/modeling/layers/factorized_embedding.py index 19e35368c45..fdc3c16a88b 100644 --- a/official/nlp/modeling/layers/factorized_embedding.py +++ b/official/nlp/modeling/layers/factorized_embedding.py @@ -15,13 +15,13 @@ """A factorized embedding layer.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import on_device_embedding -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') class FactorizedEmbedding(on_device_embedding.OnDeviceEmbedding): """A factorized embeddings layer for supporting larger embeddings. @@ -63,7 +63,7 @@ def get_config(self): return dict(list(base_config.items()) + list(config.items())) def build(self, input_shape): - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=self._output_dim, bias_axes=None, diff --git a/official/nlp/modeling/layers/factorized_embedding_test.py b/official/nlp/modeling/layers/factorized_embedding_test.py index dc9f0db1fd5..342d097e750 100644 --- a/official/nlp/modeling/layers/factorized_embedding_test.py +++ b/official/nlp/modeling/layers/factorized_embedding_test.py @@ -15,7 +15,7 @@ """Tests for FactorizedEmbedding layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import factorized_embedding @@ -32,7 +32,7 @@ def test_layer_creation(self): output_dim=output_dim) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # The output should be the same as the input, save that it has an extra @@ -51,11 +51,11 @@ def test_layer_invocation(self): output_dim=output_dim) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. diff --git a/official/nlp/modeling/layers/gated_feedforward.py b/official/nlp/modeling/layers/gated_feedforward.py index 31a97bb6851..23142c8cd81 100644 --- a/official/nlp/modeling/layers/gated_feedforward.py +++ b/official/nlp/modeling/layers/gated_feedforward.py @@ -16,15 +16,15 @@ # pylint: disable=g-classes-have-attributes import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import util -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable -class GatedFeedforward(tf.keras.layers.Layer): +class GatedFeedforward(tf_keras.layers.Layer): """Gated linear feedforward layer. This layer follows the paper "GLU Variants Improve Transformer" @@ -89,13 +89,13 @@ def __init__(self, "The dropout_position should be either `before_residual` or" "`after_residual`, got: %s" % self._dropout_position) - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) def build(self, input_shape): hidden_size = input_shape.as_list()[-1] @@ -112,7 +112,7 @@ def build(self, input_shape): self._output_dense = [] self._output_dropout = [] self._output_layer_norm = [] - activation_policy = tf.keras.mixed_precision.global_policy() + activation_policy = tf_keras.mixed_precision.global_policy() if activation_policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. @@ -120,7 +120,7 @@ def build(self, input_shape): activation_policy = tf.float32 for i in range(self._num_blocks): self._intermediate_dense.append( - tf.keras.layers.EinsumDense( + tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self._inner_dim), bias_axes="d", @@ -131,11 +131,11 @@ def build(self, input_shape): self._bias_initializer), **common_kwargs)) self._inner_activation_layers.append( - tf.keras.layers.Activation( + tf_keras.layers.Activation( self._inner_activation, dtype=activation_policy)) if self._use_gate: self._gate_dense.append( - tf.keras.layers.EinsumDense( + tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self._inner_dim), bias_axes="d", @@ -146,7 +146,7 @@ def build(self, input_shape): self._bias_initializer), **common_kwargs)) self._output_dense.append( - tf.keras.layers.EinsumDense( + tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", @@ -156,11 +156,11 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer( self._bias_initializer), **common_kwargs)) - self._output_dropout.append(tf.keras.layers.Dropout(rate=self._dropout)) + self._output_dropout.append(tf_keras.layers.Dropout(rate=self._dropout)) # Use float32 in layernorm for numeric stability. if self._apply_output_layer_norm: self._output_layer_norm.append( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="output_layer_norm_%d" % i, axis=-1, epsilon=1e-12, @@ -181,19 +181,19 @@ def get_config(self): "dropout_position": self._dropout_position, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint) + tf_keras.constraints.serialize(self._bias_constraint) } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/nlp/modeling/layers/gated_feedforward_test.py b/official/nlp/modeling/layers/gated_feedforward_test.py index 82f1f9d9138..06f9157d47d 100644 --- a/official/nlp/modeling/layers/gated_feedforward_test.py +++ b/official/nlp/modeling/layers/gated_feedforward_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import gated_feedforward @@ -25,7 +25,7 @@ class GatedFeedforwardTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(GatedFeedforwardTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.parameters( (True, 1, "after_residual", "float32"), @@ -38,7 +38,7 @@ def tearDown(self): (False, 1, "before_residual", "mixed_float16"), ) def test_layer_creation(self, use_gate, num_blocks, dropout_position, dtype): - tf.keras.mixed_precision.set_global_policy(dtype) + tf_keras.mixed_precision.set_global_policy(dtype) kwargs = dict( inner_dim=128, inner_activation="relu", @@ -53,7 +53,7 @@ def test_layer_creation(self, use_gate, num_blocks, dropout_position, dtype): sequence_length = 64 width = 128 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -70,7 +70,7 @@ def test_layer_creation(self, use_gate, num_blocks, dropout_position, dtype): ) def test_layer_invocation(self, use_gate, num_blocks, dropout_position, dtype): - tf.keras.mixed_precision.set_global_policy(dtype) + tf_keras.mixed_precision.set_global_policy(dtype) kwargs = dict( inner_dim=16, inner_activation="relu", @@ -85,11 +85,11 @@ def test_layer_invocation(self, use_gate, num_blocks, dropout_position, sequence_length = 16 width = 32 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. batch_size = 6 diff --git a/official/nlp/modeling/layers/gaussian_process.py b/official/nlp/modeling/layers/gaussian_process.py index 809812d401c..95eceb121c9 100644 --- a/official/nlp/modeling/layers/gaussian_process.py +++ b/official/nlp/modeling/layers/gaussian_process.py @@ -14,13 +14,13 @@ """Definitions for random feature Gaussian process layer.""" import math -import tensorflow as tf +import tensorflow as tf, tf_keras _SUPPORTED_LIKELIHOOD = ('binary_logistic', 'poisson', 'gaussian') -class RandomFeatureGaussianProcess(tf.keras.layers.Layer): +class RandomFeatureGaussianProcess(tf_keras.layers.Layer): """Gaussian process layer with random feature approximation [1]. During training, the model updates the maximum a posteriori (MAP) logits @@ -98,7 +98,7 @@ def __init__(self, scale_random_features: (bool) Whether to scale the random feature by sqrt(2. / num_inducing). use_custom_random_features: (bool) Whether to use custom random - features implemented using tf.keras.layers.Dense. + features implemented using tf_keras.layers.Dense. custom_random_features_initializer: (str or callable) Initializer for the random features. Default to random normal which approximates a RBF kernel function if activation function is cos. @@ -151,14 +151,14 @@ def __init__(self, minval=0., maxval=2. * math.pi) if self.custom_random_features_initializer is None: self.custom_random_features_initializer = ( - tf.keras.initializers.RandomNormal(stddev=1.)) + tf_keras.initializers.RandomNormal(stddev=1.)) if self.custom_random_features_activation is None: self.custom_random_features_activation = tf.math.cos def build(self, input_shape): # Defines model layers. if self.normalize_input: - self._input_norm_layer = tf.keras.layers.LayerNormalization( + self._input_norm_layer = tf_keras.layers.LayerNormalization( name='gp_input_normalization') self._input_norm_layer.build(input_shape) input_shape = self._input_norm_layer.compute_output_shape(input_shape) @@ -177,10 +177,10 @@ def build(self, input_shape): name='gp_covariance') self._gp_cov_layer.build(input_shape) - self._gp_output_layer = tf.keras.layers.Dense( + self._gp_output_layer = tf_keras.layers.Dense( units=self.units, use_bias=False, - kernel_regularizer=tf.keras.regularizers.l2(self.l2_regularization), + kernel_regularizer=tf_keras.regularizers.l2(self.l2_regularization), dtype=self.dtype, name='gp_output_weights', **self.gp_output_kwargs) @@ -197,8 +197,8 @@ def build(self, input_shape): def _make_random_feature_layer(self, name): """Defines random feature layer depending on kernel type.""" if not self.use_custom_random_features: - # Use default RandomFourierFeatures layer from tf.keras. - return tf.keras.layers.experimental.RandomFourierFeatures( + # Use default RandomFourierFeatures layer from tf_keras. + return tf_keras.layers.experimental.RandomFourierFeatures( output_dim=self.num_inducing, kernel_initializer=self.gp_kernel_type, scale=self.gp_kernel_scale, @@ -207,11 +207,11 @@ def _make_random_feature_layer(self, name): name=name) if self.gp_kernel_type.lower() == 'linear': - custom_random_feature_layer = tf.keras.layers.Lambda( + custom_random_feature_layer = tf_keras.layers.Lambda( lambda x: x, name=name) else: # Use user-supplied configurations. - custom_random_feature_layer = tf.keras.layers.Dense( + custom_random_feature_layer = tf_keras.layers.Dense( units=self.num_inducing, use_bias=True, activation=self.custom_random_features_activation, @@ -267,7 +267,7 @@ def call(self, inputs, global_step=None, training=None): return model_output -class LaplaceRandomFeatureCovariance(tf.keras.layers.Layer): +class LaplaceRandomFeatureCovariance(tf_keras.layers.Layer): """Computes the Gaussian Process covariance using Laplace method. At training time, this layer updates the Gaussian process posterior using @@ -324,7 +324,7 @@ def build(self, input_shape): name='gp_precision_matrix', shape=(gp_feature_dim, gp_feature_dim), dtype=self.dtype, - initializer=tf.keras.initializers.Identity(self.ridge_penalty), + initializer=tf_keras.initializers.Identity(self.ridge_penalty), trainable=False, aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA)) self.built = True @@ -417,7 +417,7 @@ def compute_predictive_covariance(self, gp_feature): def _get_training_value(self, training=None): if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() if isinstance(training, int): training = bool(training) diff --git a/official/nlp/modeling/layers/gaussian_process_test.py b/official/nlp/modeling/layers/gaussian_process_test.py index f457e8a49d1..a3b1023ee32 100644 --- a/official/nlp/modeling/layers/gaussian_process_test.py +++ b/official/nlp/modeling/layers/gaussian_process_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import gaussian_process @@ -205,9 +205,9 @@ def test_state_saving_and_loading(self): input_data = np.random.random((1, 2)) rfgp_model = gaussian_process.RandomFeatureGaussianProcess(units=1) - inputs = tf.keras.Input((2,), batch_size=1) + inputs = tf_keras.Input((2,), batch_size=1) outputs = rfgp_model(inputs) - model = tf.keras.Model(inputs, outputs) + model = tf_keras.Model(inputs, outputs) gp_output, gp_covmat = model.predict(input_data) # Save and then load the model. @@ -215,7 +215,7 @@ def test_state_saving_and_loading(self): self.addCleanup(shutil.rmtree, temp_dir) saved_model_dir = os.path.join(temp_dir, 'rfgp_model') model.save(saved_model_dir) - new_model = tf.keras.models.load_model(saved_model_dir) + new_model = tf_keras.models.load_model(saved_model_dir) gp_output_new, gp_covmat_new = new_model.predict(input_data) self.assertAllClose(gp_output, gp_output_new, atol=1e-4) diff --git a/official/nlp/modeling/layers/kernel_attention.py b/official/nlp/modeling/layers/kernel_attention.py index 09b7c55b91e..a5607588a17 100644 --- a/official/nlp/modeling/layers/kernel_attention.py +++ b/official/nlp/modeling/layers/kernel_attention.py @@ -16,14 +16,14 @@ import functools import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils _NUMERIC_STABLER = 1e-6 -class KernelMask(tf.keras.layers.Layer): +class KernelMask(tf_keras.layers.Layer): """Creates kernel attention mask. inputs: from_tensor: 2D or 3D Tensor of shape @@ -389,8 +389,8 @@ def expplus(data_orig, else: data_normalizer = 1.0 lengths = tf.math.square(data) - lengths = tf.reduce_sum(lengths, axis=tf.keras.backend.ndim(data) - 1) - lengths = tf.expand_dims(lengths, axis=tf.keras.backend.ndim(data) - 1) + lengths = tf.reduce_sum(lengths, axis=tf_keras.backend.ndim(data) - 1) + lengths = tf.expand_dims(lengths, axis=tf_keras.backend.ndim(data) - 1) lengths = tf.math.sqrt(lengths) data /= lengths ratio = 1.0 / tf.math.sqrt( @@ -399,9 +399,9 @@ def expplus(data_orig, projection_matrix) diag_data = tf.math.square(data) diag_data = tf.math.reduce_sum( - diag_data, axis=tf.keras.backend.ndim(data) - 1) + diag_data, axis=tf_keras.backend.ndim(data) - 1) diag_data = (diag_data / 2.0) * data_normalizer * data_normalizer - diag_data = tf.expand_dims(diag_data, axis=tf.keras.backend.ndim(data) - 1) + diag_data = tf.expand_dims(diag_data, axis=tf_keras.backend.ndim(data) - 1) # Calculating coefficients A, B of the FAVOR++ mechanism: _, l, _, _ = tf_utils.get_shape_list(data_orig) @@ -438,7 +438,7 @@ def expplus(data_orig, # Calculating diag_omega for the FAVOR++ mechanism: diag_omega = tf.math.square(projection_matrix) diag_omega = tf.math.reduce_sum( - diag_omega, axis=tf.keras.backend.ndim(projection_matrix) - 1) + diag_omega, axis=tf_keras.backend.ndim(projection_matrix) - 1) diag_omega = tf.expand_dims(diag_omega, axis=0) diag_omega = tf.expand_dims(diag_omega, axis=0) diag_omega = tf.expand_dims(diag_omega, axis=0) @@ -470,14 +470,14 @@ def expplus(data_orig, "elu": functools.partial( _generalized_kernel, - f=lambda x: tf.keras.activations.elu(x) + 1, + f=lambda x: tf_keras.activations.elu(x) + 1, h=lambda x: 1), "relu": functools.partial( _generalized_kernel, # Improve numerical stability and avoid NaNs in some cases by adding # a tiny epsilon. - f=lambda x: tf.keras.activations.relu(x) + 1e-3, + f=lambda x: tf_keras.activations.relu(x) + 1e-3, h=lambda x: 1), "square": functools.partial(_generalized_kernel, f=tf.math.square, h=lambda x: 1), @@ -515,7 +515,7 @@ def expplus(data_orig, # pylint: enable=g-long-lambda -class KernelAttention(tf.keras.layers.MultiHeadAttention): +class KernelAttention(tf_keras.layers.MultiHeadAttention): """A variant of efficient transformers which replaces softmax with kernels. This module combines ideas from the two following papers: @@ -742,7 +742,7 @@ def _build_from_signature(self, query, value, key=None): self._query_shape.rank - 1, common_kwargs, name="attention_output_softmax") - self._dropout_softmax = tf.keras.layers.Dropout(rate=self._dropout) + self._dropout_softmax = tf_keras.layers.Dropout(rate=self._dropout) def call(self, query, value, key=None, attention_mask=None, cache=None, training=False): diff --git a/official/nlp/modeling/layers/kernel_attention_test.py b/official/nlp/modeling/layers/kernel_attention_test.py index 327052304d8..0abd64c037e 100644 --- a/official/nlp/modeling/layers/kernel_attention_test.py +++ b/official/nlp/modeling/layers/kernel_attention_test.py @@ -16,7 +16,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import kernel_attention as attention diff --git a/official/nlp/modeling/layers/masked_lm.py b/official/nlp/modeling/layers/masked_lm.py index a33000b0496..d92e5bd1cd7 100644 --- a/official/nlp/modeling/layers/masked_lm.py +++ b/official/nlp/modeling/layers/masked_lm.py @@ -14,11 +14,11 @@ """Masked language model network.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') -class MaskedLM(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MaskedLM(tf_keras.layers.Layer): """Masked language model network head for BERT modeling. This layer implements a masked language model based on the provided @@ -50,7 +50,7 @@ def __init__(self, super().__init__(name=name, **kwargs) self.embedding_table = embedding_table self.activation = activation - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) if output not in ('predictions', 'logits'): raise ValueError( @@ -60,12 +60,12 @@ def __init__(self, def build(self, input_shape): self._vocab_size, hidden_size = self.embedding_table.shape - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( hidden_size, activation=self.activation, kernel_initializer=self.initializer, name='transform/dense') - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name='transform/LayerNorm') self.bias = self.add_weight( 'output_bias/bias', diff --git a/official/nlp/modeling/layers/masked_lm_test.py b/official/nlp/modeling/layers/masked_lm_test.py index d4e144e396b..c2e091c5034 100644 --- a/official/nlp/modeling/layers/masked_lm_test.py +++ b/official/nlp/modeling/layers/masked_lm_test.py @@ -15,7 +15,7 @@ """Tests for masked language model network.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import masked_lm from official.nlp.modeling.networks import bert_encoder @@ -52,8 +52,8 @@ def test_layer_creation(self): vocab_size=vocab_size, hidden_size=hidden_size) # Make sure that the output tensor of the masked LM is the right shape. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions=masked_positions) expected_output_shape = [None, num_predictions, vocab_size] @@ -82,14 +82,14 @@ def test_layer_invocation_with_external_logits(self): output='logits') # Create a model from the masked LM layer. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions) logit_output = logit_layer(lm_input_tensor, masked_positions) - logit_output = tf.keras.layers.Activation(tf.nn.log_softmax)(logit_output) + logit_output = tf_keras.layers.Activation(tf.nn.log_softmax)(logit_output) logit_layer.set_weights(test_layer.get_weights()) - model = tf.keras.Model([lm_input_tensor, masked_positions], output) - logits_model = tf.keras.Model(([lm_input_tensor, masked_positions]), + model = tf_keras.Model([lm_input_tensor, masked_positions], output) + logits_model = tf_keras.Model(([lm_input_tensor, masked_positions]), logit_output) # Invoke the masked LM on some fake data to make sure there are no runtime @@ -128,10 +128,10 @@ def test_layer_invocation(self, num_predictions): vocab_size=vocab_size, hidden_size=hidden_size) # Create a model from the masked LM layer. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions) - model = tf.keras.Model([lm_input_tensor, masked_positions], output) + model = tf_keras.Model([lm_input_tensor, masked_positions], output) # Invoke the masked LM on some fake data to make sure there are no runtime # errors in the code. diff --git a/official/nlp/modeling/layers/masked_softmax.py b/official/nlp/modeling/layers/masked_softmax.py index b4c747f8fa5..484cdd7c28b 100644 --- a/official/nlp/modeling/layers/masked_softmax.py +++ b/official/nlp/modeling/layers/masked_softmax.py @@ -15,7 +15,7 @@ """Keras-based softmax layer with optional masking.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras def _large_compatible_negative(tensor_type): @@ -35,8 +35,8 @@ def _large_compatible_negative(tensor_type): return -1e9 -@tf.keras.utils.register_keras_serializable(package='Text') -class MaskedSoftmax(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MaskedSoftmax(tf_keras.layers.Layer): """Performs a softmax with optional masking on a tensor. Args: diff --git a/official/nlp/modeling/layers/masked_softmax_test.py b/official/nlp/modeling/layers/masked_softmax_test.py index 53f444eac75..c8ab6591095 100644 --- a/official/nlp/modeling/layers/masked_softmax_test.py +++ b/official/nlp/modeling/layers/masked_softmax_test.py @@ -15,7 +15,7 @@ """Tests for Keras-based masked softmax layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import masked_softmax @@ -24,9 +24,9 @@ class MaskedSoftmaxLayerTest(tf.test.TestCase): def test_non_masked_softmax(self): test_layer = masked_softmax.MaskedSoftmax() - input_tensor = tf.keras.Input(shape=(4, 8)) + input_tensor = tf_keras.Input(shape=(4, 8)) output = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output) + model = tf_keras.Model(input_tensor, output) input_data = 10 * np.random.random_sample((3, 4, 8)) output_data = model.predict(input_data) @@ -35,10 +35,10 @@ def test_non_masked_softmax(self): def test_masked_softmax(self): test_layer = masked_softmax.MaskedSoftmax() - input_tensor = tf.keras.Input(shape=(4, 8)) - mask_tensor = tf.keras.Input(shape=(4, 8)) + input_tensor = tf_keras.Input(shape=(4, 8)) + mask_tensor = tf_keras.Input(shape=(4, 8)) output = test_layer(input_tensor, mask_tensor) - model = tf.keras.Model([input_tensor, mask_tensor], output) + model = tf_keras.Model([input_tensor, mask_tensor], output) input_data = 10 * np.random.random_sample((3, 4, 8)) mask_data = np.random.randint(2, size=(3, 4, 8)) @@ -50,9 +50,9 @@ def test_masked_softmax(self): def test_masked_softmax_with_none_mask(self): test_layer = masked_softmax.MaskedSoftmax() - input_tensor = tf.keras.Input(shape=(4, 8)) + input_tensor = tf_keras.Input(shape=(4, 8)) output = test_layer(input_tensor, None) - model = tf.keras.Model(input_tensor, output) + model = tf_keras.Model(input_tensor, output) input_data = 10 * np.random.random_sample((3, 4, 8)) output_data = model.predict(input_data) @@ -61,10 +61,10 @@ def test_masked_softmax_with_none_mask(self): def test_softmax_with_axes_expansion(self): test_layer = masked_softmax.MaskedSoftmax(mask_expansion_axes=[1]) - input_tensor = tf.keras.Input(shape=(4, 8)) - mask_tensor = tf.keras.Input(shape=(8)) + input_tensor = tf_keras.Input(shape=(4, 8)) + mask_tensor = tf_keras.Input(shape=(8)) output = test_layer(input_tensor, mask_tensor) - model = tf.keras.Model([input_tensor, mask_tensor], output) + model = tf_keras.Model([input_tensor, mask_tensor], output) input_data = 10 * np.random.random_sample((3, 4, 8)) mask_data = np.random.randint(2, size=(3, 8)) @@ -80,10 +80,10 @@ def test_masked_softmax_high_dims(self): mask_expansion_axes=[1], normalization_axes=[6, 7]) input_shape = [2, 3, 4, 5, 6, 7, 8] mask_shape = [5, 6, 7, 8] - input_tensor = tf.keras.Input(shape=input_shape) - mask_tensor = tf.keras.Input(shape=mask_shape) + input_tensor = tf_keras.Input(shape=input_shape) + mask_tensor = tf_keras.Input(shape=mask_shape) output = test_layer(input_tensor, mask_tensor) - model = tf.keras.Model([input_tensor, mask_tensor], output) + model = tf_keras.Model([input_tensor, mask_tensor], output) input_data = 10 * np.random.random_sample([3] + input_shape) mask_data = np.random.randint(2, size=[3] + mask_shape) diff --git a/official/nlp/modeling/layers/mat_mul_with_margin.py b/official/nlp/modeling/layers/mat_mul_with_margin.py index f9bed28c7a7..fdbccd1073e 100644 --- a/official/nlp/modeling/layers/mat_mul_with_margin.py +++ b/official/nlp/modeling/layers/mat_mul_with_margin.py @@ -17,13 +17,13 @@ from typing import Tuple # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Text') -class MatMulWithMargin(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MatMulWithMargin(tf_keras.layers.Layer): """This layer computs a dot product matrix given two encoded inputs. Args: 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 4b1446c1608..b7917cc0810 100644 --- a/official/nlp/modeling/layers/mat_mul_with_margin_test.py +++ b/official/nlp/modeling/layers/mat_mul_with_margin_test.py @@ -14,7 +14,7 @@ """Tests for mat_mul_with_margin layer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import mat_mul_with_margin @@ -26,8 +26,8 @@ def test_layer_invocation(self): input_width = 512 test_layer = mat_mul_with_margin.MatMulWithMargin() # Create a 2-dimensional input (the first dimension is implicit). - left_encoded = tf.keras.Input(shape=(input_width,), dtype=tf.float32) - right_encoded = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + left_encoded = tf_keras.Input(shape=(input_width,), dtype=tf.float32) + right_encoded = tf_keras.Input(shape=(input_width,), dtype=tf.float32) left_logits, right_logits = test_layer(left_encoded, right_encoded) # Validate that the outputs are of the expected shape. diff --git a/official/nlp/modeling/layers/mixing.py b/official/nlp/modeling/layers/mixing.py index 65efac7fe3a..12801e77b13 100644 --- a/official/nlp/modeling/layers/mixing.py +++ b/official/nlp/modeling/layers/mixing.py @@ -33,13 +33,13 @@ import gin import numpy as np from scipy import linalg -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] -default_kernel_initializer = tf.keras.initializers.TruncatedNormal(stddev=2e-2) +default_kernel_initializer = tf_keras.initializers.TruncatedNormal(stddev=2e-2) @gin.constants_from_enum @@ -56,7 +56,7 @@ class MixingMechanism(enum.Enum): LINEAR = "linear" -class MixingLayer(tf.keras.layers.Layer): +class MixingLayer(tf_keras.layers.Layer): """Mixing layer base class. This class cannot be used directly. It just specifies the API for mixing diff --git a/official/nlp/modeling/layers/mixing_test.py b/official/nlp/modeling/layers/mixing_test.py index 21f996d881c..27a6dbc7988 100644 --- a/official/nlp/modeling/layers/mixing_test.py +++ b/official/nlp/modeling/layers/mixing_test.py @@ -15,7 +15,7 @@ """Tests for mixing.py.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import mixing @@ -64,7 +64,7 @@ def test_linear_mixing_layer(self): inputs = tf.ones((batch_size, max_seq_length, hidden_dim), dtype=tf.float32) outputs = mixing.LinearTransformLayer( - kernel_initializer=tf.keras.initializers.Ones())( + kernel_initializer=tf_keras.initializers.Ones())( query=inputs, value=inputs) # hidden_dim * (max_seq_length * 1) = 12. diff --git a/official/nlp/modeling/layers/mobile_bert_layers.py b/official/nlp/modeling/layers/mobile_bert_layers.py index b580ada14f0..b66319ef698 100644 --- a/official/nlp/modeling/layers/mobile_bert_layers.py +++ b/official/nlp/modeling/layers/mobile_bert_layers.py @@ -13,7 +13,7 @@ # limitations under the License. """MobileBERT embedding and transformer layers.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -21,8 +21,8 @@ from official.nlp.modeling.layers import position_embedding -@tf.keras.utils.register_keras_serializable(package='Text') -class NoNorm(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class NoNorm(tf_keras.layers.Layer): """Apply element-wise linear transformation to the last dimension.""" def __init__(self, name=None): @@ -56,7 +56,7 @@ def _get_norm_layer(normalization_type='no_norm', name=None): if normalization_type == 'no_norm': layer = NoNorm(name=name) elif normalization_type == 'layer_norm': - layer = tf.keras.layers.LayerNormalization( + layer = tf_keras.layers.LayerNormalization( name=name, axis=-1, epsilon=1e-12, @@ -66,8 +66,8 @@ def _get_norm_layer(normalization_type='no_norm', name=None): return layer -@tf.keras.utils.register_keras_serializable(package='Text') -class MobileBertEmbedding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MobileBertEmbedding(tf_keras.layers.Layer): """Performs an embedding lookup for MobileBERT. This layer includes word embedding, token type embedding, position embedding. @@ -80,7 +80,7 @@ def __init__(self, output_embed_size, max_sequence_length=512, normalization_type='no_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), dropout_rate=0.1, **kwargs): """Class initialization. @@ -105,7 +105,7 @@ def __init__(self, self.output_embed_size = output_embed_size self.max_sequence_length = max_sequence_length self.normalization_type = normalization_type - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) self.dropout_rate = dropout_rate self.word_embedding = on_device_embedding.OnDeviceEmbedding( @@ -122,14 +122,14 @@ def __init__(self, max_length=max_sequence_length, initializer=tf_utils.clone_initializer(self.initializer), name='position_embedding') - self.word_embedding_proj = tf.keras.layers.EinsumDense( + self.word_embedding_proj = tf_keras.layers.EinsumDense( 'abc,cd->abd', output_shape=[None, self.output_embed_size], kernel_initializer=tf_utils.clone_initializer(self.initializer), bias_axes='d', name='embedding_projection') self.layer_norm = _get_norm_layer(normalization_type, 'embedding_norm') - self.dropout_layer = tf.keras.layers.Dropout( + self.dropout_layer = tf_keras.layers.Dropout( self.dropout_rate, name='embedding_dropout') @@ -141,7 +141,7 @@ def get_config(self): 'output_embed_size': self.output_embed_size, 'max_sequence_length': self.max_sequence_length, 'normalization_type': self.normalization_type, - 'initializer': tf.keras.initializers.serialize(self.initializer), + 'initializer': tf_keras.initializers.serialize(self.initializer), 'dropout_rate': self.dropout_rate } base_config = super(MobileBertEmbedding, self).get_config() @@ -167,8 +167,8 @@ def call(self, input_ids, token_type_ids=None): return embedding_out -@tf.keras.utils.register_keras_serializable(package='Text') -class MobileBertTransformer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MobileBertTransformer(tf_keras.layers.Layer): """Transformer block for MobileBERT. An implementation of one layer (block) of Transformer with bottleneck and @@ -190,7 +190,7 @@ def __init__(self, key_query_shared_bottleneck=True, num_feedforward_networks=4, normalization_type='no_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), **kwargs): """Class initialization. @@ -234,7 +234,7 @@ def __init__(self, self.key_query_shared_bottleneck = key_query_shared_bottleneck self.num_feedforward_networks = num_feedforward_networks self.normalization_type = normalization_type - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) if intra_bottleneck_size % num_attention_heads != 0: raise ValueError( @@ -244,7 +244,7 @@ def __init__(self, self.block_layers = {} # add input bottleneck - dense_layer_2d = tf.keras.layers.EinsumDense( + dense_layer_2d = tf_keras.layers.EinsumDense( 'abc,cd->abd', output_shape=[None, self.intra_bottleneck_size], bias_axes='d', @@ -256,7 +256,7 @@ def __init__(self, layer_norm] if self.key_query_shared_bottleneck: - dense_layer_2d = tf.keras.layers.EinsumDense( + dense_layer_2d = tf_keras.layers.EinsumDense( 'abc,cd->abd', output_shape=[None, self.intra_bottleneck_size], bias_axes='d', @@ -268,7 +268,7 @@ def __init__(self, layer_norm] # add attention layer - attention_layer = tf.keras.layers.MultiHeadAttention( + attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self.num_attention_heads, key_dim=attention_head_size, value_dim=attention_head_size, @@ -286,7 +286,7 @@ def __init__(self, for ffn_layer_idx in range(self.num_feedforward_networks): layer_prefix = f'ffn_layer_{ffn_layer_idx}' layer_name = layer_prefix + '/intermediate_dense' - intermediate_layer = tf.keras.layers.EinsumDense( + intermediate_layer = tf_keras.layers.EinsumDense( 'abc,cd->abd', activation=self.intermediate_act_fn, output_shape=[None, self.intermediate_size], @@ -294,7 +294,7 @@ def __init__(self, kernel_initializer=tf_utils.clone_initializer(self.initializer), name=layer_name) layer_name = layer_prefix + '/output_dense' - output_layer = tf.keras.layers.EinsumDense( + output_layer = tf_keras.layers.EinsumDense( 'abc,cd->abd', output_shape=[None, self.intra_bottleneck_size], bias_axes='d', @@ -308,14 +308,14 @@ def __init__(self, layer_norm]) # add output bottleneck - bottleneck = tf.keras.layers.EinsumDense( + bottleneck = tf_keras.layers.EinsumDense( 'abc,cd->abd', output_shape=[None, self.hidden_size], activation=None, bias_axes='d', kernel_initializer=tf_utils.clone_initializer(self.initializer), name='bottleneck_output/dense') - dropout_layer = tf.keras.layers.Dropout( + dropout_layer = tf_keras.layers.Dropout( self.hidden_dropout_prob, name='bottleneck_output/dropout') layer_norm = _get_norm_layer(self.normalization_type, @@ -337,7 +337,7 @@ def get_config(self): 'key_query_shared_bottleneck': self.key_query_shared_bottleneck, 'num_feedforward_networks': self.num_feedforward_networks, 'normalization_type': self.normalization_type, - 'initializer': tf.keras.initializers.serialize(self.initializer), + 'initializer': tf_keras.initializers.serialize(self.initializer), } base_config = super(MobileBertTransformer, self).get_config() return dict(list(base_config.items()) + list(config.items())) @@ -431,8 +431,8 @@ def call(self, return layer_output -@tf.keras.utils.register_keras_serializable(package='Text') -class MobileBertMaskedLM(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MobileBertMaskedLM(tf_keras.layers.Layer): """Masked language model network head for BERT modeling. This layer implements a masked language model based on the provided @@ -466,7 +466,7 @@ def __init__(self, super().__init__(**kwargs) self.embedding_table = embedding_table self.activation = activation - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) if output not in ('predictions', 'logits'): raise ValueError( @@ -478,7 +478,7 @@ def __init__(self, def build(self, input_shape): self._vocab_size, embedding_width = self.embedding_table.shape hidden_size = input_shape[-1] - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( hidden_size, activation=self.activation, kernel_initializer=tf_utils.clone_initializer(self.initializer), @@ -504,7 +504,7 @@ def build(self, input_shape): 'hidden size %d cannot be smaller than embedding width %d.' % (hidden_size, embedding_width)) - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name='transform/LayerNorm') self.bias = self.add_weight( 'output_bias/bias', diff --git a/official/nlp/modeling/layers/mobile_bert_layers_test.py b/official/nlp/modeling/layers/mobile_bert_layers_test.py index c10b997f14b..571772ebe63 100644 --- a/official/nlp/modeling/layers/mobile_bert_layers_test.py +++ b/official/nlp/modeling/layers/mobile_bert_layers_test.py @@ -15,7 +15,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import mobile_bert_layers from official.nlp.modeling.networks import mobile_bert_encoder @@ -60,7 +60,7 @@ def test_embedding_layer_get_config(self): output_embed_size=32, max_sequence_length=32, normalization_type='layer_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01), dropout_rate=0.5) layer_config = layer.get_config() new_layer = mobile_bert_layers.MobileBertEmbedding.from_config(layer_config) @@ -120,7 +120,7 @@ def test_transformer_get_config(self): key_query_shared_bottleneck=False, num_feedforward_networks=2, normalization_type='layer_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01), name='block') layer_config = layer.get_config() new_layer = mobile_bert_layers.MobileBertTransformer.from_config( @@ -163,8 +163,8 @@ def test_layer_creation(self): embedding_width=embedding_width) # Make sure that the output tensor of the masked LM is the right shape. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions=masked_positions) expected_output_shape = [None, num_predictions, vocab_size] @@ -196,14 +196,14 @@ def test_layer_invocation_with_external_logits(self): output='logits') # Create a model from the masked LM layer. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions) logit_output = logit_layer(lm_input_tensor, masked_positions) - logit_output = tf.keras.layers.Activation(tf.nn.log_softmax)(logit_output) + logit_output = tf_keras.layers.Activation(tf.nn.log_softmax)(logit_output) logit_layer.set_weights(test_layer.get_weights()) - model = tf.keras.Model([lm_input_tensor, masked_positions], output) - logits_model = tf.keras.Model(([lm_input_tensor, masked_positions]), + model = tf_keras.Model([lm_input_tensor, masked_positions], output) + logits_model = tf_keras.Model(([lm_input_tensor, masked_positions]), logit_output) # Invoke the masked LM on some fake data to make sure there are no runtime @@ -236,10 +236,10 @@ def test_layer_invocation(self): embedding_width=embedding_width) # Create a model from the masked LM layer. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input(shape=(num_predictions,), dtype=tf.int32) + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input(shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions) - model = tf.keras.Model([lm_input_tensor, masked_positions], output) + model = tf_keras.Model([lm_input_tensor, masked_positions], output) # Invoke the masked LM on some fake data to make sure there are no runtime # errors in the code. @@ -263,8 +263,8 @@ def test_hidden_size_smaller_than_embedding_width(self): ValueError, 'hidden size 8 cannot be smaller than embedding width 16.'): test_layer = self.create_layer( vocab_size=8, hidden_size=8, embedding_width=16) - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_positions = tf.keras.Input( + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_positions = tf_keras.Input( shape=(num_predictions,), dtype=tf.int32) _ = test_layer(lm_input_tensor, masked_positions) diff --git a/official/nlp/modeling/layers/moe.py b/official/nlp/modeling/layers/moe.py index 8c4c5e8803a..1a76ba10ff1 100644 --- a/official/nlp/modeling/layers/moe.py +++ b/official/nlp/modeling/layers/moe.py @@ -17,16 +17,16 @@ import dataclasses from typing import Callable, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -_InitializerType = tf.keras.initializers.Initializer +_InitializerType = tf_keras.initializers.Initializer -_DEFAULT_KERNEL_INITIALIZER = tf.keras.initializers.TruncatedNormal(stddev=2e-2) -_DEFAULT_BIAS_INITIALIZER = tf.keras.initializers.Zeros() +_DEFAULT_KERNEL_INITIALIZER = tf_keras.initializers.TruncatedNormal(stddev=2e-2) +_DEFAULT_BIAS_INITIALIZER = tf_keras.initializers.Zeros() ################## Routers (gating functions) ################## @@ -75,7 +75,7 @@ class RouterMask: RouterOutput = RouterMask -class Router(tf.keras.layers.Layer): +class Router(tf_keras.layers.Layer): """Abstract base router class, defining router API and inner workings. Computations are performed in float32 for stability, and returned after @@ -127,7 +127,7 @@ def __init__( self.router_z_loss_weight = router_z_loss_weight self._export_metrics = export_metrics - self.router_weights = tf.keras.layers.Dense( + self.router_weights = tf_keras.layers.Dense( num_experts, use_bias=use_bias, kernel_initializer=tf_utils.clone_initializer(kernel_initializer), @@ -147,13 +147,13 @@ def call(self, [num_groups, tokens_per_group, hidden_dim]. expert_capacity: Each group will send this many tokens to each expert. training: If true, apply jitter noise during routing. If not provided - taken from tf.keras.backend. + taken from tf_keras.backend. Returns: Router indices or mask arrays (depending on router type). """ if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() # inputs shape [num_groups, tokens_per_group, hidden_dim] router_probs, router_logits = self._compute_router_probabilities( @@ -195,7 +195,7 @@ def _compute_router_probabilities( dtype=inputs.dtype) # inputs , router_logits router_logits = self.router_weights(inputs) - router_probs = tf.keras.activations.softmax(router_logits, axis=-1) + router_probs = tf_keras.activations.softmax(router_logits, axis=-1) return router_probs, router_logits def _compute_routing_instructions(self, router_probs: tf.Tensor, @@ -321,7 +321,7 @@ def _compute_routing_instructions(self, router_probs: tf.Tensor, ################## Model layers ################## -class FeedForward(tf.keras.layers.Layer): +class FeedForward(tf_keras.layers.Layer): """Feed-forward layer - position independent, dense, nonlinear transformation. Typically used in an MLP Transformer block. @@ -333,7 +333,7 @@ def __init__( *, inner_dropout: float = 0.0, output_dropout: float = 0.0, - activation: Callable[[tf.Tensor], tf.Tensor] = tf.keras.activations.gelu, + activation: Callable[[tf.Tensor], tf.Tensor] = tf_keras.activations.gelu, kernel_initializer: _InitializerType = _DEFAULT_KERNEL_INITIALIZER, bias_initializer: _InitializerType = _DEFAULT_BIAS_INITIALIZER, name: str = "feed_forward", @@ -356,18 +356,18 @@ def __init__( self.kernel_initializer = kernel_initializer self.bias_initializer = bias_initializer - self.intermediate_layer = tf.keras.layers.Dense( + self.intermediate_layer = tf_keras.layers.Dense( d_ff, kernel_initializer=tf_utils.clone_initializer(self.kernel_initializer), bias_initializer=tf_utils.clone_initializer(self.bias_initializer), name="intermediate") - self.inner_dropout_layer = tf.keras.layers.Dropout( + self.inner_dropout_layer = tf_keras.layers.Dropout( inner_dropout) - self.output_dropout_layer = tf.keras.layers.Dropout(output_dropout) + self.output_dropout_layer = tf_keras.layers.Dropout(output_dropout) def build(self, input_shape: Tuple[int, int, int]): """Creates the input shape dependent output weight variables.""" - self.output_layer = tf.keras.layers.Dense( + self.output_layer = tf_keras.layers.Dense( input_shape[-1], kernel_initializer=tf_utils.clone_initializer(self.kernel_initializer), bias_initializer=tf_utils.clone_initializer(self.bias_initializer), @@ -396,7 +396,7 @@ def call(self, return x -class FeedForwardExperts(tf.keras.layers.Layer): +class FeedForwardExperts(tf_keras.layers.Layer): """Feed-forward layer with multiple experts. Note that call() takes inputs with shape @@ -416,7 +416,7 @@ def __init__( *, inner_dropout: float = 0.0, output_dropout: float = 0.0, - activation: Callable[[tf.Tensor], tf.Tensor] = tf.keras.activations.gelu, + activation: Callable[[tf.Tensor], tf.Tensor] = tf_keras.activations.gelu, kernel_initializer: _InitializerType = _DEFAULT_KERNEL_INITIALIZER, bias_initializer: _InitializerType = _DEFAULT_BIAS_INITIALIZER, name: str = "experts", @@ -442,16 +442,16 @@ def __init__( self.kernel_initializer = kernel_initializer self.bias_initializer = bias_initializer - self.intermediate_layer = tf.keras.layers.EinsumDense( + self.intermediate_layer = tf_keras.layers.EinsumDense( "gech,ehf->gecf", output_shape=(self.num_experts, None, d_ff), bias_axes="ef", kernel_initializer=tf_utils.clone_initializer(self.kernel_initializer), bias_initializer=tf_utils.clone_initializer(self.bias_initializer), name="intermediate") - self.inner_dropout_layer = tf.keras.layers.Dropout( + self.inner_dropout_layer = tf_keras.layers.Dropout( inner_dropout) - self.output_dropout_layer = tf.keras.layers.Dropout(output_dropout) + self.output_dropout_layer = tf_keras.layers.Dropout(output_dropout) def build(self, input_shape: Tuple[int, int, int, int]): """Creates the input shape dependent output weight variables.""" @@ -460,7 +460,7 @@ def build(self, input_shape: Tuple[int, int, int, int]): f"Input shape {input_shape} is inconsistent with num_experts " f"{self.num_experts}.") - self.output_layer = tf.keras.layers.EinsumDense( + self.output_layer = tf_keras.layers.EinsumDense( "gecf,efh->gech", output_shape=(self.num_experts, None, input_shape[-1]), bias_axes="eh", @@ -491,7 +491,7 @@ def call(self, return x -class MoeLayer(tf.keras.layers.Layer): +class MoeLayer(tf_keras.layers.Layer): """Sparse MoE layer with per-token routing. In this TF implementation, all experts need to fit onto a single device @@ -569,7 +569,7 @@ def call(self, inputs: Batch of input embeddings of shape [batch_size, seq_length, hidden_dim]. training: Only apply dropout and jitter noise during training. If not - provided taken from tf.keras.backend. + provided taken from tf_keras.backend. Returns: Transformed inputs with same shape as inputs: @@ -579,7 +579,7 @@ def call(self, ValueError if we cannot find a group_size satisfying given requirements. """ if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() # inputs shape [batch_size, seq_length, hidden_dim] batch_size, seq_length, hidden_dim = inputs.shape @@ -653,7 +653,7 @@ def _mask_and_dispatch_to_experts(self, inputs: tf.Tensor, return combined_outputs -class MoeLayerWithBackbone(tf.keras.layers.Layer): +class MoeLayerWithBackbone(tf_keras.layers.Layer): """Sparse MoE layer plus a FeedForward layer evaluated for all tokens. Uses Keras add_loss() and add_metric() APIs. @@ -667,7 +667,7 @@ def __init__( inner_dropout: float = 0.0, output_dropout: float = 0.0, activation: Callable[[tf.Tensor], - tf.Tensor] = tf.keras.activations.gelu, + tf.Tensor] = tf_keras.activations.gelu, kernel_initializer: _InitializerType = _DEFAULT_KERNEL_INITIALIZER, bias_initializer: _InitializerType = _DEFAULT_BIAS_INITIALIZER, name: str = "moe_with_backbone", @@ -710,7 +710,7 @@ def call(self, inputs: Batch of input embeddings of shape [batch_size, seq_length, hidden_dim]. training: Only apply dropout and jitter noise during training. If not - provided taken from tf.keras.backend. + provided taken from tf_keras.backend. Returns: Transformed inputs with same shape as inputs: diff --git a/official/nlp/modeling/layers/moe_test.py b/official/nlp/modeling/layers/moe_test.py index 20318358ed5..27b4cf67034 100644 --- a/official/nlp/modeling/layers/moe_test.py +++ b/official/nlp/modeling/layers/moe_test.py @@ -15,7 +15,7 @@ """Tests for moe.py.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import moe @@ -55,7 +55,7 @@ class MoeTest(tf.test.TestCase): def tearDown(self): super().tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_router_z_loss_dtype(self): x = tf.constant([[[10.0, 5.0]]], dtype=tf.float32) @@ -71,7 +71,7 @@ def test_router_z_loss_shape(self): self.assertAllClose(expected, y, atol=1e-7) def test_experts_choose_masked_router_dtype_shape(self): - tf.keras.mixed_precision.set_global_policy('mixed_bfloat16') + tf_keras.mixed_precision.set_global_policy('mixed_bfloat16') num_groups = 2 tokens_per_group = 3 hidden_dim = tokens_per_group @@ -87,8 +87,8 @@ def test_experts_choose_masked_router_dtype_shape(self): num_experts=num_experts, jitter_noise=0.1, use_bias=True, - kernel_initializer=tf.keras.initializers.get('identity'), - bias_initializer=tf.keras.initializers.get('ones')) + kernel_initializer=tf_keras.initializers.get('identity'), + bias_initializer=tf_keras.initializers.get('ones')) router_mask = router(x, expert_capacity=expert_capacity, training=False) self.assertDTypeEqual(router_mask.dispatch_mask, tf.bfloat16) @@ -141,9 +141,9 @@ def test_feed_forward_manual(self): layer = moe.FeedForward( d_ff=config['d_ff'], output_dropout=config['output_dropout'], - activation=tf.keras.activations.relu, - kernel_initializer=tf.keras.initializers.get('ones'), - bias_initializer=tf.keras.initializers.get('ones')) + activation=tf_keras.activations.relu, + kernel_initializer=tf_keras.initializers.get('ones'), + bias_initializer=tf_keras.initializers.get('ones')) inputs = make_input_ones(1, 2, 3) outputs = layer(inputs, training=False) manual_outputs = tf.constant([[[129.0, 129.0, 129.0], [129.0, 129.0, @@ -171,9 +171,9 @@ def test_feed_forward_experts_manual(self): num_experts=1, d_ff=config['expert_d_ff'], output_dropout=config['expert_dropout_rate'], - activation=tf.keras.activations.relu, - kernel_initializer=tf.keras.initializers.get('ones'), - bias_initializer=tf.keras.initializers.get('ones')) + activation=tf_keras.activations.relu, + kernel_initializer=tf_keras.initializers.get('ones'), + bias_initializer=tf_keras.initializers.get('ones')) inputs = make_experts_input_ones(1, 1, 2, 3) outputs = layer(inputs, training=False) manual_outputs = tf.constant([[[[133.0, 133.0, 133.0], diff --git a/official/nlp/modeling/layers/multi_channel_attention.py b/official/nlp/modeling/layers/multi_channel_attention.py index 06ee266bf66..2435b1761e6 100644 --- a/official/nlp/modeling/layers/multi_channel_attention.py +++ b/official/nlp/modeling/layers/multi_channel_attention.py @@ -17,13 +17,13 @@ import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import masked_softmax -class VotingAttention(tf.keras.layers.Layer): +class VotingAttention(tf_keras.layers.Layer): """Voting Attention layer. Args: @@ -52,12 +52,12 @@ def __init__(self, super().__init__(**kwargs) self._num_heads = num_heads self._head_size = head_size - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) def build(self, unused_input_shapes): common_kwargs = dict( @@ -66,7 +66,7 @@ def build(self, unused_input_shapes): activity_regularizer=self._activity_regularizer, kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._query_dense = tf.keras.layers.EinsumDense( + self._query_dense = tf_keras.layers.EinsumDense( "BAE,ENH->BANH", output_shape=(None, self._num_heads, self._head_size), bias_axes="NH", @@ -74,7 +74,7 @@ def build(self, unused_input_shapes): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._key_dense = tf.keras.layers.EinsumDense( + self._key_dense = tf_keras.layers.EinsumDense( "BAE,ENH->BANH", output_shape=(None, self._num_heads, self._head_size), bias_axes="NH", @@ -103,7 +103,7 @@ def call(self, encoder_outputs, doc_attention_mask): return tf.nn.softmax(doc_attention_probs + infadder) -class MultiChannelAttention(tf.keras.layers.MultiHeadAttention): +class MultiChannelAttention(tf_keras.layers.MultiHeadAttention): """Multi-channel Attention layer. Introduced in, [Generating Representative Headlines for News Stories diff --git a/official/nlp/modeling/layers/multi_channel_attention_test.py b/official/nlp/modeling/layers/multi_channel_attention_test.py index 304db9afa6a..4d2e5ddc3ed 100644 --- a/official/nlp/modeling/layers/multi_channel_attention_test.py +++ b/official/nlp/modeling/layers/multi_channel_attention_test.py @@ -15,7 +15,7 @@ """Tests for projects.nhnet.multi_channel_attention.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import multi_channel_attention diff --git a/official/nlp/modeling/layers/on_device_embedding.py b/official/nlp/modeling/layers/on_device_embedding.py index 2ec2a4f6ab3..ab6b8d3035a 100644 --- a/official/nlp/modeling/layers/on_device_embedding.py +++ b/official/nlp/modeling/layers/on_device_embedding.py @@ -15,11 +15,11 @@ """Keras-based one-hot embedding layer.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package="Text") -class OnDeviceEmbedding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class OnDeviceEmbedding(tf_keras.layers.Layer): """Performs an embedding lookup suitable for accelerator devices. This layer uses either tf.gather or tf.one_hot to translate integer indices to diff --git a/official/nlp/modeling/layers/on_device_embedding_test.py b/official/nlp/modeling/layers/on_device_embedding_test.py index eea3364a171..45e34e6c1b9 100644 --- a/official/nlp/modeling/layers/on_device_embedding_test.py +++ b/official/nlp/modeling/layers/on_device_embedding_test.py @@ -15,7 +15,7 @@ """Tests for Keras-based one-hot embedding layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import on_device_embedding @@ -29,7 +29,7 @@ def test_layer_creation(self): vocab_size=vocab_size, embedding_width=embedding_width) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # The output should be the same as the input, save that it has an extra @@ -46,7 +46,7 @@ def test_layer_creation_with_mixed_precision(self): dtype="mixed_float16") # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # The output should be the same as the input, save that it has an extra @@ -62,11 +62,11 @@ def test_layer_invocation(self): vocab_size=vocab_size, embedding_width=embedding_width) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -84,11 +84,11 @@ def test_layer_invocation_with_mixed_precision(self): dtype="mixed_float16") # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -107,7 +107,7 @@ def test_one_hot_layer_creation(self): use_one_hot=True) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # The output should be the same as the input, save that it has an extra @@ -126,7 +126,7 @@ def test_one_hot_layer_creation_with_mixed_precision(self): use_one_hot=True) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # The output should be the same as the input, save that it has an extra @@ -144,11 +144,11 @@ def test_one_hot_layer_invocation(self): use_one_hot=True) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -168,11 +168,11 @@ def test_one_hot_layer_invocation_with_mixed_precision(self): use_one_hot=True) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -190,11 +190,11 @@ def test_use_scale_layer_invocation(self): scale_factor=embedding_width**0.5) # Create a 2-dimensional input (the first dimension is implicit). sequence_length = 23 - input_tensor = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) + input_tensor = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer(input_tensor) # Create a model from the test layer. - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. diff --git a/official/nlp/modeling/layers/pack_optimization.py b/official/nlp/modeling/layers/pack_optimization.py index ad86ec6c61d..cfc01d4f18f 100644 --- a/official/nlp/modeling/layers/pack_optimization.py +++ b/official/nlp/modeling/layers/pack_optimization.py @@ -14,7 +14,7 @@ """Pack sequence optimization on accelerators.""" from typing import Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import rezero_transformer from official.nlp.modeling.layers import self_attention_mask @@ -22,8 +22,8 @@ from official.nlp.modeling.layers import transformer_scaffold -@tf.keras.utils.register_keras_serializable(package='Text') -class PackBertEmbeddings(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class PackBertEmbeddings(tf_keras.layers.Layer): """Performs packing tricks for BERT inputs to improve TPU utilization.""" def __init__(self, pack_sequences: int, **kwargs): @@ -62,7 +62,7 @@ def call(self, input_embeddings: tf.Tensor, combined_attention_mask=combined_attention_mask) -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') class StridedTransformerEncoderBlock( transformer_encoder_block.TransformerEncoderBlock): """Transformer layer for packing optimization to stride over inputs.""" @@ -128,7 +128,7 @@ def call(self, inputs, stride: tf.Tensor): return self._output_layer_norm(layer_output + attention_output) -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') class StridedReZeroTransformer(rezero_transformer.ReZeroTransformer): """ReZeroTransformer for packing optimization to stride over inputs.""" @@ -179,7 +179,7 @@ def call(self, inputs, stride: tf.Tensor): return layer_output -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') class StridedTransformerScaffold(transformer_scaffold.TransformerScaffold): """TransformerScaffold for packing optimization to stride over inputs.""" diff --git a/official/nlp/modeling/layers/pack_optimization_test.py b/official/nlp/modeling/layers/pack_optimization_test.py index 5233f84fcd8..8f2cc2e9bea 100644 --- a/official/nlp/modeling/layers/pack_optimization_test.py +++ b/official/nlp/modeling/layers/pack_optimization_test.py @@ -14,7 +14,7 @@ """Tests for pack_optimization.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import pack_optimization diff --git a/official/nlp/modeling/layers/per_dim_scale_attention.py b/official/nlp/modeling/layers/per_dim_scale_attention.py index 37f0047c471..75c8f98f8bf 100644 --- a/official/nlp/modeling/layers/per_dim_scale_attention.py +++ b/official/nlp/modeling/layers/per_dim_scale_attention.py @@ -15,12 +15,12 @@ """Keras-based attention layer with learnable per dim scaling.""" import gin import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras @gin.configurable -@tf.keras.utils.register_keras_serializable(package='Text') -class PerDimScaleAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package='Text') +class PerDimScaleAttention(tf_keras.layers.MultiHeadAttention): """Learn scales for individual dims. It can improve quality but might hurt training stability. diff --git a/official/nlp/modeling/layers/per_dim_scale_attention_test.py b/official/nlp/modeling/layers/per_dim_scale_attention_test.py index eb8cf6c77a5..17ecae25a9c 100644 --- a/official/nlp/modeling/layers/per_dim_scale_attention_test.py +++ b/official/nlp/modeling/layers/per_dim_scale_attention_test.py @@ -14,7 +14,7 @@ """Tests for PerDimScaleAttention.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import per_dim_scale_attention as attention diff --git a/official/nlp/modeling/layers/position_embedding.py b/official/nlp/modeling/layers/position_embedding.py index 0b13fa4cc89..b87298857f7 100644 --- a/official/nlp/modeling/layers/position_embedding.py +++ b/official/nlp/modeling/layers/position_embedding.py @@ -17,21 +17,21 @@ import math from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -Initializer = tf.keras.initializers.Initializer +Initializer = tf_keras.initializers.Initializer -@tf.keras.utils.register_keras_serializable(package="Text") -class PositionEmbedding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class PositionEmbedding(tf_keras.layers.Layer): """Creates a positional embedding. Example: ```python position_embedding = PositionEmbedding(max_length=100) - inputs = tf.keras.Input((100, 32), dtype=tf.float32) + inputs = tf_keras.Input((100, 32), dtype=tf.float32) outputs = position_embedding(inputs) ``` @@ -59,13 +59,13 @@ def __init__(self, "`max_length` must be an Integer, not `None`." ) self._max_length = max_length - self._initializer = tf.keras.initializers.get(initializer) + self._initializer = tf_keras.initializers.get(initializer) self._seq_axis = seq_axis def get_config(self): config = { "max_length": self._max_length, - "initializer": tf.keras.initializers.serialize(self._initializer), + "initializer": tf_keras.initializers.serialize(self._initializer), "seq_axis": self._seq_axis, } base_config = super(PositionEmbedding, self).get_config() @@ -94,8 +94,8 @@ def call(self, inputs): return tf.broadcast_to(position_embeddings, input_shape) -@tf.keras.utils.register_keras_serializable(package="Text") -class RelativePositionEmbedding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class RelativePositionEmbedding(tf_keras.layers.Layer): """Creates a positional embedding. This layer calculates the position encoding as a mix of sine and cosine @@ -227,8 +227,8 @@ def _relative_position_bucket(relative_position, return ret -@tf.keras.utils.register_keras_serializable(package="Text") -class RelativePositionBias(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class RelativePositionBias(tf_keras.layers.Layer): """Relative position embedding via per-head bias in T5 style. Reference implementation in MeshTF: @@ -254,7 +254,7 @@ def __init__(self, if embeddings_initializer: self._embed_init = embeddings_initializer else: - self._embed_init = tf.keras.initializers.TruncatedNormal(stddev=1.0) + self._embed_init = tf_keras.initializers.TruncatedNormal(stddev=1.0) with tf.name_scope(self.name): self._relative_attention_bias = self.add_weight( "rel_embedding", @@ -274,7 +274,7 @@ def get_config(self): "bidirectional": self.bidirectional, "embeddings_initializer": - tf.keras.initializers.serialize(self._embed_init), + tf_keras.initializers.serialize(self._embed_init), } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/nlp/modeling/layers/position_embedding_test.py b/official/nlp/modeling/layers/position_embedding_test.py index 2b4a10d8053..4bf0b541358 100644 --- a/official/nlp/modeling/layers/position_embedding_test.py +++ b/official/nlp/modeling/layers/position_embedding_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import position_embedding @@ -29,7 +29,7 @@ def test_static_layer_output_shape(self): test_layer = position_embedding.PositionEmbedding( max_length=sequence_length) width = 30 - input_tensor = tf.keras.Input(shape=(sequence_length, width)) + input_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(input_tensor) # When using static positional embedding shapes, the output is expected @@ -45,7 +45,7 @@ def test_non_default_axis_static(self): test_layer = position_embedding.PositionEmbedding( max_length=sequence_length, seq_axis=2) width = 30 - input_tensor = tf.keras.Input(shape=(width, sequence_length, width)) + input_tensor = tf_keras.Input(shape=(width, sequence_length, width)) output_tensor = test_layer(input_tensor) # When using static positional embedding shapes, the output is expected @@ -61,7 +61,7 @@ def test_float16_dtype(self): test_layer = position_embedding.PositionEmbedding( max_length=sequence_length, dtype="float16") width = 30 - input_tensor = tf.keras.Input(shape=(sequence_length, width)) + input_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(input_tensor) # When using static positional embedding shapes, the output is expected @@ -77,7 +77,7 @@ def test_dynamic_layer_output_shape(self): max_length=max_sequence_length) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor = test_layer(input_tensor) # When using dynamic positional embedding shapes, the output is expected @@ -92,7 +92,7 @@ def test_non_default_axis_dynamic(self): max_length=max_sequence_length, seq_axis=2) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, None, width)) + input_tensor = tf_keras.Input(shape=(None, None, width)) output_tensor = test_layer(input_tensor) # When using dynamic positional embedding shapes, the output is expected @@ -107,10 +107,10 @@ def test_dynamic_layer_slicing(self): max_length=max_sequence_length) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) # Create input data that is shorter than max_sequence_length, which should # trigger a down-slice. diff --git a/official/nlp/modeling/layers/relative_attention.py b/official/nlp/modeling/layers/relative_attention.py index 57b341985c3..272d67d95c0 100644 --- a/official/nlp/modeling/layers/relative_attention.py +++ b/official/nlp/modeling/layers/relative_attention.py @@ -15,7 +15,7 @@ """Keras-based relative attention layers.""" import math import string -import tensorflow as tf +import tensorflow as tf, tf_keras _CHR_IDX = string.ascii_lowercase @@ -69,12 +69,12 @@ def _rel_shift(x, klen=-1): return x -@tf.keras.utils.register_keras_serializable(package="Text") -class MultiHeadRelativeAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package="Text") +class MultiHeadRelativeAttention(tf_keras.layers.MultiHeadAttention): """A multi-head attention layer with relative attention + position encoding. This layer shares the same input/output projections as the common - `tf.keras.layers.MultiHeadAttention` layer. + `tf_keras.layers.MultiHeadAttention` layer. When it calculates attention logits, position encoding is projected to form relative keys. The logits are composed by shifted relative logits and content @@ -144,7 +144,7 @@ def _build_from_signature(self, query, value, key=None): with tf.init_scope(): einsum_equation, _, output_rank = _build_proj_equation( key_shape.rank - 1, bound_dims=1, output_dims=2) - self._encoding_dense = tf.keras.layers.EinsumDense( + self._encoding_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._key_dim]), @@ -319,7 +319,7 @@ def call(self, # pytype: disable=signature-mismatch # overriding-parameter-cou return attention_output -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") class TwoStreamRelativeAttention(MultiHeadRelativeAttention): """Two-stream relative self-attention for XLNet. @@ -333,7 +333,7 @@ class TwoStreamRelativeAttention(MultiHeadRelativeAttention): but not the content. This layer shares the same build signature as - `tf.keras.layers.MultiHeadAttention` but has different input/output + `tf_keras.layers.MultiHeadAttention` but has different input/output projections. **Note: This layer is currently experimental. diff --git a/official/nlp/modeling/layers/relative_attention_test.py b/official/nlp/modeling/layers/relative_attention_test.py index fbfc98b46c2..00fe06a6833 100644 --- a/official/nlp/modeling/layers/relative_attention_test.py +++ b/official/nlp/modeling/layers/relative_attention_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.nlp.modeling.layers import relative_attention diff --git a/official/nlp/modeling/layers/reuse_attention.py b/official/nlp/modeling/layers/reuse_attention.py index 46584cba4b8..a718d0e90ee 100644 --- a/official/nlp/modeling/layers/reuse_attention.py +++ b/official/nlp/modeling/layers/reuse_attention.py @@ -20,7 +20,7 @@ import string import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -109,7 +109,7 @@ def _get_output_shape(output_rank, known_last_dims): return [None] * (output_rank - len(known_last_dims)) + list(known_last_dims) -class ReuseMultiHeadAttention(tf.keras.layers.Layer): +class ReuseMultiHeadAttention(tf_keras.layers.Layer): """MultiHeadAttention layer. This is an implementation of multi-headed attention as described in the paper @@ -138,8 +138,8 @@ class ReuseMultiHeadAttention(tf.keras.layers.Layer): Returns the additional attention weights over heads. >>> layer = MultiHeadAttention(num_heads=2, key_dim=2) - >>> target = tf.keras.Input(shape=[8, 16]) - >>> source = tf.keras.Input(shape=[4, 16]) + >>> target = tf_keras.Input(shape=[8, 16]) + >>> source = tf_keras.Input(shape=[4, 16]) >>> output_tensor, weights = layer(target, source, ... return_attention_scores=True) >>> print(output_tensor.shape) @@ -150,7 +150,7 @@ class ReuseMultiHeadAttention(tf.keras.layers.Layer): Performs 2D self-attention over a 5D input tensor on axes 2 and 3. >>> layer = MultiHeadAttention(num_heads=2, key_dim=2, attention_axes=(2, 3)) - >>> input_tensor = tf.keras.Input(shape=[5, 3, 4, 16]) + >>> input_tensor = tf_keras.Input(shape=[5, 3, 4, 16]) >>> output_tensor = layer(input_tensor, input_tensor) >>> print(output_tensor.shape) (None, 5, 3, 4, 16) @@ -239,12 +239,12 @@ def __init__(self, self._pe_max_seq_length = pe_max_seq_length self._use_bias = use_bias self._output_shape = output_shape - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) if attention_axes is not None and not isinstance(attention_axes, collections.abc.Sized): self._attention_axes = (attention_axes,) @@ -255,7 +255,7 @@ def __init__(self, # Use relative PE only if reuse_heads < num_heads. if self._use_relative_pe and self._reuse_heads < self._num_heads: # Determine the dtype from global policy. - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": policy = tf.bfloat16 elif policy.name == "mixed_float16": @@ -284,19 +284,19 @@ def get_config(self): "use_relative_pe": self._use_relative_pe, "pe_max_seq_length": self._pe_max_seq_length, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "query_shape": self._query_shape, "key_shape": self._key_shape, "value_shape": self._value_shape, @@ -362,7 +362,7 @@ def _build_from_signature(self, query, value, key=None): if self._reuse_heads < self._num_heads: einsum_equation, bias_axes, output_rank = _build_proj_equation( free_dims, bound_dims=1, output_dims=2) - self._query_dense = tf.keras.layers.EinsumDense( + self._query_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape( output_rank - 1, @@ -375,7 +375,7 @@ def _build_from_signature(self, query, value, key=None): **common_kwargs) einsum_equation, bias_axes, output_rank = _build_proj_equation( self._key_shape.rank - 1, bound_dims=1, output_dims=2) - self._key_dense = tf.keras.layers.EinsumDense( + self._key_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape( output_rank - 1, @@ -392,7 +392,7 @@ def _build_from_signature(self, query, value, key=None): self._value_dense = [] if self._reuse_heads > 0: self._value_dense.append( - tf.keras.layers.EinsumDense( + tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape( output_rank - 1, [self._reuse_heads, self._value_dim]), @@ -405,7 +405,7 @@ def _build_from_signature(self, query, value, key=None): **common_kwargs)) if self._reuse_heads < self._num_heads: self._value_dense.append( - tf.keras.layers.EinsumDense( + tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape( output_rank - 1, @@ -453,7 +453,7 @@ def _make_output_dense(self, free_dims, common_kwargs, name=None, output_shape = [self._query_shape[-1]] einsum_equation, bias_axes, output_rank = _build_proj_equation( free_dims, bound_dims=2, output_dims=len(output_shape)) - return tf.keras.layers.EinsumDense( + return tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, output_shape), bias_axes=bias_axes if (use_bias and self._use_bias) else None, @@ -480,8 +480,8 @@ def _build_attention(self, rank): _build_attention_equation(rank, attn_axes=self._attention_axes)) norm_axes = tuple( range(attn_scores_rank - len(self._attention_axes), attn_scores_rank)) - self._softmax = tf.keras.layers.Softmax(axis=norm_axes) - self._dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) + self._softmax = tf_keras.layers.Softmax(axis=norm_axes) + self._dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) def _masked_softmax(self, attention_scores, attention_mask=None): # Normalize the attention scores to probabilities. diff --git a/official/nlp/modeling/layers/reuse_attention_test.py b/official/nlp/modeling/layers/reuse_attention_test.py index 7bc9ab5ce17..7d307b89ff4 100644 --- a/official/nlp/modeling/layers/reuse_attention_test.py +++ b/official/nlp/modeling/layers/reuse_attention_test.py @@ -17,7 +17,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import reuse_attention as attention @@ -36,8 +36,8 @@ def test_non_masked_attention(self, value_dim, output_shape, output_dims): value_dim=value_dim, output_shape=output_shape) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - value = tf.keras.Input(shape=(20, 80)) + query = tf_keras.Input(shape=(40, 80)) + value = tf_keras.Input(shape=(20, 80)) output = test_layer(query=query, value=value) self.assertEqual(output.shape.as_list(), [None] + output_dims) @@ -46,7 +46,7 @@ def test_non_masked_self_attention(self): test_layer = attention.ReuseMultiHeadAttention( num_heads=12, key_dim=64) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output = test_layer(query, query) self.assertEqual(output.shape.as_list(), [None, 40, 80]) @@ -55,7 +55,7 @@ def test_attention_scores(self): test_layer = attention.ReuseMultiHeadAttention( num_heads=12, key_dim=64) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output, coef = test_layer(query, query, return_attention_scores=True) self.assertEqual(output.shape.as_list(), [None, 40, 80]) self.assertEqual(coef.shape.as_list(), [None, 12, 40, 40]) @@ -65,8 +65,8 @@ def test_attention_scores_with_values(self): test_layer = attention.ReuseMultiHeadAttention( num_heads=12, key_dim=64) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - value = tf.keras.Input(shape=(60, 80)) + query = tf_keras.Input(shape=(40, 80)) + value = tf_keras.Input(shape=(60, 80)) output, coef = test_layer(query, value, return_attention_scores=True) self.assertEqual(output.shape.as_list(), [None, 40, 80]) self.assertEqual(coef.shape.as_list(), [None, 12, 40, 60]) @@ -83,14 +83,14 @@ def test_masked_attention(self, use_bias, reuse_attention): reuse_attention=reuse_attention) # Create a 3-dimensional input (the first dimension is implicit). batch_size = 3 - query = tf.keras.Input(shape=(4, 8)) - value = tf.keras.Input(shape=(2, 8)) - mask_tensor = tf.keras.Input(shape=(4, 2)) - reuse_attention_scores = tf.keras.Input(shape=(2, 4, 2)) + query = tf_keras.Input(shape=(4, 8)) + value = tf_keras.Input(shape=(2, 8)) + mask_tensor = tf_keras.Input(shape=(4, 2)) + reuse_attention_scores = tf_keras.Input(shape=(2, 4, 2)) output = test_layer(query=query, value=value, attention_mask=mask_tensor, reuse_attention_scores=reuse_attention_scores) # Create a model containing the test layer. - model = tf.keras.Model( + model = tf_keras.Model( [query, value, mask_tensor, reuse_attention_scores], output) # Generate data for the input (non-mask) tensors. @@ -116,10 +116,10 @@ def test_masked_attention(self, use_bias, reuse_attention): self.assertNotAllClose(masked_output_data, unmasked_output_data) # Tests the layer with three inputs: Q, K, V. - key = tf.keras.Input(shape=(2, 8)) + key = tf_keras.Input(shape=(2, 8)) output = test_layer(query, value=value, key=key, attention_mask=mask_tensor, reuse_attention_scores=reuse_attention_scores) - model = tf.keras.Model( + model = tf_keras.Model( [query, value, key, mask_tensor, reuse_attention_scores], output) masked_output_data = model.predict( @@ -152,9 +152,9 @@ def test_initializer(self): test_layer = attention.ReuseMultiHeadAttention( num_heads=12, key_dim=64, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output = test_layer(query, query) self.assertEqual(output.shape.as_list(), [None, 40, 80]) @@ -164,13 +164,13 @@ def test_masked_attention_with_scores(self): num_heads=2, key_dim=2) # Create a 3-dimensional input (the first dimension is implicit). batch_size = 3 - query = tf.keras.Input(shape=(4, 8)) - value = tf.keras.Input(shape=(2, 8)) - mask_tensor = tf.keras.Input(shape=(4, 2)) + query = tf_keras.Input(shape=(4, 8)) + value = tf_keras.Input(shape=(2, 8)) + mask_tensor = tf_keras.Input(shape=(4, 2)) output = test_layer(query=query, value=value, attention_mask=mask_tensor) # Create a model containing the test layer. - model = tf.keras.Model([query, value, mask_tensor], output) + model = tf_keras.Model([query, value, mask_tensor], output) # Generate data for the input (non-mask) tensors. from_data = 10 * np.random.random_sample((batch_size, 4, 8)) @@ -193,7 +193,7 @@ def test_masked_attention_with_scores(self): output, scores = test_layer( query=query, value=value, attention_mask=mask_tensor, return_attention_scores=True) - model = tf.keras.Model([query, value, mask_tensor], [output, scores]) + model = tf_keras.Model([query, value, mask_tensor], [output, scores]) masked_output_data_score, masked_score = model.predict( [from_data, to_data, mask_data]) unmasked_output_data_score, unmasked_score = model.predict( @@ -230,12 +230,12 @@ def test_high_dim_attention(self, q_dims, v_dims, mask_dims, attention_axes): null_mask_data = np.ones(mask_shape) # Because one data is masked and one is not, the outputs should not be the # same. - query_tensor = tf.keras.Input(query_shape[1:], name="query") - value_tensor = tf.keras.Input(value_shape[1:], name="value") - mask_tensor = tf.keras.Input(mask_shape[1:], name="mask") + query_tensor = tf_keras.Input(query_shape[1:], name="query") + value_tensor = tf_keras.Input(value_shape[1:], name="value") + mask_tensor = tf_keras.Input(mask_shape[1:], name="mask") output = test_layer(query=query_tensor, value=value_tensor, attention_mask=mask_tensor) - model = tf.keras.Model([query_tensor, value_tensor, mask_tensor], output) + model = tf_keras.Model([query_tensor, value_tensor, mask_tensor], output) self.assertNotAllClose( model.predict([query, value, mask_data]), @@ -246,24 +246,24 @@ def test_dropout(self): num_heads=2, key_dim=2, dropout=0.5) # Generate data for the input (non-mask) tensors. - from_data = tf.keras.backend.ones(shape=(32, 4, 8)) - to_data = tf.keras.backend.ones(shape=(32, 2, 8)) + from_data = tf_keras.backend.ones(shape=(32, 4, 8)) + to_data = tf_keras.backend.ones(shape=(32, 2, 8)) train_out = test_layer(from_data, to_data, None, None, None, True) test_out = test_layer(from_data, to_data, None, None, None, False) # Output should be close when not in training mode, # and should not be close when enabling dropout in training mode. self.assertNotAllClose( - tf.keras.backend.eval(train_out), - tf.keras.backend.eval(test_out)) + tf_keras.backend.eval(train_out), + tf_keras.backend.eval(test_out)) def test_non_masked_self_attention_with_reuse(self): """Test with one input (self-attenntion) and no mask tensor.""" test_layer = attention.ReuseMultiHeadAttention( num_heads=12, key_dim=64, reuse_attention=True) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - reuse_scores = tf.keras.Input(shape=(12, 40, 40)) + query = tf_keras.Input(shape=(40, 80)) + reuse_scores = tf_keras.Input(shape=(12, 40, 40)) output = test_layer(query, query, reuse_attention_scores=reuse_scores) self.assertEqual(output.shape.as_list(), [None, 40, 80]) @@ -281,22 +281,22 @@ def test_non_masked_self_attention_with_relative_pe(self, reuse_attention, num_heads=12, key_dim=64, reuse_attention=reuse_attention, use_relative_pe=True, pe_max_seq_length=pe_max_seq_length) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - reuse_scores = tf.keras.Input(shape=(12, 40, 40)) + query = tf_keras.Input(shape=(40, 80)) + reuse_scores = tf_keras.Input(shape=(12, 40, 40)) output = test_layer(query, query, reuse_attention_scores=reuse_scores) self.assertEqual(output.shape.as_list(), [None, 40, 80]) - query = tf.keras.Input(shape=(30, 80)) - reuse_scores = tf.keras.Input(shape=(12, 30, 30)) + query = tf_keras.Input(shape=(30, 80)) + reuse_scores = tf_keras.Input(shape=(12, 30, 30)) output = test_layer(query, query, reuse_attention_scores=reuse_scores) self.assertEqual(output.shape.as_list(), [None, 30, 80]) - query = tf.keras.Input(shape=(30, 80)) - key = tf.keras.Input(shape=(20, 80)) - reuse_scores = tf.keras.Input(shape=(12, 30, 20)) + query = tf_keras.Input(shape=(30, 80)) + key = tf_keras.Input(shape=(20, 80)) + reuse_scores = tf_keras.Input(shape=(12, 30, 20)) output = test_layer(query, key, reuse_attention_scores=reuse_scores) self.assertEqual(output.shape.as_list(), [None, 30, 80]) - query = tf.keras.Input(shape=(50, 80)) - key = tf.keras.Input(shape=(60, 80)) - reuse_scores = tf.keras.Input(shape=(12, 50, 60)) + query = tf_keras.Input(shape=(50, 80)) + key = tf_keras.Input(shape=(60, 80)) + reuse_scores = tf_keras.Input(shape=(12, 50, 60)) output = test_layer(query, key, reuse_attention_scores=reuse_scores) self.assertEqual(output.shape.as_list(), [None, 50, 80]) diff --git a/official/nlp/modeling/layers/reuse_transformer.py b/official/nlp/modeling/layers/reuse_transformer.py index ecb680694ea..23d11e86cd6 100644 --- a/official/nlp/modeling/layers/reuse_transformer.py +++ b/official/nlp/modeling/layers/reuse_transformer.py @@ -13,13 +13,13 @@ # limitations under the License. """Keras-based TransformerEncoder block layer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import reuse_attention as attention -class ReuseTransformer(tf.keras.layers.Layer): +class ReuseTransformer(tf_keras.layers.Layer): """Transformer layer. This layer implements the ReuseTransformer Encoder from @@ -108,13 +108,13 @@ def __init__(self, self._output_dropout = output_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon @@ -130,7 +130,7 @@ def __init__(self, self._max_reuse_layer_idx < self._layer_idx)): self._reuse_attention = 0 if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -177,17 +177,17 @@ def build(self, input_shape): pe_max_seq_length=self._pe_max_seq_length, name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout( + self._attention_dropout = tf_keras.layers.Dropout( rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", @@ -195,17 +195,17 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, hidden_size), bias_axes="d", @@ -213,9 +213,9 @@ def build(self, input_shape): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -245,19 +245,19 @@ def get_config(self): "pe_max_seq_length": self._pe_max_seq_length, "max_reuse_layer_idx": self._max_reuse_layer_idx, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "use_bias": self._use_bias, "norm_first": @@ -267,7 +267,7 @@ def get_config(self): "inner_dropout": self._inner_dropout, "attention_initializer": - tf.keras.initializers.serialize(self._attention_initializer), + tf_keras.initializers.serialize(self._attention_initializer), "attention_axes": self._attention_axes, } base_config = super(ReuseTransformer, self).get_config() diff --git a/official/nlp/modeling/layers/reuse_transformer_test.py b/official/nlp/modeling/layers/reuse_transformer_test.py index 02c3faa33b6..ab2ce911a27 100644 --- a/official/nlp/modeling/layers/reuse_transformer_test.py +++ b/official/nlp/modeling/layers/reuse_transformer_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import reuse_transformer @@ -27,7 +27,7 @@ class ReuseTransformerLayerTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(ReuseTransformerLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self, transformer_cls): test_layer = transformer_cls( @@ -35,7 +35,7 @@ def test_layer_creation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor, _ = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -46,9 +46,9 @@ def test_layer_creation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor, _ = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -59,11 +59,11 @@ def test_layer_invocation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -78,13 +78,13 @@ def test_layer_invocation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -206,19 +206,19 @@ def test_layer_output_range_with_pre_norm(self, transformer_cls): new_output_tensor, output_tensor[:, 0:1, :], atol=0.002, rtol=0.01) def test_layer_invocation_with_float16_dtype(self, transformer_cls): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = transformer_cls( num_attention_heads=10, inner_dim=2048, inner_activation='relu') sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -236,11 +236,11 @@ def test_transform_with_initializer(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output, _ = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -250,12 +250,12 @@ def test_dynamic_layer_sequence(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor, _ = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_length = 17 input_data = np.ones((1, input_length, width)) @@ -279,7 +279,7 @@ def test_use_bias_norm_first(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) # Forward path. dummy_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) @@ -300,7 +300,7 @@ def test_get_config(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) encoder_block_config = encoder_block.get_config() new_encoder_block = reuse_transformer.ReuseTransformer.from_config( @@ -325,7 +325,7 @@ def test_several_attention_axes(self, attention_axes): num_cols = 13 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(num_rows, num_cols, width)) + data_tensor = tf_keras.Input(shape=(num_rows, num_cols, width)) output_tensor, _ = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -351,17 +351,17 @@ def test_layer_invocation_with_mask(self, reuse_attention, sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) - return_scores_tensor = tf.keras.Input(shape=(1,)) - reuse_attention_scores = tf.keras.Input( + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) + return_scores_tensor = tf_keras.Input(shape=(1,)) + reuse_attention_scores = tf_keras.Input( shape=(10, sequence_length, sequence_length)) output_tensor, _ = test_layer( [data_tensor, mask_tensor, reuse_attention_scores]) # Create a model from the test layer. - model = tf.keras.Model( + model = tf_keras.Model( ([data_tensor, mask_tensor, reuse_attention_scores], return_scores_tensor), output_tensor) @@ -386,20 +386,20 @@ def test_layer_invocation_with_mask(self, reuse_attention, ('with_relative_pe_with_pe_max_seq_length_100', True, 100)) def test_layer_invocation_with_float16_with_relative_pe( self, use_relative_pe, pe_max_seq_length): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = reuse_transformer.ReuseTransformer( num_attention_heads=10, inner_dim=2048, inner_activation='relu', use_relative_pe=use_relative_pe, pe_max_seq_length=pe_max_seq_length) sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. diff --git a/official/nlp/modeling/layers/rezero_transformer.py b/official/nlp/modeling/layers/rezero_transformer.py index f50873fda56..d68be7ee532 100644 --- a/official/nlp/modeling/layers/rezero_transformer.py +++ b/official/nlp/modeling/layers/rezero_transformer.py @@ -18,15 +18,15 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import util -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable -class ReZeroTransformer(tf.keras.layers.Layer): +class ReZeroTransformer(tf_keras.layers.Layer): """Transformer layer with ReZero. This layer implements the Transformer from "Attention Is All You Need". @@ -93,12 +93,12 @@ def __init__(self, self._attention_dropout_rate = attention_dropout_rate self._dropout_rate = dropout_rate self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_layer_norm = use_layer_norm self._share_rezero = share_rezero @@ -138,7 +138,7 @@ def build(self, input_shape): activity_regularizer=self._activity_regularizer, kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._attention_layer = tf.keras.layers.MultiHeadAttention( + self._attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self._num_heads, key_dim=self._attention_head_size, dropout=self._attention_dropout_rate, @@ -146,17 +146,17 @@ def build(self, input_shape): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) if self._use_layer_norm: # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=1e-12, dtype=tf.float32)) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self._inner_dim), bias_axes="d", @@ -164,15 +164,15 @@ def build(self, input_shape): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._inner_activation_layer = tf.keras.layers.Activation( + self._inner_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", @@ -180,15 +180,15 @@ def build(self, input_shape): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._output_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) if self._use_layer_norm: # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=1e-12, dtype=tf.float32) self._rezero_a = self.add_weight( name="rezero_alpha", - initializer=tf.keras.initializers.Zeros(), + initializer=tf_keras.initializers.Zeros(), trainable=True, dtype=tf.float32) @@ -197,7 +197,7 @@ def build(self, input_shape): else: self._rezero_a_ffn = self.add_weight( name="rezero_alpha_ffn", - initializer=tf.keras.initializers.Zeros(), + initializer=tf_keras.initializers.Zeros(), trainable=True, dtype=tf.float32) @@ -222,19 +222,19 @@ def get_config(self): "share_rezero": self._share_rezero, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/nlp/modeling/layers/rezero_transformer_test.py b/official/nlp/modeling/layers/rezero_transformer_test.py index 955bd006462..48c4bc15b02 100644 --- a/official/nlp/modeling/layers/rezero_transformer_test.py +++ b/official/nlp/modeling/layers/rezero_transformer_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import rezero_transformer @@ -25,12 +25,12 @@ class TransformerWithReZeroLayerTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(TransformerWithReZeroLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') @parameterized.named_parameters(('no_share_attn_ffn', False), ('share_attn_ffn', True)) def test_layer_invocation_with_float16_dtype(self, share_rezero): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = rezero_transformer.ReZeroTransformer( num_attention_heads=10, intermediate_size=2048, @@ -39,13 +39,13 @@ def test_layer_invocation_with_float16_dtype(self, share_rezero): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -66,9 +66,9 @@ def test_rezero_without_layer_norm(self): use_layer_norm=False) input_length, width = 16, 30 - input_tensor = tf.keras.Input(shape=(input_length, width)) + input_tensor = tf_keras.Input(shape=(input_length, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_data = np.random.rand(2, input_length, width) test_layer._rezero_a.assign(1.0) @@ -85,9 +85,9 @@ def test_rezero_with_layer_norm(self): use_layer_norm=True) input_length, width = 16, 30 - input_tensor = tf.keras.Input(shape=(input_length, width)) + input_tensor = tf_keras.Input(shape=(input_length, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_data = np.random.rand(2, input_length, width) + 2.0 output_data = model.predict(input_data) @@ -132,7 +132,7 @@ def test_separate_qkv(self): num_attention_heads=2, intermediate_size=128, intermediate_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Forward path. q_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) kv_tensor = tf.zeros([2, 8, 16], dtype=tf.float32) diff --git a/official/nlp/modeling/layers/routing.py b/official/nlp/modeling/layers/routing.py index 66c3d9a1793..3197a81155e 100644 --- a/official/nlp/modeling/layers/routing.py +++ b/official/nlp/modeling/layers/routing.py @@ -18,11 +18,11 @@ Later on, different sets of tokens can potentially go to different experts. """ -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package="Text") -class TokenImportanceWithMovingAvg(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class TokenImportanceWithMovingAvg(tf_keras.layers.Layer): """Routing based on per-token importance value.""" def __init__(self, @@ -39,7 +39,7 @@ def build(self, input_shape): self._importance_embedding = self.add_weight( name="importance_embed", shape=(self._vocab_size), - initializer=tf.keras.initializers.Constant(self._init_importance), + initializer=tf_keras.initializers.Constant(self._init_importance), trainable=False) def get_config(self): @@ -70,8 +70,8 @@ def call(self, inputs): return tf.gather(self._importance_embedding, inputs) -@tf.keras.utils.register_keras_serializable(package="Text") -class SelectTopK(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class SelectTopK(tf_keras.layers.Layer): """Select top-k + random-k tokens according to importance.""" def __init__(self, diff --git a/official/nlp/modeling/layers/routing_test.py b/official/nlp/modeling/layers/routing_test.py index 857a437d344..3d1f5225038 100644 --- a/official/nlp/modeling/layers/routing_test.py +++ b/official/nlp/modeling/layers/routing_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import routing diff --git a/official/nlp/modeling/layers/self_attention_mask.py b/official/nlp/modeling/layers/self_attention_mask.py index feecb03f5ef..0eb15b16610 100644 --- a/official/nlp/modeling/layers/self_attention_mask.py +++ b/official/nlp/modeling/layers/self_attention_mask.py @@ -14,7 +14,7 @@ """Keras layer that creates a self-attention mask.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras def get_mask(inputs: tf.Tensor, @@ -45,8 +45,8 @@ def get_mask(inputs: tf.Tensor, return tf.broadcast_to(to_mask, [batch_size, from_seq_length, to_seq_length]) -@tf.keras.utils.register_keras_serializable(package='Text') -class SelfAttentionMask(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class SelfAttentionMask(tf_keras.layers.Layer): """Create 3D attention mask from a 2D tensor mask. inputs[0]: from_tensor: 2D or 3D Tensor of shape diff --git a/official/nlp/modeling/layers/spectral_normalization.py b/official/nlp/modeling/layers/spectral_normalization.py index 8a3c6f18de7..0cf17a7de98 100644 --- a/official/nlp/modeling/layers/spectral_normalization.py +++ b/official/nlp/modeling/layers/spectral_normalization.py @@ -30,10 +30,10 @@ """ import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras -class SpectralNormalization(tf.keras.layers.Wrapper): +class SpectralNormalization(tf_keras.layers.Wrapper): """Implements spectral normalization for Dense layer.""" def __init__(self, @@ -47,7 +47,7 @@ def __init__(self, """Initializer. Args: - layer: (tf.keras.layers.Layer) A TF Keras layer to apply normalization to. + layer: (tf_keras.layers.Layer) A TF Keras layer to apply normalization to. iteration: (int) The number of power iteration to perform to estimate weight matrix's singular value. norm_multiplier: (float) Multiplicative constant to threshold the @@ -71,8 +71,8 @@ def __init__(self, if inhere_layer_name: wrapper_name = layer.name - if not isinstance(layer, tf.keras.layers.Layer): - raise ValueError('`layer` must be a `tf.keras.layer.Layer`. ' + if not isinstance(layer, tf_keras.layers.Layer): + raise ValueError('`layer` must be a `tf_keras.layer.Layer`. ' 'Observed `{}`'.format(layer)) super().__init__( layer, name=wrapper_name, **kwargs) @@ -150,7 +150,7 @@ def restore_weights(self): return self.layer.kernel.assign(self.w) -class SpectralNormalizationConv2D(tf.keras.layers.Wrapper): +class SpectralNormalizationConv2D(tf_keras.layers.Wrapper): """Implements spectral normalization for Conv2D layer based on [3].""" def __init__(self, @@ -164,7 +164,7 @@ def __init__(self, """Initializer. Args: - layer: (tf.keras.layers.Layer) A TF Keras layer to apply normalization to. + layer: (tf_keras.layers.Layer) A TF Keras layer to apply normalization to. iteration: (int) The number of power iteration to perform to estimate weight matrix's singular value. norm_multiplier: (float) Multiplicative constant to threshold the @@ -189,9 +189,9 @@ def __init__(self, # Set layer attributes. layer._name += '_spec_norm' - if not isinstance(layer, tf.keras.layers.Conv2D): + if not isinstance(layer, tf_keras.layers.Conv2D): raise ValueError( - 'layer must be a `tf.keras.layer.Conv2D` instance. You passed: {input}' + 'layer must be a `tf_keras.layer.Conv2D` instance. You passed: {input}' .format(input=layer)) super().__init__(layer, **kwargs) diff --git a/official/nlp/modeling/layers/spectral_normalization_test.py b/official/nlp/modeling/layers/spectral_normalization_test.py index 04dc576a0f7..3956903debd 100644 --- a/official/nlp/modeling/layers/spectral_normalization_test.py +++ b/official/nlp/modeling/layers/spectral_normalization_test.py @@ -23,12 +23,12 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import spectral_normalization -DenseLayer = tf.keras.layers.Dense(10) -Conv2DLayer = tf.keras.layers.Conv2D(filters=64, kernel_size=3, padding='valid') +DenseLayer = tf_keras.layers.Dense(10) +Conv2DLayer = tf_keras.layers.Conv2D(filters=64, kernel_size=3, padding='valid') def _compute_spectral_norm(weight): diff --git a/official/nlp/modeling/layers/talking_heads_attention.py b/official/nlp/modeling/layers/talking_heads_attention.py index 4b910c6f8b6..5ae3eca4db8 100644 --- a/official/nlp/modeling/layers/talking_heads_attention.py +++ b/official/nlp/modeling/layers/talking_heads_attention.py @@ -18,16 +18,16 @@ import string import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils _CHR_IDX = string.ascii_lowercase -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable -class TalkingHeadsAttention(tf.keras.layers.MultiHeadAttention): +class TalkingHeadsAttention(tf_keras.layers.MultiHeadAttention): """Implements Talking-Heads Attention. This is an implementation of Talking-Heads Attention based on the paper @@ -35,7 +35,7 @@ class TalkingHeadsAttention(tf.keras.layers.MultiHeadAttention): multi-head attention by including linearprojections across the attention-heads dimension, immediately before and after the softmax operation. - See the base class `tf.keras.layers.MultiHeadAttention` for more details. + See the base class `tf_keras.layers.MultiHeadAttention` for more details. Args: num_heads: Number of attention heads. diff --git a/official/nlp/modeling/layers/talking_heads_attention_test.py b/official/nlp/modeling/layers/talking_heads_attention_test.py index e89263cb904..f3acb21dd86 100644 --- a/official/nlp/modeling/layers/talking_heads_attention_test.py +++ b/official/nlp/modeling/layers/talking_heads_attention_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import talking_heads_attention @@ -36,8 +36,8 @@ def test_non_masked_attention(self, value_dim, output_shape, output_dims): value_dim=value_dim, output_shape=output_shape) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - value = tf.keras.Input(shape=(20, 80)) + query = tf_keras.Input(shape=(40, 80)) + value = tf_keras.Input(shape=(20, 80)) output = test_layer(query=query, value=value) self.assertEqual(output.shape.as_list(), [None] + output_dims) @@ -46,7 +46,7 @@ def test_non_masked_self_attention(self): test_layer = talking_heads_attention.TalkingHeadsAttention( num_heads=12, key_dim=64) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output = test_layer(query=query, value=query) self.assertEqual(output.shape.as_list(), [None, 40, 80]) @@ -55,7 +55,7 @@ def test_attention_scores(self): test_layer = talking_heads_attention.TalkingHeadsAttention( num_heads=12, key_dim=64) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output, coef = test_layer(query=query, value=query, return_attention_scores=True) self.assertEqual(output.shape.as_list(), [None, 40, 80]) @@ -68,13 +68,13 @@ def test_masked_attention(self, use_bias): num_heads=12, key_dim=2, use_bias=use_bias) # Create a 3-dimensional input (the first dimension is implicit). batch_size = 3 - query = tf.keras.Input(shape=(4, 8)) - value = tf.keras.Input(shape=(2, 8)) - mask_tensor = tf.keras.Input(shape=(4, 2)) + query = tf_keras.Input(shape=(4, 8)) + value = tf_keras.Input(shape=(2, 8)) + mask_tensor = tf_keras.Input(shape=(4, 2)) output = test_layer(query=query, value=value, attention_mask=mask_tensor) # Create a model containing the test layer. - model = tf.keras.Model([query, value, mask_tensor], output) + model = tf_keras.Model([query, value, mask_tensor], output) # Generate data for the input (non-mask) tensors. from_data = 10 * np.random.random_sample((batch_size, 4, 8)) @@ -94,10 +94,10 @@ def test_masked_attention(self, use_bias): self.assertNotAllClose(masked_output_data, unmasked_output_data) # Tests the layer with three inputs: Q, K, V. - key = tf.keras.Input(shape=(2, 8)) + key = tf_keras.Input(shape=(2, 8)) output = test_layer( query=query, value=value, key=key, attention_mask=mask_tensor) - model = tf.keras.Model([query, value, key, mask_tensor], output) + model = tf_keras.Model([query, value, key, mask_tensor], output) masked_output_data = model.predict([from_data, to_data, to_data, mask_data]) unmasked_output_data = model.predict( @@ -118,9 +118,9 @@ def test_initializer(self): test_layer = talking_heads_attention.TalkingHeadsAttention( num_heads=12, key_dim=64, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) + query = tf_keras.Input(shape=(40, 80)) output = test_layer(query=query, value=query) self.assertEqual(output.shape.as_list(), [None, 40, 80]) diff --git a/official/nlp/modeling/layers/text_layers.py b/official/nlp/modeling/layers/text_layers.py index 8b5ffbbcdd3..afcd6ba3e57 100644 --- a/official/nlp/modeling/layers/text_layers.py +++ b/official/nlp/modeling/layers/text_layers.py @@ -17,7 +17,7 @@ from typing import Any, Dict, List, Mapping, Optional, Text, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras try: # pytype: disable=import-error @@ -58,7 +58,7 @@ def fn(x): return result -class BertTokenizer(tf.keras.layers.Layer): +class BertTokenizer(tf_keras.layers.Layer): """Wraps TF.Text's BertTokenizer with pre-defined vocab as a Keras Layer. Attributes: @@ -235,7 +235,7 @@ def _create_special_tokens_dict(self, vocab_table, vocab_file): return result -class SentencepieceTokenizer(tf.keras.layers.Layer): +class SentencepieceTokenizer(tf_keras.layers.Layer): """Wraps `tf_text.SentencepieceTokenizer` as a Keras Layer. Attributes: @@ -437,7 +437,7 @@ def _create_special_tokens_dict(self): return result -class BertPackInputs(tf.keras.layers.Layer): +class BertPackInputs(tf_keras.layers.Layer): """Packs tokens into model inputs for BERT.""" def __init__(self, @@ -602,7 +602,7 @@ def _reshape(t): input_type_ids=_reshape(input_type_ids)) -class FastWordpieceBertTokenizer(tf.keras.layers.Layer): +class FastWordpieceBertTokenizer(tf_keras.layers.Layer): """A bert tokenizer keras layer using text.FastWordpieceTokenizer. See details: "Fast WordPiece Tokenization" (https://arxiv.org/abs/2012.15524) diff --git a/official/nlp/modeling/layers/text_layers_test.py b/official/nlp/modeling/layers/text_layers_test.py index f928ba994df..20094b7b4d5 100644 --- a/official/nlp/modeling/layers/text_layers_test.py +++ b/official/nlp/modeling/layers/text_layers_test.py @@ -18,7 +18,7 @@ import tempfile import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow import estimator as tf_estimator from sentencepiece import SentencePieceTrainer @@ -103,7 +103,7 @@ def input_fn(): with tf.init_scope(): self.assertFalse(tf.executing_eagerly()) # Build a preprocessing Model. - sentences = tf.keras.layers.Input(shape=[], dtype=tf.string) + sentences = tf_keras.layers.Input(shape=[], dtype=tf.string) bert_tokenizer = text_layers.BertTokenizer( vocab_file=vocab_file, lower_case=True) special_tokens_dict = bert_tokenizer.get_special_tokens_dict() @@ -112,7 +112,7 @@ def input_fn(): tokens = bert_tokenizer(sentences) packed_inputs = text_layers.BertPackInputs( 4, special_tokens_dict=special_tokens_dict)(tokens) - preprocessing = tf.keras.Model(sentences, packed_inputs) + preprocessing = tf_keras.Model(sentences, packed_inputs) # Map the dataset. ds = tf.data.Dataset.from_tensors( (tf.constant(["abc", "DEF"]), tf.constant([0, 1]))) @@ -214,7 +214,7 @@ def input_fn(): with tf.init_scope(): self.assertFalse(tf.executing_eagerly()) # Build a preprocessing Model. - sentences = tf.keras.layers.Input(shape=[], dtype=tf.string) + sentences = tf_keras.layers.Input(shape=[], dtype=tf.string) sentencepiece_tokenizer = text_layers.SentencepieceTokenizer( model_file_path=self._spm_path, lower_case=True, nbest_size=0) special_tokens_dict = sentencepiece_tokenizer.get_special_tokens_dict() @@ -223,7 +223,7 @@ def input_fn(): tokens = sentencepiece_tokenizer(sentences) packed_inputs = text_layers.BertPackInputs( 4, special_tokens_dict=special_tokens_dict)(tokens) - preprocessing = tf.keras.Model(sentences, packed_inputs) + preprocessing = tf_keras.Model(sentences, packed_inputs) # Map the dataset. ds = tf.data.Dataset.from_tensors( (tf.constant(["abc", "DEF"]), tf.constant([0, 1]))) @@ -294,9 +294,9 @@ def test_serialize_deserialize(self): def test_saving(self): sentencepiece_tokenizer = text_layers.SentencepieceTokenizer( model_file_path=self._spm_path, lower_case=True, nbest_size=0) - inputs = tf.keras.layers.Input([], dtype=tf.string) + inputs = tf_keras.layers.Input([], dtype=tf.string) outputs = sentencepiece_tokenizer(inputs) - model = tf.keras.Model(inputs, outputs) + model = tf_keras.Model(inputs, outputs) export_path = tempfile.mkdtemp(dir=self.get_temp_dir()) model.save(export_path, signatures={}) @@ -520,7 +520,7 @@ def input_fn(): with tf.init_scope(): self.assertFalse(tf.executing_eagerly()) # Build a preprocessing Model. - sentences = tf.keras.layers.Input(shape=[], dtype=tf.string) + sentences = tf_keras.layers.Input(shape=[], dtype=tf.string) bert_tokenizer = text_layers.FastWordpieceBertTokenizer( vocab_file=vocab_file, lower_case=True) special_tokens_dict = bert_tokenizer.get_special_tokens_dict() @@ -529,7 +529,7 @@ def input_fn(): tokens = bert_tokenizer(sentences) packed_inputs = text_layers.BertPackInputs( 4, special_tokens_dict=special_tokens_dict)(tokens) - preprocessing = tf.keras.Model(sentences, packed_inputs) + preprocessing = tf_keras.Model(sentences, packed_inputs) # Map the dataset. ds = tf.data.Dataset.from_tensors( (tf.constant(["abc", "DEF"]), tf.constant([0, 1]))) diff --git a/official/nlp/modeling/layers/tn_expand_condense.py b/official/nlp/modeling/layers/tn_expand_condense.py index 865591b8cc4..139efac00ae 100644 --- a/official/nlp/modeling/layers/tn_expand_condense.py +++ b/official/nlp/modeling/layers/tn_expand_condense.py @@ -15,16 +15,16 @@ """ExpandCondense tensor network layer used in TN-BERT.""" # pylint: disable=g-classes-have-attributes from typing import List, Optional, Text, Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -Layer = tf.keras.layers.Layer -activations = tf.keras.activations -initializers = tf.keras.initializers +Layer = tf_keras.layers.Layer +activations = tf_keras.activations +initializers = tf_keras.initializers -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') class TNExpandCondense(Layer): """A TPU-optimized TensorNetwork layer. diff --git a/official/nlp/modeling/layers/tn_expand_condense_test.py b/official/nlp/modeling/layers/tn_expand_condense_test.py index 54f638b1d16..671bf35d7cc 100644 --- a/official/nlp/modeling/layers/tn_expand_condense_test.py +++ b/official/nlp/modeling/layers/tn_expand_condense_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers.tn_expand_condense import TNExpandCondense @@ -31,19 +31,19 @@ def setUp(self): self.labels = np.concatenate((np.ones((50, 1)), np.zeros((50, 1))), axis=0) def _build_model(self, data, proj_multiple=2): - model = tf.keras.models.Sequential() + model = tf_keras.models.Sequential() model.add( TNExpandCondense( proj_multiplier=proj_multiple, use_bias=True, activation='relu', input_shape=(data.shape[-1],))) - model.add(tf.keras.layers.Dense(1, activation='sigmoid')) + model.add(tf_keras.layers.Dense(1, activation='sigmoid')) return model @parameterized.parameters((768, 6), (1024, 2)) def test_train(self, input_dim, proj_multiple): - tf.keras.utils.set_random_seed(0) + tf_keras.utils.set_random_seed(0) data = np.random.randint(10, size=(100, input_dim)) model = self._build_model(data, proj_multiple) @@ -60,7 +60,7 @@ def test_train(self, input_dim, proj_multiple): @parameterized.parameters((768, 6), (1024, 2)) def test_weights_change(self, input_dim, proj_multiple): - tf.keras.utils.set_random_seed(0) + tf_keras.utils.set_random_seed(0) data = np.random.randint(10, size=(100, input_dim)) model = self._build_model(data, proj_multiple) model.compile( @@ -90,7 +90,7 @@ def test_output_shape(self, input_dim, proj_multiple): def test_expandcondense_num_parameters(self, input_dim, proj_multiple): data = np.random.randint(10, size=(100, input_dim)) proj_size = proj_multiple * data.shape[-1] - model = tf.keras.models.Sequential() + model = tf_keras.models.Sequential() model.add( TNExpandCondense( proj_multiplier=proj_multiple, @@ -150,7 +150,7 @@ def test_model_save(self, input_dim, proj_multiple): save_path = os.path.join(self.get_temp_dir(), 'test_model') model.save(save_path) - loaded_model = tf.keras.models.load_model(save_path) + loaded_model = tf_keras.models.load_model(save_path) # Compare model predictions and loaded_model predictions self.assertAllEqual(model.predict(data), loaded_model.predict(data)) diff --git a/official/nlp/modeling/layers/tn_transformer_expand_condense.py b/official/nlp/modeling/layers/tn_transformer_expand_condense.py index 9fff8f523af..7d7a310f589 100644 --- a/official/nlp/modeling/layers/tn_transformer_expand_condense.py +++ b/official/nlp/modeling/layers/tn_transformer_expand_condense.py @@ -17,15 +17,15 @@ # Import libraries import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers.tn_expand_condense import TNExpandCondense -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable -class TNTransformerExpandCondense(tf.keras.layers.Layer): +class TNTransformerExpandCondense(tf_keras.layers.Layer): """Transformer layer using tensor network Expand-Condense layer. This layer implements the Transformer from transformer.py, with a single @@ -86,19 +86,19 @@ def __init__(self, self._attention_dropout_rate = attention_dropout_rate self._dropout_rate = dropout_rate self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._intermediate_dropout = intermediate_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -135,7 +135,7 @@ def build(self, input_shape): activity_regularizer=self._activity_regularizer, kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._attention_layer = tf.keras.layers.MultiHeadAttention( + self._attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self._num_heads, key_dim=self._attention_head_size, dropout=self._attention_dropout_rate, @@ -144,11 +144,11 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -162,9 +162,9 @@ def build(self, input_shape): kernel_initializer=self._kernel_initializer, bias_initializer=self._bias_initializer) - self._output_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._output_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -187,19 +187,19 @@ def get_config(self): "output_range": self._output_range, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "use_bias": self._use_bias, "norm_first": @@ -209,7 +209,7 @@ def get_config(self): "intermediate_dropout": self._intermediate_dropout, "attention_initializer": - tf.keras.initializers.serialize(self._attention_initializer) + tf_keras.initializers.serialize(self._attention_initializer) } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/nlp/modeling/layers/tn_transformer_test.py b/official/nlp/modeling/layers/tn_transformer_test.py index 9602d5d79b7..e59719d170c 100644 --- a/official/nlp/modeling/layers/tn_transformer_test.py +++ b/official/nlp/modeling/layers/tn_transformer_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers.tn_transformer_expand_condense import TNTransformerExpandCondense @@ -26,7 +26,7 @@ class TransformerLayerTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(TransformerLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self, transformer_cls): test_layer = transformer_cls( @@ -36,7 +36,7 @@ def test_layer_creation(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -49,9 +49,9 @@ def test_layer_creation_with_mask(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -64,9 +64,9 @@ def test_layer_creation_with_incorrect_mask_fails(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length - 3)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length - 3)) with self.assertRaisesRegex(ValueError, 'When passing a mask tensor.*'): _ = test_layer([data_tensor, mask_tensor]) @@ -78,11 +78,11 @@ def test_layer_invocation(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -99,13 +99,13 @@ def test_layer_invocation_with_mask(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -147,7 +147,7 @@ def test_layer_output_range(self, transformer_cls): new_output_tensor, output_tensor[:, 0:1, :], atol=5e-5, rtol=0.003) def test_layer_invocation_with_float16_dtype(self, transformer_cls): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = transformer_cls( num_attention_heads=16, intermediate_size=2048, @@ -155,13 +155,13 @@ def test_layer_invocation_with_float16_dtype(self, transformer_cls): sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -179,11 +179,11 @@ def test_transform_with_initializer(self, transformer_cls): num_attention_heads=16, intermediate_size=2048, intermediate_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) sequence_length = 21 width = 256 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -193,12 +193,12 @@ def test_dynamic_layer_sequence(self, transformer_cls): num_attention_heads=16, intermediate_size=2048, intermediate_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). width = 256 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_length = 17 input_data = np.ones((1, input_length, width)) diff --git a/official/nlp/modeling/layers/transformer.py b/official/nlp/modeling/layers/transformer.py index f5a8ba18780..913622ff0bf 100644 --- a/official/nlp/modeling/layers/transformer.py +++ b/official/nlp/modeling/layers/transformer.py @@ -17,7 +17,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import attention @@ -26,7 +26,7 @@ from official.nlp.modeling.layers.util import tf_function_if_eager -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") class Transformer(transformer_encoder_block.TransformerEncoderBlock): """Transformer layer. @@ -144,7 +144,7 @@ def get_config(self): } -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable class CompiledTransformer(Transformer): @@ -153,8 +153,8 @@ def call(self, inputs): return super().call(inputs) -@tf.keras.utils.register_keras_serializable(package="Text") -class TransformerDecoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class TransformerDecoderBlock(tf_keras.layers.Layer): """Single transformer layer for decoder. It has three sub-layers: @@ -215,24 +215,24 @@ def __init__(self, super().__init__(**kwargs) self.num_attention_heads = num_attention_heads self.intermediate_size = intermediate_size - self.intermediate_activation = tf.keras.activations.get( + self.intermediate_activation = tf_keras.activations.get( intermediate_activation) self.dropout_rate = dropout_rate self.attention_dropout_rate = attention_dropout_rate self.multi_channel_cross_attention = multi_channel_cross_attention - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._intermediate_dropout = intermediate_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -279,7 +279,7 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="self_attention", **common_kwargs) - self.self_attention_output_dense = tf.keras.layers.EinsumDense( + self.self_attention_output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", @@ -287,10 +287,10 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="output", **common_kwargs) - self.self_attention_dropout = tf.keras.layers.Dropout( + self.self_attention_dropout = tf_keras.layers.Dropout( rate=self.dropout_rate) self.self_attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -308,17 +308,17 @@ def build(self, input_shape): name="attention/encdec", **common_kwargs) - self.encdec_attention_dropout = tf.keras.layers.Dropout( + self.encdec_attention_dropout = tf_keras.layers.Dropout( rate=self.dropout_rate) self.encdec_attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="attention/encdec_output_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype="float32")) # Feed-forward projection. - self.intermediate_dense = tf.keras.layers.EinsumDense( + self.intermediate_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self.intermediate_size), bias_axes="d", @@ -326,11 +326,11 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="intermediate", **common_kwargs) - self.intermediate_activation_layer = tf.keras.layers.Activation( + self.intermediate_activation_layer = tf_keras.layers.Activation( self.intermediate_activation) - self._intermediate_dropout_layer = tf.keras.layers.Dropout( + self._intermediate_dropout_layer = tf_keras.layers.Dropout( rate=self._intermediate_dropout) - self.output_dense = tf.keras.layers.EinsumDense( + self.output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", @@ -338,8 +338,8 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="output", **common_kwargs) - self.output_dropout = tf.keras.layers.Dropout(rate=self.dropout_rate) - self.output_layer_norm = tf.keras.layers.LayerNormalization( + self.output_dropout = tf_keras.layers.Dropout(rate=self.dropout_rate) + self.output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, diff --git a/official/nlp/modeling/layers/transformer_encoder_block.py b/official/nlp/modeling/layers/transformer_encoder_block.py index 23104abc241..1260fb3c496 100644 --- a/official/nlp/modeling/layers/transformer_encoder_block.py +++ b/official/nlp/modeling/layers/transformer_encoder_block.py @@ -15,19 +15,19 @@ """Keras-based TransformerEncoder block layer.""" from typing import Any, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import util -@tf.keras.utils.register_keras_serializable(package="Text") -class TransformerEncoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class TransformerEncoderBlock(tf_keras.layers.Layer): """TransformerEncoderBlock layer. This layer implements the Transformer Encoder from "Attention Is All You Need". (https://arxiv.org/abs/1706.03762), - which combines a `tf.keras.layers.MultiHeadAttention` layer with a + which combines a `tf_keras.layers.MultiHeadAttention` layer with a two-layer feedforward network. References: @@ -114,9 +114,9 @@ def __init__(self, attention_axes: axes over which the attention is applied. `None` means attention over all axes, but batch, heads, and features. use_query_residual: Toggle to execute residual connection after attention. - key_dim: `key_dim` for the `tf.keras.layers.MultiHeadAttention`. If + key_dim: `key_dim` for the `tf_keras.layers.MultiHeadAttention`. If `None`, we use the first `input_shape`'s last dim. - value_dim: `value_dim` for the `tf.keras.layers.MultiHeadAttention`. + value_dim: `value_dim` for the `tf_keras.layers.MultiHeadAttention`. output_last_dim: Final dimension of the output of this module. This also dictates the value for the final dimension of the multi-head-attention. When it's `None`, we use, in order of decreasing precedence, `key_dim` * @@ -144,13 +144,13 @@ def __init__(self, self._attention_dropout_rate = attention_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon @@ -162,7 +162,7 @@ def __init__(self, self._diff_q_kv_att_layer_norm = diff_q_kv_att_layer_norm self._return_attention_scores = return_attention_scores if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -202,7 +202,7 @@ def build(self, input_shape): activity_regularizer=self._activity_regularizer, kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._attention_layer = tf.keras.layers.MultiHeadAttention( + self._attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self._num_heads, key_dim=self._key_dim, value_dim=self._value_dim, @@ -214,12 +214,12 @@ def build(self, input_shape): output_shape=self._output_last_dim, name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout( + self._attention_dropout = tf_keras.layers.Dropout( rate=self._attention_dropout_rate) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -227,13 +227,13 @@ def build(self, input_shape): self._attention_layer_norm_kv = self._attention_layer_norm if self._diff_q_kv_att_layer_norm: self._attention_layer_norm_kv = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm_kv", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", @@ -241,17 +241,17 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, last_output_shape), bias_axes="d", @@ -259,10 +259,10 @@ def build(self, input_shape): kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout( + self._output_dropout = tf_keras.layers.Dropout( rate=self._output_dropout_rate) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, diff --git a/official/nlp/modeling/layers/transformer_encoder_block_test.py b/official/nlp/modeling/layers/transformer_encoder_block_test.py index c2ffa328463..ea711fd93ab 100644 --- a/official/nlp/modeling/layers/transformer_encoder_block_test.py +++ b/official/nlp/modeling/layers/transformer_encoder_block_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers.transformer_encoder_block import TransformerEncoderBlock @@ -27,7 +27,7 @@ class TransformerEncoderBlockLayerTest( def tearDown(self): super(TransformerEncoderBlockLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self, transformer_cls): test_layer = transformer_cls( @@ -35,7 +35,7 @@ def test_layer_creation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -46,9 +46,9 @@ def test_layer_creation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -59,11 +59,11 @@ def test_layer_invocation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -78,13 +78,13 @@ def test_layer_invocation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -185,19 +185,19 @@ def test_layer_output_range_with_pre_norm(self, transformer_cls): self.assertAllClose(new_output_tensor, output_tensor, atol=5e-5, rtol=0.003) def test_layer_invocation_with_float16_dtype(self, transformer_cls): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = transformer_cls( num_attention_heads=10, inner_dim=2048, inner_activation='relu') sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -215,11 +215,11 @@ def test_transform_with_initializer(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -229,12 +229,12 @@ def test_dynamic_layer_sequence(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_length = 17 input_data = np.ones((1, input_length, width)) @@ -247,7 +247,7 @@ def test_separate_qkv(self, transformer_cls): num_attention_heads=2, inner_dim=128, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Forward path. q_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) kv_tensor = tf.zeros([2, 8, 16], dtype=tf.float32) @@ -262,7 +262,7 @@ class TransformerEncoderBlockLayerTestWithoutParams( def tearDown(self): super(TransformerEncoderBlockLayerTestWithoutParams, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_raises_invalid_arg_error_when_q_kv_dims_are_different(self): test_layer = TransformerEncoderBlock( @@ -314,9 +314,9 @@ def test_use_query_residual_false_removes_add_op(self, norm_first): inner_dim=128, inner_activation='relu', norm_first=norm_first) - inputs = tf.keras.Input(shape=(None, None, 2)) + inputs = tf_keras.Input(shape=(None, None, 2)) outputs = layer(inputs) - tf.keras.Model(inputs=inputs, outputs=outputs) + tf_keras.Model(inputs=inputs, outputs=outputs) graph_without_res = tf.Graph() with graph_without_res.as_default(): @@ -326,9 +326,9 @@ def test_use_query_residual_false_removes_add_op(self, norm_first): inner_activation='relu', norm_first=norm_first, use_query_residual=False) - inputs = tf.keras.Input(shape=(None, None, 2)) + inputs = tf_keras.Input(shape=(None, None, 2)) outputs = layer(inputs) - tf.keras.Model(inputs=inputs, outputs=outputs) + tf_keras.Model(inputs=inputs, outputs=outputs) graph_with_res_names = {x.name for x in graph_with_res.get_operations()} graph_without_res_names = { x.name for x in graph_without_res.get_operations() @@ -420,7 +420,7 @@ def test_use_bias_norm_first(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) # Forward path. dummy_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) @@ -573,7 +573,7 @@ def test_get_config(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.), use_query_residual=False, key_dim=20, @@ -603,7 +603,7 @@ def test_several_attention_axes(self, attention_axes): num_cols = 13 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(num_rows, num_cols, width)) + data_tensor = tf_keras.Input(shape=(num_rows, num_cols, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -637,7 +637,7 @@ def test_dropout_config(self, output_dropout, attention_dropout, inner_dropout=inner_dropout) seq_len = 21 hidden_size = 512 - input_tensor = tf.keras.Input(shape=(seq_len, hidden_size)) + input_tensor = tf_keras.Input(shape=(seq_len, hidden_size)) _ = test_layer(input_tensor) true_output_dropout = test_layer._output_dropout.get_config()['rate'] @@ -668,7 +668,7 @@ def test_return_attention_scores(self, return_attention_scores): inner_activation='relu', return_attention_scores=return_attention_scores) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) expected_layer_output_shape = [None, sequence_length, width] diff --git a/official/nlp/modeling/layers/transformer_scaffold.py b/official/nlp/modeling/layers/transformer_scaffold.py index a928f8276aa..102c367e123 100644 --- a/official/nlp/modeling/layers/transformer_scaffold.py +++ b/official/nlp/modeling/layers/transformer_scaffold.py @@ -17,16 +17,16 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import attention from official.nlp.modeling.layers import util -@tf.keras.utils.register_keras_serializable(package="Text") +@tf_keras.utils.register_keras_serializable(package="Text") @gin.configurable -class TransformerScaffold(tf.keras.layers.Layer): +class TransformerScaffold(tf_keras.layers.Layer): """Transformer scaffold layer. This layer implements the Transformer from "Attention Is All You Need". @@ -117,12 +117,12 @@ def __init__(self, self._inner_activation = inner_activation self._attention_dropout_rate = attention_dropout_rate self._dropout_rate = dropout_rate - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) def build(self, input_shape): if isinstance(input_shape, tf.TensorShape): @@ -153,11 +153,11 @@ def build(self, input_shape): bias_constraint=self._bias_constraint) def get_layer_instance(instance_or_cls, config, default_config): - if isinstance(instance_or_cls, tf.keras.layers.Layer): + if isinstance(instance_or_cls, tf_keras.layers.Layer): return instance_or_cls elif isinstance(instance_or_cls, dict): return get_layer_instance( - tf.keras.utils.deserialize_keras_object(instance_or_cls), + tf_keras.utils.deserialize_keras_object(instance_or_cls), config, default_config, ) @@ -206,18 +206,18 @@ def get_layer_instance(instance_or_cls, config, default_config): # self._dropout_rate controls dropout rates at two places: # after attention, and after FFN. - self._attention_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) if self._feedforward_block is None: - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self._inner_dim), bias_axes="d", @@ -226,15 +226,15 @@ def get_layer_instance(instance_or_cls, config, default_config): self._kernel_initializer), bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", @@ -244,9 +244,9 @@ def get_layer_instance(instance_or_cls, config, default_config): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._output_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, diff --git a/official/nlp/modeling/layers/transformer_scaffold_test.py b/official/nlp/modeling/layers/transformer_scaffold_test.py index 95627dfc6d2..07c1b1d2710 100644 --- a/official/nlp/modeling/layers/transformer_scaffold_test.py +++ b/official/nlp/modeling/layers/transformer_scaffold_test.py @@ -15,7 +15,7 @@ """Tests for Keras-based transformer block layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import attention from official.nlp.modeling.layers import transformer_scaffold @@ -25,7 +25,7 @@ # at any point, the list passed to the config object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package='TestOnlyAttention') +@tf_keras.utils.register_keras_serializable(package='TestOnlyAttention') class ValidatedAttentionLayer(attention.MultiHeadAttention): def __init__(self, call_list, **kwargs): @@ -47,8 +47,8 @@ def get_config(self): # at any point, the list passed to the config object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package='TestOnlyFeedforward') -class ValidatedFeedforwardLayer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='TestOnlyFeedforward') +class ValidatedFeedforwardLayer(tf_keras.layers.Layer): def __init__(self, call_list, activation, **kwargs): super(ValidatedFeedforwardLayer, self).__init__(**kwargs) @@ -57,7 +57,7 @@ def __init__(self, call_list, activation, **kwargs): def build(self, input_shape): hidden_size = input_shape[-1] - self._feedforward_dense = tf.keras.layers.EinsumDense( + self._feedforward_dense = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -79,7 +79,7 @@ class TransformerLayerTest(tf.test.TestCase): def tearDown(self): super(TransformerLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self): sequence_length = 21 @@ -99,7 +99,7 @@ def test_layer_creation(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -134,7 +134,7 @@ def test_layer_creation_with_feedforward_cls(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -165,9 +165,9 @@ def test_layer_creation_with_mask(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -194,11 +194,11 @@ def test_layer_invocation(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -236,13 +236,13 @@ def test_layer_invocation_with_feedforward_cls(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -280,13 +280,13 @@ def test_layer_invocation_with_mask(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -304,7 +304,7 @@ def test_layer_invocation_with_mask(self): self.assertTrue(call_list[0], "The passed layer class wasn't instantiated.") def test_layer_invocation_with_float16_dtype(self): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') sequence_length = 21 width = 80 @@ -322,13 +322,13 @@ def test_layer_invocation_with_float16_dtype(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -361,10 +361,10 @@ def test_transform_with_initializer(self): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -392,13 +392,13 @@ def test_layer_restoration_from_config(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -417,7 +417,7 @@ def test_layer_restoration_from_config(self): # Create a new model from the old config, and copy the weights. These models # should have identical outputs. - new_model = tf.keras.Model.from_config(serialized_data) + new_model = tf_keras.Model.from_config(serialized_data) new_model.set_weights(model.get_weights()) output = new_model.predict([input_data, mask_data]) @@ -458,13 +458,13 @@ def test_layer_with_feedforward_cls_restoration_from_config(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -480,7 +480,7 @@ def test_layer_with_feedforward_cls_restoration_from_config(self): serialized_data = model.get_config() # Create a new model from the old config, and copy the weights. These models # should have identical outputs. - new_model = tf.keras.Model.from_config(serialized_data) + new_model = tf_keras.Model.from_config(serialized_data) new_model.set_weights(model.get_weights()) output = new_model.predict([input_data, mask_data]) diff --git a/official/nlp/modeling/layers/transformer_test.py b/official/nlp/modeling/layers/transformer_test.py index 61152cb4c06..f26e03f443b 100644 --- a/official/nlp/modeling/layers/transformer_test.py +++ b/official/nlp/modeling/layers/transformer_test.py @@ -15,7 +15,7 @@ """Tests for Keras-based transformer block layer.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.layers import transformer @@ -64,7 +64,7 @@ def test_use_bias_norm_first(self): norm_first=True, norm_epsilon=1e-6, intermediate_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) # Forward path. dummy_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) @@ -85,7 +85,7 @@ def test_get_config(self): norm_first=True, norm_epsilon=1e-6, intermediate_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) decoder_block_config = decoder_block.get_config() new_decoder_block = transformer.TransformerDecoderBlock.from_config( diff --git a/official/nlp/modeling/layers/transformer_xl.py b/official/nlp/modeling/layers/transformer_xl.py index 18ecfddc227..7b344ccc344 100644 --- a/official/nlp/modeling/layers/transformer_xl.py +++ b/official/nlp/modeling/layers/transformer_xl.py @@ -16,7 +16,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling.layers import relative_attention @@ -51,8 +51,8 @@ def _cache_memory(current_state, previous_state, memory_length, reuse_length=0): return tf.stop_gradient(new_mem) -@tf.keras.utils.register_keras_serializable(package="Text") -class TransformerXLBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class TransformerXLBlock(tf_keras.layers.Layer): """Transformer XL block. This implements a Transformer XL block from "Transformer-XL: Attentive @@ -151,32 +151,32 @@ def build(self, input_shape): use_bias=False, kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="rel_attn") - self._attention_dropout = tf.keras.layers.Dropout( + self._attention_dropout = tf_keras.layers.Dropout( rate=self._attention_dropout_rate) - self._attention_layer_norm = tf.keras.layers.LayerNormalization( + self._attention_layer_norm = tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32) - self._inner_dense = tf.keras.layers.EinsumDense( + self._inner_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self._inner_size), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="inner") - self._inner_activation_layer = tf.keras.layers.Activation( + self._inner_activation_layer = tf_keras.layers.Activation( self._inner_activation) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", name="output", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer)) - self._output_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon) @@ -319,7 +319,7 @@ def call(self, return attention_output -class TransformerXL(tf.keras.layers.Layer): +class TransformerXL(tf_keras.layers.Layer): """Transformer XL. This layer combines multiple Transformer XL blocks from "Transformer-XL: @@ -428,7 +428,7 @@ def __init__(self, kernel_initializer="variance_scaling", name="layer_%d" % i)) - self.output_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self.output_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) def get_config(self): config = { diff --git a/official/nlp/modeling/layers/transformer_xl_test.py b/official/nlp/modeling/layers/transformer_xl_test.py index e5836343f0e..f1f03b4d477 100644 --- a/official/nlp/modeling/layers/transformer_xl_test.py +++ b/official/nlp/modeling/layers/transformer_xl_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations @@ -231,7 +231,7 @@ def test_transformer_xl( inner_size=inner_size, dropout_rate=0., attention_dropout_rate=0., - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), two_stream=two_stream, tie_attention_biases=tie_attention_biases, memory_length=memory_length, @@ -256,7 +256,7 @@ def test_get_config(self): inner_size=12, dropout_rate=0., attention_dropout_rate=0., - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), two_stream=False, tie_attention_biases=True, memory_length=0, diff --git a/official/nlp/modeling/layers/util.py b/official/nlp/modeling/layers/util.py index 2f8259b0bd4..7ad2c31a8c6 100644 --- a/official/nlp/modeling/layers/util.py +++ b/official/nlp/modeling/layers/util.py @@ -16,7 +16,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras class TfFunctionIfEagerDecorator(object): diff --git a/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy.py b/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy.py index 651bdfa57c0..a1f961ec75d 100644 --- a/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy.py +++ b/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy.py @@ -14,7 +14,7 @@ """Weighted sparse categorical cross-entropy losses.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def _adjust_labels(labels, predictions): @@ -61,7 +61,7 @@ def loss(labels, predictions, weights=None, from_logits=False): labels, predictions = _adjust_labels(labels, predictions) _validate_rank(labels, predictions, weights) - example_losses = tf.keras.losses.sparse_categorical_crossentropy( + example_losses = tf_keras.losses.sparse_categorical_crossentropy( labels, predictions, from_logits=from_logits) if weights is None: 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 d9705e49b6f..b387eca194e 100644 --- a/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py +++ b/official/nlp/modeling/losses/weighted_sparse_categorical_crossentropy_test.py @@ -15,7 +15,7 @@ """Tests for masked LM loss.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling import networks @@ -39,9 +39,9 @@ def create_lm_model(self, hidden_size=hidden_size, num_attention_heads=4, ) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) _ = xformer_stack([word_ids, mask, type_ids]) # Create a maskedLM from the transformer stack. @@ -49,11 +49,11 @@ def create_lm_model(self, embedding_table=xformer_stack.get_embedding_table(), output=output) # Create a model from the masked LM layer. - lm_input_tensor = tf.keras.Input(shape=(sequence_length, hidden_size)) - masked_lm_positions = tf.keras.Input( + lm_input_tensor = tf_keras.Input(shape=(sequence_length, hidden_size)) + masked_lm_positions = tf_keras.Input( shape=(num_predictions,), dtype=tf.int32) output = test_layer(lm_input_tensor, masked_positions=masked_lm_positions) - return tf.keras.Model([lm_input_tensor, masked_lm_positions], output) + return tf_keras.Model([lm_input_tensor, masked_lm_positions], output) def test_loss_3d_input(self): """Test overall loss with a 3-dimensional input, from a masked LM.""" diff --git a/official/nlp/modeling/models/bert_classifier.py b/official/nlp/modeling/models/bert_classifier.py index 9643edc21ad..df326e1fed0 100644 --- a/official/nlp/modeling/models/bert_classifier.py +++ b/official/nlp/modeling/models/bert_classifier.py @@ -15,13 +15,13 @@ """BERT cls-token classifier.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class BertClassifier(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertClassifier(tf_keras.Model): """Classifier model based on a BERT-style transformer-based encoder. This is an implementation of the network structure surrounding a transformer @@ -79,7 +79,7 @@ def __init__(self, cls_inputs = outputs[1] else: cls_inputs = outputs['pooled_output'] - cls_inputs = tf.keras.layers.Dropout(rate=dropout_rate)(cls_inputs) + cls_inputs = tf_keras.layers.Dropout(rate=dropout_rate)(cls_inputs) else: outputs = network(inputs) if isinstance(outputs, list): diff --git a/official/nlp/modeling/models/bert_classifier_test.py b/official/nlp/modeling/models/bert_classifier_test.py index efbeec477d1..f504050d27e 100644 --- a/official/nlp/modeling/models/bert_classifier_test.py +++ b/official/nlp/modeling/models/bert_classifier_test.py @@ -15,7 +15,7 @@ """Tests for BERT trainer network.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling import networks @@ -39,9 +39,9 @@ def test_bert_trainer(self, num_classes, dict_outputs): test_network, num_classes=num_classes) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. cls_outs = bert_trainer_model([word_ids, mask, type_ids]) diff --git a/official/nlp/modeling/models/bert_pretrainer.py b/official/nlp/modeling/models/bert_pretrainer.py index f5d202e277c..b7170217389 100644 --- a/official/nlp/modeling/models/bert_pretrainer.py +++ b/official/nlp/modeling/models/bert_pretrainer.py @@ -20,15 +20,15 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers from official.nlp.modeling import networks -@tf.keras.utils.register_keras_serializable(package='Text') -class BertPretrainer(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertPretrainer(tf_keras.Model): """BERT pretraining model. [Note] Please use the new `BertPretrainerV2` for your projects. @@ -92,7 +92,7 @@ def __init__(self, 'requested num_token_predictions %s.' % (sequence_output_length, num_token_predictions)) - masked_lm_positions = tf.keras.layers.Input( + masked_lm_positions = tf_keras.layers.Input( shape=(num_token_predictions,), name='masked_lm_positions', dtype=tf.int32) @@ -158,9 +158,9 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') @gin.configurable -class BertPretrainerV2(tf.keras.Model): +class BertPretrainerV2(tf_keras.Model): """BERT pretraining model V2. Adds the masked language model head and optional classification heads upon the @@ -189,11 +189,11 @@ class BertPretrainerV2(tf.keras.Model): def __init__( self, - encoder_network: tf.keras.Model, + encoder_network: tf_keras.Model, mlm_activation=None, mlm_initializer='glorot_uniform', - classification_heads: Optional[List[tf.keras.layers.Layer]] = None, - customized_masked_lm: Optional[tf.keras.layers.Layer] = None, + classification_heads: Optional[List[tf_keras.layers.Layer]] = None, + customized_masked_lm: Optional[tf_keras.layers.Layer] = None, name: str = 'bert', **kwargs): super().__init__(self, name=name, **kwargs) @@ -218,7 +218,7 @@ def __init__( activation=mlm_activation, initializer=mlm_initializer, name='cls/predictions') - masked_lm_positions = tf.keras.layers.Input( + masked_lm_positions = tf_keras.layers.Input( shape=(None,), name='masked_lm_positions', dtype=tf.int32) if isinstance(inputs, dict): inputs['masked_lm_positions'] = masked_lm_positions diff --git a/official/nlp/modeling/models/bert_pretrainer_test.py b/official/nlp/modeling/models/bert_pretrainer_test.py index 012f0309757..007a4a7f8d9 100644 --- a/official/nlp/modeling/models/bert_pretrainer_test.py +++ b/official/nlp/modeling/models/bert_pretrainer_test.py @@ -16,7 +16,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling import networks @@ -44,10 +44,10 @@ def test_bert_pretrainer(self): num_token_predictions=num_token_predictions) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - masked_lm_positions = tf.keras.Input( + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + masked_lm_positions = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. @@ -141,11 +141,11 @@ def test_bert_pretrainerv2(self, dict_outputs, return_all_encoder_outputs, num_token_predictions = 20 # Create a set of 2-dimensional inputs (the first dimension is implicit). inputs = dict( - input_word_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32)) if has_masked_lm_positions: - inputs['masked_lm_positions'] = tf.keras.Input( + inputs['masked_lm_positions'] = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. @@ -193,10 +193,10 @@ def test_multiple_cls_outputs(self): num_token_predictions = 20 # Create a set of 2-dimensional inputs (the first dimension is implicit). inputs = dict( - input_word_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - masked_lm_positions=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + masked_lm_positions=tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32)) # Invoke the trainer model on the inputs. This causes the layer to be built. diff --git a/official/nlp/modeling/models/bert_span_labeler.py b/official/nlp/modeling/models/bert_span_labeler.py index 3a7d8254727..0cd18c303b2 100644 --- a/official/nlp/modeling/models/bert_span_labeler.py +++ b/official/nlp/modeling/models/bert_span_labeler.py @@ -15,13 +15,13 @@ """BERT Question Answering model.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks -@tf.keras.utils.register_keras_serializable(package='Text') -class BertSpanLabeler(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertSpanLabeler(tf_keras.Model): """Span labeler model based on a BERT-style transformer-based encoder. This is an implementation of the network structure surrounding a transformer @@ -80,10 +80,10 @@ def __init__(self, # Use identity layers wrapped in lambdas to explicitly name the output # tensors. This allows us to use string-keyed dicts in Keras fit/predict/ # evaluate calls. - start_logits = tf.keras.layers.Lambda( + start_logits = tf_keras.layers.Lambda( tf.identity, name='start_positions')( start_logits) - end_logits = tf.keras.layers.Lambda( + end_logits = tf_keras.layers.Lambda( tf.identity, name='end_positions')( end_logits) diff --git a/official/nlp/modeling/models/bert_span_labeler_test.py b/official/nlp/modeling/models/bert_span_labeler_test.py index 7ac25c23664..9af165526a0 100644 --- a/official/nlp/modeling/models/bert_span_labeler_test.py +++ b/official/nlp/modeling/models/bert_span_labeler_test.py @@ -15,7 +15,7 @@ """Tests for BERT trainer network.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks from official.nlp.modeling.models import bert_span_labeler @@ -36,9 +36,9 @@ def test_bert_trainer(self, dict_outputs): bert_trainer_model = bert_span_labeler.BertSpanLabeler(test_network) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. cls_outs = bert_trainer_model([word_ids, mask, type_ids]) diff --git a/official/nlp/modeling/models/bert_token_classifier.py b/official/nlp/modeling/models/bert_token_classifier.py index d10b749799e..549e0425bc8 100644 --- a/official/nlp/modeling/models/bert_token_classifier.py +++ b/official/nlp/modeling/models/bert_token_classifier.py @@ -15,11 +15,11 @@ """BERT token classifier.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras -@tf.keras.utils.register_keras_serializable(package='Text') -class BertTokenClassifier(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertTokenClassifier(tf_keras.Model): """Token classifier model based on a BERT-style transformer-based encoder. This is an implementation of the network structure surrounding a transformer @@ -68,10 +68,10 @@ def __init__(self, sequence_output = outputs[0] else: sequence_output = outputs['sequence_output'] - sequence_output = tf.keras.layers.Dropout(rate=dropout_rate)( + sequence_output = tf_keras.layers.Dropout(rate=dropout_rate)( sequence_output) - classifier = tf.keras.layers.Dense( + classifier = tf_keras.layers.Dense( num_classes, activation=None, kernel_initializer=initializer, @@ -81,7 +81,7 @@ def __init__(self, output_tensors = {'logits': logits} elif output == 'predictions': output_tensors = { - 'predictions': tf.keras.layers.Activation(tf.nn.log_softmax)(logits) + 'predictions': tf_keras.layers.Activation(tf.nn.log_softmax)(logits) } else: raise ValueError( diff --git a/official/nlp/modeling/models/bert_token_classifier_test.py b/official/nlp/modeling/models/bert_token_classifier_test.py index 0672d0c5050..af83c78f842 100644 --- a/official/nlp/modeling/models/bert_token_classifier_test.py +++ b/official/nlp/modeling/models/bert_token_classifier_test.py @@ -15,7 +15,7 @@ """Tests for BERT token classifier.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks from official.nlp.modeling.models import bert_token_classifier @@ -45,9 +45,9 @@ def test_bert_trainer(self, dict_outputs, output_encoder_outputs): output_encoder_outputs=output_encoder_outputs) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. outputs = bert_trainer_model([word_ids, mask, type_ids]) diff --git a/official/nlp/modeling/models/dual_encoder.py b/official/nlp/modeling/models/dual_encoder.py index 33583a13301..1fed679f261 100644 --- a/official/nlp/modeling/models/dual_encoder.py +++ b/official/nlp/modeling/models/dual_encoder.py @@ -15,13 +15,13 @@ """Trainer network for dual encoder style models.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class DualEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class DualEncoder(tf_keras.Model): """A dual encoder model based on a transformer-based encoder. This is an implementation of the dual encoder network structure based on the @@ -43,7 +43,7 @@ class DualEncoder(tf.keras.Model): """ def __init__(self, - network: tf.keras.Model, + network: tf_keras.Model, max_seq_length: int = 32, normalize: bool = True, logit_scale: float = 1.0, @@ -52,19 +52,19 @@ def __init__(self, **kwargs) -> None: if output == 'logits': - left_word_ids = tf.keras.layers.Input( + left_word_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='left_word_ids') - left_mask = tf.keras.layers.Input( + left_mask = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='left_mask') - left_type_ids = tf.keras.layers.Input( + left_type_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='left_type_ids') else: # Keep the consistant with legacy BERT hub module input names. - left_word_ids = tf.keras.layers.Input( + left_word_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_word_ids') - left_mask = tf.keras.layers.Input( + left_mask = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_mask') - left_type_ids = tf.keras.layers.Input( + left_type_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='input_type_ids') left_inputs = [left_word_ids, left_mask, left_type_ids] @@ -75,16 +75,16 @@ def __init__(self, left_sequence_output = left_outputs['sequence_output'] left_encoded = left_outputs['pooled_output'] if normalize: - left_encoded = tf.keras.layers.Lambda( + left_encoded = tf_keras.layers.Lambda( lambda x: tf.nn.l2_normalize(x, axis=1))( left_encoded) if output == 'logits': - right_word_ids = tf.keras.layers.Input( + right_word_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='right_word_ids') - right_mask = tf.keras.layers.Input( + right_mask = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='right_mask') - right_type_ids = tf.keras.layers.Input( + right_type_ids = tf_keras.layers.Input( shape=(max_seq_length,), dtype=tf.int32, name='right_type_ids') right_inputs = [right_word_ids, right_mask, right_type_ids] @@ -94,7 +94,7 @@ def __init__(self, else: right_encoded = right_outputs['pooled_output'] if normalize: - right_encoded = tf.keras.layers.Lambda( + right_encoded = tf_keras.layers.Lambda( lambda x: tf.nn.l2_normalize(x, axis=1))( right_encoded) diff --git a/official/nlp/modeling/models/dual_encoder_test.py b/official/nlp/modeling/models/dual_encoder_test.py index 61809b7c1a9..b8dc2324280 100644 --- a/official/nlp/modeling/models/dual_encoder_test.py +++ b/official/nlp/modeling/models/dual_encoder_test.py @@ -15,7 +15,7 @@ """Tests for dual encoder network.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks from official.nlp.modeling.models import dual_encoder @@ -40,13 +40,13 @@ def test_dual_encoder(self, hidden_size, output): test_network, max_seq_length=sequence_length, output=output) # Create a set of 2-dimensional inputs (the first dimension is implicit). - left_word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - left_mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - left_type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + left_word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + left_mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + left_type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - right_word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - right_mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - right_type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + right_word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + right_mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + right_type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) if output == 'logits': outputs = dual_encoder_model([ diff --git a/official/nlp/modeling/models/electra_pretrainer.py b/official/nlp/modeling/models/electra_pretrainer.py index 515e81d2a26..3e5331c591b 100644 --- a/official/nlp/modeling/models/electra_pretrainer.py +++ b/official/nlp/modeling/models/electra_pretrainer.py @@ -17,14 +17,14 @@ import copy -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class ElectraPretrainer(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class ElectraPretrainer(tf_keras.Model): """ELECTRA network training model. This is an implementation of the network structure described in "ELECTRA: @@ -104,12 +104,12 @@ def __init__(self, num_classes=num_classes, initializer=tf_utils.clone_initializer(mlm_initializer), name='generator_classification_head') - self.discriminator_projection = tf.keras.layers.Dense( + self.discriminator_projection = tf_keras.layers.Dense( units=discriminator_network.get_config()['hidden_size'], activation=mlm_activation, kernel_initializer=tf_utils.clone_initializer(mlm_initializer), name='discriminator_projection_head') - self.discriminator_head = tf.keras.layers.Dense( + self.discriminator_head = tf_keras.layers.Dense( units=1, kernel_initializer=tf_utils.clone_initializer(mlm_initializer)) diff --git a/official/nlp/modeling/models/electra_pretrainer_test.py b/official/nlp/modeling/models/electra_pretrainer_test.py index 9c330b84a05..15e24a11a91 100644 --- a/official/nlp/modeling/models/electra_pretrainer_test.py +++ b/official/nlp/modeling/models/electra_pretrainer_test.py @@ -14,7 +14,7 @@ """Tests for ELECTRA pre trainer network.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks from official.nlp.modeling.models import electra_pretrainer @@ -50,12 +50,12 @@ def test_electra_pretrainer(self): disallow_correct=True) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - lm_positions = tf.keras.Input( + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + lm_positions = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) - lm_ids = tf.keras.Input(shape=(num_token_predictions,), dtype=tf.int32) + lm_ids = tf_keras.Input(shape=(num_token_predictions,), dtype=tf.int32) inputs = { 'input_word_ids': word_ids, 'input_mask': mask, diff --git a/official/nlp/modeling/models/seq2seq_transformer.py b/official/nlp/modeling/models/seq2seq_transformer.py index 3fd607548a8..6a40040979b 100644 --- a/official/nlp/modeling/models/seq2seq_transformer.py +++ b/official/nlp/modeling/models/seq2seq_transformer.py @@ -19,7 +19,7 @@ import inspect import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers @@ -28,7 +28,7 @@ EOS_ID = 1 -class Seq2SeqTransformer(tf.keras.Model): +class Seq2SeqTransformer(tf_keras.Model): """Transformer model with Keras. Implemented as described in: https://arxiv.org/pdf/1706.03762.pdf @@ -89,8 +89,8 @@ def __init__(self, self.decoder_layer = decoder_layer self.position_embedding = layers.RelativePositionEmbedding( hidden_size=self._embedding_width) - self.encoder_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) - self.decoder_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self.encoder_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) + self.decoder_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) def get_config(self): config = { @@ -359,7 +359,7 @@ def symbols_to_logits_fn(ids, i, cache): return symbols_to_logits_fn -class TransformerEncoder(tf.keras.layers.Layer): +class TransformerEncoder(tf_keras.layers.Layer): """Transformer encoder. Transformer encoder is made up of N identical layers. Each layer is composed @@ -396,7 +396,7 @@ def __init__(self, layers is normalized. norm_epsilon: Epsilon value to initialize normalization layers. intermediate_dropout: Dropout probability for intermediate_dropout_layer. - **kwargs: key word arguemnts passed to tf.keras.layers.Layer. + **kwargs: key word arguemnts passed to tf_keras.layers.Layer. """ super(TransformerEncoder, self).__init__(**kwargs) @@ -428,7 +428,7 @@ def build(self, input_shape): inner_dropout=self._intermediate_dropout, attention_initializer=attention_initializer(input_shape[2]), name=("layer_%d" % i))) - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=self._norm_epsilon, dtype="float32") super(TransformerEncoder, self).build(input_shape) @@ -471,7 +471,7 @@ def call(self, encoder_inputs, attention_mask=None): return output_tensor -class TransformerDecoder(tf.keras.layers.Layer): +class TransformerDecoder(tf_keras.layers.Layer): """Transformer decoder. Like the encoder, the decoder is made up of N identical layers. @@ -516,7 +516,7 @@ def __init__(self, or a function that provides the class per layer. cross_attention_cls: An optional class to use for cross attention or a function that provides the class per layer. - **kwargs: key word arguemnts passed to tf.keras.layers.Layer. + **kwargs: key word arguemnts passed to tf_keras.layers.Layer. """ super(TransformerDecoder, self).__init__(**kwargs) self.num_layers = num_layers @@ -564,7 +564,7 @@ def _select_attention_cls(attention_cls, index): name=("layer_%d" % i), self_attention_cls=self_attention_cls, cross_attention_cls=cross_attention_cls)) - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=1e-6, dtype="float32") super(TransformerDecoder, self).build(input_shape) @@ -647,4 +647,4 @@ def attention_initializer(hidden_size): """Initializer for attention layers in Seq2SeqTransformer.""" hidden_size = int(hidden_size) limit = math.sqrt(6.0 / (hidden_size + hidden_size)) - return tf.keras.initializers.RandomUniform(minval=-limit, maxval=limit) + return tf_keras.initializers.RandomUniform(minval=-limit, maxval=limit) diff --git a/official/nlp/modeling/models/seq2seq_transformer_test.py b/official/nlp/modeling/models/seq2seq_transformer_test.py index 3e84adef588..533c4d76550 100644 --- a/official/nlp/modeling/models/seq2seq_transformer_test.py +++ b/official/nlp/modeling/models/seq2seq_transformer_test.py @@ -17,7 +17,7 @@ from absl import logging from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations diff --git a/official/nlp/modeling/models/t5.py b/official/nlp/modeling/models/t5.py index c701c73100f..561a25e88ac 100644 --- a/official/nlp/modeling/models/t5.py +++ b/official/nlp/modeling/models/t5.py @@ -28,7 +28,7 @@ from typing import Callable, Dict, Optional, Sequence, Text, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -157,7 +157,7 @@ def __init__(self, if embeddings_initializer: self.embed_init = embeddings_initializer else: - self.embed_init = tf.keras.initializers.TruncatedNormal(stddev=1.0) + self.embed_init = tf_keras.initializers.TruncatedNormal(stddev=1.0) with self.name_scope: self.embeddings = self.create_variable( "embedding", [self.vocab_size, self.features], @@ -224,7 +224,7 @@ def __init__(self, hidden_size: int, epsilon: float = 1e-6, **kwargs): self.weight = self.create_variable( "scale", [hidden_size], dtype=self.dtype, - initializer=tf.keras.initializers.Ones()) + initializer=tf_keras.initializers.Ones()) @tf.Module.with_name_scope def __call__(self, x): @@ -254,14 +254,14 @@ def __init__(self, self.use_bias = use_bias self.w_init = w_init if self.use_bias: - self.b_init = b_init if b_init else tf.keras.initializers.Zeros() + self.b_init = b_init if b_init else tf_keras.initializers.Zeros() elif b_init is not None: raise ValueError("When not using a bias the b_init must be None.") with self.name_scope: if self.w_init is None: stddev = 1 / math.sqrt(self.in_features) - self.w_init = tf.keras.initializers.HeNormal() + self.w_init = tf_keras.initializers.HeNormal() self.w = self.create_variable( "kernel", [self.in_features, self.out_features], @@ -322,13 +322,13 @@ def __init__(self, self.bias_shape = (self.out_features,) bias_rank = 1 if self.use_bias: - self.b_init = b_init or tf.keras.initializers.Zeros() + self.b_init = b_init or tf_keras.initializers.Zeros() elif b_init is not None: raise ValueError("When not using a bias the b_init must be None.") with self.name_scope: if self.w_init is None: - self.w_init = tf.keras.initializers.HeNormal() + self.w_init = tf_keras.initializers.HeNormal() self.w = self.create_variable( "kernel", @@ -1019,7 +1019,7 @@ class T5TransformerParams: relative_attention_num_buckets: int = 32 relative_attention_max_distance: int = 128 relative_embeddings_initializer: Optional[Initializer] = None - weight_initializer: Optional[Initializer] = (tf.keras.initializers.HeNormal()) + weight_initializer: Optional[Initializer] = (tf_keras.initializers.HeNormal()) bias_initializer: Optional[Initializer] = None rescale_query: bool = False bidirectional: bool = True diff --git a/official/nlp/modeling/models/t5_test.py b/official/nlp/modeling/models/t5_test.py index fa33898a704..bb37886bbd1 100644 --- a/official/nlp/modeling/models/t5_test.py +++ b/official/nlp/modeling/models/t5_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -62,7 +62,7 @@ def test_embed(self, dtype): features=4, compute_dtype=dtype, name="foo", - embeddings_initializer=tf.keras.initializers.Zeros()) + embeddings_initializer=tf_keras.initializers.Zeros()) self.assertAllClose(l(inputs), tf.zeros((2, 2, 4), dtype)) @parameterized.named_parameters(("bfloat16", tf.bfloat16), @@ -82,7 +82,7 @@ def test_linear(self, dtype): l = t5.Linear( in_features=4, out_features=4, - w_init=tf.keras.initializers.Ones(), + w_init=tf_keras.initializers.Ones(), name="foo") inputs = tf.ones((2, 4), dtype=dtype) outputs = l(inputs) @@ -97,7 +97,7 @@ def test_linear3d(self): out_features=4, num_heads=2, to_3d=True, - w_init=tf.keras.initializers.Ones(), + w_init=tf_keras.initializers.Ones(), name="foo") inputs = np.ones((batch_size, 2, 4), dtype=np.float32) self.assertEqual(l(inputs).shape, (batch_size, 2, 2, 4)) @@ -107,7 +107,7 @@ def test_linear3d(self): out_features=4, num_heads=2, to_3d=False, - w_init=tf.keras.initializers.Ones(), + w_init=tf_keras.initializers.Ones(), name="foo") inputs = np.ones((batch_size, 2, 2, 2), dtype=np.float32) self.assertEqual(l(inputs).shape, (batch_size, 2, 4)) @@ -140,14 +140,14 @@ def test_relative_position(self, dtype): l = t5.RelativePositionEmbedding( num_heads=4, bidirectional=False, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), compute_dtype=dtype, name="foo") self.assertEqual(l(4, 2).shape, (1, 4, 4, 2)) l = t5.RelativePositionEmbedding( num_heads=4, bidirectional=True, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), compute_dtype=dtype, name="bar") outputs = l(4, 2) @@ -172,7 +172,7 @@ def test_attention(self, distribution): pos_embed = t5.RelativePositionEmbedding( num_heads=4, bidirectional=False, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), name="pos_embed") position_bias = pos_embed(from_seq_length, from_seq_length) l = t5.MultiHeadAttention(d_model=4, d_kv=2, num_heads=4, dropout_rate=0.1) @@ -234,7 +234,7 @@ def test_attention_layers(self, distribution): pos_embed = t5.RelativePositionEmbedding( num_heads=head_size, bidirectional=False, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), name="pos_embed") l = t5.SelfAttention( d_model=4, d_kv=head_size, num_heads=num_heads, dropout_rate=0.1) @@ -302,7 +302,7 @@ def test_encoder_block(self): pos_embed = t5.RelativePositionEmbedding( num_heads=2, bidirectional=True, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), name="bar") attention_mask = t5.make_attention_mask( tf.ones((batch_size, from_seq_length)), @@ -322,7 +322,7 @@ def test_encdec_block(self): pos_embed = t5.RelativePositionEmbedding( num_heads=2, bidirectional=True, - embeddings_initializer=tf.keras.initializers.Ones(), + embeddings_initializer=tf_keras.initializers.Ones(), name="bar") encoder_decoder_mask = t5.make_attention_mask( tf.ones((batch_size, from_seq_length)), @@ -348,8 +348,8 @@ def test_encoder(self, dtype): num_heads=4, d_ff=16, vocab_size=10, - vocab_embeddings_initializer=tf.keras.initializers.Ones(), - relative_embeddings_initializer=tf.keras.initializers.Ones()) + vocab_embeddings_initializer=tf_keras.initializers.Ones(), + relative_embeddings_initializer=tf_keras.initializers.Ones()) encoder = t5.Encoder(config, compute_dtype=dtype) encoded = encoder(tf.zeros((4, 8), dtype=tf.int32)) self.assertEqual(encoded.shape, (4, 8, config.d_model)) @@ -364,8 +364,8 @@ def test_encoder_att_scores(self, return_attention_scores): num_heads=4, d_ff=16, vocab_size=10, - vocab_embeddings_initializer=tf.keras.initializers.Ones(), - relative_embeddings_initializer=tf.keras.initializers.Ones(), + vocab_embeddings_initializer=tf_keras.initializers.Ones(), + relative_embeddings_initializer=tf_keras.initializers.Ones(), return_attention_scores=return_attention_scores) encoder = t5.Encoder(config, compute_dtype=tf.float32) encoded = encoder(tf.zeros((4, 8), dtype=tf.int32)) @@ -388,8 +388,8 @@ def test_encoder_with_dense(self, dtype): num_heads=4, d_ff=16, vocab_size=10, - vocab_embeddings_initializer=tf.keras.initializers.Ones(), - relative_embeddings_initializer=tf.keras.initializers.Ones()) + vocab_embeddings_initializer=tf_keras.initializers.Ones(), + relative_embeddings_initializer=tf_keras.initializers.Ones()) encoder = t5.Encoder(config, compute_dtype=dtype) encoded = encoder( tf.zeros((4, 8), dtype=tf.int32), @@ -406,8 +406,8 @@ def test_encoder_only_dense(self, dtype): num_heads=4, d_ff=16, vocab_size=10, - vocab_embeddings_initializer=tf.keras.initializers.Ones(), - relative_embeddings_initializer=tf.keras.initializers.Ones()) + vocab_embeddings_initializer=tf_keras.initializers.Ones(), + relative_embeddings_initializer=tf_keras.initializers.Ones()) encoder = t5.Encoder(config, compute_dtype=dtype) encoded = encoder(dense_inputs=tf.ones((4, 2, 4), dtype=dtype)) self.assertEqual(encoded.shape, (4, 2, config.d_model)) @@ -421,8 +421,8 @@ def test_decoder(self): num_heads=4, d_ff=16, vocab_size=10, - vocab_embeddings_initializer=tf.keras.initializers.Ones(), - relative_embeddings_initializer=tf.keras.initializers.Ones()) + vocab_embeddings_initializer=tf_keras.initializers.Ones(), + relative_embeddings_initializer=tf_keras.initializers.Ones()) decoder = t5.Decoder(config) batch_size = 4 targets = tf.zeros((4, 8), dtype=tf.int32) diff --git a/official/nlp/modeling/models/xlnet.py b/official/nlp/modeling/models/xlnet.py index 33fdb4c7e31..1c066d6027d 100644 --- a/official/nlp/modeling/models/xlnet.py +++ b/official/nlp/modeling/models/xlnet.py @@ -17,13 +17,13 @@ from typing import Any, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling import networks -class XLNetMaskedLM(tf.keras.layers.Layer): +class XLNetMaskedLM(tf_keras.layers.Layer): """XLNet pretraining head.""" def __init__(self, @@ -40,12 +40,12 @@ def __init__(self, self._activation = activation def build(self, input_shape): - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( units=self._hidden_size, activation=self._activation, kernel_initializer=self._initializer, name='transform/dense') - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name='transform/LayerNorm') self.bias = self.add_weight( 'output_bias/bias', @@ -76,8 +76,8 @@ def get_config(self) -> Mapping[str, Any]: return dict(list(base_config.items()) + list(config.items())) -@tf.keras.utils.register_keras_serializable(package='Text') -class XLNetPretrainer(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class XLNetPretrainer(tf_keras.Model): """XLNet-based pretrainer. This is an implementation of the network structure surrounding a @@ -96,7 +96,7 @@ class XLNetPretrainer(tf.keras.Model): def __init__( self, - network: Union[tf.keras.layers.Layer, tf.keras.Model], + network: Union[tf_keras.layers.Layer, tf_keras.Model], mlm_activation=None, mlm_initializer='glorot_uniform', name: Optional[str] = None, @@ -152,8 +152,8 @@ def checkpoint_items(self): return dict(encoder=self._network) -@tf.keras.utils.register_keras_serializable(package='Text') -class XLNetClassifier(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class XLNetClassifier(tf_keras.Model): """Classifier model based on XLNet. This is an implementation of the network structure surrounding a @@ -176,9 +176,9 @@ class XLNetClassifier(tf.keras.Model): def __init__( self, - network: Union[tf.keras.layers.Layer, tf.keras.Model], + network: Union[tf_keras.layers.Layer, tf_keras.Model], num_classes: int, - initializer: tf.keras.initializers.Initializer = 'random_normal', + initializer: tf_keras.initializers.Initializer = 'random_normal', summary_type: str = 'last', dropout_rate: float = 0.1, head_name: str = 'sentence_prediction', # pytype: disable=annotation-type-mismatch # typed-keras @@ -244,8 +244,8 @@ def checkpoint_items(self): return items -@tf.keras.utils.register_keras_serializable(package='Text') -class XLNetSpanLabeler(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class XLNetSpanLabeler(tf_keras.Model): """Span labeler model based on XLNet. This is an implementation of the network structure surrounding a @@ -266,12 +266,12 @@ class XLNetSpanLabeler(tf.keras.Model): def __init__( self, - network: Union[tf.keras.layers.Layer, tf.keras.Model], + network: Union[tf_keras.layers.Layer, tf_keras.Model], start_n_top: int = 5, end_n_top: int = 5, dropout_rate: float = 0.1, - span_labeling_activation: tf.keras.initializers.Initializer = 'tanh', - initializer: tf.keras.initializers.Initializer = 'glorot_uniform', # pytype: disable=annotation-type-mismatch # typed-keras + span_labeling_activation: tf_keras.initializers.Initializer = 'tanh', + initializer: tf_keras.initializers.Initializer = 'glorot_uniform', # pytype: disable=annotation-type-mismatch # typed-keras **kwargs): super().__init__(**kwargs) self._config = { diff --git a/official/nlp/modeling/models/xlnet_test.py b/official/nlp/modeling/models/xlnet_test.py index 140e665ae8e..1c4fa8e1462 100644 --- a/official/nlp/modeling/models/xlnet_test.py +++ b/official/nlp/modeling/models/xlnet_test.py @@ -17,13 +17,13 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import networks from official.nlp.modeling.models import xlnet -def _get_xlnet_base() -> tf.keras.layers.Layer: +def _get_xlnet_base() -> tf_keras.layers.Layer: """Returns a trivial base XLNet model.""" return networks.XLNetBase( vocab_size=100, @@ -36,7 +36,7 @@ def _get_xlnet_base() -> tf.keras.layers.Layer: attention_dropout_rate=0., attention_type='bi', bi_data=True, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), two_stream=False, tie_attention_biases=True, reuse_length=0, @@ -70,19 +70,19 @@ def test_xlnet_trainer(self): # Create an XLNet trainer with the created network. xlnet_trainer_model = xlnet.XLNetPretrainer(network=xlnet_base) inputs = dict( - input_word_ids=tf.keras.layers.Input( + input_word_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_word_ids'), - input_type_ids=tf.keras.layers.Input( + input_type_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_type_ids'), - input_mask=tf.keras.layers.Input( + input_mask=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_mask'), - permutation_mask=tf.keras.layers.Input( + permutation_mask=tf_keras.layers.Input( shape=(seq_length, seq_length,), dtype=tf.int32, name='permutation_mask'), - target_mapping=tf.keras.layers.Input( + target_mapping=tf_keras.layers.Input( shape=(num_predictions, seq_length), dtype=tf.int32, name='target_mapping'), - masked_tokens=tf.keras.layers.Input( + masked_tokens=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='masked_tokens')) logits, _ = xlnet_trainer_model(inputs) @@ -152,20 +152,20 @@ def test_xlnet_trainer(self): xlnet_trainer_model = xlnet.XLNetClassifier( network=xlnet_base, num_classes=num_classes, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), summary_type='last', dropout_rate=0.1) inputs = dict( - input_word_ids=tf.keras.layers.Input( + input_word_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_word_ids'), - input_type_ids=tf.keras.layers.Input( + input_type_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_type_ids'), - input_mask=tf.keras.layers.Input( + input_mask=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_mask'), - permutation_mask=tf.keras.layers.Input( + permutation_mask=tf_keras.layers.Input( shape=(seq_length, seq_length,), dtype=tf.int32, name='permutation_mask'), - masked_tokens=tf.keras.layers.Input( + masked_tokens=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='masked_tokens')) logits = xlnet_trainer_model(inputs) @@ -184,7 +184,7 @@ def test_xlnet_tensor_call(self, num_classes): xlnet_trainer_model = xlnet.XLNetClassifier( network=xlnet_base, num_classes=num_classes, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), summary_type='last', dropout_rate=0.1) @@ -209,7 +209,7 @@ def test_serialize_deserialize(self): xlnet_trainer_model = xlnet.XLNetClassifier( network=xlnet_base, num_classes=2, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), summary_type='last', dropout_rate=0.1) @@ -240,21 +240,21 @@ def test_xlnet_trainer(self): network=xlnet_base, start_n_top=top_n, end_n_top=top_n, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), span_labeling_activation='tanh', dropout_rate=0.1) inputs = dict( - input_word_ids=tf.keras.layers.Input( + input_word_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_word_ids'), - input_type_ids=tf.keras.layers.Input( + input_type_ids=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_type_ids'), - input_mask=tf.keras.layers.Input( + input_mask=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_mask'), - paragraph_mask=tf.keras.layers.Input( + paragraph_mask=tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='paragraph_mask'), - class_index=tf.keras.layers.Input( + class_index=tf_keras.layers.Input( shape=(), dtype=tf.int32, name='class_index'), - start_positions=tf.keras.layers.Input( + start_positions=tf_keras.layers.Input( shape=(), dtype=tf.int32, name='start_positions')) outputs = xlnet_trainer_model(inputs) self.assertIsInstance(outputs, dict) @@ -300,7 +300,7 @@ def test_serialize_deserialize(self): network=xlnet_base, start_n_top=2, end_n_top=2, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), span_labeling_activation='tanh', dropout_rate=0.1) diff --git a/official/nlp/modeling/networks/albert_encoder.py b/official/nlp/modeling/networks/albert_encoder.py index 4e3abb3b274..1457f4f9a37 100644 --- a/official/nlp/modeling/networks/albert_encoder.py +++ b/official/nlp/modeling/networks/albert_encoder.py @@ -15,15 +15,15 @@ """ALBERT (https://arxiv.org/abs/1810.04805) text encoder network.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations from official.modeling import tf_utils from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class AlbertEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class AlbertEncoder(tf_keras.Model): """ALBERT (https://arxiv.org/abs/1810.04805) text encoder network. This network implements the encoder described in the paper "ALBERT: A Lite @@ -75,17 +75,17 @@ def __init__(self, activation=activations.gelu, dropout_rate=0.1, attention_dropout_rate=0.1, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), dict_outputs=False, **kwargs): - activation = tf.keras.activations.get(activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(activation) + initializer = tf_keras.initializers.get(initializer) - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') if embedding_width is None: @@ -112,19 +112,19 @@ def __init__(self, use_one_hot=True, name='type_embeddings')(type_ids)) - embeddings = tf.keras.layers.Add()( + embeddings = tf_keras.layers.Add()( [word_embeddings, position_embeddings, type_embeddings]) embeddings = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32)(embeddings)) - embeddings = (tf.keras.layers.Dropout(rate=dropout_rate)(embeddings)) + embeddings = (tf_keras.layers.Dropout(rate=dropout_rate)(embeddings)) # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. if embedding_width != hidden_size: - embeddings = tf.keras.layers.EinsumDense( + embeddings = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -151,7 +151,7 @@ def __init__(self, # like this will create a SliceOpLambda layer. This is better than a Lambda # layer with Python code, because that is fundamentally less portable. first_token_tensor = data[:, 0, :] - cls_output = tf.keras.layers.Dense( + cls_output = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -184,10 +184,10 @@ def __init__(self, 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'intermediate_size': intermediate_size, - 'activation': tf.keras.activations.serialize(activation), + 'activation': tf_keras.activations.serialize(activation), 'dropout_rate': dropout_rate, 'attention_dropout_rate': attention_dropout_rate, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), } # We are storing the config dict as a namedtuple here to ensure checkpoint diff --git a/official/nlp/modeling/networks/albert_encoder_test.py b/official/nlp/modeling/networks/albert_encoder_test.py index b9f3d0bf147..db1a2179afe 100644 --- a/official/nlp/modeling/networks/albert_encoder_test.py +++ b/official/nlp/modeling/networks/albert_encoder_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import albert_encoder @@ -25,7 +25,7 @@ class AlbertEncoderTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(AlbertEncoderTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( dict(testcase_name="default", expected_dtype=tf.float32), @@ -41,15 +41,15 @@ def test_network_creation(self, expected_dtype): num_attention_heads=2, num_layers=3) if expected_dtype == tf.float16: - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small TransformerEncoder for testing. test_network = albert_encoder.AlbertEncoder(**kwargs) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) expected_data_shape = [None, sequence_length, hidden_size] @@ -86,13 +86,13 @@ def test_network_invocation(self): num_layers=num_layers, type_vocab_size=num_types) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -114,7 +114,7 @@ def test_network_invocation(self): num_attention_heads=2, num_layers=num_layers, type_vocab_size=num_types) - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) _ = model.predict([word_id_data, mask_data, type_id_data]) # Tests dictionary outputs. @@ -140,7 +140,7 @@ def test_network_invocation(self): self.assertLen(dict_outputs["pooled_output"], num_layers) def test_serialize_deserialize(self): - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a network object that sets all of its config options. kwargs = dict( vocab_size=100, @@ -158,10 +158,10 @@ def test_serialize_deserialize(self): network = albert_encoder.AlbertEncoder(**kwargs) expected_config = dict(kwargs) - expected_config["activation"] = tf.keras.activations.serialize( - tf.keras.activations.get(expected_config["activation"])) - expected_config["initializer"] = tf.keras.initializers.serialize( - tf.keras.initializers.get(expected_config["initializer"])) + expected_config["activation"] = tf_keras.activations.serialize( + tf_keras.activations.get(expected_config["activation"])) + expected_config["initializer"] = tf_keras.initializers.serialize( + tf_keras.initializers.get(expected_config["initializer"])) self.assertEqual(network.get_config(), expected_config) # Create another network object from the first object's config. diff --git a/official/nlp/modeling/networks/bert_dense_encoder_test.py b/official/nlp/modeling/networks/bert_dense_encoder_test.py index 8156f9863b3..fdd8ccc5775 100644 --- a/official/nlp/modeling/networks/bert_dense_encoder_test.py +++ b/official/nlp/modeling/networks/bert_dense_encoder_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import bert_encoder @@ -26,7 +26,7 @@ class BertEncoderV2Test(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(BertEncoderV2Test, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") def test_dict_outputs_network_creation(self): hidden_size = 32 @@ -42,14 +42,14 @@ def test_dict_outputs_network_creation(self): with_dense_inputs=True, **kwargs) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) dict_outputs = test_network( @@ -65,7 +65,7 @@ def test_dict_outputs_network_creation(self): self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [ None, sequence_length + dense_sequence_length, hidden_size @@ -91,14 +91,14 @@ def test_dict_outputs_all_encoder_outputs_network_creation(self): dict_outputs=True, with_dense_inputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) dict_outputs = test_network( @@ -130,7 +130,7 @@ def test_dict_outputs_network_creation_with_float16_dtype(self): hidden_size = 32 sequence_length = 21 dense_sequence_length = 20 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = bert_encoder.BertEncoderV2( vocab_size=100, @@ -140,14 +140,14 @@ def test_dict_outputs_network_creation_with_float16_dtype(self): dict_outputs=True, with_dense_inputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) dict_outputs = test_network( @@ -196,13 +196,13 @@ def test_dict_outputs_network_invocation( with_dense_inputs=True, output_range=output_range) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) dict_outputs = test_network( @@ -217,7 +217,7 @@ def test_dict_outputs_network_invocation( pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model( + model = tf_keras.Model( [word_ids, mask, type_ids, dense_inputs, dense_mask, dense_type_ids], [data, pooled]) @@ -263,7 +263,7 @@ def test_dict_outputs_network_invocation( dense_type_ids=dense_type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model( + model = tf_keras.Model( [word_ids, mask, type_ids, dense_inputs, dense_mask, dense_type_ids], [data, pooled]) outputs = model.predict([ @@ -285,7 +285,7 @@ def test_dict_outputs_network_invocation( embedding_width=embedding_width, dict_outputs=True) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, embedding_width), dtype=tf.float32) dense_input_data = np.zeros( (batch_size, dense_sequence_length, embedding_width), dtype=float) @@ -300,7 +300,7 @@ def test_dict_outputs_network_invocation( dense_type_ids=dense_type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model( + model = tf_keras.Model( [word_ids, mask, type_ids, dense_inputs, dense_mask, dense_type_ids], [data, pooled]) outputs = model.predict([ @@ -322,14 +322,14 @@ def test_embeddings_as_inputs(self): num_layers=3, with_dense_inputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) test_network.build( diff --git a/official/nlp/modeling/networks/bert_encoder.py b/official/nlp/modeling/networks/bert_encoder.py index bd01a8eaecf..ec8f262de47 100644 --- a/official/nlp/modeling/networks/bert_encoder.py +++ b/official/nlp/modeling/networks/bert_encoder.py @@ -17,19 +17,19 @@ from typing import Any, Callable, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] _Activation = Union[str, Callable[..., Any]] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -@tf.keras.utils.register_keras_serializable(package='Text') -class BertEncoderV2(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertEncoderV2(tf_keras.layers.Layer): """Bi-directional Transformer-based encoder network. This network implements a bi-directional Transformer-based encoder as @@ -93,11 +93,11 @@ def __init__( inner_activation: _Activation = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, with_dense_inputs: bool = False, return_attention_scores: bool = False, @@ -119,8 +119,8 @@ def __init__( self._output_range = output_range - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -146,17 +146,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -180,7 +180,7 @@ def __init__( name='transformer/layer_%d' % i) self._transformer_layers.append(layer) - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -211,19 +211,19 @@ def __init__( } if with_dense_inputs: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_inputs=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_inputs=tf_keras.Input( shape=(None, embedding_width), dtype=tf.float32), - dense_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + dense_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) else: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32)) def call(self, inputs): word_embeddings = None @@ -331,8 +331,8 @@ def _get_embeddings(self, word_ids: tf.Tensor, type_ids: tf.Tensor, return word_embeddings + position_embeddings + type_embeddings -@tf.keras.utils.register_keras_serializable(package='Text') -class BertEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertEncoder(tf_keras.Model): """Bi-directional Transformer-based encoder network. This network implements a bi-directional Transformer-based encoder as @@ -401,10 +401,10 @@ def __init__( max_sequence_length=512, type_vocab_size=16, inner_dim=3072, - inner_activation=lambda x: tf.keras.activations.gelu(x, approximate=True), + inner_activation=lambda x: tf_keras.activations.gelu(x, approximate=True), output_dropout=0.1, attention_dropout=0.1, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), output_range=None, embedding_width=None, embedding_layer=None, @@ -432,14 +432,14 @@ def __init__( if 'attention_dropout_rate' in kwargs: attention_dropout = kwargs.pop('attention_dropout_rate') - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') if embedding_width is None: @@ -469,19 +469,19 @@ def __init__( name='type_embeddings') type_embeddings = type_embedding_layer(type_ids) - embeddings = tf.keras.layers.Add()( + embeddings = tf_keras.layers.Add()( [word_embeddings, position_embeddings, type_embeddings]) - embedding_norm_layer = tf.keras.layers.LayerNormalization( + embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) embeddings = embedding_norm_layer(embeddings) - embeddings = (tf.keras.layers.Dropout(rate=output_dropout)(embeddings)) + embeddings = (tf_keras.layers.Dropout(rate=output_dropout)(embeddings)) # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. if embedding_width != hidden_size: - embedding_projection = tf.keras.layers.EinsumDense( + embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -523,7 +523,7 @@ def __init__( # like this will create a SliceOpLambda layer. This is better than a Lambda # layer with Python code, because that is fundamentally less portable. first_token_tensor = last_encoder_output[:, 0, :] - pooler_layer = tf.keras.layers.Dense( + pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), diff --git a/official/nlp/modeling/networks/bert_encoder_test.py b/official/nlp/modeling/networks/bert_encoder_test.py index f0b0dbddef1..61a83cf99e8 100644 --- a/official/nlp/modeling/networks/bert_encoder_test.py +++ b/official/nlp/modeling/networks/bert_encoder_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import bert_encoder @@ -26,7 +26,7 @@ class BertEncoderTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(BertEncoderTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( ("encoder_v2", bert_encoder.BertEncoderV2), @@ -47,9 +47,9 @@ def test_dict_outputs_network_creation(self, encoder_cls): num_layers=3, **kwargs) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -57,7 +57,7 @@ def test_dict_outputs_network_creation(self, encoder_cls): self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -83,9 +83,9 @@ def test_dict_outputs_all_encoder_outputs_network_creation(self, encoder_cls): num_layers=3, dict_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) all_encoder_outputs = dict_outputs["encoder_outputs"] @@ -121,9 +121,9 @@ def test_dict_outputs_network_creation_return_attention_scores( return_attention_scores=True, dict_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) all_attention_outputs = dict_outputs["attention_scores"] @@ -145,7 +145,7 @@ def test_dict_outputs_network_creation_return_attention_scores( def test_dict_outputs_network_creation_with_float16_dtype(self, encoder_cls): hidden_size = 32 sequence_length = 21 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = encoder_cls( vocab_size=100, @@ -154,9 +154,9 @@ def test_dict_outputs_network_creation_with_float16_dtype(self, encoder_cls): num_layers=3, dict_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -194,16 +194,16 @@ def test_dict_outputs_network_invocation( output_range=output_range, dict_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -230,7 +230,7 @@ def test_dict_outputs_network_invocation( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[1], sequence_length) @@ -248,7 +248,7 @@ def test_dict_outputs_network_invocation( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -263,9 +263,9 @@ def test_embeddings_as_inputs(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) test_network.build( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) embeddings = test_network.get_embedding_layer()(word_ids) @@ -317,18 +317,18 @@ def test_serialize_deserialize(self): # Tests model saving/loading with SavedModel. model_path = self.get_temp_dir() + "/model" network.save(model_path) - _ = tf.keras.models.load_model(model_path) + _ = tf_keras.models.load_model(model_path) # Test model saving/loading with Keras V3. keras_path = self.get_temp_dir() + "/model.keras" network.save(keras_path) - _ = tf.keras.models.load_model(keras_path) + _ = tf_keras.models.load_model(keras_path) with self.subTest("BertEncoderV2"): new_net = bert_encoder.BertEncoderV2(**kwargs) inputs = new_net.inputs outputs = new_net(inputs) - network_v2 = tf.keras.Model(inputs=inputs, outputs=outputs) + network_v2 = tf_keras.Model(inputs=inputs, outputs=outputs) # Validate that the config can be forced to JSON. _ = network_v2.to_json() @@ -336,12 +336,12 @@ def test_serialize_deserialize(self): # Tests model saving/loading with SavedModel. model_path = self.get_temp_dir() + "/v2_model" network_v2.save(model_path) - _ = tf.keras.models.load_model(model_path) + _ = tf_keras.models.load_model(model_path) # Test model saving/loading with Keras V3. keras_path = self.get_temp_dir() + "/v2_model.keras" network_v2.save(keras_path) - _ = tf.keras.models.load_model(keras_path) + _ = tf_keras.models.load_model(keras_path) def test_network_creation(self): hidden_size = 32 @@ -353,14 +353,14 @@ def test_network_creation(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -411,9 +411,9 @@ def test_all_encoder_outputs_network_creation(self): num_layers=3, return_all_encoder_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) all_encoder_outputs, pooled = test_network([word_ids, mask, type_ids]) expected_data_shape = [None, sequence_length, hidden_size] @@ -440,9 +440,9 @@ def test_attention_scores_output_network_creation(self): num_layers=num_layers, return_attention_scores=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) _, _, all_attention_outputs = test_network([word_ids, mask, type_ids]) expected_data_shape = [ @@ -458,7 +458,7 @@ def test_attention_scores_output_network_creation(self): def test_network_creation_with_float16_dtype(self): hidden_size = 32 sequence_length = 21 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = bert_encoder.BertEncoder( vocab_size=100, @@ -466,9 +466,9 @@ def test_network_creation_with_float16_dtype(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) expected_data_shape = [None, sequence_length, hidden_size] @@ -499,13 +499,13 @@ def test_network_invocation(self, output_range, out_seq_len): type_vocab_size=num_types, output_range=output_range) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -528,7 +528,7 @@ def test_network_invocation(self, output_range, out_seq_len): num_layers=3, type_vocab_size=num_types) data, pooled = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[1], sequence_length) @@ -542,7 +542,7 @@ def test_network_invocation(self, output_range, out_seq_len): type_vocab_size=num_types, embedding_width=16) data, pooled = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -552,7 +552,7 @@ class BertEncoderV2CompatibilityTest(tf.test.TestCase): def tearDown(self): super().tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") def test_weights_forward_compatible(self): batch_size = 3 @@ -685,7 +685,7 @@ def test_keras_model_checkpoint_forward_compatible(self): old_net = bert_encoder.BertEncoder(**kwargs) inputs = old_net.inputs outputs = old_net(inputs) - old_model = tf.keras.Model(inputs=inputs, outputs=outputs) + old_model = tf_keras.Model(inputs=inputs, outputs=outputs) old_model_outputs = old_model(data) ckpt = tf.train.Checkpoint(net=old_model) path = ckpt.save(self.get_temp_dir()) @@ -693,7 +693,7 @@ def test_keras_model_checkpoint_forward_compatible(self): new_net = bert_encoder.BertEncoderV2(**kwargs) inputs = new_net.inputs outputs = new_net(inputs) - new_model = tf.keras.Model(inputs=inputs, outputs=outputs) + new_model = tf_keras.Model(inputs=inputs, outputs=outputs) new_ckpt = tf.train.Checkpoint(net=new_model) status = new_ckpt.restore(path) diff --git a/official/nlp/modeling/networks/classification.py b/official/nlp/modeling/networks/classification.py index 16eb1a9919e..00a55265b2f 100644 --- a/official/nlp/modeling/networks/classification.py +++ b/official/nlp/modeling/networks/classification.py @@ -15,12 +15,12 @@ """Classification and regression network.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.util import deprecation -@tf.keras.utils.register_keras_serializable(package='Text') -class Classification(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class Classification(tf_keras.Model): """Classification network head for BERT modeling. This network implements a simple classifier head based on a dense layer. If @@ -49,10 +49,10 @@ def __init__(self, output='logits', **kwargs): - cls_output = tf.keras.layers.Input( + cls_output = tf_keras.layers.Input( shape=(input_width,), name='cls_output', dtype=tf.float32) - logits = tf.keras.layers.Dense( + logits = tf_keras.layers.Dense( num_classes, activation=None, kernel_initializer=initializer, @@ -62,11 +62,11 @@ def __init__(self, if output == 'logits': output_tensors = logits elif output == 'predictions': - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == 'mixed_bfloat16': # b/158514794: bf16 is not stable with post-softmax cross-entropy. policy = tf.float32 - output_tensors = tf.keras.layers.Activation( + output_tensors = tf_keras.layers.Activation( tf.nn.log_softmax, dtype=policy)( logits) else: diff --git a/official/nlp/modeling/networks/classification_test.py b/official/nlp/modeling/networks/classification_test.py index d5cb3aa6e10..9f3b98227f8 100644 --- a/official/nlp/modeling/networks/classification_test.py +++ b/official/nlp/modeling/networks/classification_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import classification @@ -30,7 +30,7 @@ def test_network_creation(self, num_classes): test_object = classification.Classification( input_width=input_width, num_classes=num_classes) # Create a 2-dimensional input (the first dimension is implicit). - cls_data = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + cls_data = tf_keras.Input(shape=(input_width,), dtype=tf.float32) output = test_object(cls_data) # Validate that the outputs are of the expected shape. @@ -44,11 +44,11 @@ def test_network_invocation(self, num_classes): test_object = classification.Classification( input_width=input_width, num_classes=num_classes, output='predictions') # Create a 2-dimensional input (the first dimension is implicit). - cls_data = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + cls_data = tf_keras.Input(shape=(input_width,), dtype=tf.float32) output = test_object(cls_data) # Invoke the network as part of a Model. - model = tf.keras.Model(cls_data, output) + model = tf_keras.Model(cls_data, output) input_data = 10 * np.random.random_sample((3, input_width)) _ = model.predict(input_data) @@ -60,10 +60,10 @@ def test_network_invocation_with_internal_logits(self): input_width=input_width, num_classes=num_classes, output='predictions') # Create a 2-dimensional input (the first dimension is implicit). - cls_data = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + cls_data = tf_keras.Input(shape=(input_width,), dtype=tf.float32) output = test_object(cls_data) - model = tf.keras.Model(cls_data, output) - logits_model = tf.keras.Model(test_object.inputs, test_object.logits) + model = tf_keras.Model(cls_data, output) + logits_model = tf_keras.Model(test_object.inputs, test_object.logits) batch_size = 3 input_data = 10 * np.random.random_sample((batch_size, input_width)) @@ -76,9 +76,9 @@ def test_network_invocation_with_internal_logits(self): self.assertEqual(expected_output_shape, logits.shape) # Ensure that the logits, when softmaxed, create the outputs. - input_tensor = tf.keras.Input(expected_output_shape[1:]) - output_tensor = tf.keras.layers.Activation(tf.nn.log_softmax)(input_tensor) - softmax_model = tf.keras.Model(input_tensor, output_tensor) + input_tensor = tf_keras.Input(expected_output_shape[1:]) + output_tensor = tf_keras.layers.Activation(tf.nn.log_softmax)(input_tensor) + softmax_model = tf_keras.Model(input_tensor, output_tensor) calculated_softmax = softmax_model.predict(logits) self.assertAllClose(outputs, calculated_softmax) @@ -92,10 +92,10 @@ def test_network_invocation_with_internal_and_external_logits( input_width=input_width, num_classes=num_classes, output='logits') # Create a 2-dimensional input (the first dimension is implicit). - cls_data = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + cls_data = tf_keras.Input(shape=(input_width,), dtype=tf.float32) output = test_object(cls_data) - model = tf.keras.Model(cls_data, output) - logits_model = tf.keras.Model(test_object.inputs, test_object.logits) + model = tf_keras.Model(cls_data, output) + logits_model = tf_keras.Model(test_object.inputs, test_object.logits) batch_size = 3 input_data = 10 * np.random.random_sample((batch_size, input_width)) @@ -120,12 +120,12 @@ def test_network_invocation_with_logit_output(self): logit_object.set_weights(test_object.get_weights()) # Create a 2-dimensional input (the first dimension is implicit). - cls_data = tf.keras.Input(shape=(input_width,), dtype=tf.float32) + cls_data = tf_keras.Input(shape=(input_width,), dtype=tf.float32) output = test_object(cls_data) logit_output = logit_object(cls_data) - model = tf.keras.Model(cls_data, output) - logits_model = tf.keras.Model(cls_data, logit_output) + model = tf_keras.Model(cls_data, output) + logits_model = tf_keras.Model(cls_data, logit_output) batch_size = 3 input_data = 10 * np.random.random_sample((batch_size, input_width)) @@ -138,9 +138,9 @@ def test_network_invocation_with_logit_output(self): self.assertEqual(expected_output_shape, logits.shape) # Ensure that the logits, when softmaxed, create the outputs. - input_tensor = tf.keras.Input(expected_output_shape[1:]) - output_tensor = tf.keras.layers.Activation(tf.nn.log_softmax)(input_tensor) - softmax_model = tf.keras.Model(input_tensor, output_tensor) + input_tensor = tf_keras.Input(expected_output_shape[1:]) + output_tensor = tf_keras.layers.Activation(tf.nn.log_softmax)(input_tensor) + softmax_model = tf_keras.Model(input_tensor, output_tensor) calculated_softmax = softmax_model.predict(logits) self.assertAllClose(outputs, calculated_softmax) diff --git a/official/nlp/modeling/networks/encoder_scaffold.py b/official/nlp/modeling/networks/encoder_scaffold.py index 953b4afc304..fa55d8d6099 100644 --- a/official/nlp/modeling/networks/encoder_scaffold.py +++ b/official/nlp/modeling/networks/encoder_scaffold.py @@ -19,15 +19,15 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') +@tf_keras.utils.register_keras_serializable(package='Text') @gin.configurable -class EncoderScaffold(tf.keras.Model): +class EncoderScaffold(tf_keras.Model): """Bi-directional Transformer-based encoder network scaffold. This network allows users to flexibly implement an encoder similar to the one @@ -110,7 +110,7 @@ class or instance defines the inputs to this encoder and outputs (1) def __init__(self, pooled_output_dim, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), embedding_cls=None, embedding_cfg=None, @@ -143,11 +143,11 @@ def __init__(self, else: embedding_network = None seq_length = embedding_cfg.get('seq_length', None) - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(seq_length,), dtype=tf.int32, name='input_type_ids') inputs = [word_ids, mask, type_ids] @@ -174,10 +174,10 @@ def __init__(self, name='type_embeddings') type_embeddings = type_embedding_layer(type_ids) - embeddings = tf.keras.layers.Add()( + embeddings = tf_keras.layers.Add()( [word_embeddings, position_embeddings, type_embeddings]) - embedding_norm_layer = tf.keras.layers.LayerNormalization( + embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, @@ -185,7 +185,7 @@ def __init__(self, embeddings = embedding_norm_layer(embeddings) embeddings = ( - tf.keras.layers.Dropout( + tf_keras.layers.Dropout( rate=embedding_cfg['dropout_rate'])(embeddings)) mask_cfg = {} if mask_cfg is None else mask_cfg @@ -233,7 +233,7 @@ def __init__(self, if layer_norm_before_pooling: # Normalize the final output. - output_layer_norm = tf.keras.layers.LayerNormalization( + output_layer_norm = tf_keras.layers.LayerNormalization( name='final_layer_norm', axis=-1, epsilon=1e-12) @@ -244,9 +244,9 @@ def __init__(self, # like this will create a SliceOpLambda layer. This is better than a Lambda # layer with Python code, because that is fundamentally less portable. first_token_tensor = last_layer_output[:, 0, :] - pooler_layer_initializer = tf.keras.initializers.get( + pooler_layer_initializer = tf_keras.initializers.get( pooler_layer_initializer) - pooler_layer = tf.keras.layers.Dense( + pooler_layer = tf_keras.layers.Dense( units=pooled_output_dim, activation='tanh', kernel_initializer=pooler_layer_initializer, @@ -306,7 +306,7 @@ def get_config(self): config_dict = { 'num_hidden_instances': self._num_hidden_instances, 'pooled_output_dim': self._pooled_output_dim, - 'pooler_layer_initializer': tf.keras.initializers.serialize( + 'pooler_layer_initializer': tf_keras.initializers.serialize( self._pooler_layer_initializer), 'embedding_cls': self._embedding_network, 'embedding_cfg': self._embedding_cfg, @@ -327,7 +327,7 @@ def get_config(self): # `self._hidden_cfg` may contain `class`, e.g., when `hidden_cfg` is # `TransformerScaffold`, `attention_cls` argument can be a `class`. if inspect.isclass(v): - config_dict[cfg_name][k] = tf.keras.utils.get_registered_name(v) + config_dict[cfg_name][k] = tf_keras.utils.get_registered_name(v) else: config_dict[cfg_name][k] = v @@ -339,7 +339,7 @@ def get_config(self): for cls_name, cls in clss.items(): if inspect.isclass(cls): key = '{}_string'.format(cls_name) - config_dict[key] = tf.keras.utils.get_registered_name(cls) + config_dict[key] = tf_keras.utils.get_registered_name(cls) else: config_dict[cls_name] = cls @@ -352,7 +352,7 @@ def from_config(cls, config, custom_objects=None): for cls_name in cls_names: cls_string = '{}_string'.format(cls_name) if cls_string in config: - config[cls_name] = tf.keras.utils.get_registered_object( + config[cls_name] = tf_keras.utils.get_registered_object( config[cls_string], custom_objects=custom_objects) del config[cls_string] return cls(**config) diff --git a/official/nlp/modeling/networks/encoder_scaffold_test.py b/official/nlp/modeling/networks/encoder_scaffold_test.py index 9ce7d078521..594d939d428 100644 --- a/official/nlp/modeling/networks/encoder_scaffold_test.py +++ b/official/nlp/modeling/networks/encoder_scaffold_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations from official.nlp.modeling import layers @@ -27,7 +27,7 @@ # at any point, the list passed to the config object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package="TestOnly") +@tf_keras.utils.register_keras_serializable(package="TestOnly") class ValidatedTransformerLayer(layers.Transformer): def __init__(self, call_list, call_class=None, **kwargs): @@ -42,7 +42,7 @@ def call(self, inputs): def get_config(self): config = super(ValidatedTransformerLayer, self).get_config() config["call_list"] = self.list - config["call_class"] = tf.keras.utils.get_registered_name(self.call_class) + config["call_class"] = tf_keras.utils.get_registered_name(self.call_class) return config @@ -51,7 +51,7 @@ def get_config(self): # object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package="TestOnly") +@tf_keras.utils.register_keras_serializable(package="TestOnly") class ValidatedMaskLayer(layers.SelfAttentionMask): def __init__(self, call_list, call_class=None, **kwargs): @@ -66,12 +66,12 @@ def call(self, inputs, mask): def get_config(self): config = super(ValidatedMaskLayer, self).get_config() config["call_list"] = self.list - config["call_class"] = tf.keras.utils.get_registered_name(self.call_class) + config["call_class"] = tf_keras.utils.get_registered_name(self.call_class) return config -@tf.keras.utils.register_keras_serializable(package="TestLayerOnly") -class TestLayer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="TestLayerOnly") +class TestLayer(tf_keras.layers.Layer): pass @@ -79,7 +79,7 @@ class EncoderScaffoldLayerClassTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(EncoderScaffoldLayerClassTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( dict(testcase_name="only_final_output", return_all_layer_outputs=False), @@ -94,7 +94,7 @@ def test_network_creation(self, return_all_layer_outputs): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } @@ -111,7 +111,7 @@ def test_network_creation(self, return_all_layer_outputs): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), "call_list": call_list } @@ -124,7 +124,7 @@ def test_network_creation(self, return_all_layer_outputs): test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=num_hidden_instances, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cls=ValidatedTransformerLayer, hidden_cfg=hidden_cfg, @@ -134,9 +134,9 @@ def test_network_creation(self, return_all_layer_outputs): layer_norm_before_pooling=True, return_all_layer_outputs=return_all_layer_outputs) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) output_data, pooled = test_network([word_ids, mask, type_ids]) if return_all_layer_outputs: @@ -147,7 +147,7 @@ def test_network_creation(self, return_all_layer_outputs): data = output_data self.assertIsInstance(test_network.hidden_layers, list) self.assertLen(test_network.hidden_layers, num_hidden_instances) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -166,7 +166,7 @@ def test_network_creation(self, return_all_layer_outputs): self.assertTrue(hasattr(test_network, "_output_layer_norm")) def test_network_creation_with_float16_dtype(self): - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") hidden_size = 32 sequence_length = 21 embedding_cfg = { @@ -175,7 +175,7 @@ def test_network_creation_with_float16_dtype(self): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } hidden_cfg = { @@ -190,20 +190,20 @@ def test_network_creation_with_float16_dtype(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cfg=embedding_cfg) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) expected_data_shape = [None, sequence_length, hidden_size] @@ -227,7 +227,7 @@ def test_network_invocation(self): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } hidden_cfg = { @@ -242,26 +242,26 @@ def test_network_invocation(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cfg=embedding_cfg, dict_outputs=True) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) outputs = test_network([word_ids, mask, type_ids]) # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], outputs) + model = tf_keras.Model([word_ids, mask, type_ids], outputs) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -282,7 +282,7 @@ def test_network_invocation(self): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length * 2, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } hidden_cfg = { @@ -297,18 +297,18 @@ def test_network_invocation(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cfg=embedding_cfg) outputs = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], outputs) + model = tf_keras.Model([word_ids, mask, type_ids], outputs) _ = model.predict([word_id_data, mask_data, type_id_data]) def test_serialize_deserialize(self): @@ -321,7 +321,7 @@ def test_serialize_deserialize(self): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } hidden_cfg = { @@ -336,13 +336,13 @@ def test_serialize_deserialize(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cfg=embedding_cfg) @@ -358,20 +358,20 @@ def test_serialize_deserialize(self): self.assertAllEqual(network.get_config(), new_network.get_config()) -class Embeddings(tf.keras.Model): +class Embeddings(tf_keras.Model): def __init__(self, vocab_size, hidden_size): super().__init__() self.inputs = [ - tf.keras.layers.Input( + tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name="input_word_ids"), - tf.keras.layers.Input(shape=(None,), dtype=tf.int32, name="input_mask") + tf_keras.layers.Input(shape=(None,), dtype=tf.int32, name="input_mask") ] self.attention_mask = layers.SelfAttentionMask() self.embedding_layer = layers.OnDeviceEmbedding( vocab_size=vocab_size, embedding_width=hidden_size, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), name="word_embeddings") def call(self, inputs): @@ -404,25 +404,25 @@ def test_network_invocation(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cls=network) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask]) # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask], [data, pooled]) + model = tf_keras.Model([word_ids, mask], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -441,18 +441,18 @@ def test_serialize_deserialize(self): # will have 2 inputs (mask and word_ids) instead of 3, and won't use # positional embeddings. - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(sequence_length,), dtype=tf.int32, name="input_word_ids") - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(sequence_length,), dtype=tf.int32, name="input_mask") embedding_layer = layers.OnDeviceEmbedding( vocab_size=vocab_size, embedding_width=hidden_size, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), name="word_embeddings") word_embeddings = embedding_layer(word_ids) attention_mask = layers.SelfAttentionMask()([word_embeddings, mask]) - network = tf.keras.Model([word_ids, mask], + network = tf_keras.Model([word_ids, mask], [word_embeddings, attention_mask]) hidden_cfg = { @@ -467,14 +467,14 @@ def test_serialize_deserialize(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } # Create a small EncoderScaffold for testing. test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cfg=hidden_cfg, embedding_cls=network, @@ -491,14 +491,14 @@ def test_serialize_deserialize(self): self.assertAllEqual(test_network.get_config(), new_network.get_config()) # Create a model based off of the old and new networks: - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = new_network([word_ids, mask]) - new_model = tf.keras.Model([word_ids, mask], [data, pooled]) + new_model = tf_keras.Model([word_ids, mask], [data, pooled]) data, pooled = test_network([word_ids, mask]) - model = tf.keras.Model([word_ids, mask], [data, pooled]) + model = tf_keras.Model([word_ids, mask], [data, pooled]) # Copy the weights between models. new_model.set_weights(model.get_weights()) @@ -535,7 +535,7 @@ def test_network_invocation(self): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } @@ -552,7 +552,7 @@ def test_network_invocation(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), "call_list": call_list } @@ -569,20 +569,20 @@ def test_network_invocation(self): test_network = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cls=xformer, mask_cls=xmask, embedding_cfg=embedding_cfg) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = test_network([word_ids, mask, type_ids]) # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -619,7 +619,7 @@ def test_hidden_cls_list(self): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), "call_list": call_list } @@ -635,7 +635,7 @@ def test_hidden_cls_list(self): test_network_a = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), hidden_cls=xformer, mask_cls=xmask, @@ -644,7 +644,7 @@ def test_hidden_cls_list(self): test_network_b = encoder_scaffold.EncoderScaffold( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), mask_cls=xmask, embedding_cls=test_network_a.embedding_network, @@ -656,25 +656,25 @@ def test_hidden_cls_list(self): test_network_c = encoder_scaffold.EncoderScaffold( num_hidden_instances=2, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), mask_cls=xmask, embedding_cls=test_network_a.embedding_network, hidden_cls=hidden_layers) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) # Create model based off of network a: data_a, pooled_a = test_network_a([word_ids, mask]) - model_a = tf.keras.Model([word_ids, mask], [data_a, pooled_a]) + model_a = tf_keras.Model([word_ids, mask], [data_a, pooled_a]) # Create model based off of network b: data_b, pooled_b = test_network_b([word_ids, mask]) - model_b = tf.keras.Model([word_ids, mask], [data_b, pooled_b]) + model_b = tf_keras.Model([word_ids, mask], [data_b, pooled_b]) # Create model based off of network b: data_c, pooled_c = test_network_c([word_ids, mask]) - model_c = tf.keras.Model([word_ids, mask], [data_c, pooled_c]) + model_c = tf_keras.Model([word_ids, mask], [data_c, pooled_c]) batch_size = 3 word_id_data = np.random.randint( @@ -704,7 +704,7 @@ def test_serialize_deserialize(self, use_hidden_cls_instance): "hidden_size": hidden_size, "seq_length": sequence_length, "max_seq_length": sequence_length, - "initializer": tf.keras.initializers.TruncatedNormal(stddev=0.02), + "initializer": tf_keras.initializers.TruncatedNormal(stddev=0.02), "dropout_rate": 0.1, } @@ -721,7 +721,7 @@ def test_serialize_deserialize(self, use_hidden_cls_instance): "attention_dropout_rate": 0.1, "kernel_initializer": - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), "call_list": call_list, "call_class": @@ -734,7 +734,7 @@ def test_serialize_deserialize(self, use_hidden_cls_instance): kwargs = dict( num_hidden_instances=3, pooled_output_dim=hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=0.02), embedding_cfg=embedding_cfg) @@ -762,15 +762,15 @@ def test_serialize_deserialize(self, use_hidden_cls_instance): self.assertAllEqual(test_network.get_config(), new_network.get_config()) # Create a model based off of the old and new networks: - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) data, pooled = new_network([word_ids, mask, type_ids]) - new_model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + new_model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) data, pooled = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Copy the weights between models. new_model.set_weights(model.get_weights()) diff --git a/official/nlp/modeling/networks/fnet.py b/official/nlp/modeling/networks/fnet.py index 673bbeac756..0ffea66cccb 100644 --- a/official/nlp/modeling/networks/fnet.py +++ b/official/nlp/modeling/networks/fnet.py @@ -21,18 +21,18 @@ from typing import Any, Callable, Optional, Sequence, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers _Activation = Union[str, Callable[..., Any]] -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class FNet(tf.keras.layers.Layer): +class FNet(tf_keras.layers.Layer): """FNet encoder network. Based on ["FNet: Mixing Tokens with Fourier Transforms"] @@ -106,18 +106,18 @@ def __init__( inner_activation: _Activation = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, with_dense_inputs: bool = False, **kwargs): super().__init__(**kwargs) - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -133,10 +133,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -165,17 +165,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -213,7 +213,7 @@ def __init__( self._attention_mask_layer = layers.SelfAttentionMask( name='self_attention_mask') - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -223,22 +223,22 @@ def __init__( self.inputs = dict( # The total length of token ids and dense inputs still has to be # max_sequence_length. It is checked in call(). - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_inputs=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_inputs=tf_keras.Input( shape=(None, embedding_width), dtype=tf.float32), - dense_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + dense_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) else: self.inputs = dict( - input_word_ids=tf.keras.Input( + input_word_ids=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input( + input_mask=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input( + input_type_ids=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32)) self._max_sequence_length = max_sequence_length diff --git a/official/nlp/modeling/networks/fnet_test.py b/official/nlp/modeling/networks/fnet_test.py index 3854c2c6555..2f28bf2e931 100644 --- a/official/nlp/modeling/networks/fnet_test.py +++ b/official/nlp/modeling/networks/fnet_test.py @@ -17,7 +17,7 @@ from typing import Sequence from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling.networks import fnet @@ -27,7 +27,7 @@ class FNetTest(parameterized.TestCase, tf.test.TestCase): def tearDown(self): super(FNetTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( ("fnet", layers.MixingMechanism.FOURIER, ()), @@ -53,9 +53,9 @@ def test_network(self, mixing_mechanism: layers.MixingMechanism, attention_layers=attention_layers) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) @@ -64,7 +64,7 @@ def test_network(self, mixing_mechanism: layers.MixingMechanism, self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -86,9 +86,9 @@ def test_embeddings_as_inputs(self): num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) test_network.build( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) diff --git a/official/nlp/modeling/networks/funnel_transformer.py b/official/nlp/modeling/networks/funnel_transformer.py index 13fe556da7b..acde51a791c 100644 --- a/official/nlp/modeling/networks/funnel_transformer.py +++ b/official/nlp/modeling/networks/funnel_transformer.py @@ -20,12 +20,12 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] _Activation = Union[str, Callable[..., Any]] _MAX = 'max' @@ -42,12 +42,12 @@ 'ReZeroTransformer': layers.ReZeroTransformer } -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) def _get_policy_dtype(): try: - return tf.keras.mixed_precision.global_policy().compute_dtype or tf.float32 + return tf_keras.mixed_precision.global_policy().compute_dtype or tf.float32 except AttributeError: # tf1 has no attribute 'global_policy' return tf.float32 @@ -218,8 +218,8 @@ def create_2d_mask(from_length, mask): return attention_masks -@tf.keras.utils.register_keras_serializable(package='Text') -class FunnelTransformerEncoder(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class FunnelTransformerEncoder(tf_keras.layers.Layer): """Funnel Transformer-based encoder network. Funnel Transformer Implementation of https://arxiv.org/abs/2006.03236. @@ -287,15 +287,15 @@ def __init__( pool_type: str = _MAX, pool_stride: Union[int, Sequence[Union[int, float]]] = 2, unpool_length: int = 0, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02 ), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, transformer_cls: Union[ - str, tf.keras.layers.Layer + str, tf_keras.layers.Layer ] = layers.TransformerEncoderBlock, share_rezero: bool = False, append_dense_inputs: bool = False, @@ -307,8 +307,8 @@ def __init__( logging.warning('`output_range` is available as an argument for `call()`.' 'The `output_range` as __init__ argument is deprecated.') - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -334,17 +334,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -373,7 +373,7 @@ def __init__( name='transformer/layer_%d' % i) self._transformer_layers.append(layer) - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -395,11 +395,11 @@ def __init__( ' `pool_type`=`truncated_average`' ) - # TODO(crickwu): explore tf.keras.layers.serialize method. + # TODO(crickwu): explore tf_keras.layers.serialize method. if pool_type == _MAX: - pool_cls = tf.keras.layers.MaxPooling1D + pool_cls = tf_keras.layers.MaxPooling1D elif pool_type == _AVG: - pool_cls = tf.keras.layers.AveragePooling1D + pool_cls = tf_keras.layers.AveragePooling1D elif pool_type == _TRUNCATED_AVG: # TODO(b/203665205): unpool_length should be implemented. if unpool_length != 0: @@ -431,10 +431,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -448,9 +448,9 @@ def __init__( } self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32)) def call(self, inputs, output_range: Optional[tf.Tensor] = None): # inputs are [word_ids, mask, type_ids] @@ -507,7 +507,7 @@ def call(self, inputs, output_range: Optional[tf.Tensor] = None): position_embeddings = self._position_embedding_layer(word_embeddings) type_embeddings = self._type_embedding_layer(type_ids) - embeddings = tf.keras.layers.add( + embeddings = tf_keras.layers.add( [word_embeddings, position_embeddings, type_embeddings]) embeddings = self._embedding_norm_layer(embeddings) embeddings = self._embedding_dropout(embeddings) diff --git a/official/nlp/modeling/networks/funnel_transformer_test.py b/official/nlp/modeling/networks/funnel_transformer_test.py index 42effb71159..f31e4f0aa9e 100644 --- a/official/nlp/modeling/networks/funnel_transformer_test.py +++ b/official/nlp/modeling/networks/funnel_transformer_test.py @@ -16,12 +16,12 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import funnel_transformer -class SingleLayerModel(tf.keras.Model): +class SingleLayerModel(tf_keras.Model): def __init__(self, layer): super().__init__() @@ -35,7 +35,7 @@ class FunnelTransformerEncoderTest(parameterized.TestCase, tf.test.TestCase): def tearDown(self): super(FunnelTransformerEncoderTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( ("mix_truncated_avg_rezero", "mixed_float16", tf.float16, "truncated_avg", @@ -52,7 +52,7 @@ def tearDown(self): ("float32_avg", "float32", tf.float32, "avg", "TransformerEncoderBlock")) def test_network_creation(self, policy, pooled_dtype, pool_type, transformer_cls): - tf.keras.mixed_precision.set_global_policy(policy) + tf_keras.mixed_precision.set_global_policy(policy) hidden_size = 32 sequence_length = 21 @@ -70,16 +70,16 @@ def test_network_creation(self, policy, pooled_dtype, pool_type, unpool_length=0, transformer_cls=transformer_cls) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, num_layers) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) # Stride=2 compresses sequence length to half the size at each layer. # For pool_type = max or avg, @@ -106,7 +106,7 @@ def test_network_creation(self, policy, pooled_dtype, pool_type, ("dense_inputs_at_sequence_begin", False), ) def test_network_creation_dense(self, append_dense_inputs): - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") pool_type = "avg" hidden_size = 32 @@ -127,14 +127,14 @@ def test_network_creation_dense(self, append_dense_inputs): transformer_cls="TransformerEncoderBlock", append_dense_inputs=append_dense_inputs) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) - dense_inputs = tf.keras.Input( + dense_inputs = tf_keras.Input( shape=(dense_sequence_length, hidden_size), dtype=tf.float32) - dense_mask = tf.keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) - dense_type_ids = tf.keras.Input( + dense_mask = tf_keras.Input(shape=(dense_sequence_length,), dtype=tf.int32) + dense_type_ids = tf_keras.Input( shape=(dense_sequence_length,), dtype=tf.int32) dict_outputs = test_network( @@ -144,7 +144,7 @@ def test_network_creation_dense(self, append_dense_inputs): self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, num_layers) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) # Stride=2 compresses sequence length to half the size at each layer. # For pool_type = max or avg, @@ -175,9 +175,9 @@ def test_fractional_pooling(self, transformer_cls): max_sequence_length=sequence_length, unpool_length=0, transformer_cls=transformer_cls) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] @@ -221,9 +221,9 @@ def test_all_encoder_outputs_network_creation(self, pool_stride, pool_stride=pool_stride, unpool_length=unpool_length) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) all_encoder_outputs = dict_outputs["encoder_outputs"] pooled = dict_outputs["pooled_output"] @@ -275,16 +275,16 @@ def test_network_invocation( pool_stride=pool_stride, unpool_length=unpool_length) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids], output_range=output_range) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -311,7 +311,7 @@ def test_network_invocation( dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) expected_sequence_length = float(sequence_length) for _ in range(num_layers): @@ -331,7 +331,7 @@ def test_network_invocation( dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -348,9 +348,9 @@ def test_embeddings_as_inputs(self): pool_stride=2, ) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) test_network.build( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids) ) @@ -397,10 +397,10 @@ def test_serialize_deserialize(self): transformer_cls="TransformerEncoderBlock") network = funnel_transformer.FunnelTransformerEncoder(**kwargs) expected_config = dict(kwargs) - expected_config["inner_activation"] = tf.keras.activations.serialize( - tf.keras.activations.get(expected_config["inner_activation"])) - expected_config["initializer"] = tf.keras.initializers.serialize( - tf.keras.initializers.get(expected_config["initializer"])) + expected_config["inner_activation"] = tf_keras.activations.serialize( + tf_keras.activations.get(expected_config["inner_activation"])) + expected_config["initializer"] = tf_keras.initializers.serialize( + tf_keras.initializers.get(expected_config["initializer"])) self.assertEqual(network.get_config(), expected_config) # Create another network object from the first object's config. new_network = funnel_transformer.FunnelTransformerEncoder.from_config( @@ -425,7 +425,7 @@ def test_serialize_deserialize(self): _ = network_wrapper.predict([word_id_data, mask_data, type_id_data]) network_wrapper.save(model_path) - _ = tf.keras.models.load_model(model_path) + _ = tf_keras.models.load_model(model_path) if __name__ == "__main__": diff --git a/official/nlp/modeling/networks/mobile_bert_encoder.py b/official/nlp/modeling/networks/mobile_bert_encoder.py index 6fdb6df8280..65cff604a4f 100644 --- a/official/nlp/modeling/networks/mobile_bert_encoder.py +++ b/official/nlp/modeling/networks/mobile_bert_encoder.py @@ -14,13 +14,13 @@ """MobileBERT text encoder network.""" import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers @gin.configurable -class MobileBERTEncoder(tf.keras.Model): +class MobileBERTEncoder(tf_keras.Model): """A Keras functional API implementation for MobileBERT encoder.""" def __init__(self, @@ -84,7 +84,7 @@ def __init__(self, **kwargs: Other keyworded and arguments. """ self._self_setattr_tracking = False - initializer = tf.keras.initializers.TruncatedNormal( + initializer = tf_keras.initializers.TruncatedNormal( stddev=initializer_range) # layer instantiation @@ -117,11 +117,11 @@ def __init__(self, self._transformer_layers.append(transformer) # input tensor - input_ids = tf.keras.layers.Input( + input_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), dtype=input_mask_dtype, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') self.inputs = [input_ids, input_mask, type_ids] @@ -146,7 +146,7 @@ def __init__(self, first_token = tf.squeeze(prev_output[:, 0:1, :], axis=1) if classifier_activation: - self._pooler_layer = tf.keras.layers.EinsumDense( + self._pooler_layer = tf_keras.layers.EinsumDense( 'ab,bc->ac', output_shape=hidden_size, activation=tf.tanh, diff --git a/official/nlp/modeling/networks/mobile_bert_encoder_test.py b/official/nlp/modeling/networks/mobile_bert_encoder_test.py index 67e3c9a6f28..071eb132717 100644 --- a/official/nlp/modeling/networks/mobile_bert_encoder_test.py +++ b/official/nlp/modeling/networks/mobile_bert_encoder_test.py @@ -15,7 +15,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import models from official.nlp.modeling.networks import mobile_bert_encoder @@ -55,9 +55,9 @@ def test_mobilebert_encoder(self, act_fn, kq_shared_bottleneck, normalization_type=normalization_type, classifier_activation=use_pooler) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) outputs = test_network([word_ids, mask, type_ids]) layer_output, pooler_output = outputs['sequence_output'], outputs[ 'pooled_output'] @@ -80,9 +80,9 @@ def test_mobilebert_encoder_return_all_layer_output(self): hidden_size=hidden_size, num_blocks=num_blocks) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) outputs = test_network([word_ids, mask, type_ids]) all_layer_output = outputs['encoder_outputs'] @@ -101,11 +101,11 @@ def test_mobilebert_encoder_invocation(self, input_mask_dtype): num_blocks=num_blocks, input_mask_dtype=input_mask_dtype) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=input_mask_dtype) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=input_mask_dtype) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) outputs = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], outputs) + model = tf_keras.Model([word_ids, mask, type_ids], outputs) input_seq = generate_fake_input( batch_size=1, seq_len=sequence_length, vocab_size=vocab_size) @@ -130,11 +130,11 @@ def test_mobilebert_encoder_invocation_with_attention_score(self): hidden_size=hidden_size, num_blocks=num_blocks) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) outputs = test_network([word_ids, mask, type_ids]) - model = tf.keras.Model([word_ids, mask, type_ids], outputs) + model = tf_keras.Model([word_ids, mask, type_ids], outputs) input_seq = generate_fake_input( batch_size=1, seq_len=sequence_length, vocab_size=vocab_size) @@ -156,9 +156,9 @@ def test_mobilebert_encoder_for_downstream_task(self, task, prediction_shape): num_classes = 5 classifier = task(network=mobilebert_encoder, num_classes=num_classes) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) prediction = classifier([word_ids, mask, type_ids]) if task == models.BertTokenClassifier: prediction = prediction['logits'] diff --git a/official/nlp/modeling/networks/packed_sequence_embedding.py b/official/nlp/modeling/networks/packed_sequence_embedding.py index 0848953cd5b..1314ff712cc 100644 --- a/official/nlp/modeling/networks/packed_sequence_embedding.py +++ b/official/nlp/modeling/networks/packed_sequence_embedding.py @@ -15,14 +15,14 @@ """An embedding network supporting packed sequences and position ids.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class PackedSequenceEmbedding(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class PackedSequenceEmbedding(tf_keras.Model): """An embedding network supporting packed sequences and position ids. This network implements an embedding layer similar to the one described in @@ -60,7 +60,7 @@ def __init__(self, use_position_id=False, pack_multiple_sequences=False, **kwargs): - initializer = tf.keras.initializers.get(initializer) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size config_dict = { @@ -69,21 +69,21 @@ def __init__(self, 'embedding_width': embedding_width, 'hidden_size': hidden_size, 'max_seq_length': max_seq_length, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'dropout_rate': dropout_rate, 'use_position_id': use_position_id, 'pack_multiple_sequences': pack_multiple_sequences, } - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') inputs = [word_ids, mask, type_ids] if use_position_id: - position_ids = tf.keras.layers.Input( + position_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='position_ids') inputs.append(position_ids) else: @@ -118,17 +118,17 @@ def __init__(self, use_one_hot=True, name='type_embeddings')(type_ids)) - embeddings = tf.keras.layers.Add()( + embeddings = tf_keras.layers.Add()( [word_embeddings, position_embeddings, type_embeddings]) - embeddings = tf.keras.layers.LayerNormalization( + embeddings = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32)( embeddings) - embeddings = tf.keras.layers.Dropout( + embeddings = tf_keras.layers.Dropout( rate=dropout_rate, dtype=tf.float32)( embeddings) if embedding_width != hidden_size: - embeddings = tf.keras.layers.EinsumDense( + embeddings = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes=None, @@ -138,7 +138,7 @@ def __init__(self, attention_mask = layers.SelfAttentionMask()(embeddings, mask) if sub_seq_mask is not None: - attention_mask = tf.keras.layers.Lambda( + attention_mask = tf_keras.layers.Lambda( lambda x: x[0] * tf.cast(x[1], x[0].dtype))( [attention_mask, sub_seq_mask]) @@ -163,8 +163,8 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Text') -class PackedSequenceMask(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class PackedSequenceMask(tf_keras.layers.Layer): """A layer to create a mask to indicate multiple sub sequences.""" def call(self, input_ids): @@ -189,8 +189,8 @@ def call(self, input_ids): return tf.equal(seq_ids, tf.transpose(seq_ids, [0, 2, 1])) -@tf.keras.utils.register_keras_serializable(package='Text') -class PositionEmbeddingWithSubSeqMask(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class PositionEmbeddingWithSubSeqMask(tf_keras.layers.Layer): """Creates a positional embedding with sub-sequence masking. This layer creates a positional embedding as described in "BERT: Pre-training @@ -227,13 +227,13 @@ def __init__(self, 'If `use_dynamic_slicing` is True, `max_sequence_length` must be set.' ) self._max_sequence_length = max_sequence_length - self._initializer = tf.keras.initializers.get(initializer) + self._initializer = tf_keras.initializers.get(initializer) self._use_dynamic_slicing = use_dynamic_slicing def get_config(self): config = { 'max_sequence_length': self._max_sequence_length, - 'initializer': tf.keras.initializers.serialize(self._initializer), + 'initializer': tf_keras.initializers.serialize(self._initializer), 'use_dynamic_slicing': self._use_dynamic_slicing, } base_config = super().get_config() diff --git a/official/nlp/modeling/networks/packed_sequence_embedding_test.py b/official/nlp/modeling/networks/packed_sequence_embedding_test.py index 80eaba45943..7386cef39e5 100644 --- a/official/nlp/modeling/networks/packed_sequence_embedding_test.py +++ b/official/nlp/modeling/networks/packed_sequence_embedding_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import packed_sequence_embedding @@ -27,7 +27,7 @@ class PackedSequenceEmbeddingTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(PackedSequenceEmbeddingTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') @parameterized.parameters([ (True, True, True), @@ -39,7 +39,7 @@ def test_network_creation(self, use_position_id, pack_multiple_sequences, use_float16): """Validate that the Keras object can be created.""" if use_float16: - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') seq_length = 16 vocab_size = 100 max_position_embeddings = 32 @@ -52,7 +52,7 @@ def test_network_creation(self, use_position_id, pack_multiple_sequences, embedding_width=embedding_width, hidden_size=hidden_size, max_seq_length=max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), dropout_rate=0.1, use_position_id=use_position_id, pack_multiple_sequences=pack_multiple_sequences, @@ -60,22 +60,22 @@ def test_network_creation(self, use_position_id, pack_multiple_sequences, test_object = packed_sequence_embedding.PackedSequenceEmbedding( **embedding_cfg) - input_word_ids = tf.keras.Input(shape=(seq_length,), dtype=tf.int32) - input_mask = tf.keras.Input(shape=(seq_length,), dtype=tf.int32) - input_type_ids = tf.keras.Input(shape=(seq_length,), dtype=tf.int32) + input_word_ids = tf_keras.Input(shape=(seq_length,), dtype=tf.int32) + input_mask = tf_keras.Input(shape=(seq_length,), dtype=tf.int32) + input_type_ids = tf_keras.Input(shape=(seq_length,), dtype=tf.int32) network_inputs = { 'input_word_ids': input_word_ids, 'input_mask': input_mask, 'input_type_ids': input_type_ids, } if use_position_id: - network_inputs['position_ids'] = tf.keras.Input( + network_inputs['position_ids'] = tf_keras.Input( shape=(seq_length,), dtype=tf.int32) embedding, mask = test_object(network_inputs) # Create a model based off of this network: - model = tf.keras.Model(network_inputs, [embedding, mask]) + model = tf_keras.Model(network_inputs, [embedding, mask]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -99,7 +99,7 @@ def test_network_creation(self, use_position_id, pack_multiple_sequences, self.assertAllEqual(expected_attention_mask_shape, attention_mask.shape) def test_serialize_deserialize(self): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') # Create a network object that sets all of its config options. embedding_cfg = dict( vocab_size=100, @@ -107,7 +107,7 @@ def test_serialize_deserialize(self): embedding_width=64, hidden_size=64, max_seq_length=32, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), dropout_rate=0.1, use_position_id=True, pack_multiple_sequences=False, @@ -115,8 +115,8 @@ def test_serialize_deserialize(self): network = packed_sequence_embedding.PackedSequenceEmbedding(**embedding_cfg) expected_config = dict(embedding_cfg) - expected_config['initializer'] = tf.keras.initializers.serialize( - tf.keras.initializers.get(expected_config['initializer'])) + expected_config['initializer'] = tf_keras.initializers.serialize( + tf_keras.initializers.get(expected_config['initializer'])) self.assertEqual(network.get_config(), expected_config) # Create another network object from the first object's config. diff --git a/official/nlp/modeling/networks/span_labeling.py b/official/nlp/modeling/networks/span_labeling.py index 6eef3b1ebd6..d3a85d8714a 100644 --- a/official/nlp/modeling/networks/span_labeling.py +++ b/official/nlp/modeling/networks/span_labeling.py @@ -15,7 +15,7 @@ """Span labeling network.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -26,8 +26,8 @@ def _apply_paragraph_mask(logits, paragraph_mask): return tf.nn.log_softmax(masked_logits, -1), masked_logits -@tf.keras.utils.register_keras_serializable(package='Text') -class SpanLabeling(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class SpanLabeling(tf_keras.Model): """Span labeling network head for BERT modeling. This network implements a simple single-span labeler based on a dense layer. @@ -50,10 +50,10 @@ def __init__(self, output='logits', **kwargs): - sequence_data = tf.keras.layers.Input( + sequence_data = tf_keras.layers.Input( shape=(None, input_width), name='sequence_data', dtype=tf.float32) - intermediate_logits = tf.keras.layers.Dense( + intermediate_logits = tf_keras.layers.Dense( 2, # This layer predicts start location and end location. activation=activation, kernel_initializer=initializer, @@ -61,9 +61,9 @@ def __init__(self, sequence_data) start_logits, end_logits = self._split_output_tensor(intermediate_logits) - start_predictions = tf.keras.layers.Activation(tf.nn.log_softmax)( + start_predictions = tf_keras.layers.Activation(tf.nn.log_softmax)( start_logits) - end_predictions = tf.keras.layers.Activation(tf.nn.log_softmax)(end_logits) + end_predictions = tf_keras.layers.Activation(tf.nn.log_softmax)(end_logits) if output == 'logits': output_tensors = [start_logits, end_logits] @@ -111,7 +111,7 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -class XLNetSpanLabeling(tf.keras.layers.Layer): +class XLNetSpanLabeling(tf_keras.layers.Layer): """Span labeling network head for XLNet on SQuAD2.0. This networks implements a span-labeler based on dense layers and question @@ -156,31 +156,31 @@ def __init__(self, raise ValueError('`start_n_top` must be greater than 1.') self._start_n_top = start_n_top self._end_n_top = end_n_top - self.start_logits_dense = tf.keras.layers.Dense( + self.start_logits_dense = tf_keras.layers.Dense( units=1, kernel_initializer=tf_utils.clone_initializer(initializer), name='predictions/transform/start_logits') - self.end_logits_inner_dense = tf.keras.layers.Dense( + self.end_logits_inner_dense = tf_keras.layers.Dense( units=input_width, kernel_initializer=tf_utils.clone_initializer(initializer), activation=activation, name='predictions/transform/end_logits/inner') - self.end_logits_layer_norm = tf.keras.layers.LayerNormalization( + self.end_logits_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name='predictions/transform/end_logits/layernorm') - self.end_logits_output_dense = tf.keras.layers.Dense( + self.end_logits_output_dense = tf_keras.layers.Dense( units=1, kernel_initializer=tf_utils.clone_initializer(initializer), name='predictions/transform/end_logits/output') - self.answer_logits_inner = tf.keras.layers.Dense( + self.answer_logits_inner = tf_keras.layers.Dense( units=input_width, kernel_initializer=tf_utils.clone_initializer(initializer), activation=activation, name='predictions/transform/answer_logits/inner') - self.answer_logits_dropout = tf.keras.layers.Dropout(rate=dropout_rate) - self.answer_logits_output = tf.keras.layers.Dense( + self.answer_logits_dropout = tf_keras.layers.Dropout(rate=dropout_rate) + self.answer_logits_output = tf_keras.layers.Dense( units=1, kernel_initializer=tf_utils.clone_initializer(initializer), use_bias=False, diff --git a/official/nlp/modeling/networks/span_labeling_test.py b/official/nlp/modeling/networks/span_labeling_test.py index 93b176b4a75..5aff0803f30 100644 --- a/official/nlp/modeling/networks/span_labeling_test.py +++ b/official/nlp/modeling/networks/span_labeling_test.py @@ -14,7 +14,7 @@ """Tests for span_labeling network.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import span_labeling @@ -28,7 +28,7 @@ def test_network_creation(self): test_network = span_labeling.SpanLabeling( input_width=input_width, output='predictions') # Create a 3-dimensional input (the first dimension is implicit). - sequence_data = tf.keras.Input( + sequence_data = tf_keras.Input( shape=(sequence_length, input_width), dtype=tf.float32) start_outputs, end_outputs = test_network(sequence_data) @@ -44,10 +44,10 @@ def test_network_invocation(self): test_network = span_labeling.SpanLabeling(input_width=input_width) # Create a 3-dimensional input (the first dimension is implicit). - sequence_data = tf.keras.Input( + sequence_data = tf_keras.Input( shape=(sequence_length, input_width), dtype=tf.float32) outputs = test_network(sequence_data) - model = tf.keras.Model(sequence_data, outputs) + model = tf_keras.Model(sequence_data, outputs) # Invoke the network as part of a Model. batch_size = 3 @@ -67,11 +67,11 @@ def test_network_invocation_with_internal_logit_output(self): test_network = span_labeling.SpanLabeling( input_width=input_width, output='predictions') # Create a 3-dimensional input (the first dimension is implicit). - sequence_data = tf.keras.Input( + sequence_data = tf_keras.Input( shape=(sequence_length, input_width), dtype=tf.float32) output = test_network(sequence_data) - model = tf.keras.Model(sequence_data, output) - logit_model = tf.keras.Model( + model = tf_keras.Model(sequence_data, output) + logit_model = tf_keras.Model( test_network.inputs, [test_network.start_logits, test_network.end_logits]) @@ -89,9 +89,9 @@ def test_network_invocation_with_internal_logit_output(self): self.assertEqual(expected_output_shape, end_logits.shape) # Ensure that the logits, when softmaxed, create the outputs. - input_tensor = tf.keras.Input(expected_output_shape[1:]) - output_tensor = tf.keras.layers.Activation(tf.nn.log_softmax)(input_tensor) - softmax_model = tf.keras.Model(input_tensor, output_tensor) + input_tensor = tf_keras.Input(expected_output_shape[1:]) + output_tensor = tf_keras.layers.Activation(tf.nn.log_softmax)(input_tensor) + softmax_model = tf_keras.Model(input_tensor, output_tensor) start_softmax = softmax_model.predict(start_logits) self.assertAllClose(start_outputs, start_softmax) @@ -109,12 +109,12 @@ def test_network_invocation_with_external_logit_output(self): logit_network.set_weights(test_network.get_weights()) # Create a 3-dimensional input (the first dimension is implicit). - sequence_data = tf.keras.Input( + sequence_data = tf_keras.Input( shape=(sequence_length, input_width), dtype=tf.float32) output = test_network(sequence_data) logit_output = logit_network(sequence_data) - model = tf.keras.Model(sequence_data, output) - logit_model = tf.keras.Model(sequence_data, logit_output) + model = tf_keras.Model(sequence_data, output) + logit_model = tf_keras.Model(sequence_data, logit_output) batch_size = 3 input_data = 10 * np.random.random_sample( @@ -130,9 +130,9 @@ def test_network_invocation_with_external_logit_output(self): self.assertEqual(expected_output_shape, end_logits.shape) # Ensure that the logits, when softmaxed, create the outputs. - input_tensor = tf.keras.Input(expected_output_shape[1:]) - output_tensor = tf.keras.layers.Activation(tf.nn.log_softmax)(input_tensor) - softmax_model = tf.keras.Model(input_tensor, output_tensor) + input_tensor = tf_keras.Input(expected_output_shape[1:]) + output_tensor = tf_keras.layers.Activation(tf.nn.log_softmax)(input_tensor) + softmax_model = tf_keras.Model(input_tensor, output_tensor) start_softmax = softmax_model.predict(start_logits) self.assertAllClose(start_outputs, start_softmax) @@ -228,11 +228,11 @@ def test_subclass_invocation(self): hidden_size = 4 batch_size = 2 - sequence_data = tf.keras.Input(shape=(seq_length, hidden_size), + sequence_data = tf_keras.Input(shape=(seq_length, hidden_size), dtype=tf.float32) - class_index = tf.keras.Input(shape=(), dtype=tf.uint8) - paragraph_mask = tf.keras.Input(shape=(seq_length), dtype=tf.float32) - start_positions = tf.keras.Input(shape=(), dtype=tf.int32) + class_index = tf_keras.Input(shape=(), dtype=tf.uint8) + paragraph_mask = tf_keras.Input(shape=(seq_length), dtype=tf.float32) + start_positions = tf_keras.Input(shape=(), dtype=tf.int32) layer = span_labeling.XLNetSpanLabeling( input_width=hidden_size, @@ -246,7 +246,7 @@ def test_subclass_invocation(self): class_index=class_index, paragraph_mask=paragraph_mask, start_positions=start_positions) - model = tf.keras.Model( + model = tf_keras.Model( inputs={ 'sequence_data': sequence_data, 'class_index': class_index, diff --git a/official/nlp/modeling/networks/sparse_mixer.py b/official/nlp/modeling/networks/sparse_mixer.py index 12f05960dc3..623a2cea467 100644 --- a/official/nlp/modeling/networks/sparse_mixer.py +++ b/official/nlp/modeling/networks/sparse_mixer.py @@ -21,18 +21,18 @@ from typing import Any, Callable, Optional, Sequence, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers _Activation = Union[str, Callable[..., Any]] -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class SparseMixer(tf.keras.layers.Layer): +class SparseMixer(tf_keras.layers.Layer): """Sparse Mixer encoder network. Based on ["Sparse Mixers: Combining MoE and Mixing to build a more efficient @@ -134,19 +134,19 @@ def __init__( inner_activation: _Activation = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, with_dense_inputs: bool = False, export_metrics: bool = True, **kwargs): super().__init__(**kwargs) - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -167,10 +167,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -200,17 +200,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -269,7 +269,7 @@ def __init__( self._attention_mask_layer = layers.SelfAttentionMask( name='self_attention_mask') - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -279,21 +279,21 @@ def __init__( self.inputs = dict( # The total length of token ids and dense inputs still has to be # max_sequence_length. It is checked in call(). - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_inputs=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_inputs=tf_keras.Input( shape=(None, embedding_width), dtype=tf.float32), - dense_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + dense_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) else: self.inputs = dict( - input_word_ids=tf.keras.Input( + input_word_ids=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input( + input_mask=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input( + input_type_ids=tf_keras.Input( shape=(max_sequence_length,), dtype=tf.int32)) self._max_sequence_length = max_sequence_length diff --git a/official/nlp/modeling/networks/sparse_mixer_test.py b/official/nlp/modeling/networks/sparse_mixer_test.py index 3deae0890be..43e19eb6ce6 100644 --- a/official/nlp/modeling/networks/sparse_mixer_test.py +++ b/official/nlp/modeling/networks/sparse_mixer_test.py @@ -17,7 +17,7 @@ from typing import Sequence from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling.networks import sparse_mixer @@ -27,7 +27,7 @@ class SparseMixerTest(parameterized.TestCase, tf.test.TestCase): def tearDown(self): super().tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") @parameterized.named_parameters( dict( @@ -68,11 +68,11 @@ def test_network(self, mixing_mechanism: layers.MixingMechanism, attention_layers=attention_layers) batch_size = 4 - word_ids = tf.keras.Input( + word_ids = tf_keras.Input( shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32) - mask = tf.keras.Input( + mask = tf_keras.Input( shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32) - type_ids = tf.keras.Input( + type_ids = tf_keras.Input( shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32) dict_outputs = test_network( @@ -82,7 +82,7 @@ def test_network(self, mixing_mechanism: layers.MixingMechanism, self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [batch_size, sequence_length, hidden_size] expected_pooled_shape = [batch_size, hidden_size] @@ -107,11 +107,11 @@ def test_embeddings_as_inputs(self): attention_layers=(2,)) batch_size = 2 - word_ids = tf.keras.Input( + word_ids = tf_keras.Input( shape=(sequence_length), batch_size=batch_size, dtype=tf.int32) - mask = tf.keras.Input( + mask = tf_keras.Input( shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32) - type_ids = tf.keras.Input( + type_ids = tf_keras.Input( shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32) test_network.build( diff --git a/official/nlp/modeling/networks/xlnet_base.py b/official/nlp/modeling/networks/xlnet_base.py index b0251587f6d..d49f0cf4a9b 100644 --- a/official/nlp/modeling/networks/xlnet_base.py +++ b/official/nlp/modeling/networks/xlnet_base.py @@ -16,7 +16,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers @@ -366,7 +366,7 @@ def _compute_positional_encoding( return relative_position_encoding -class RelativePositionEncoding(tf.keras.layers.Layer): +class RelativePositionEncoding(tf_keras.layers.Layer): """Creates a relative positional encoding. This layer creates a relative positional encoding as described in @@ -412,8 +412,8 @@ def call(self, pos_seq, batch_size=None): return relative_position_encoding -@tf.keras.utils.register_keras_serializable(package="Text") -class XLNetBase(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class XLNetBase(tf_keras.layers.Layer): """Base XLNet model. Attributes: @@ -511,9 +511,9 @@ def __init__(self, initializer=tf_utils.clone_initializer(self._initializer), dtype=tf.float32, name="word_embedding") - self._dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self._dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) - self.embedding_dropout = tf.keras.layers.Dropout(rate=self._dropout_rate) + self.embedding_dropout = tf_keras.layers.Dropout(rate=self._dropout_rate) self.position_encoding = RelativePositionEncoding(self._hidden_size) self._transformer_xl = transformer_xl.TransformerXL( diff --git a/official/nlp/modeling/networks/xlnet_base_test.py b/official/nlp/modeling/networks/xlnet_base_test.py index cd284554a7c..3889d5e34d6 100644 --- a/official/nlp/modeling/networks/xlnet_base_test.py +++ b/official/nlp/modeling/networks/xlnet_base_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.nlp.modeling.networks import xlnet_base @@ -411,7 +411,7 @@ def test_xlnet_model(self): attention_dropout_rate=0., attention_type="bi", bi_data=True, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), two_stream=False, tie_attention_biases=True, reuse_length=0, @@ -435,7 +435,7 @@ def test_get_config(self): attention_dropout_rate=0., attention_type="bi", bi_data=True, - initializer=tf.keras.initializers.RandomNormal(stddev=0.1), + initializer=tf_keras.initializers.RandomNormal(stddev=0.1), two_stream=False, tie_attention_biases=True, memory_length=0, diff --git a/official/nlp/modeling/ops/beam_search.py b/official/nlp/modeling/ops/beam_search.py index ad0db2e4b94..02d8634d146 100644 --- a/official/nlp/modeling/ops/beam_search.py +++ b/official/nlp/modeling/ops/beam_search.py @@ -15,7 +15,7 @@ """Beam search to find the translated sequence with the highest probability.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras def inf(dtype): diff --git a/official/nlp/modeling/ops/beam_search_test.py b/official/nlp/modeling/ops/beam_search_test.py index e22464c4f69..9087303a15b 100644 --- a/official/nlp/modeling/ops/beam_search_test.py +++ b/official/nlp/modeling/ops/beam_search_test.py @@ -15,7 +15,7 @@ """Test beam search helper methods.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras 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 e0b9346f04d..3f20fa5a304 100644 --- a/official/nlp/modeling/ops/decoding_module.py +++ b/official/nlp/modeling/ops/decoding_module.py @@ -17,7 +17,7 @@ import abc from typing import Any, Callable, Dict, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.framework import dtypes from official.modeling import tf_utils diff --git a/official/nlp/modeling/ops/decoding_module_test.py b/official/nlp/modeling/ops/decoding_module_test.py index df33fe387da..5d5536d35e0 100644 --- a/official/nlp/modeling/ops/decoding_module_test.py +++ b/official/nlp/modeling/ops/decoding_module_test.py @@ -15,7 +15,7 @@ """Test decoding utility methods.""" import abc -import tensorflow as tf +import tensorflow as tf, tf_keras 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 3d0706296d3..024c796a7f4 100644 --- a/official/nlp/modeling/ops/sampling_module.py +++ b/official/nlp/modeling/ops/sampling_module.py @@ -18,7 +18,7 @@ from typing import Any, Callable, Dict, Optional import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.ops import decoding_module diff --git a/official/nlp/modeling/ops/segment_extractor.py b/official/nlp/modeling/ops/segment_extractor.py index 32aec9cee4a..38ee278bdc4 100644 --- a/official/nlp/modeling/ops/segment_extractor.py +++ b/official/nlp/modeling/ops/segment_extractor.py @@ -14,7 +14,7 @@ """Module for extracting segments from sentences in documents.""" -import tensorflow as tf +import tensorflow as tf, tf_keras # Get a random tensor like `positions` and make some decisions diff --git a/official/nlp/modeling/ops/segment_extractor_test.py b/official/nlp/modeling/ops/segment_extractor_test.py index b0a2b532c87..f1ecb7220b8 100644 --- a/official/nlp/modeling/ops/segment_extractor_test.py +++ b/official/nlp/modeling/ops/segment_extractor_test.py @@ -17,7 +17,7 @@ import functools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.ops import segment_extractor diff --git a/official/nlp/optimization.py b/official/nlp/optimization.py index a1f50816226..5f29c7ceea6 100644 --- a/official/nlp/optimization.py +++ b/official/nlp/optimization.py @@ -16,7 +16,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.optimization import lamb from official.modeling.optimization import legacy_adamw @@ -25,7 +25,7 @@ LAMB = lamb.LAMB -class WarmUp(tf.keras.optimizers.schedules.LearningRateSchedule): +class WarmUp(tf_keras.optimizers.schedules.LearningRateSchedule): """Applies a warmup schedule on a given learning rate decay schedule.""" def __init__(self, @@ -77,7 +77,7 @@ def create_optimizer(init_lr, poly_power=1.0): """Creates an optimizer with learning rate schedule.""" # Implements linear decay of the learning rate. - lr_schedule = tf.keras.optimizers.schedules.PolynomialDecay( + lr_schedule = tf_keras.optimizers.schedules.PolynomialDecay( initial_learning_rate=init_lr, decay_steps=num_train_steps, end_learning_rate=end_lr, diff --git a/official/nlp/serving/export_savedmodel_test.py b/official/nlp/serving/export_savedmodel_test.py index a3d63daebb0..8f9dd11e8e1 100644 --- a/official/nlp/serving/export_savedmodel_test.py +++ b/official/nlp/serving/export_savedmodel_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders from official.nlp.serving import export_savedmodel diff --git a/official/nlp/serving/export_savedmodel_util.py b/official/nlp/serving/export_savedmodel_util.py index e06209796c5..13889e31818 100644 --- a/official/nlp/serving/export_savedmodel_util.py +++ b/official/nlp/serving/export_savedmodel_util.py @@ -15,7 +15,7 @@ """Common library to export a SavedModel from the export module.""" from typing import Dict, List, Optional, Union, Any -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import export_base diff --git a/official/nlp/serving/serving_modules.py b/official/nlp/serving/serving_modules.py index 2dcb19448dc..ed40f5efe1e 100644 --- a/official/nlp/serving/serving_modules.py +++ b/official/nlp/serving/serving_modules.py @@ -17,7 +17,7 @@ import dataclasses from typing import Dict, List, Optional, Text -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_text as tf_text from official.core import export_base @@ -65,7 +65,7 @@ class Params(base_config.Config): # ...or load preprocessing from a SavedModel at this location. preprocessing_hub_module_url: str = "" - def __init__(self, params, model: tf.keras.Model, inference_step=None): + def __init__(self, params, model: tf_keras.Model, inference_step=None): super().__init__(params, model, inference_step) if params.use_v2_feature_names: self.input_word_ids_field = "input_word_ids" @@ -188,7 +188,7 @@ def get_inference_signatures(self, function_keys: Dict[Text, Text]): class MaskedLM(export_base.ExportModule): """The export module for the Bert Pretrain (MaskedLM) task.""" - def __init__(self, params, model: tf.keras.Model, inference_step=None): + def __init__(self, params, model: tf_keras.Model, inference_step=None): super().__init__(params, model, inference_step) if params.use_v2_feature_names: self.input_word_ids_field = "input_word_ids" @@ -269,7 +269,7 @@ class Params(base_config.Config): parse_sequence_length: Optional[int] = None use_v2_feature_names: bool = True - def __init__(self, params, model: tf.keras.Model, inference_step=None): + def __init__(self, params, model: tf_keras.Model, inference_step=None): super().__init__(params, model, inference_step) if params.use_v2_feature_names: self.input_word_ids_field = "input_word_ids" @@ -344,7 +344,7 @@ class Params(base_config.Config): use_v2_feature_names: bool = True output_encoder_outputs: bool = False - def __init__(self, params, model: tf.keras.Model, inference_step=None): + def __init__(self, params, model: tf_keras.Model, inference_step=None): super().__init__(params, model, inference_step) if params.use_v2_feature_names: self.input_word_ids_field = "input_word_ids" @@ -420,7 +420,7 @@ class Params(base_config.Config): # Needs to be specified if padded_decode is True/on TPUs. batch_size: Optional[int] = None - def __init__(self, params, model: tf.keras.Model, inference_step=None): + def __init__(self, params, model: tf_keras.Model, inference_step=None): super().__init__(params, model, inference_step) self._sp_tokenizer = tf_text.SentencepieceTokenizer( model=tf.io.gfile.GFile(params.sentencepiece_model_path, "rb").read(), diff --git a/official/nlp/serving/serving_modules_test.py b/official/nlp/serving/serving_modules_test.py index fceacfbd8c5..22d89553e32 100644 --- a/official/nlp/serving/serving_modules_test.py +++ b/official/nlp/serving/serving_modules_test.py @@ -17,7 +17,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from sentencepiece import SentencePieceTrainer from official.core import export_base diff --git a/official/nlp/tasks/dual_encoder.py b/official/nlp/tasks/dual_encoder.py index e1332782352..a09cbd91b63 100644 --- a/official/nlp/tasks/dual_encoder.py +++ b/official/nlp/tasks/dual_encoder.py @@ -17,7 +17,7 @@ # Import libraries from absl import logging import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -141,12 +141,12 @@ def dummy_data(_): def build_metrics(self, training=None): del training - metrics = [tf.keras.metrics.Mean(name='batch_size_per_core')] + metrics = [tf_keras.metrics.Mean(name='batch_size_per_core')] for k in self.task_config.model.eval_top_k: - metrics.append(tf.keras.metrics.SparseTopKCategoricalAccuracy( + metrics.append(tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name=f'left_recall_at_{k}')) if self.task_config.model.bidirectional: - metrics.append(tf.keras.metrics.SparseTopKCategoricalAccuracy( + metrics.append(tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name=f'right_recall_at_{k}')) return metrics @@ -171,7 +171,7 @@ def process_metrics(self, metrics, labels, model_outputs): def validation_step(self, inputs, - model: tf.keras.Model, + model: tf_keras.Model, metrics=None) -> Mapping[str, tf.Tensor]: outputs = model(inputs) loss = self.build_losses( diff --git a/official/nlp/tasks/dual_encoder_test.py b/official/nlp/tasks/dual_encoder_test.py index 012f3fc419f..1c4ae70cb0a 100644 --- a/official/nlp/tasks/dual_encoder_test.py +++ b/official/nlp/tasks/dual_encoder_test.py @@ -17,7 +17,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import configs from official.nlp.configs import bert @@ -53,7 +53,7 @@ def _run_task(self, config): dataset.batch(10) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) model.save(os.path.join(self.get_temp_dir(), "saved_model")) @@ -69,7 +69,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/nlp/tasks/electra_task.py b/official/nlp/tasks/electra_task.py index f3aac2d6c29..966b353e67c 100644 --- a/official/nlp/tasks/electra_task.py +++ b/official/nlp/tasks/electra_task.py @@ -15,7 +15,7 @@ """ELECTRA pretraining task (Joint Masked LM and Replaced Token Detection).""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -74,7 +74,7 @@ def _build_pretrainer( num_token_predictions=config.num_masked_tokens, mlm_activation=tf_utils.get_activation( generator_encoder_cfg.hidden_activation), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=generator_encoder_cfg.initializer_range), classification_heads=[ layers.ClassificationHead(**cfg.as_dict()) for cfg in config.cls_heads @@ -97,7 +97,7 @@ def build_losses(self, metrics = dict([(metric.name, metric) for metric in metrics]) # generator lm and (optional) nsp loss. - lm_prediction_losses = tf.keras.losses.sparse_categorical_crossentropy( + lm_prediction_losses = tf_keras.losses.sparse_categorical_crossentropy( labels['masked_lm_ids'], tf.cast(model_outputs['lm_outputs'], tf.float32), from_logits=True) @@ -110,7 +110,7 @@ def build_losses(self, sentence_labels = labels['next_sentence_labels'] sentence_outputs = tf.cast( model_outputs['sentence_outputs'], dtype=tf.float32) - sentence_loss = tf.keras.losses.sparse_categorical_crossentropy( + sentence_loss = tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_outputs, from_logits=True) metrics['next_sentence_loss'].update_state(sentence_loss) total_loss = mlm_loss + sentence_loss @@ -164,19 +164,19 @@ def dummy_data(_): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), - tf.keras.metrics.Mean(name='lm_example_loss'), - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), + tf_keras.metrics.Mean(name='lm_example_loss'), + tf_keras.metrics.SparseCategoricalAccuracy( name='discriminator_accuracy'), ] if self.task_config.train_data.use_next_sentence_label: metrics.append( - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='next_sentence_accuracy')) - metrics.append(tf.keras.metrics.Mean(name='next_sentence_loss')) + metrics.append(tf_keras.metrics.Mean(name='next_sentence_loss')) - metrics.append(tf.keras.metrics.Mean(name='discriminator_loss')) - metrics.append(tf.keras.metrics.Mean(name='total_loss')) + metrics.append(tf_keras.metrics.Mean(name='discriminator_loss')) + metrics.append(tf_keras.metrics.Mean(name='total_loss')) return metrics @@ -197,8 +197,8 @@ def process_metrics(self, metrics, labels, model_outputs): model_outputs['disc_label'], discrim_full_logits, labels['input_mask']) - def train_step(self, inputs, model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, metrics): + def train_step(self, inputs, model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics): """Does forward and backward. Args: @@ -227,7 +227,7 @@ def train_step(self, inputs, model: tf.keras.Model, self.process_metrics(metrics, inputs, outputs) return {self.loss: loss} - def validation_step(self, inputs, model: tf.keras.Model, metrics): + def validation_step(self, inputs, model: tf_keras.Model, metrics): """Validatation step. Args: diff --git a/official/nlp/tasks/electra_task_test.py b/official/nlp/tasks/electra_task_test.py index de888b0302d..c4a945dc21b 100644 --- a/official/nlp/tasks/electra_task_test.py +++ b/official/nlp/tasks/electra_task_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.tasks.electra_task.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import electra @@ -51,7 +51,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/nlp/tasks/masked_lm.py b/official/nlp/tasks/masked_lm.py index c9bd84a4a8b..bde5a08e632 100644 --- a/official/nlp/tasks/masked_lm.py +++ b/official/nlp/tasks/masked_lm.py @@ -15,7 +15,7 @@ """Masked language task.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -68,7 +68,7 @@ def build_model(self, params=None): ] if config.cls_heads else [] return models.BertPretrainerV2( mlm_activation=tf_utils.get_activation(config.mlm_activation), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=config.mlm_initializer_range), encoder_network=encoder_network, classification_heads=cls_heads) @@ -80,7 +80,7 @@ def build_losses(self, aux_losses=None) -> tf.Tensor: with tf.name_scope('MaskedLMTask/losses'): metrics = dict([(metric.name, metric) for metric in metrics]) - lm_prediction_losses = tf.keras.losses.sparse_categorical_crossentropy( + lm_prediction_losses = tf_keras.losses.sparse_categorical_crossentropy( labels['masked_lm_ids'], tf.cast(model_outputs['mlm_logits'], tf.float32), from_logits=True) @@ -95,7 +95,7 @@ def build_losses(self, sentence_outputs = tf.cast( model_outputs['next_sentence'], dtype=tf.float32) sentence_loss = tf.reduce_mean( - tf.keras.losses.sparse_categorical_crossentropy( + tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_outputs, from_logits=True)) metrics['next_sentence_loss'].update_state(sentence_loss) total_loss = mlm_loss + sentence_loss @@ -133,15 +133,15 @@ def dummy_data(_): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), - tf.keras.metrics.Mean(name='lm_example_loss') + tf_keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), + tf_keras.metrics.Mean(name='lm_example_loss') ] # TODO(hongkuny): rethink how to manage metrics creation with heads. if self.task_config.train_data.use_next_sentence_label: metrics.append( - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='next_sentence_accuracy')) - metrics.append(tf.keras.metrics.Mean(name='next_sentence_loss')) + metrics.append(tf_keras.metrics.Mean(name='next_sentence_loss')) return metrics def process_metrics(self, metrics, labels, model_outputs): @@ -155,8 +155,8 @@ def process_metrics(self, metrics, labels, model_outputs): metrics['next_sentence_accuracy'].update_state( labels['next_sentence_labels'], model_outputs['next_sentence']) - def train_step(self, inputs, model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, metrics): + def train_step(self, inputs, model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics): """Does forward and backward. Args: @@ -189,7 +189,7 @@ def train_step(self, inputs, model: tf.keras.Model, self.process_metrics(metrics, inputs, outputs) return {self.loss: loss} - def validation_step(self, inputs, model: tf.keras.Model, metrics): + def validation_step(self, inputs, model: tf_keras.Model, metrics): """Validatation step. Args: diff --git a/official/nlp/tasks/masked_lm_determinism_test.py b/official/nlp/tasks/masked_lm_determinism_test.py index 2282374294d..3807f8deb24 100644 --- a/official/nlp/tasks/masked_lm_determinism_test.py +++ b/official/nlp/tasks/masked_lm_determinism_test.py @@ -14,7 +14,7 @@ """Tests that masked LM models are deterministic when determinism is enabled.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders @@ -54,7 +54,7 @@ def _build_and_run_model(self, config, num_steps=5): config.model.encoder.get().vocab_size) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) # Run training for _ in range(num_steps): @@ -87,9 +87,9 @@ def test_task_determinism(self): seq_length=128, global_batch_size=1)) - tf.keras.utils.set_random_seed(1) + tf_keras.utils.set_random_seed(1) logs1, validation_logs1, weights1 = self._build_and_run_model(config) - tf.keras.utils.set_random_seed(1) + tf_keras.utils.set_random_seed(1) logs2, validation_logs2, weights2 = self._build_and_run_model(config) self.assertEqual(logs1["loss"], logs2["loss"]) diff --git a/official/nlp/tasks/masked_lm_test.py b/official/nlp/tasks/masked_lm_test.py index 32bcb759a33..225d8d895f5 100644 --- a/official/nlp/tasks/masked_lm_test.py +++ b/official/nlp/tasks/masked_lm_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.tasks.masked_lm.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders @@ -47,7 +47,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/nlp/tasks/question_answering.py b/official/nlp/tasks/question_answering.py index 119f18d0ab0..c9c929daf39 100644 --- a/official/nlp/tasks/question_answering.py +++ b/official/nlp/tasks/question_answering.py @@ -21,7 +21,7 @@ from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -111,7 +111,7 @@ def build_model(self): encoder_cfg = self.task_config.model.encoder.get() return models.BertSpanLabeler( network=encoder_network, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range)) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: @@ -119,11 +119,11 @@ def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: end_positions = labels['end_positions'] start_logits, end_logits = model_outputs - start_loss = tf.keras.losses.sparse_categorical_crossentropy( + start_loss = tf_keras.losses.sparse_categorical_crossentropy( start_positions, tf.cast(start_logits, dtype=tf.float32), from_logits=True) - end_loss = tf.keras.losses.sparse_categorical_crossentropy( + end_loss = tf_keras.losses.sparse_categorical_crossentropy( end_positions, tf.cast(end_logits, dtype=tf.float32), from_logits=True) loss = (tf.reduce_mean(start_loss) + tf.reduce_mean(end_loss)) / 2 @@ -224,9 +224,9 @@ def build_metrics(self, training=None): return [] # TODO(lehou): a list of metrics doesn't work the same as in compile/fit. metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='start_position_accuracy'), - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='end_position_accuracy'), ] return metrics @@ -248,7 +248,7 @@ def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): 'end_positions': end_logits }) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, _ = inputs unique_ids = features.pop('unique_ids') model_outputs = self.inference_step(features, model) @@ -351,7 +351,7 @@ def build_model(self): network=encoder_network, start_n_top=self.task_config.n_best_size, end_n_top=self.task_config.n_best_size, - initializer=tf.keras.initializers.RandomNormal( + initializer=tf_keras.initializers.RandomNormal( stddev=encoder_cfg.initializer_range)) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: @@ -368,7 +368,7 @@ def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: start_positions, start_logits) end_loss = tf.nn.sparse_softmax_cross_entropy_with_logits( end_positions, end_logits) - is_impossible_loss = tf.keras.losses.binary_crossentropy( + is_impossible_loss = tf_keras.losses.binary_crossentropy( is_impossible, class_logits, from_logits=True) loss = (tf.reduce_mean(start_loss) + tf.reduce_mean(end_loss)) / 2 @@ -412,7 +412,7 @@ def _dummy_data(self, params, _): is_impossible=zero) return x, y - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, _ = inputs unique_ids = features.pop('unique_ids') model_outputs = self.inference_step(features, model) @@ -459,7 +459,7 @@ def aggregate_logs(self, state=None, step_outputs=None): def predict(task: QuestionAnsweringTask, params: cfg.DataConfig, - model: tf.keras.Model): + model: tf_keras.Model): """Predicts on the input data. Args: diff --git a/official/nlp/tasks/question_answering_test.py b/official/nlp/tasks/question_answering_test.py index 2c903b1a9b3..e90cb5ee23a 100644 --- a/official/nlp/tasks/question_answering_test.py +++ b/official/nlp/tasks/question_answering_test.py @@ -18,7 +18,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders @@ -90,7 +90,7 @@ def _run_task(self, config): train_dataset = task.build_inputs(config.train_data) train_iterator = iter(train_dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(train_iterator), model, optimizer, metrics=metrics) val_dataset = task.build_inputs(config.validation_data) @@ -137,7 +137,7 @@ def _export_bert_tfhub(self): bert=encoders.BertEncoderConfig(vocab_size=30522, num_layers=1))) encoder_inputs_dict = {x.name: x for x in encoder.inputs} encoder_output_dict = encoder(encoder_inputs_dict) - core_model = tf.keras.Model( + core_model = tf_keras.Model( inputs=encoder_inputs_dict, outputs=encoder_output_dict) hub_destination = os.path.join(self.get_temp_dir(), "hub") core_model.save(hub_destination, include_optimizer=False, save_format="tf") @@ -240,7 +240,7 @@ def _run_task(self, config): train_dataset = task.build_inputs(config.train_data) train_iterator = iter(train_dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(train_iterator), model, optimizer, metrics=metrics) val_dataset = task.build_inputs(config.validation_data) diff --git a/official/nlp/tasks/sentence_prediction.py b/official/nlp/tasks/sentence_prediction.py index d648cf76dd4..e353a7428af 100644 --- a/official/nlp/tasks/sentence_prediction.py +++ b/official/nlp/tasks/sentence_prediction.py @@ -21,7 +21,7 @@ import orbit from scipy import stats from sklearn import metrics as sklearn_metrics -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -88,22 +88,22 @@ def build_model(self): return models.XLNetClassifier( network=encoder_network, num_classes=self.task_config.model.num_classes, - initializer=tf.keras.initializers.RandomNormal( + initializer=tf_keras.initializers.RandomNormal( stddev=encoder_cfg.initializer_range)) else: return models.BertClassifier( network=encoder_network, num_classes=self.task_config.model.num_classes, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), use_encoder_pooler=self.task_config.model.use_encoder_pooler) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: label_ids = labels[self.label_field] if self.task_config.model.num_classes == 1: - loss = tf.keras.losses.mean_squared_error(label_ids, model_outputs) + loss = tf_keras.losses.mean_squared_error(label_ids, model_outputs) else: - loss = tf.keras.losses.sparse_categorical_crossentropy( + loss = tf_keras.losses.sparse_categorical_crossentropy( label_ids, tf.cast(model_outputs, tf.float32), from_logits=True) if aux_losses: @@ -139,15 +139,15 @@ def dummy_data(_): def build_metrics(self, training=None): del training if self.task_config.model.num_classes == 1: - metrics = [tf.keras.metrics.MeanSquaredError()] + metrics = [tf_keras.metrics.MeanSquaredError()] elif self.task_config.model.num_classes == 2: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), - tf.keras.metrics.AUC(name='auc', curve='PR'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.AUC(name='auc', curve='PR'), ] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), ] return metrics @@ -164,7 +164,7 @@ def process_metrics(self, metrics, labels, model_outputs): def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): compiled_metrics.update_state(labels[self.label_field], model_outputs) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, labels = inputs, inputs outputs = self.inference_step(features, model) loss = self.build_losses( @@ -254,7 +254,7 @@ def initialize(self, model): def predict(task: SentencePredictionTask, params: cfg.DataConfig, - model: tf.keras.Model, + model: tf_keras.Model, params_aug: Optional[cfg.DataConfig] = None, test_time_aug_wgt: float = 0.3) -> List[Union[int, float]]: """Predicts on the input data. diff --git a/official/nlp/tasks/sentence_prediction_test.py b/official/nlp/tasks/sentence_prediction_test.py index f08e512d9e8..8109f82e88c 100644 --- a/official/nlp/tasks/sentence_prediction_test.py +++ b/official/nlp/tasks/sentence_prediction_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders @@ -83,7 +83,7 @@ def _run_task(self, config): functools.partial(task.build_inputs, config.train_data)) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(learning_rate=0.1) + optimizer = tf_keras.optimizers.SGD(learning_rate=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) model.save(os.path.join(self.get_temp_dir(), "saved_model")) return task.validation_step(next(iterator), model, metrics=metrics) @@ -120,7 +120,7 @@ def test_task(self, init_cls_pooler): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(learning_rate=0.1) + optimizer = tf_keras.optimizers.SGD(learning_rate=0.1) task.initialize(model) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) @@ -144,14 +144,14 @@ def test_metrics_and_losses(self, num_classes): model = task.build_model() metrics = task.build_metrics() if num_classes == 1: - self.assertIsInstance(metrics[0], tf.keras.metrics.MeanSquaredError) + self.assertIsInstance(metrics[0], tf_keras.metrics.MeanSquaredError) else: self.assertIsInstance(metrics[0], - tf.keras.metrics.SparseCategoricalAccuracy) + tf_keras.metrics.SparseCategoricalAccuracy) dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(learning_rate=0.1) + optimizer = tf_keras.optimizers.SGD(learning_rate=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) logs = task.validation_step(next(iterator), model, metrics=metrics) @@ -219,7 +219,7 @@ def _export_bert_tfhub(self): bert=encoders.BertEncoderConfig(vocab_size=30522, num_layers=1))) encoder_inputs_dict = {x.name: x for x in encoder.inputs} encoder_output_dict = encoder(encoder_inputs_dict) - core_model = tf.keras.Model( + core_model = tf_keras.Model( inputs=encoder_inputs_dict, outputs=encoder_output_dict) hub_destination = os.path.join(self.get_temp_dir(), "hub") core_model.save(hub_destination, include_optimizer=False, save_format="tf") diff --git a/official/nlp/tasks/tagging.py b/official/nlp/tasks/tagging.py index 60ac80fbdaa..8392846f33c 100644 --- a/official/nlp/tasks/tagging.py +++ b/official/nlp/tasks/tagging.py @@ -20,7 +20,7 @@ from seqeval import metrics as seqeval_metrics -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -95,7 +95,7 @@ def build_model(self): return models.BertTokenClassifier( network=encoder_network, num_classes=len(self.task_config.class_names), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self.task_config.model.head_initializer_range), dropout_rate=self.task_config.model.head_dropout, output='logits', @@ -104,7 +104,7 @@ def build_model(self): def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: logits = tf.cast(model_outputs['logits'], tf.float32) masked_labels, masked_weights = _masked_labels_and_weights(labels) - loss = tf.keras.losses.sparse_categorical_crossentropy( + loss = tf_keras.losses.sparse_categorical_crossentropy( masked_labels, logits, from_logits=True) numerator_loss = tf.reduce_sum(loss * masked_weights) denominator_loss = tf.reduce_sum(masked_weights) @@ -138,13 +138,13 @@ def dummy_data(_): return data_loader_factory.get_data_loader(params).load(input_context) - def inference_step(self, inputs, model: tf.keras.Model): + def inference_step(self, inputs, model: tf_keras.Model): """Performs the forward step.""" logits = model(inputs, training=False)['logits'] return {'logits': logits, 'predict_ids': tf.argmax(logits, axis=-1, output_type=tf.int32)} - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): """Validatation step. Args: @@ -207,7 +207,7 @@ def reduce_aggregated_logs(self, aggregated_logs, global_step=None): def predict(task: TaggingTask, params: cfg.DataConfig, - model: tf.keras.Model) -> List[Tuple[int, int, List[int]]]: + model: tf_keras.Model) -> List[Tuple[int, int, List[int]]]: """Predicts on the input data. Args: diff --git a/official/nlp/tasks/tagging_test.py b/official/nlp/tasks/tagging_test.py index 971ef51dc68..1d63ab6508d 100644 --- a/official/nlp/tasks/tagging_test.py +++ b/official/nlp/tasks/tagging_test.py @@ -17,7 +17,7 @@ import os import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import encoders from official.nlp.data import tagging_dataloader @@ -67,7 +67,7 @@ def _run_task(self, config): functools.partial(task.build_inputs, config.train_data)) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) model.save(os.path.join(self.get_temp_dir(), "saved_model")) @@ -89,7 +89,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) task.initialize(model) @@ -100,7 +100,7 @@ def _export_bert_tfhub(self): bert=encoders.BertEncoderConfig(vocab_size=30522, num_layers=1))) encoder_inputs_dict = {x.name: x for x in encoder.inputs} encoder_output_dict = encoder(encoder_inputs_dict) - core_model = tf.keras.Model( + core_model = tf_keras.Model( inputs=encoder_inputs_dict, outputs=encoder_output_dict) hub_destination = os.path.join(self.get_temp_dir(), "hub") core_model.save(hub_destination, include_optimizer=False, save_format="tf") diff --git a/official/nlp/tasks/translation.py b/official/nlp/tasks/translation.py index 5c2eaaa6037..425d6988fff 100644 --- a/official/nlp/tasks/translation.py +++ b/official/nlp/tasks/translation.py @@ -19,7 +19,7 @@ from absl import logging import sacrebleu -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_text as tftxt from official.core import base_task @@ -203,7 +203,7 @@ def __init__(self, params: cfg.TaskConfig, logging_dir=None, name=None): self._references, self._tf_record_input_path = write_test_record( params.validation_data, self.logging_dir) - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Creates model architecture. Returns: @@ -266,8 +266,8 @@ def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: def train_step(self, inputs, - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics=None): """Does forward and backward. @@ -292,13 +292,13 @@ def train_step(self, # For mixed precision, when a LossScaleOptimizer is used, the loss is # scaled to avoid numeric underflow. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) logs = {self.loss: loss} @@ -306,7 +306,7 @@ def train_step(self, self.process_metrics(metrics, inputs["targets"], outputs) return logs - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): unique_ids = inputs.pop("unique_id") # Validation loss outputs = model(inputs, training=False) diff --git a/official/nlp/tasks/translation_test.py b/official/nlp/tasks/translation_test.py index 054ed466149..aa8f0e299c1 100644 --- a/official/nlp/tasks/translation_test.py +++ b/official/nlp/tasks/translation_test.py @@ -17,7 +17,7 @@ import os import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from sentencepiece import SentencePieceTrainer from official.nlp.data import wmt_dataloader @@ -97,7 +97,7 @@ def test_task(self): model = task.build_model() dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer) def test_no_sentencepiece_path(self): diff --git a/official/nlp/tasks/utils.py b/official/nlp/tasks/utils.py index f7a5fe97e02..9039aaf153c 100644 --- a/official/nlp/tasks/utils.py +++ b/official/nlp/tasks/utils.py @@ -16,24 +16,24 @@ from typing import Any, Callable import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub -def get_encoder_from_hub(hub_model_path: str) -> tf.keras.Model: +def get_encoder_from_hub(hub_model_path: str) -> tf_keras.Model: """Gets an encoder from hub. Args: hub_model_path: The path to the tfhub model. Returns: - A tf.keras.Model. + A tf_keras.Model. """ - input_word_ids = tf.keras.layers.Input( + input_word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - input_type_ids = tf.keras.layers.Input( + input_type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') hub_layer = hub.KerasLayer(hub_model_path, trainable=True) output_dict = {} @@ -43,7 +43,7 @@ def get_encoder_from_hub(hub_model_path: str) -> tf.keras.Model: input_type_ids=input_type_ids) output_dict = hub_layer(dict_input) - return tf.keras.Model(inputs=dict_input, outputs=output_dict) + return tf_keras.Model(inputs=dict_input, outputs=output_dict) def predict(predict_step_fn: Callable[[Any], Any], diff --git a/official/nlp/tools/export_tfhub_lib.py b/official/nlp/tools/export_tfhub_lib.py index 4d89bdd5c05..43ea5ed5ec5 100644 --- a/official/nlp/tools/export_tfhub_lib.py +++ b/official/nlp/tools/export_tfhub_lib.py @@ -23,7 +23,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import TODO(b/175369555): Remove these. from tensorflow.core.protobuf import saved_model_pb2 from tensorflow.python.ops import control_flow_assert @@ -49,7 +49,7 @@ def get_bert_encoder(bert_config): attention_dropout_rate=bert_config.attention_probs_dropout_prob, max_sequence_length=bert_config.max_position_embeddings, type_vocab_size=bert_config.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), embedding_width=bert_config.embedding_size, dict_outputs=True) @@ -80,7 +80,7 @@ def _create_model( bert_config: Optional[configs.BertConfig] = None, encoder_config: Optional[encoders.EncoderConfig] = None, with_mlm: bool, -) -> Tuple[tf.keras.Model, tf.keras.Model]: +) -> Tuple[tf_keras.Model, tf_keras.Model]: """Creates the model to export and the model to restore the checkpoint. Args: @@ -119,7 +119,7 @@ def _create_model( # For interchangeability with other text representations, # add "default" as an alias for BERT's whole-input reptesentations. encoder_output_dict["default"] = encoder_output_dict["pooled_output"] - core_model = tf.keras.Model( + core_model = tf_keras.Model( inputs=encoder_inputs_dict, outputs=encoder_output_dict) if with_mlm: @@ -138,7 +138,7 @@ def _create_model( else: pretrainer_inputs_dict = {x.name: x for x in pretrainer.inputs} pretrainer_output_dict = pretrainer(pretrainer_inputs_dict) - mlm_model = tf.keras.Model( + mlm_model = tf_keras.Model( inputs=pretrainer_inputs_dict, outputs=pretrainer_output_dict) # Set `_auto_track_sub_layers` to False, so that the additional weights # from `mlm` sub-object will not be included in the core model. @@ -315,7 +315,7 @@ def create_preprocessing(*, sp_model_file: Optional[str] = None, do_lower_case: bool, tokenize_with_offsets: bool, - default_seq_length: int) -> tf.keras.Model: + default_seq_length: int) -> tf_keras.Model: """Returns a preprocessing Model for given tokenization parameters. This function builds a Keras Model with attached subobjects suitable for @@ -336,7 +336,7 @@ def create_preprocessing(*, bert_pack_inputs subobject. Returns: - A tf.keras.Model object with several attached subobjects, suitable for + A tf_keras.Model object with several attached subobjects, suitable for saving as a preprocessing SavedModel. """ # Select tokenizer. @@ -356,7 +356,7 @@ def create_preprocessing(*, # The root object of the preprocessing model can be called to do # one-shot preprocessing for users with single-sentence inputs. - sentences = tf.keras.layers.Input(shape=(), dtype=tf.string, name="sentences") + sentences = tf_keras.layers.Input(shape=(), dtype=tf.string, name="sentences") if tokenize_with_offsets: tokens, start_offsets, limit_offsets = tokenize(sentences) else: @@ -365,24 +365,24 @@ def create_preprocessing(*, seq_length=default_seq_length, special_tokens_dict=tokenize.get_special_tokens_dict()) model_inputs = pack(tokens) - preprocessing = tf.keras.Model(sentences, model_inputs) + preprocessing = tf_keras.Model(sentences, model_inputs) # Individual steps of preprocessing are made available as named subobjects # to enable more general preprocessing. For saving, they need to be Models # in their own right. - preprocessing.tokenize = tf.keras.Model(sentences, tokens) + preprocessing.tokenize = tf_keras.Model(sentences, tokens) # Provide an equivalent to tokenize.get_special_tokens_dict(). preprocessing.tokenize.get_special_tokens_dict = tf.train.Checkpoint() preprocessing.tokenize.get_special_tokens_dict.__call__ = tf.function( lambda: tokenize.get_special_tokens_dict(), # pylint: disable=[unnecessary-lambda] input_signature=[]) if tokenize_with_offsets: - preprocessing.tokenize_with_offsets = tf.keras.Model( + preprocessing.tokenize_with_offsets = tf_keras.Model( sentences, [tokens, start_offsets, limit_offsets]) preprocessing.tokenize_with_offsets.get_special_tokens_dict = ( preprocessing.tokenize.get_special_tokens_dict) # Conceptually, this should be - # preprocessing.bert_pack_inputs = tf.keras.Model(tokens, model_inputs) + # preprocessing.bert_pack_inputs = tf_keras.Model(tokens, model_inputs) # but technicalities require us to use a wrapper (see comments there). # In particular, seq_length can be overridden when calling this. preprocessing.bert_pack_inputs = BertPackInputsSavedModelWrapper(pack) diff --git a/official/nlp/tools/export_tfhub_lib_test.py b/official/nlp/tools/export_tfhub_lib_test.py index 597a9d8bc34..27bb9b23593 100644 --- a/official/nlp/tools/export_tfhub_lib_test.py +++ b/official/nlp/tools/export_tfhub_lib_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow import estimator as tf_estimator import tensorflow_hub as hub import tensorflow_text as text @@ -111,7 +111,7 @@ def _read_asset(asset: tf.saved_model.Asset): def _find_lambda_layers(layer): """Returns list of all Lambda layers in a Keras model.""" - if isinstance(layer, tf.keras.layers.Lambda): + if isinstance(layer, tf_keras.layers.Lambda): return [layer] elif hasattr(layer, "layers"): # It's nested, like a Model. result = [] @@ -233,9 +233,9 @@ def _dropout_mean_stddev(training, num_runs=20): self.assertGreater(_dropout_mean_stddev(training=True), 1e-3) # Test propagation of seq_length in shape inference. - input_word_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_mask = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_type_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_word_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_mask = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_type_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) input_dict = dict( input_word_ids=input_word_ids, input_mask=input_mask, @@ -469,9 +469,9 @@ def _dropout_mean_stddev_mlm(training, num_runs=20): self.assertGreater(_dropout_mean_stddev_mlm(training=True), 1e-3) # Test propagation of seq_length in shape inference. - input_word_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_mask = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_type_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_word_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_mask = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_type_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) input_dict = dict( input_word_ids=input_word_ids, input_mask=input_mask, @@ -1006,7 +1006,7 @@ def _get_special_tokens_dict(obj): def input_fn(): self.assertFalse(tf.executing_eagerly()) # Build a preprocessing Model. - sentences = tf.keras.layers.Input(shape=[], dtype=tf.string) + sentences = tf_keras.layers.Input(shape=[], dtype=tf.string) preprocess = tf.saved_model.load(preprocess_export_path) tokenize = hub.KerasLayer(preprocess.tokenize) special_tokens_dict = _get_special_tokens_dict(tokenize.resolved_object) @@ -1016,7 +1016,7 @@ def input_fn(): packed_inputs = layers.BertPackInputs( 4, special_tokens_dict=special_tokens_dict)( tokens) - preprocessing = tf.keras.Model(sentences, packed_inputs) + preprocessing = tf_keras.Model(sentences, packed_inputs) # Map the dataset. ds = tf.data.Dataset.from_tensors( (tf.constant(["abc", "D EF"]), tf.constant([0, 1]))) diff --git a/official/nlp/tools/tf2_albert_encoder_checkpoint_converter.py b/official/nlp/tools/tf2_albert_encoder_checkpoint_converter.py index 3c5e415710f..e79e0b00ed7 100644 --- a/official/nlp/tools/tf2_albert_encoder_checkpoint_converter.py +++ b/official/nlp/tools/tf2_albert_encoder_checkpoint_converter.py @@ -22,7 +22,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.albert import configs from official.modeling import tf_utils from official.nlp.modeling import models @@ -94,7 +94,7 @@ def _create_albert_model(cfg): attention_dropout_rate=cfg.attention_probs_dropout_prob, max_sequence_length=cfg.max_position_embeddings, type_vocab_size=cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=cfg.initializer_range)) return albert_encoder @@ -112,7 +112,7 @@ def _create_pretrainer_model(cfg): pretrainer = models.BertPretrainerV2( encoder_network=albert_encoder, mlm_activation=tf_utils.get_activation(cfg.hidden_act), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=cfg.initializer_range)) # Makes sure masked_lm layer's variables in pretrainer are created. _ = pretrainer(pretrainer.inputs) diff --git a/official/nlp/tools/tf2_bert_encoder_checkpoint_converter.py b/official/nlp/tools/tf2_bert_encoder_checkpoint_converter.py index d071d16d964..90730a4185f 100644 --- a/official/nlp/tools/tf2_bert_encoder_checkpoint_converter.py +++ b/official/nlp/tools/tf2_bert_encoder_checkpoint_converter.py @@ -24,7 +24,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import configs from official.modeling import tf_utils from official.nlp.modeling import models @@ -71,7 +71,7 @@ def _create_bert_model(cfg): attention_dropout_rate=cfg.attention_probs_dropout_prob, max_sequence_length=cfg.max_position_embeddings, type_vocab_size=cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=cfg.initializer_range), embedding_width=cfg.embedding_size) @@ -91,7 +91,7 @@ def _create_bert_pretrainer_model(cfg): pretrainer = models.BertPretrainerV2( encoder_network=bert_encoder, mlm_activation=tf_utils.get_activation(cfg.hidden_act), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=cfg.initializer_range)) # Makes sure the pretrainer variables are created. _ = pretrainer(pretrainer.inputs) diff --git a/official/nlp/tools/tokenization.py b/official/nlp/tools/tokenization.py index fabe8792be6..28970c9ae6f 100644 --- a/official/nlp/tools/tokenization.py +++ b/official/nlp/tools/tokenization.py @@ -24,7 +24,7 @@ import unicodedata import six -import tensorflow as tf +import tensorflow as tf, tf_keras import sentencepiece as spm diff --git a/official/nlp/tools/tokenization_test.py b/official/nlp/tools/tokenization_test.py index 43106ad7077..08c0f9c506f 100644 --- a/official/nlp/tools/tokenization_test.py +++ b/official/nlp/tools/tokenization_test.py @@ -16,7 +16,7 @@ import tempfile import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.tools import tokenization diff --git a/official/nlp/train.py b/official/nlp/train.py index 472be037ebb..67813671611 100644 --- a/official/nlp/train.py +++ b/official/nlp/train.py @@ -18,7 +18,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils # pylint: disable=unused-import diff --git a/official/projects/assemblenet/configs/assemblenet_test.py b/official/projects/assemblenet/configs/assemblenet_test.py index 9d870d36285..5ffa9c667f7 100644 --- a/official/projects/assemblenet/configs/assemblenet_test.py +++ b/official/projects/assemblenet/configs/assemblenet_test.py @@ -13,7 +13,7 @@ # limitations under the License. from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory from official.projects.assemblenet.configs import assemblenet diff --git a/official/projects/assemblenet/modeling/assemblenet.py b/official/projects/assemblenet/modeling/assemblenet.py index 8612126fd94..8d9715fef3c 100644 --- a/official/projects/assemblenet/modeling/assemblenet.py +++ b/official/projects/assemblenet/modeling/assemblenet.py @@ -51,7 +51,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.assemblenet.configs import assemblenet as cfg @@ -59,7 +59,7 @@ from official.vision.modeling import factory_3d as model_factory from official.vision.modeling.backbones import factory as backbone_factory -layers = tf.keras.layers +layers = tf_keras.layers intermediate_channel_size = [64, 128, 256, 512] @@ -76,7 +76,7 @@ def fixed_padding(inputs, kernel_size): A padded `Tensor` of the same `data_format` with size either intact (if `kernel_size == 1`) or padded (if `kernel_size > 1`). """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() pad_total = kernel_size - 1 pad_beg = pad_total // 2 pad_end = pad_total - pad_beg @@ -118,7 +118,7 @@ def reshape_temporal_conv1d_bn(inputs: tf.Tensor, A padded `Tensor` of the same `data_format` with size either intact (if `kernel_size == 1`) or padded (if `kernel_size > 1`). """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' feature_shape = inputs.shape @@ -128,23 +128,23 @@ def reshape_temporal_conv1d_bn(inputs: tf.Tensor, [-1, num_frames, feature_shape[1] * feature_shape[2], feature_shape[3]]) if temporal_dilation == 1: - inputs = tf.keras.layers.Conv2D( + inputs = tf_keras.layers.Conv2D( filters=filters, kernel_size=(kernel_size, 1), strides=1, padding='SAME', use_bias=False, - kernel_initializer=tf.keras.initializers.VarianceScaling())( + kernel_initializer=tf_keras.initializers.VarianceScaling())( inputs=inputs) else: - inputs = tf.keras.layers.Conv2D( + inputs = tf_keras.layers.Conv2D( filters=filters, kernel_size=(kernel_size, 1), strides=1, padding='SAME', dilation_rate=(temporal_dilation, 1), use_bias=False, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=math.sqrt(2.0 / (kernel_size * feature_shape[3]))))( inputs=inputs) @@ -164,7 +164,7 @@ def conv2d_fixed_padding(inputs: tf.Tensor, filters: int, kernel_size: int, """Strided 2-D convolution with explicit padding. The padding is consistent and is based only on `kernel_size`, not on the - dimensions of `inputs` (as opposed to using `tf.keras.layers.Conv2D` alone). + dimensions of `inputs` (as opposed to using `tf_keras.layers.Conv2D` alone). Args: inputs: `Tensor` of size `[batch, channels, height_in, width_in]`. @@ -178,13 +178,13 @@ def conv2d_fixed_padding(inputs: tf.Tensor, filters: int, kernel_size: int, if strides > 1: inputs = fixed_padding(inputs, kernel_size) - return tf.keras.layers.Conv2D( + return tf_keras.layers.Conv2D( filters=filters, kernel_size=kernel_size, strides=strides, padding=('SAME' if strides == 1 else 'VALID'), use_bias=False, - kernel_initializer=tf.keras.initializers.VarianceScaling())( + kernel_initializer=tf_keras.initializers.VarianceScaling())( inputs=inputs) @@ -215,14 +215,14 @@ def conv3d_same_padding(inputs: tf.Tensor, else: kernel_size = [kernel_size, kernel_size, kernel_size] - return tf.keras.layers.Conv3D( + return tf_keras.layers.Conv3D( filters=filters, kernel_size=kernel_size, strides=[1, strides, strides], padding='SAME', dilation_rate=[temporal_dilation, 1, 1], use_bias=False, - kernel_initializer=tf.keras.initializers.VarianceScaling())( + kernel_initializer=tf_keras.initializers.VarianceScaling())( inputs=inputs) @@ -374,7 +374,7 @@ def spatial_resize_and_concat(inputs): Returns: The output `Tensor` after concatenation. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' # Do nothing if only 1 input @@ -393,7 +393,7 @@ def spatial_resize_and_concat(inputs): for i in range(len(inputs)): if inputs[i].shape[1] != sm_size[0] or inputs[i].shape[2] != sm_size[1]: ratio = (inputs[i].shape[1] + 1) // sm_size[0] - inputs[i] = tf.keras.layers.MaxPool2D([ratio, ratio], + inputs[i] = tf_keras.layers.MaxPool2D([ratio, ratio], ratio, padding='same')( inputs[i]) @@ -431,7 +431,7 @@ def __init__(self, self._index = index self._use_5d_mode = use_5d_mode self._model_edge_weights = model_edge_weights - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' def get_config(self): @@ -452,7 +452,7 @@ def build(self, input_shape: tf.TensorShape): if self._index is None or not self._model_edge_weights: self._edge_weights = self.add_weight( shape=self._weights_shape, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( mean=0.0, stddev=0.01), trainable=True, name='agg_weights') @@ -499,11 +499,11 @@ def call(self, assert sm_size[0] != 0 ratio = (inp.shape[h_channel_loc] + 1) // sm_size[0] if use_5d_mode: - inp = tf.keras.layers.MaxPool3D([1, ratio, ratio], [1, ratio, ratio], + inp = tf_keras.layers.MaxPool3D([1, ratio, ratio], [1, ratio, ratio], padding='same')( inp) else: - inp = tf.keras.layers.MaxPool2D([ratio, ratio], ratio, + inp = tf_keras.layers.MaxPool2D([ratio, ratio], ratio, padding='same')( inp) @@ -610,7 +610,7 @@ def rgb_conv_stem(inputs, Returns: The output `Tensor`. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' if temporal_dilation < 1: @@ -634,7 +634,7 @@ def rgb_conv_stem(inputs, bn_epsilon=bn_epsilon, use_sync_bn=use_sync_bn) - inputs = tf.keras.layers.MaxPool2D( + inputs = tf_keras.layers.MaxPool2D( pool_size=3, strides=2, padding='SAME')( inputs=inputs) inputs = tf.identity(inputs, 'initial_max_pool') @@ -673,7 +673,7 @@ def flow_conv_stem(inputs, inputs) inputs = tf.nn.relu(inputs) - inputs = tf.keras.layers.MaxPool2D( + inputs = tf_keras.layers.MaxPool2D( pool_size=2, strides=2, padding='SAME')( inputs=inputs) inputs = tf.identity(inputs, 'initial_max_pool') @@ -704,7 +704,7 @@ def multi_stream_heads(streams, def _pool_and_reshape(net): # The activation is 7x7 so this is a global average pool. - net = tf.keras.layers.GlobalAveragePooling2D()(inputs=net) + net = tf_keras.layers.GlobalAveragePooling2D()(inputs=net) net = tf.identity(net, 'final_avg_pool0') net = tf.reshape(net, [-1, num_frames, num_channels]) @@ -724,7 +724,7 @@ def _pool_and_reshape(net): if len(final_nodes) > 1: outputs = outputs / len(final_nodes) - outputs = tf.keras.layers.Dense( + outputs = tf_keras.layers.Dense( units=num_classes, kernel_initializer=tf.random_normal_initializer(stddev=.01))( inputs=outputs) @@ -739,7 +739,7 @@ def _pool_and_reshape(net): return outputs -class AssembleNet(tf.keras.Model): +class AssembleNet(tf_keras.Model): """AssembleNet backbone.""" def __init__( @@ -766,7 +766,7 @@ def __init__( inputs of the same resolution. num_frames: the number of frames in the input tensor. model_structure: AssembleNet model structure in the string format. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. Dimension should be `[batch*time, height, width, channels]`. model_edge_weights: AssembleNet model structure connection weights in the string format. @@ -776,8 +776,8 @@ def __init__( combine_method: 'str' for the weighted summation to fuse different blocks. **kwargs: pass through arguments. """ - inputs = tf.keras.Input(shape=input_specs.shape[1:]) - data_format = tf.keras.backend.image_data_format() + inputs = tf_keras.Input(shape=input_specs.shape[1:]) + data_format = tf_keras.backend.image_data_format() # Creation of the model graph. logging.info('model_structure=%r', model_structure) @@ -883,7 +883,7 @@ def __init__( inputs=original_inputs, outputs=streams, **kwargs) -class AssembleNetModel(tf.keras.Model): +class AssembleNetModel(tf_keras.Model): """An AssembleNet model builder.""" def __init__(self, @@ -892,7 +892,7 @@ def __init__(self, num_frames: int, model_structure: List[Any], input_specs: Optional[Mapping[str, - tf.keras.layers.InputSpec]] = None, + tf_keras.layers.InputSpec]] = None, max_pool_predictions: bool = False, **kwargs): if not input_specs: @@ -914,7 +914,7 @@ def __init__(self, grouping[model_structure[i][0]].append(i) inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } streams = self._backbone(inputs['image']) @@ -985,7 +985,7 @@ def assemblenet_v1(assemblenet_depth: int, **kwargs): """Returns the AssembleNet model for a given size and number of output classes.""" - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' if assemblenet_depth not in ASSEMBLENET_SPECS: @@ -1014,11 +1014,11 @@ def assemblenet_v1(assemblenet_depth: int, @backbone_factory.register_backbone_builder('assemblenet') def build_assemblenet_v1( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds assemblenet backbone.""" del l2_regularizer @@ -1055,10 +1055,10 @@ def build_assemblenet_v1( @model_factory.register_model_builder('assemblenet') def build_assemblenet_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: cfg.AssembleNetModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds assemblenet model.""" input_specs_dict = {'image': input_specs} backbone = build_assemblenet_v1(input_specs, model_config.backbone, diff --git a/official/projects/assemblenet/modeling/assemblenet_plus.py b/official/projects/assemblenet/modeling/assemblenet_plus.py index e4eb289d55b..c077ab31cdc 100644 --- a/official/projects/assemblenet/modeling/assemblenet_plus.py +++ b/official/projects/assemblenet/modeling/assemblenet_plus.py @@ -58,7 +58,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.assemblenet.configs import assemblenet as cfg @@ -67,7 +67,7 @@ from official.vision.modeling import factory_3d as model_factory from official.vision.modeling.backbones import factory as backbone_factory -layers = tf.keras.layers +layers = tf_keras.layers def softmax_merge_peer_attentions(peers): @@ -80,11 +80,11 @@ def softmax_merge_peer_attentions(peers): Returns: The output `Tensor` of size `[batch*time, channels]. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() dtype = peers[0].dtype assert data_format == 'channels_last' - initial_attn_weights = tf.keras.initializers.TruncatedNormal(stddev=0.01)( + initial_attn_weights = tf_keras.initializers.TruncatedNormal(stddev=0.01)( [len(peers)]) attn_weights = tf.cast(tf.nn.softmax(initial_attn_weights), dtype) weighted_peers = [] @@ -116,7 +116,7 @@ def apply_attention(inputs, Returns: The output `Tensor` after concatenation. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' if use_5d_mode: @@ -128,7 +128,7 @@ def apply_attention(inputs, attn = softmax_merge_peer_attentions(attention_in) else: attn = tf.math.reduce_mean(inputs, [h_channel_loc, h_channel_loc + 1]) - attn = tf.keras.layers.Dense( + attn = tf_keras.layers.Dense( units=inputs.shape[-1], kernel_initializer=tf.random_normal_initializer(stddev=.01))( inputs=attn) @@ -180,7 +180,7 @@ def __init__(self, self._use_5d_mode = use_5d_mode self._model_edge_weights = model_edge_weights self._num_object_classes = num_object_classes - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' def get_config(self): @@ -202,7 +202,7 @@ def build(self, input_shape: tf.TensorShape): if self._index is None or not self._model_edge_weights: self._edge_weights = self.add_weight( shape=self._weights_shape, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( mean=0.0, stddev=0.01), trainable=True, name='agg_weights') @@ -253,11 +253,11 @@ def call(self, assert sm_size[0] != 0 ratio = (inp.shape[h_channel_loc] + 1) // sm_size[0] if use_5d_mode: - inp = tf.keras.layers.MaxPool3D([1, ratio, ratio], [1, ratio, ratio], + inp = tf_keras.layers.MaxPool3D([1, ratio, ratio], [1, ratio, ratio], padding='same')( inp) else: - inp = tf.keras.layers.MaxPool2D([ratio, ratio], ratio, + inp = tf_keras.layers.MaxPool2D([ratio, ratio], ratio, padding='same')( inp) @@ -375,7 +375,7 @@ def object_conv_stem(inputs): Returns: The output `Tensor`. """ - inputs = tf.keras.layers.MaxPool2D( + inputs = tf_keras.layers.MaxPool2D( pool_size=4, strides=4, padding='SAME')( inputs=inputs) inputs = tf.identity(inputs, 'initial_max_pool') @@ -383,7 +383,7 @@ def object_conv_stem(inputs): return inputs -class AssembleNetPlus(tf.keras.Model): +class AssembleNetPlus(tf_keras.Model): """AssembleNet++ backbone.""" def __init__(self, @@ -410,7 +410,7 @@ def __init__(self, inputs of the same resolution. num_frames: the number of frames in the input tensor. model_structure: AssembleNetPlus model structure in the string format. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. Dimension should be `[batch*time, height, width, channels]`. model_edge_weights: AssembleNet model structure connection weight in the string format. @@ -425,7 +425,7 @@ def __init__(self, Model `function` that takes in `inputs` and `is_training` and returns the output `Tensor` of the AssembleNetPlus model. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() # Creation of the model graph. logging.info('model_structure=%r', model_structure) @@ -434,11 +434,11 @@ def __init__(self, structure = model_structure if use_object_input: - original_inputs = tf.keras.Input(shape=input_specs[0].shape[1:]) - object_inputs = tf.keras.Input(shape=input_specs[1].shape[1:]) + original_inputs = tf_keras.Input(shape=input_specs[0].shape[1:]) + object_inputs = tf_keras.Input(shape=input_specs[1].shape[1:]) input_specs = input_specs[0] else: - original_inputs = tf.keras.Input(shape=input_specs.shape[1:]) + original_inputs = tf_keras.Input(shape=input_specs.shape[1:]) object_inputs = None original_num_frames = num_frames @@ -529,7 +529,7 @@ def __init__(self, for node_index in nodes_below: attn = tf.reduce_mean(streams[node_index], [1, 2]) - attn = tf.keras.layers.Dense( + attn = tf_keras.layers.Dense( units=lg_channel, kernel_initializer=tf.random_normal_initializer(stddev=.01))( inputs=attn) @@ -564,8 +564,8 @@ def __init__(self, inputs=inputs, outputs=streams, **kwargs) -@tf.keras.utils.register_keras_serializable(package='Vision') -class AssembleNetPlusModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class AssembleNetPlusModel(tf_keras.Model): """An AssembleNet++ model builder.""" def __init__(self, @@ -574,7 +574,7 @@ def __init__(self, num_frames: int, model_structure: List[Any], input_specs: Optional[Dict[str, - tf.keras.layers.InputSpec]] = None, + tf_keras.layers.InputSpec]] = None, max_pool_predictions: bool = False, use_object_input: bool = False, **kwargs): @@ -602,7 +602,7 @@ def __init__(self, grouping[model_structure[i][0]].append(i) inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } if use_object_input: @@ -650,7 +650,7 @@ def assemblenet_plus(assemblenet_depth: int, **kwargs): """Returns the AssembleNet++ model for a given size and number of output classes.""" - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' if assemblenet_depth not in asn.ASSEMBLENET_SPECS: @@ -686,11 +686,11 @@ def assemblenet_plus(assemblenet_depth: int, @backbone_factory.register_backbone_builder('assemblenet_plus') def build_assemblenet_plus( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds assemblenet++ backbone.""" del l2_regularizer @@ -728,10 +728,10 @@ def build_assemblenet_plus( @model_factory.register_model_builder('assemblenet_plus') def build_assemblenet_plus_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: cfg.AssembleNetPlusModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds assemblenet++ model.""" input_specs_dict = {'image': input_specs} backbone = build_assemblenet_plus(input_specs, model_config.backbone, diff --git a/official/projects/assemblenet/modeling/assemblenet_plus_test.py b/official/projects/assemblenet/modeling/assemblenet_plus_test.py index afeb3b51ab3..bc47e771fce 100644 --- a/official/projects/assemblenet/modeling/assemblenet_plus_test.py +++ b/official/projects/assemblenet/modeling/assemblenet_plus_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.assemblenet.configs import assemblenet as asn_config from official.projects.assemblenet.modeling import assemblenet_plus as asnp @@ -39,8 +39,8 @@ def test_network_creation(self, depth, use_object_input, attention_mode): vid_input = (batch_size * num_frames, img_size, img_size, 3) obj_input = (batch_size * num_frames, img_size, img_size, num_object_classes) - input_specs = (tf.keras.layers.InputSpec(shape=(vid_input)), - tf.keras.layers.InputSpec(shape=(obj_input))) + input_specs = (tf_keras.layers.InputSpec(shape=(vid_input)), + tf_keras.layers.InputSpec(shape=(obj_input))) vid_inputs = np.random.rand(batch_size * num_frames, img_size, img_size, 3) obj_inputs = np.random.rand(batch_size * num_frames, img_size, img_size, @@ -52,7 +52,7 @@ def test_network_creation(self, depth, use_object_input, attention_mode): edge_weights = asn_config.full_asnp_structure_weights else: # video input: (batch_size, FLAGS.num_frames, image_size, image_size, 3) - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=(batch_size, num_frames, img_size, img_size, 3)) inputs = np.random.rand(batch_size, num_frames, img_size, img_size, 3) diff --git a/official/projects/assemblenet/modeling/rep_flow_2d_layer.py b/official/projects/assemblenet/modeling/rep_flow_2d_layer.py index a0aefe55246..24fe8876dd0 100644 --- a/official/projects/assemblenet/modeling/rep_flow_2d_layer.py +++ b/official/projects/assemblenet/modeling/rep_flow_2d_layer.py @@ -24,9 +24,9 @@ """ import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers BATCH_NORM_DECAY = 0.99 BATCH_NORM_EPSILON = 1e-5 @@ -53,7 +53,7 @@ def build_batch_norm(init_zero: bool = False, else: gamma_initializer = tf.ones_initializer() - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() assert data_format == 'channels_last' if data_format == 'channels_first': @@ -91,7 +91,7 @@ def divergence(p1, p2, f_grad_x, f_grad_y, name): Returns: A `Tensor` with the same `data_format` and shape as input. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() df = 'NHWC' if data_format == 'channels_last' else 'NCHW' with tf.name_scope('divergence_' + name): @@ -108,7 +108,7 @@ def divergence(p1, p2, f_grad_x, f_grad_y, name): def forward_grad(x, f_grad_x, f_grad_y, name): - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() with tf.name_scope('forward_grad_' + name): df = 'NHWC' if data_format == 'channels_last' else 'NCHW' grad_x = tf.nn.conv2d(x, f_grad_x, [1, 1, 1, 1], 'SAME', data_format=df) @@ -257,7 +257,7 @@ def build(self, input_shape: tf.TensorShape): strides=1, padding='same', use_bias=False, - kernel_initializer=tf.keras.initializers.VarianceScaling(), + kernel_initializer=tf_keras.initializers.VarianceScaling(), name='rf/bottleneck1') self._bottleneck_conv2 = layers.Conv2D( filters=self._depth, @@ -265,7 +265,7 @@ def build(self, input_shape: tf.TensorShape): strides=1, padding='same', use_bias=False, - kernel_initializer=tf.keras.initializers.VarianceScaling(), + kernel_initializer=tf_keras.initializers.VarianceScaling(), name='rf/bottleneck2') self._batch_norm = build_batch_norm(init_zero=True) @@ -280,7 +280,7 @@ def call(self, inputs: tf.Tensor, training: bool = None) -> tf.Tensor: Returns: A tensor of the same shape as the inputs. """ - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() df = 'NHWC' if data_format == 'channels_last' else 'NCHW' axis = 3 if data_format == 'channels_last' else 1 # channel axis dtype = inputs.dtype diff --git a/official/projects/assemblenet/train_test.py b/official/projects/assemblenet/train_test.py index bc4ca2b16b2..2aaf1fb0ae5 100644 --- a/official/projects/assemblenet/train_test.py +++ b/official/projects/assemblenet/train_test.py @@ -19,7 +19,7 @@ from absl import flags from absl import logging from absl.testing import flagsaver -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.assemblenet import train as train_lib from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/basnet/configs/basnet_test.py b/official/projects/basnet/configs/basnet_test.py index 81b2c2c2a62..40a499ba66e 100644 --- a/official/projects/basnet/configs/basnet_test.py +++ b/official/projects/basnet/configs/basnet_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/basnet/evaluation/metrics_test.py b/official/projects/basnet/evaluation/metrics_test.py index b6fc0656fcd..cff204fa9da 100644 --- a/official/projects/basnet/evaluation/metrics_test.py +++ b/official/projects/basnet/evaluation/metrics_test.py @@ -14,7 +14,7 @@ """Tests for metrics.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.basnet.evaluation import metrics @@ -32,7 +32,7 @@ def test_mae(self): mae_obj.update_state(labels, inputs) output = mae_obj.result() - mae_tf = tf.keras.metrics.MeanAbsoluteError() + mae_tf = tf_keras.metrics.MeanAbsoluteError() mae_tf.reset_state() mae_tf.update_state(labels[0], inputs[0]) compare = mae_tf.result().numpy() @@ -51,8 +51,8 @@ def test_max_f(self): max_f_obj.update_state(labels, inputs) output = max_f_obj.result() - pre_tf = tf.keras.metrics.Precision(thresholds=0.78) - rec_tf = tf.keras.metrics.Recall(thresholds=0.78) + pre_tf = tf_keras.metrics.Precision(thresholds=0.78) + rec_tf = tf_keras.metrics.Recall(thresholds=0.78) pre_tf.reset_state() rec_tf.reset_state() pre_tf.update_state(labels[0], inputs[0]) diff --git a/official/projects/basnet/losses/basnet_losses.py b/official/projects/basnet/losses/basnet_losses.py index 9009275ccfa..92350e57e56 100644 --- a/official/projects/basnet/losses/basnet_losses.py +++ b/official/projects/basnet/losses/basnet_losses.py @@ -13,7 +13,7 @@ # limitations under the License. """Losses used for BASNet models.""" -import tensorflow as tf +import tensorflow as tf, tf_keras EPSILON = 1e-5 @@ -22,8 +22,8 @@ class BASNetLoss: """BASNet hybrid loss.""" def __init__(self): - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=False) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=False) self._ssim = tf.image.ssim def __call__(self, sigmoids, labels): diff --git a/official/projects/basnet/modeling/basnet_model.py b/official/projects/basnet/modeling/basnet_model.py index bca0a52704b..aadc12c56ff 100644 --- a/official/projects/basnet/modeling/basnet_model.py +++ b/official/projects/basnet/modeling/basnet_model.py @@ -16,7 +16,7 @@ from typing import Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.basnet.modeling import nn_blocks @@ -52,8 +52,8 @@ ] -@tf.keras.utils.register_keras_serializable(package='Vision') -class BASNetModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BASNetModel(tf_keras.Model): """A BASNet model. Boundary-Awar network (BASNet) were proposed in: @@ -119,13 +119,13 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') -class BASNetEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BASNetEncoder(tf_keras.Model): """BASNet encoder.""" def __init__( self, - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), activation='relu', use_sync_bn=False, use_bias=True, @@ -138,7 +138,7 @@ def __init__( """BASNet encoder initialization function. Args: - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. activation: `str` name of the activation function. use_sync_bn: if True, use synchronized batch normalization. use_bias: if True, use bias in conv2d. @@ -146,9 +146,9 @@ def __init__( norm_epsilon: `float` small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. **kwargs: keyword arguments to be passed. """ @@ -159,22 +159,22 @@ def __init__( self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = -1 else: bn_axis = 1 # Build BASNet Encoder. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) - x = tf.keras.layers.Conv2D( + x = tf_keras.layers.Conv2D( filters=64, kernel_size=3, strides=1, use_bias=self._use_bias, padding='same', kernel_initializer=self._kernel_initializer, @@ -196,7 +196,7 @@ def __init__( name='block_group_l{}'.format(i + 2)) endpoints[str(i)] = x if spec[3]: - x = tf.keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same')(x) + x = tf_keras.layers.MaxPool2D(pool_size=2, strides=2, padding='same')(x) self._output_specs = {l: endpoints[l].get_shape() for l in endpoints} super(BASNetEncoder, self).__init__( inputs=inputs, outputs=endpoints, **kwargs) @@ -263,9 +263,9 @@ def output_specs(self): @factory.register_backbone_builder('basnet_encoder') def build_basnet_encoder( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds BASNet Encoder backbone from a config.""" backbone_type = model_config.backbone.type norm_activation_config = model_config.norm_activation @@ -281,8 +281,8 @@ def build_basnet_encoder( kernel_regularizer=l2_regularizer) -@tf.keras.utils.register_keras_serializable(package='Vision') -class BASNetDecoder(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BASNetDecoder(tf_keras.layers.Layer): """BASNet decoder.""" def __init__(self, @@ -305,8 +305,8 @@ def __init__(self, norm_epsilon: `float` small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. **kwargs: keyword arguments to be passed. """ super(BASNetDecoder, self).__init__(**kwargs) @@ -322,12 +322,12 @@ def __init__(self, } self._activation = tf_utils.get_activation(activation) - self._concat = tf.keras.layers.Concatenate(axis=-1) - self._sigmoid = tf.keras.layers.Activation(activation='sigmoid') + self._concat = tf_keras.layers.Concatenate(axis=-1) + self._sigmoid = tf_keras.layers.Activation(activation='sigmoid') def build(self, input_shape): """Creates the variables of the BASNet decoder.""" - conv_op = tf.keras.layers.Conv2D + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'kernel_size': 3, 'strides': 1, @@ -358,7 +358,7 @@ def build(self, input_shape): filters=1, padding='same', **conv_kwargs)) - self._out_usmps.append(tf.keras.layers.UpSampling2D( + self._out_usmps.append(tf_keras.layers.UpSampling2D( size=spec[6], interpolation='bilinear' )) @@ -381,7 +381,7 @@ def build(self, input_shape): filters=1, padding='same', **conv_kwargs)) - self._out_usmps.append(tf.keras.layers.UpSampling2D( + self._out_usmps.append(tf_keras.layers.UpSampling2D( size=spec[6], interpolation='bilinear' )) @@ -415,7 +415,7 @@ def call(self, backbone_output: Mapping[str, tf.Tensor]): for block in blocks: x = block(x) sup[str(i+1)] = x - x = tf.keras.layers.UpSampling2D( + x = tf_keras.layers.UpSampling2D( size=2, interpolation='bilinear' )(x) diff --git a/official/projects/basnet/modeling/basnet_model_test.py b/official/projects/basnet/modeling/basnet_model_test.py index b6a393a0d3a..9616332394e 100644 --- a/official/projects/basnet/modeling/basnet_model_test.py +++ b/official/projects/basnet/modeling/basnet_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.basnet.modeling import basnet_model from official.projects.basnet.modeling import refunet @@ -32,7 +32,7 @@ def test_basnet_network_creation( self, input_size): """Test for creation of a segmentation network.""" inputs = np.random.rand(2, input_size, input_size, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = basnet_model.BASNetEncoder() decoder = basnet_model.BASNetDecoder() diff --git a/official/projects/basnet/modeling/nn_blocks.py b/official/projects/basnet/modeling/nn_blocks.py index bb618f73c55..68bfa7ec34d 100644 --- a/official/projects/basnet/modeling/nn_blocks.py +++ b/official/projects/basnet/modeling/nn_blocks.py @@ -14,13 +14,13 @@ """Contains common building blocks for BasNet model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class ConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ConvBlock(tf_keras.layers.Layer): """A (Conv+BN+Activation) block.""" def __init__(self, @@ -47,9 +47,9 @@ def __init__(self, dilation_rate: `int`, dilation rate for conv layers. kernel_size: `int`, kernel size of conv layers. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. activation: `str` name of the activation function. use_bias: `bool`, whether or not use bias in conv layers. @@ -75,10 +75,10 @@ def __init__(self, 'norm_epsilon': norm_epsilon } if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -93,7 +93,7 @@ def build(self, input_shape): 'bias_regularizer': self._config_dict['bias_regularizer'], } - self._conv0 = tf.keras.layers.Conv2D( + self._conv0 = tf_keras.layers.Conv2D( filters=self._config_dict['filters'], kernel_size=self._config_dict['kernel_size'], strides=self._config_dict['strides'], @@ -117,8 +117,8 @@ def call(self, inputs, training=None): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResBlock(tf_keras.layers.Layer): """A residual block.""" def __init__(self, @@ -147,9 +147,9 @@ def __init__(self, filters and the resolution. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -173,10 +173,10 @@ def __init__(self, 'norm_epsilon': norm_epsilon } if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -193,7 +193,7 @@ def build(self, input_shape): } if self._config_dict['use_projection']: - self._shortcut = tf.keras.layers.Conv2D( + self._shortcut = tf_keras.layers.Conv2D( filters=self._config_dict['filters'], kernel_size=1, strides=self._config_dict['strides'], @@ -206,7 +206,7 @@ def build(self, input_shape): momentum=self._config_dict['norm_momentum'], epsilon=self._config_dict['norm_epsilon']) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( kernel_size=3, strides=self._config_dict['strides'], **conv_kwargs) @@ -215,7 +215,7 @@ def build(self, input_shape): momentum=self._config_dict['norm_momentum'], epsilon=self._config_dict['norm_epsilon']) - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( kernel_size=3, strides=1, **conv_kwargs) diff --git a/official/projects/basnet/modeling/refunet.py b/official/projects/basnet/modeling/refunet.py index 36f1b7dfc29..93eb167d400 100644 --- a/official/projects/basnet/modeling/refunet.py +++ b/official/projects/basnet/modeling/refunet.py @@ -13,12 +13,12 @@ # limitations under the License. """RefUNet model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.basnet.modeling import nn_blocks -@tf.keras.utils.register_keras_serializable(package='Vision') -class RefUnet(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RefUnet(tf_keras.layers.Layer): """Residual Refinement Module of BASNet. Boundary-Aware network (BASNet) were proposed in: @@ -46,9 +46,9 @@ def __init__(self, norm_epsilon: `float` small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. **kwargs: keyword arguments to be passed. """ @@ -63,19 +63,19 @@ def __init__(self, 'kernel_regularizer': kernel_regularizer, 'bias_regularizer': bias_regularizer, } - self._concat = tf.keras.layers.Concatenate(axis=-1) - self._sigmoid = tf.keras.layers.Activation(activation='sigmoid') - self._maxpool = tf.keras.layers.MaxPool2D( + self._concat = tf_keras.layers.Concatenate(axis=-1) + self._sigmoid = tf_keras.layers.Activation(activation='sigmoid') + self._maxpool = tf_keras.layers.MaxPool2D( pool_size=2, strides=2, padding='valid') - self._upsample = tf.keras.layers.UpSampling2D( + self._upsample = tf_keras.layers.UpSampling2D( size=2, interpolation='bilinear') def build(self, input_shape): """Creates the variables of the BASNet decoder.""" - conv_op = tf.keras.layers.Conv2D + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'kernel_size': 3, 'strides': 1, diff --git a/official/projects/basnet/serving/basnet.py b/official/projects/basnet/serving/basnet.py index 5514e84ea39..99670f269e7 100644 --- a/official/projects/basnet/serving/basnet.py +++ b/official/projects/basnet/serving/basnet.py @@ -14,7 +14,7 @@ """Export module for BASNet.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.basnet.tasks import basnet from official.vision.serving import semantic_segmentation @@ -24,7 +24,7 @@ class BASNetModule(semantic_segmentation.SegmentationModule): """BASNet Module.""" def _build_model(self): - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[self._batch_size] + self._input_image_size + [3]) return basnet.build_basnet_model( diff --git a/official/projects/basnet/tasks/basnet.py b/official/projects/basnet/tasks/basnet.py index 0763ba86a7e..68f6260391d 100644 --- a/official/projects/basnet/tasks/basnet.py +++ b/official/projects/basnet/tasks/basnet.py @@ -16,7 +16,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -31,9 +31,9 @@ def build_basnet_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: exp_cfg.BASNetModel, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds BASNet model.""" norm_activation_config = model_config.norm_activation backbone = basnet_model.BASNetEncoder( @@ -71,14 +71,14 @@ class BASNetTask(base_task.Task): def build_model(self): """Builds basnet model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = build_basnet_model( @@ -87,7 +87,7 @@ def build_model(self): l2_regularizer=l2_regularizer) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -203,7 +203,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables @@ -211,7 +211,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) # Apply gradient clipping. diff --git a/official/projects/bigbird/encoder.py b/official/projects/bigbird/encoder.py index ffb5d60193e..d2f8d6cf994 100644 --- a/official/projects/bigbird/encoder.py +++ b/official/projects/bigbird/encoder.py @@ -15,7 +15,7 @@ """Transformer-based text encoder network.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations from official.modeling import tf_utils @@ -51,8 +51,8 @@ def f(*args): return f(emb, *mask) -@tf.keras.utils.register_keras_serializable(package='Text') -class BigBirdEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BigBirdEncoder(tf_keras.Model): """Transformer-based encoder network with BigBird attentions. *Note* that the network is constructed by @@ -101,15 +101,15 @@ def __init__(self, activation=activations.gelu, dropout_rate=0.1, attention_dropout_rate=0.1, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), embedding_width=None, use_gradient_checkpointing=False, **kwargs): - activation = tf.keras.activations.get(activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(activation) + initializer = tf_keras.initializers.get(initializer) if use_gradient_checkpointing: - tf.keras.layers.Dropout = recomputing_dropout.RecomputingDropout + tf_keras.layers.Dropout = recomputing_dropout.RecomputingDropout layer_cls = RecomputeTransformerLayer else: layer_cls = layers.TransformerScaffold @@ -136,11 +136,11 @@ def __init__(self, 'embedding_width': embedding_width, } - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') if embedding_width is None: @@ -166,19 +166,19 @@ def __init__(self, name='type_embeddings') type_embeddings = self._type_embedding_layer(type_ids) - embeddings = tf.keras.layers.Add()( + embeddings = tf_keras.layers.Add()( [word_embeddings, position_embeddings, type_embeddings]) - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) embeddings = self._embedding_norm_layer(embeddings) - embeddings = tf.keras.layers.Dropout(rate=dropout_rate)(embeddings) + embeddings = tf_keras.layers.Dropout(rate=dropout_rate)(embeddings) # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', diff --git a/official/projects/bigbird/encoder_test.py b/official/projects/bigbird/encoder_test.py index 6a9a11d8bd3..ebfb80aaa54 100644 --- a/official/projects/bigbird/encoder_test.py +++ b/official/projects/bigbird/encoder_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.projects.bigbird.encoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.bigbird import encoder @@ -53,7 +53,7 @@ def test_save_restore(self): ref_outputs = network(inputs) model_path = self.get_temp_dir() + "/model" network.save(model_path) - loaded = tf.keras.models.load_model(model_path) + loaded = tf_keras.models.load_model(model_path) outputs = loaded(inputs) self.assertAllClose(outputs["sequence_output"], ref_outputs["sequence_output"]) diff --git a/official/projects/bigbird/recompute_grad.py b/official/projects/bigbird/recompute_grad.py index 1ea5f57863b..83501b08bfd 100644 --- a/official/projects/bigbird/recompute_grad.py +++ b/official/projects/bigbird/recompute_grad.py @@ -23,7 +23,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras class RecomputeContext( diff --git a/official/projects/bigbird/recomputing_dropout.py b/official/projects/bigbird/recomputing_dropout.py index ef29b479cc0..84b865e4980 100644 --- a/official/projects/bigbird/recomputing_dropout.py +++ b/official/projects/bigbird/recomputing_dropout.py @@ -15,7 +15,7 @@ """Keras dropout layer that is aware of `RecomputeContext`.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.bigbird import recompute_grad as recompute_grad_lib from official.projects.bigbird import stateless_dropout as stateless_dropout_lib @@ -57,8 +57,8 @@ def smart_cond(pred, true_fn=None, false_fn=None, name=None): # See https://www.tensorflow.org/api_docs/python/tf/keras/layers/Dropout. -class RecomputingDropout(tf.keras.layers.Layer): - """`tf.keras.layers.Dropout` that supports `recompute_grad`.""" +class RecomputingDropout(tf_keras.layers.Layer): + """`tf_keras.layers.Dropout` that supports `recompute_grad`.""" def __init__(self, rate, @@ -78,7 +78,7 @@ def __init__(self, seed: A Python integer to use as random seed. force_recomputation: If `True`, then raises an error if called outside a recompute context. - **kwargs: Keyword arguments for `tf.keras.layers.Layer`. + **kwargs: Keyword arguments for `tf_keras.layers.Layer`. """ super(RecomputingDropout, self).__init__(**kwargs) @@ -121,7 +121,7 @@ def call(self, inputs, training=None): a recompute context. """ if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() def dropped_inputs(): """Randomly drops elements of `inputs` when `training=True`.""" diff --git a/official/projects/bigbird/stateless_dropout.py b/official/projects/bigbird/stateless_dropout.py index 4055f5f12ac..7f0c5084d72 100644 --- a/official/projects/bigbird/stateless_dropout.py +++ b/official/projects/bigbird/stateless_dropout.py @@ -18,7 +18,7 @@ from typing import Optional, Sequence, Text, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def _as_shape(shape: Union[Sequence[int], tf.TensorShape]) -> tf.TensorShape: diff --git a/official/projects/centernet/configs/centernet_test.py b/official/projects/centernet/configs/centernet_test.py index 91674900d8f..ba2c581c1e8 100644 --- a/official/projects/centernet/configs/centernet_test.py +++ b/official/projects/centernet/configs/centernet_test.py @@ -15,7 +15,7 @@ """Tests for centernet.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/centernet/dataloaders/centernet_input.py b/official/projects/centernet/dataloaders/centernet_input.py index a7e037c964f..259cd633f8d 100644 --- a/official/projects/centernet/dataloaders/centernet_input.py +++ b/official/projects/centernet/dataloaders/centernet_input.py @@ -16,7 +16,7 @@ from typing import Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.ops import box_list from official.projects.centernet.ops import box_list_ops diff --git a/official/projects/centernet/losses/centernet_losses.py b/official/projects/centernet/losses/centernet_losses.py index 8a78e811f4b..cac5387b944 100644 --- a/official/projects/centernet/losses/centernet_losses.py +++ b/official/projects/centernet/losses/centernet_losses.py @@ -15,7 +15,7 @@ """Losses for centernet model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras class PenaltyReducedLogisticFocalLoss(object): diff --git a/official/projects/centernet/losses/centernet_losses_test.py b/official/projects/centernet/losses/centernet_losses_test.py index 9229d0a548a..956e91d8904 100644 --- a/official/projects/centernet/losses/centernet_losses_test.py +++ b/official/projects/centernet/losses/centernet_losses_test.py @@ -15,7 +15,7 @@ """Tests for losses of centernet model.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.losses import centernet_losses diff --git a/official/projects/centernet/modeling/backbones/hourglass.py b/official/projects/centernet/modeling/backbones/hourglass.py index f338fc1c3f4..48aab58055f 100644 --- a/official/projects/centernet/modeling/backbones/hourglass.py +++ b/official/projects/centernet/modeling/backbones/hourglass.py @@ -16,7 +16,7 @@ from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.centernet.modeling.layers import cn_nn_blocks @@ -48,14 +48,14 @@ } -class Hourglass(tf.keras.Model): +class Hourglass(tf_keras.Model): """CenterNet Hourglass backbone.""" def __init__( self, model_id: int, input_channel_dims: int, - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), num_hourglasses: int = 1, initial_downsample: bool = True, activation: str = 'relu', @@ -63,8 +63,8 @@ def __init__( norm_momentum=0.1, norm_epsilon=1e-5, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize Hourglass backbone. @@ -72,7 +72,7 @@ def __init__( model_id: An `int` of the scale of Hourglass backbone model. input_channel_dims: `int`, number of filters used to downsample the input image. - input_specs: A `tf.keras.layers.InputSpec` of specs of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of specs of the input tensor. num_hourglasses: `int``, number of hourglass blocks in backbone. For example, hourglass-104 has two hourglass-52 modules. initial_downsample: `bool`, whether or not to downsample the input. @@ -81,9 +81,9 @@ def __init__( norm_momentum: `float`, momentum for the batch normalization layers. norm_epsilon: `float`, epsilon for the batch normalization layers. kernel_initializer: A `str` for kernel initializer of conv layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -104,7 +104,7 @@ def __init__( self._channel_dims_per_stage = [item * self._input_channel_dims for item in specs['channel_dims_per_stage']] - inputs = tf.keras.layers.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.layers.Input(shape=input_specs.shape[1:]) inp_filters = self._channel_dims_per_stage[0] @@ -203,8 +203,8 @@ def __init__( norm_epsilon=self._norm_epsilon )(x_hg) - x_downsampled = tf.keras.layers.Add()([inter_hg_conv1, inter_hg_conv2]) - x_downsampled = tf.keras.layers.ReLU()(x_downsampled) + x_downsampled = tf_keras.layers.Add()([inter_hg_conv1, inter_hg_conv2]) + x_downsampled = tf_keras.layers.ReLU()(x_downsampled) x_downsampled = nn_blocks.ResidualBlock( filters=inp_filters, @@ -250,11 +250,11 @@ def output_specs(self): @factory.register_backbone_builder('hourglass') def build_hourglass( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None - ) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None + ) -> tf_keras.Model: """Builds Hourglass backbone from a configuration.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/projects/centernet/modeling/backbones/hourglass_test.py b/official/projects/centernet/modeling/backbones/hourglass_test.py index 98a4dfb59c7..b22996bc230 100644 --- a/official/projects/centernet/modeling/backbones/hourglass_test.py +++ b/official/projects/centernet/modeling/backbones/hourglass_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.common import registry_imports # pylint: disable=unused-import from official.projects.centernet.configs import backbones @@ -28,7 +28,7 @@ class HourglassTest(tf.test.TestCase, parameterized.TestCase): def test_hourglass(self): backbone = hourglass.build_hourglass( - input_specs=tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, 512, 512, 3]), backbone_config=backbones.Backbone(type='hourglass'), norm_activation_config=common.NormActivation(use_sync_bn=True) ) diff --git a/official/projects/centernet/modeling/centernet_model.py b/official/projects/centernet/modeling/centernet_model.py index 84f2d2bc2c7..be704e9b026 100644 --- a/official/projects/centernet/modeling/centernet_model.py +++ b/official/projects/centernet/modeling/centernet_model.py @@ -16,16 +16,16 @@ from typing import Mapping, Union, Any -import tensorflow as tf +import tensorflow as tf, tf_keras -class CenterNetModel(tf.keras.Model): +class CenterNetModel(tf_keras.Model): """CenterNet Model.""" def __init__(self, - backbone: tf.keras.Model, - head: tf.keras.Model, - detection_generator: tf.keras.layers.Layer, + backbone: tf_keras.Model, + head: tf_keras.Model, + detection_generator: tf_keras.layers.Layer, **kwargs): """CenterNet Model. @@ -55,7 +55,7 @@ def call(self, # pytype: disable=signature-mismatch # overriding-parameter-cou @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) diff --git a/official/projects/centernet/modeling/centernet_model_test.py b/official/projects/centernet/modeling/centernet_model_test.py index b6b4bd151d3..127057bc54b 100644 --- a/official/projects/centernet/modeling/centernet_model_test.py +++ b/official/projects/centernet/modeling/centernet_model_test.py @@ -15,7 +15,7 @@ """Test for centernet detection model.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.configs import backbones from official.projects.centernet.modeling import centernet_model @@ -29,7 +29,7 @@ class CenterNetTest(parameterized.TestCase, tf.test.TestCase): def testBuildCenterNet(self): backbone = hourglass.build_hourglass( - input_specs=tf.keras.layers.InputSpec(shape=[None, 512, 512, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, 512, 512, 3]), backbone_config=backbones.Backbone(type='hourglass'), norm_activation_config=common.NormActivation(use_sync_bn=True) ) diff --git a/official/projects/centernet/modeling/heads/centernet_head.py b/official/projects/centernet/modeling/heads/centernet_head.py index 14241a4f19b..7c783829ead 100644 --- a/official/projects/centernet/modeling/heads/centernet_head.py +++ b/official/projects/centernet/modeling/heads/centernet_head.py @@ -16,12 +16,12 @@ from typing import Any, Dict, List, Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.modeling.layers import cn_nn_blocks -class CenterNetHead(tf.keras.Model): +class CenterNetHead(tf_keras.Model): """CenterNet Head.""" def __init__(self, @@ -61,7 +61,7 @@ def __init__(self, self._heatmap_bias = heatmap_bias self._num_inputs = len(input_levels) - inputs = {level: tf.keras.layers.Input(shape=self._input_specs[level][1:]) + inputs = {level: tf_keras.layers.Input(shape=self._input_specs[level][1:]) for level in input_levels} outputs = {} diff --git a/official/projects/centernet/modeling/heads/centernet_head_test.py b/official/projects/centernet/modeling/heads/centernet_head_test.py index 4c98ee10a52..5243f2d0eef 100644 --- a/official/projects/centernet/modeling/heads/centernet_head_test.py +++ b/official/projects/centernet/modeling/heads/centernet_head_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.modeling.heads import centernet_head @@ -30,8 +30,8 @@ def test_decoder_shape(self): 'ct_size': 2, } input_specs = { - '2_0': tf.keras.layers.InputSpec(shape=(None, 128, 128, 256)).shape, - '2': tf.keras.layers.InputSpec(shape=(None, 128, 128, 256)).shape, + '2_0': tf_keras.layers.InputSpec(shape=(None, 128, 128, 256)).shape, + '2': tf_keras.layers.InputSpec(shape=(None, 128, 128, 256)).shape, } input_levels = ['2', '2_0'] diff --git a/official/projects/centernet/modeling/layers/cn_nn_blocks.py b/official/projects/centernet/modeling/layers/cn_nn_blocks.py index 3b06fa2e46d..a44704dcf24 100644 --- a/official/projects/centernet/modeling/layers/cn_nn_blocks.py +++ b/official/projects/centernet/modeling/layers/cn_nn_blocks.py @@ -16,7 +16,7 @@ from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import nn_blocks @@ -41,8 +41,8 @@ def _make_repeated_residual_blocks( initial_stride: int = 1, initial_skip_conv: bool = False, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, ): """Stack Residual blocks one after the other. @@ -61,9 +61,9 @@ def _make_repeated_residual_blocks( convolution. This is useful when the number of channels in the input are not the same as residual_channels. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. Returns: @@ -120,10 +120,10 @@ def _make_repeated_residual_blocks( kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)) - return tf.keras.Sequential(blocks) + return tf_keras.Sequential(blocks) -class HourglassBlock(tf.keras.layers.Layer): +class HourglassBlock(tf_keras.layers.Layer): """Hourglass module: an encoder-decoder block.""" def __init__( @@ -135,8 +135,8 @@ def __init__( norm_momentum: float = 0.1, norm_epsilon: float = 1e-5, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize Hourglass module. @@ -158,9 +158,9 @@ def __init__( norm_momentum: `float`, momentum for the batch normalization layers. norm_epsilon: `float`, epsilon for the batch normalization layers. kernel_initializer: A `str` for kernel initializer of conv layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -241,7 +241,7 @@ def build(self, input_shape): kernel_initializer=self._kernel_initializer, kernel_regularizer=self._kernel_regularizer) - self.upsample_layer = tf.keras.layers.UpSampling2D( + self.upsample_layer = tf_keras.layers.UpSampling2D( size=2, interpolation='nearest') @@ -273,7 +273,7 @@ def get_config(self): return config -class CenterNetHeadConv(tf.keras.layers.Layer): +class CenterNetHeadConv(tf_keras.layers.Layer): """Convolution block for the CenterNet head.""" def __init__(self, @@ -297,15 +297,15 @@ def __init__(self, def build(self, input_shape): n_channels = input_shape[-1] - self.conv1 = tf.keras.layers.Conv2D( + self.conv1 = tf_keras.layers.Conv2D( filters=n_channels, kernel_size=(3, 3), padding='same') - self.relu = tf.keras.layers.ReLU() + self.relu = tf_keras.layers.ReLU() # Initialize bias to the last Conv2D Layer - self.conv2 = tf.keras.layers.Conv2D( + self.conv2 = tf_keras.layers.Conv2D( filters=self._output_filters, kernel_size=(1, 1), padding='valid', diff --git a/official/projects/centernet/modeling/layers/cn_nn_blocks_test.py b/official/projects/centernet/modeling/layers/cn_nn_blocks_test.py index 1ecb12412ad..e9ea90074d0 100644 --- a/official/projects/centernet/modeling/layers/cn_nn_blocks_test.py +++ b/official/projects/centernet/modeling/layers/cn_nn_blocks_test.py @@ -19,13 +19,13 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.modeling.layers import cn_nn_blocks from official.vision.modeling.layers import nn_blocks -class HourglassBlockPyTorch(tf.keras.layers.Layer): +class HourglassBlockPyTorch(tf_keras.layers.Layer): """An CornerNet-style implementation of the hourglass block.""" def __init__(self, dims, modules, k=0, **kwargs): @@ -63,7 +63,7 @@ def build(self, input_shape): next_dim = dims[k + 1] self.up1 = self.make_up_layer(3, curr_dim, curr_dim, curr_mod, **kwargs) - self.max1 = tf.keras.layers.MaxPool2D(strides=2) + self.max1 = tf_keras.layers.MaxPool2D(strides=2) self.low1 = self.make_hg_layer(3, curr_dim, next_dim, curr_mod, **kwargs) if self.n - k > 1: self.low2 = type(self)(dims, modules, k=k + 1, **kwargs) @@ -72,8 +72,8 @@ def build(self, input_shape): 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 = tf.keras.layers.UpSampling2D(2) - self.merge = tf.keras.layers.Add() + self.up2 = tf_keras.layers.UpSampling2D(2) + self.merge = tf_keras.layers.Add() super(HourglassBlockPyTorch, self).build(input_shape) @@ -91,7 +91,7 @@ def make_layer(self, k, inp_dim, out_dim, modules, **kwargs): nn_blocks.ResidualBlock(out_dim, 1, use_projection=True, **kwargs)] for _ in range(1, modules): layers.append(nn_blocks.ResidualBlock(out_dim, 1, **kwargs)) - return tf.keras.Sequential(layers) + return tf_keras.Sequential(layers) def make_layer_revr(self, k, inp_dim, out_dim, modules, **kwargs): layers = [] @@ -100,7 +100,7 @@ def make_layer_revr(self, k, inp_dim, out_dim, modules, **kwargs): nn_blocks.ResidualBlock(inp_dim, 1, **kwargs)) layers.append( nn_blocks.ResidualBlock(out_dim, 1, use_projection=True, **kwargs)) - return tf.keras.Sequential(layers) + 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) @@ -121,7 +121,7 @@ def test_hourglass_block(self): dims = [256, 256, 384, 384, 384, 512] modules = [2, 2, 2, 2, 2, 4] model = cn_nn_blocks.HourglassBlock(dims, modules) - test_input = tf.keras.Input((512, 512, 256)) + test_input = tf_keras.Input((512, 512, 256)) _ = model(test_input) filter_sizes = [256, 256, 384, 384, 384, 512] diff --git a/official/projects/centernet/modeling/layers/detection_generator.py b/official/projects/centernet/modeling/layers/detection_generator.py index 775b8706d3a..169def4c0b5 100644 --- a/official/projects/centernet/modeling/layers/detection_generator.py +++ b/official/projects/centernet/modeling/layers/detection_generator.py @@ -23,14 +23,14 @@ from typing import Any, Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.ops import loss_ops from official.projects.centernet.ops import nms_ops from official.vision.ops import box_ops -class CenterNetDetectionGenerator(tf.keras.layers.Layer): +class CenterNetDetectionGenerator(tf_keras.layers.Layer): """CenterNet Detection Generator.""" def __init__(self, diff --git a/official/projects/centernet/modeling/layers/detection_generator_test.py b/official/projects/centernet/modeling/layers/detection_generator_test.py index c5c827b3f53..e0dbc033b6b 100644 --- a/official/projects/centernet/modeling/layers/detection_generator_test.py +++ b/official/projects/centernet/modeling/layers/detection_generator_test.py @@ -17,7 +17,7 @@ from collections.abc import Mapping, Sequence from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.modeling.layers import detection_generator diff --git a/official/projects/centernet/ops/box_list.py b/official/projects/centernet/ops/box_list.py index 87f621d1423..9cc44061dc9 100644 --- a/official/projects/centernet/ops/box_list.py +++ b/official/projects/centernet/ops/box_list.py @@ -33,7 +33,7 @@ * Tensors are always provided as (flat) [N, 4] tensors. """ -import tensorflow as tf +import tensorflow as tf, tf_keras def _get_dim_as_int(dim): diff --git a/official/projects/centernet/ops/box_list_ops.py b/official/projects/centernet/ops/box_list_ops.py index 1916ab3284b..97666ca0473 100644 --- a/official/projects/centernet/ops/box_list_ops.py +++ b/official/projects/centernet/ops/box_list_ops.py @@ -14,7 +14,7 @@ """Bounding Box List operations.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.ops import box_list from official.vision.ops import sampling_ops diff --git a/official/projects/centernet/ops/loss_ops.py b/official/projects/centernet/ops/loss_ops.py index f7c40bdc402..55b1d4c8acf 100644 --- a/official/projects/centernet/ops/loss_ops.py +++ b/official/projects/centernet/ops/loss_ops.py @@ -14,7 +14,7 @@ """Operations for compute losses for centernet.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import sampling_ops diff --git a/official/projects/centernet/ops/nms_ops.py b/official/projects/centernet/ops/nms_ops.py index af7a34e3a47..b7c4e5a1ad7 100644 --- a/official/projects/centernet/ops/nms_ops.py +++ b/official/projects/centernet/ops/nms_ops.py @@ -14,7 +14,7 @@ """nms computation.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops diff --git a/official/projects/centernet/ops/preprocess_ops.py b/official/projects/centernet/ops/preprocess_ops.py index 05eb2b2301e..8f10198daf7 100644 --- a/official/projects/centernet/ops/preprocess_ops.py +++ b/official/projects/centernet/ops/preprocess_ops.py @@ -16,7 +16,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.ops import box_list from official.projects.centernet.ops import box_list_ops diff --git a/official/projects/centernet/ops/target_assigner.py b/official/projects/centernet/ops/target_assigner.py index 7079d8c7266..455deec7c91 100644 --- a/official/projects/centernet/ops/target_assigner.py +++ b/official/projects/centernet/ops/target_assigner.py @@ -16,7 +16,7 @@ from typing import Dict, List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import sampling_ops diff --git a/official/projects/centernet/ops/target_assigner_test.py b/official/projects/centernet/ops/target_assigner_test.py index 5a39be9684c..fea9e922d6b 100644 --- a/official/projects/centernet/ops/target_assigner_test.py +++ b/official/projects/centernet/ops/target_assigner_test.py @@ -15,7 +15,7 @@ """Tests for targets generations of centernet.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.ops import target_assigner from official.vision.ops import preprocess_ops diff --git a/official/projects/centernet/tasks/centernet.py b/official/projects/centernet/tasks/centernet.py index af272deaffc..ff8f9e52a53 100644 --- a/official/projects/centernet/tasks/centernet.py +++ b/official/projects/centernet/tasks/centernet.py @@ -17,7 +17,7 @@ from typing import Any, List, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import input_reader @@ -90,14 +90,14 @@ def build_inputs(self, def build_model(self): """get an instance of CenterNet.""" model_config = self.task_config.model - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + model_config.input_size) l2_weight_decay = self.task_config.weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) backbone = factory.build_backbone( @@ -145,7 +145,7 @@ def build_model(self): return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -305,7 +305,7 @@ def build_metrics(self, training=True): metrics = [] metric_names = ['total_loss', 'ct_loss', 'scale_loss', 'ct_offset_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if not training: if (self.task_config.validation_data.tfds_name @@ -321,8 +321,8 @@ def build_metrics(self, training=True): def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. @@ -349,7 +349,7 @@ def train_step(self, scaled_loss = losses['total_loss'] / num_replicas # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) # compute the gradient @@ -357,7 +357,7 @@ def train_step(self, gradients = tape.gradient(scaled_loss, tvars) # get unscaled loss if the scaled loss was used - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): gradients = optimizer.get_unscaled_gradients(gradients) if self.task_config.gradient_clip_norm > 0.0: @@ -377,7 +377,7 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validation step. diff --git a/official/projects/centernet/utils/checkpoints/config_classes.py b/official/projects/centernet/utils/checkpoints/config_classes.py index 6d50aab324d..ea0eebab86e 100644 --- a/official/projects/centernet/utils/checkpoints/config_classes.py +++ b/official/projects/centernet/utils/checkpoints/config_classes.py @@ -26,7 +26,7 @@ from typing import Dict, Optional import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras class Config(abc.ABC): @@ -36,7 +36,7 @@ def get_weights(self): """Generates the weights needed to be loaded into the layer.""" raise NotImplementedError - def load_weights(self, layer: tf.keras.layers.Layer) -> int: + def load_weights(self, layer: tf_keras.layers.Layer) -> int: """Assign weights to layer. Given a layer, this function retrieves the weights for that layer in an @@ -47,7 +47,7 @@ def load_weights(self, layer: tf.keras.layers.Layer) -> int: will be raised by set_weights(). Args: - layer: A `tf.keras.layers.Layer`. + layer: A `tf_keras.layers.Layer`. Returns: diff --git a/official/projects/centernet/utils/checkpoints/read_checkpoints.py b/official/projects/centernet/utils/checkpoints/read_checkpoints.py index 1c16513e229..f743c7f24cc 100644 --- a/official/projects/centernet/utils/checkpoints/read_checkpoints.py +++ b/official/projects/centernet/utils/checkpoints/read_checkpoints.py @@ -15,7 +15,7 @@ """Functions used to convert a TF checkpoint into a dictionary.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras def update_weights_dict(weights_dict, variable_key, value): diff --git a/official/projects/centernet/utils/tf2_centernet_checkpoint_converter.py b/official/projects/centernet/utils/tf2_centernet_checkpoint_converter.py index 01ea2e194ee..b71ada492c2 100644 --- a/official/projects/centernet/utils/tf2_centernet_checkpoint_converter.py +++ b/official/projects/centernet/utils/tf2_centernet_checkpoint_converter.py @@ -17,7 +17,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.centernet.common import registry_imports # pylint: disable=unused-import from official.projects.centernet.configs import backbones @@ -58,7 +58,7 @@ def _create_centernet_model(model_id: int = 52, model_config = task_config.model backbone = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[1, 512, 512, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[1, 512, 512, 3]), backbone_config=model_config.backbone, norm_activation_config=model_config.norm_activation) diff --git a/official/projects/const_cl/configs/backbones_3d_test.py b/official/projects/const_cl/configs/backbones_3d_test.py index 15058f94640..2c6e9fa7a20 100644 --- a/official/projects/const_cl/configs/backbones_3d_test.py +++ b/official/projects/const_cl/configs/backbones_3d_test.py @@ -14,7 +14,7 @@ """Tests for backbones_3d.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.configs import backbones_3d diff --git a/official/projects/const_cl/configs/const_cl_test.py b/official/projects/const_cl/configs/const_cl_test.py index 2b454953e1f..989f425d5c4 100644 --- a/official/projects/const_cl/configs/const_cl_test.py +++ b/official/projects/const_cl/configs/const_cl_test.py @@ -14,7 +14,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/const_cl/configs/head_test.py b/official/projects/const_cl/configs/head_test.py index 95d06d40dff..cb818c76cfc 100644 --- a/official/projects/const_cl/configs/head_test.py +++ b/official/projects/const_cl/configs/head_test.py @@ -14,7 +14,7 @@ """Tests for head.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.configs import head as head_cfg diff --git a/official/projects/const_cl/datasets/video_ssl_inputs.py b/official/projects/const_cl/datasets/video_ssl_inputs.py index e7c93660471..9d41328fa96 100644 --- a/official/projects/const_cl/datasets/video_ssl_inputs.py +++ b/official/projects/const_cl/datasets/video_ssl_inputs.py @@ -15,7 +15,7 @@ """Video SSL datasets.""" from typing import Dict, Tuple, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.video_ssl.dataloaders import video_ssl_input diff --git a/official/projects/const_cl/datasets/video_ssl_inputs_test.py b/official/projects/const_cl/datasets/video_ssl_inputs_test.py index 17f3d0958a8..a521e4f7e19 100644 --- a/official/projects/const_cl/datasets/video_ssl_inputs_test.py +++ b/official/projects/const_cl/datasets/video_ssl_inputs_test.py @@ -18,7 +18,7 @@ import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.configs import const_cl as exp_cfg from official.projects.const_cl.datasets import video_ssl_inputs diff --git a/official/projects/const_cl/losses/losses.py b/official/projects/const_cl/losses/losses.py index 2b0bad17d73..d76ae841aa1 100644 --- a/official/projects/const_cl/losses/losses.py +++ b/official/projects/const_cl/losses/losses.py @@ -16,7 +16,7 @@ from typing import Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.compiler.tf2xla.python import xla # pylint: disable=g-direct-tensorflow-import from official.projects.video_ssl.losses import losses as video_ssl_losses diff --git a/official/projects/const_cl/losses/losses_test.py b/official/projects/const_cl/losses/losses_test.py index c867a690a6d..1fab1c2420d 100644 --- a/official/projects/const_cl/losses/losses_test.py +++ b/official/projects/const_cl/losses/losses_test.py @@ -14,7 +14,7 @@ """Tests for losses.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.losses import losses diff --git a/official/projects/const_cl/modeling/backbones/nn_blocks_3d.py b/official/projects/const_cl/modeling/backbones/nn_blocks_3d.py index c6453fb9e72..48e256322a2 100644 --- a/official/projects/const_cl/modeling/backbones/nn_blocks_3d.py +++ b/official/projects/const_cl/modeling/backbones/nn_blocks_3d.py @@ -13,7 +13,7 @@ # limitations under the License. """Contains common building blocks for 3D networks.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import nn_blocks_3d from official.vision.modeling.layers import nn_layers @@ -25,13 +25,13 @@ class BottleneckBlock3D(nn_blocks_3d.BottleneckBlock3D): """Creates a 3D bottleneck block.""" def build(self, input_shape): - self._shortcut_maxpool = tf.keras.layers.MaxPool3D( + self._shortcut_maxpool = tf_keras.layers.MaxPool3D( pool_size=[1, 1, 1], strides=[ self._temporal_strides, self._spatial_strides, self._spatial_strides ]) - self._shortcut_conv = tf.keras.layers.Conv3D( + self._shortcut_conv = tf_keras.layers.Conv3D( filters=4 * self._filters, kernel_size=1, strides=[ @@ -48,7 +48,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, name='shortcut_conv/batch_norm') - self._temporal_conv = tf.keras.layers.Conv3D( + self._temporal_conv = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=[self._temporal_kernel_size, 1, 1], strides=[self._temporal_strides, 1, 1], @@ -64,7 +64,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, name='temporal_conv/batch_norm') - self._spatial_conv = tf.keras.layers.Conv3D( + self._spatial_conv = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=[1, 3, 3], strides=[1, self._spatial_strides, self._spatial_strides], @@ -80,7 +80,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, name='spatial_conv/batch_norm') - self._expand_conv = tf.keras.layers.Conv3D( + self._expand_conv = tf_keras.layers.Conv3D( filters=4 * self._filters, kernel_size=[1, 1, 1], strides=[1, 1, 1], diff --git a/official/projects/const_cl/modeling/backbones/nn_blocks_3d_test.py b/official/projects/const_cl/modeling/backbones/nn_blocks_3d_test.py index 9477c520b83..b911049702a 100644 --- a/official/projects/const_cl/modeling/backbones/nn_blocks_3d_test.py +++ b/official/projects/const_cl/modeling/backbones/nn_blocks_3d_test.py @@ -15,7 +15,7 @@ """Tests for resnet.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.backbones import nn_blocks_3d @@ -33,7 +33,7 @@ def test_bottleneck_block_creation(self, block_fn, temporal_kernel_size, temporal_size = 16 spatial_size = 128 filters = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(temporal_size, spatial_size, spatial_size, filters * 4), batch_size=1) block = block_fn( diff --git a/official/projects/const_cl/modeling/backbones/resnet_3d.py b/official/projects/const_cl/modeling/backbones/resnet_3d.py index d2da6c0fd29..e903179b863 100644 --- a/official/projects/const_cl/modeling/backbones/resnet_3d.py +++ b/official/projects/const_cl/modeling/backbones/resnet_3d.py @@ -15,7 +15,7 @@ """Contains definitions of 3D Residual Networks.""" from typing import Any, Callable, List, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -24,13 +24,13 @@ from official.vision.modeling.backbones import resnet_3d from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers RESNET_SPECS = resnet_3d.RESNET_SPECS -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResNet3DY(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResNet3DY(tf_keras.Model): """Creates a 3D ResNet family model with branched res5 block.""" def __init__( @@ -39,7 +39,7 @@ def __init__( temporal_strides: List[int], temporal_kernel_sizes: List[Tuple[int]], use_self_gating: Optional[List[int]] = None, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, None, 3]), stem_type: str = 'v0', stem_conv_temporal_kernel_size: int = 5, @@ -52,8 +52,8 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a 3D ResNet model. @@ -65,7 +65,7 @@ def __init__( sizes for all 3d blocks in different block groups. use_self_gating: A list of booleans to specify applying self-gating module or not in each block group. If None, self-gating is not applied. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. stem_type: A `str` of stem type of ResNet. Default to `v0`. If set to `v1`, use ResNet-D type stem (https://arxiv.org/abs/1812.01187). stem_conv_temporal_kernel_size: An `int` of temporal kernel size for the @@ -81,9 +81,9 @@ def __init__( norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -111,13 +111,13 @@ def __init__( self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build ResNet3D backbone. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) self._build_model(inputs) def _build_model(self, inputs): @@ -227,7 +227,7 @@ def _build_block_group( temporal_strides: int, spatial_strides: int, block_fn: Callable[ - ..., tf.keras.layers.Layer] = nn_blocks_3d.BottleneckBlock3D, + ..., tf_keras.layers.Layer] = nn_blocks_3d.BottleneckBlock3D, block_repeats: int = 1, stochastic_depth_drop_rate: float = 0.0, use_self_gating: bool = False, @@ -354,11 +354,11 @@ def from_config(cls, config, custom_objects=None): @factory.register_backbone_builder('resnet_3dy') def build_resnet3dy( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds ResNet 3d-Y backbone from a config.""" backbone_cfg = backbone_config.get() diff --git a/official/projects/const_cl/modeling/backbones/resnet_3d_test.py b/official/projects/const_cl/modeling/backbones/resnet_3d_test.py index 2e0df70f744..90b596fda89 100644 --- a/official/projects/const_cl/modeling/backbones/resnet_3d_test.py +++ b/official/projects/const_cl/modeling/backbones/resnet_3d_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.backbones import resnet_3d @@ -31,7 +31,7 @@ class ResNet3DTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, model_id, endpoint_filter_scale, stem_type, se_ratio, init_stochastic_depth_rate): """Test creation of ResNet3D family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') temporal_strides = [1, 1, 1, 1] temporal_kernel_sizes = [(3, 3, 3), (3, 1, 3, 1), (3, 1, 3, 1, 3, 1), (1, 3, 1)] @@ -45,7 +45,7 @@ def test_network_creation(self, input_size, model_id, endpoint_filter_scale, stem_type=stem_type, se_ratio=se_ratio, init_stochastic_depth_rate=init_stochastic_depth_rate) - inputs = tf.keras.Input(shape=(8, input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(8, input_size, input_size, 3), batch_size=1) endpoints = network(inputs) self.assertAllEqual([ diff --git a/official/projects/const_cl/modeling/const_cl_model.py b/official/projects/const_cl/modeling/const_cl_model.py index 630c61de638..2dad8dc3a6c 100644 --- a/official/projects/const_cl/modeling/const_cl_model.py +++ b/official/projects/const_cl/modeling/const_cl_model.py @@ -15,7 +15,7 @@ """Builds ConST-CL SSL models.""" from typing import Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.configs import const_cl as const_cl_cfg from official.projects.const_cl.modeling.heads import instance_reconstructor @@ -24,16 +24,16 @@ from official.vision.modeling import backbones from official.vision.modeling import factory_3d as model_factory -layers = tf.keras.layers +layers = tf_keras.layers -class ConstCLModel(tf.keras.Model): +class ConstCLModel(tf_keras.Model): """A ConST-CL SSL model class builder.""" def __init__( self, backbone, - input_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + input_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, # global_head num_hidden_layers: int = 3, num_hidden_channels: int = 1024, @@ -62,7 +62,7 @@ def __init__( Args: backbone: a 3d backbone network. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. num_hidden_layers: the number of hidden layers in the MLP. num_hidden_channels: the number of hidden nodes in the MLP. num_output_channels: the number of final output nodes in the MLP. @@ -122,12 +122,12 @@ def __init__( self._backbone = backbone inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } endpoints = backbone(inputs['image']) res5 = endpoints['5'] - res5 = tf.keras.layers.GlobalAveragePooling3D()(res5) + res5 = tf_keras.layers.GlobalAveragePooling3D()(res5) res5_1 = endpoints['5_1'] global_embeddings = simple.MLP( @@ -186,10 +186,10 @@ def from_config(cls, config, custom_objects=None): @model_factory.register_model_builder('const_cl_model') def build_const_cl_pretrain_model( - input_specs_dict: Mapping[str, tf.keras.layers.InputSpec], + input_specs_dict: Mapping[str, tf_keras.layers.InputSpec], model_config: const_cl_cfg.ConstCLModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None ) -> ConstCLModel: """Builds the ConST-CL video ssl model.""" del num_classes diff --git a/official/projects/const_cl/modeling/const_cl_model_test.py b/official/projects/const_cl/modeling/const_cl_model_test.py index 1720cbd17bb..dcb57d3bcd3 100644 --- a/official/projects/const_cl/modeling/const_cl_model_test.py +++ b/official/projects/const_cl/modeling/const_cl_model_test.py @@ -13,7 +13,7 @@ # limitations under the License. """Tests for const_cl_model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.configs import const_cl as const_cl_cfg from official.projects.const_cl.modeling import const_cl_model @@ -26,10 +26,10 @@ class ConstClModelTest(tf.test.TestCase): def test_build_const_cl_pretrain_model(self): model_config = const_cl_cfg.ConstCLModel() - images_input_specs = tf.keras.layers.InputSpec( + images_input_specs = tf_keras.layers.InputSpec( shape=[None, 16, 224, 224, 4]) - boxes_input_specs = tf.keras.layers.InputSpec(shape=[None, 16, 8, 4]) - masks_input_specs = tf.keras.layers.InputSpec(shape=[None, 16, 8]) + boxes_input_specs = tf_keras.layers.InputSpec(shape=[None, 16, 8, 4]) + masks_input_specs = tf_keras.layers.InputSpec(shape=[None, 16, 8]) input_specs_dict = { 'image': images_input_specs, diff --git a/official/projects/const_cl/modeling/heads/instance_reconstructor.py b/official/projects/const_cl/modeling/heads/instance_reconstructor.py index d528a0c0039..f3f956fb198 100644 --- a/official/projects/const_cl/modeling/heads/instance_reconstructor.py +++ b/official/projects/const_cl/modeling/heads/instance_reconstructor.py @@ -16,7 +16,7 @@ from typing import Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.heads import transformer_decoder from official.vision.modeling.layers import roi_aligner @@ -29,7 +29,7 @@ def _get_shape(x): return [dynamic[i] if s is None else s for i, s in enumerate(static)] -class InstanceReconstructor(tf.keras.layers.Layer): +class InstanceReconstructor(tf_keras.layers.Layer): """The SSL head for reconstructing contextualized instance representations.""" def __init__(self, @@ -90,14 +90,14 @@ def __init__(self, if self._use_positional_embedding: self._spatial_mlp = [ - tf.keras.layers.Dense( + tf_keras.layers.Dense( 4, use_bias=True, activation='relu', name='spatial_mlp_l1'), - tf.keras.layers.Dense( + tf_keras.layers.Dense( 8, use_bias=True, name='spatial_mlp_l2')] self._temporal_mlp = [ - tf.keras.layers.Dense( + tf_keras.layers.Dense( 4, use_bias=True, activation='relu', name='temporal_mlp_l1'), - tf.keras.layers.Dense( + tf_keras.layers.Dense( 8, use_bias=True, name='temporal_mlp_l2')] self._attention_decoder = transformer_decoder.TransformerDecoder( @@ -109,7 +109,7 @@ def __init__(self, dropout_rate=dropout_rate, layer_norm_epsilon=layer_norm_epsilon) - self._projection_layer = tf.keras.layers.Dense(num_output_channels) + self._projection_layer = tf_keras.layers.Dense(num_output_channels) def _get_memory_embeddings(self, inputs: tf.Tensor) -> tf.Tensor: """Uniformly samples frames to construct memory embeddings.""" diff --git a/official/projects/const_cl/modeling/heads/instance_reconstructor_test.py b/official/projects/const_cl/modeling/heads/instance_reconstructor_test.py index d3c81c178dd..a4fef24938a 100644 --- a/official/projects/const_cl/modeling/heads/instance_reconstructor_test.py +++ b/official/projects/const_cl/modeling/heads/instance_reconstructor_test.py @@ -14,7 +14,7 @@ """Tests for instance_reconstructor.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.heads import instance_reconstructor diff --git a/official/projects/const_cl/modeling/heads/simple.py b/official/projects/const_cl/modeling/heads/simple.py index ec6463835e0..fd1c0d01353 100644 --- a/official/projects/const_cl/modeling/heads/simple.py +++ b/official/projects/const_cl/modeling/heads/simple.py @@ -16,11 +16,11 @@ from typing import Any, Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class MLP(tf.keras.layers.Layer): +class MLP(tf_keras.layers.Layer): """Constructs the Multi-Layer Perceptron head.""" def __init__(self, @@ -61,22 +61,22 @@ def __init__(self, # MLP hidden layers for _ in range(num_hidden_layers): self._layers.append( - tf.keras.layers.Dense(num_hidden_channels, use_bias=False)) + tf_keras.layers.Dense(num_hidden_channels, use_bias=False)) if use_sync_bn: self._layers.append( - tf.keras.layers.experimental.SyncBatchNormalization( + tf_keras.layers.experimental.SyncBatchNormalization( momentum=norm_momentum, epsilon=norm_epsilon)) else: self._layers.append( - tf.keras.layers.BatchNormalization( + tf_keras.layers.BatchNormalization( momentum=norm_momentum, epsilon=norm_epsilon)) if activation is not None: self._layers.append(tf_utils.get_activation(activation)) # Projection head - self._layers.append(tf.keras.layers.Dense(num_output_channels)) + self._layers.append(tf_keras.layers.Dense(num_output_channels)) def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: """Forward calls with N-D inputs tensor.""" @@ -84,7 +84,7 @@ def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: inputs = tf.nn.l2_normalize(inputs, axis=-1) for layer in self._layers: - if isinstance(layer, tf.keras.layers.Layer): + if isinstance(layer, tf_keras.layers.Layer): inputs = layer(inputs, training=training) else: # activation inputs = layer(inputs) diff --git a/official/projects/const_cl/modeling/heads/simple_test.py b/official/projects/const_cl/modeling/heads/simple_test.py index 251ac6effab..0e1babb8138 100644 --- a/official/projects/const_cl/modeling/heads/simple_test.py +++ b/official/projects/const_cl/modeling/heads/simple_test.py @@ -15,7 +15,7 @@ """Tests for simple.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.heads import simple diff --git a/official/projects/const_cl/modeling/heads/transformer_decoder.py b/official/projects/const_cl/modeling/heads/transformer_decoder.py index 8153f395122..70c966c42dd 100644 --- a/official/projects/const_cl/modeling/heads/transformer_decoder.py +++ b/official/projects/const_cl/modeling/heads/transformer_decoder.py @@ -17,7 +17,7 @@ from typing import Any, Mapping, Optional, Union, List, Sequence from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def _get_shape(x: tf.Tensor): @@ -27,7 +27,7 @@ def _get_shape(x: tf.Tensor): return [dynamic[i] if s is None else s for i, s in enumerate(static)] -class DecoderUnit(tf.keras.layers.Layer): +class DecoderUnit(tf_keras.layers.Layer): """Constructs the decoder MHA module used in Transformer layers.""" def __init__(self, @@ -52,38 +52,38 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): input_shape: the input shape for the keras tensor. """ # Query, key, and value mapping. - self.layer_q = tf.keras.layers.Dense( + self.layer_q = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, name='query') - self.layer_k = tf.keras.layers.Dense( + self.layer_k = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, name='key') - self.layer_v = tf.keras.layers.Dense( + self.layer_v = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, name='value') - self.dropout = tf.keras.layers.Dropout(self._dropout_rate) + self.dropout = tf_keras.layers.Dropout(self._dropout_rate) # Note here is a different behavior for contrib_layers.layer_norm and - # tf.keras.layers.LayerNormalization, where by default, the former + # tf_keras.layers.LayerNormalization, where by default, the former # calculates mean/variance across all axes except the first one # (batch axis), while the latter one computes statistics only on the last # axis. - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( epsilon=self._layer_norm_epsilon, name='layer_norm') - self.ffn1 = tf.keras.layers.Dense( + self.ffn1 = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=self._activation, name='ffn1') - self.ffn2 = tf.keras.layers.Dense( + self.ffn2 = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, @@ -156,7 +156,7 @@ def from_config(cls, config: Mapping[str, Any]): return cls(**config) -class TransformerDecoderLayer(tf.keras.layers.Layer): +class TransformerDecoderLayer(tf_keras.layers.Layer): """Constructs the main Transformer decoder module which includes MHA + FFN.""" def __init__(self, @@ -245,7 +245,7 @@ def from_config(cls, config: Mapping[str, Any]): return cls(**config) -class TransformerDecoder(tf.keras.layers.Layer): +class TransformerDecoder(tf_keras.layers.Layer): """Constructs the final Transformer decoder stack.""" def __init__(self, diff --git a/official/projects/const_cl/modeling/heads/transformer_decoder_test.py b/official/projects/const_cl/modeling/heads/transformer_decoder_test.py index f1e864f585b..113824c0d1a 100644 --- a/official/projects/const_cl/modeling/heads/transformer_decoder_test.py +++ b/official/projects/const_cl/modeling/heads/transformer_decoder_test.py @@ -14,7 +14,7 @@ """Tests for TransformerDecoder.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.const_cl.modeling.heads import transformer_decoder diff --git a/official/projects/const_cl/tasks/const_cl.py b/official/projects/const_cl/tasks/const_cl.py index 598920ed5ab..a31da4534df 100644 --- a/official/projects/const_cl/tasks/const_cl.py +++ b/official/projects/const_cl/tasks/const_cl.py @@ -16,7 +16,7 @@ from typing import Any, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import input_reader from official.core import task_factory from official.projects.const_cl.configs import const_cl as exp_cfg @@ -42,12 +42,12 @@ def build_model(self): num_instances = self.task_config.train_data.num_instances input_specs_dict = { 'image': - tf.keras.layers.InputSpec(shape=[None] + common_input_shape), + tf_keras.layers.InputSpec(shape=[None] + common_input_shape), 'instances_position': - tf.keras.layers.InputSpec( + tf_keras.layers.InputSpec( shape=[None, num_frames, num_instances, 4]), 'instances_mask': - tf.keras.layers.InputSpec(shape=[None, num_frames, num_instances]), + tf_keras.layers.InputSpec(shape=[None, num_frames, num_instances]), } logging.info('Build model input %r', common_input_shape) @@ -137,19 +137,19 @@ def build_losses(self, model_outputs, num_replicas, model): def build_metrics(self, training=True): """Gets streaming metrics for training/validation.""" metrics = [ - tf.keras.metrics.Mean(name='regularization_loss'), - - tf.keras.metrics.Mean(name='global_loss/loss'), - tf.keras.metrics.Mean(name='global_loss/contrastive_accuracy'), - tf.keras.metrics.Mean(name='global_loss/contrastive_entropy'), - - tf.keras.metrics.Mean(name='local_loss/loss'), - tf.keras.metrics.Mean(name='local_loss/positive_similarity_mean'), - tf.keras.metrics.Mean(name='local_loss/positive_similarity_max'), - tf.keras.metrics.Mean(name='local_loss/positive_similarity_min'), - tf.keras.metrics.Mean(name='local_loss/negative_similarity_mean'), - tf.keras.metrics.Mean(name='local_loss/negative_similarity_max'), - tf.keras.metrics.Mean(name='local_loss/negative_similarity_min'), + tf_keras.metrics.Mean(name='regularization_loss'), + + tf_keras.metrics.Mean(name='global_loss/loss'), + tf_keras.metrics.Mean(name='global_loss/contrastive_accuracy'), + tf_keras.metrics.Mean(name='global_loss/contrastive_entropy'), + + tf_keras.metrics.Mean(name='local_loss/loss'), + tf_keras.metrics.Mean(name='local_loss/positive_similarity_mean'), + tf_keras.metrics.Mean(name='local_loss/positive_similarity_max'), + tf_keras.metrics.Mean(name='local_loss/positive_similarity_min'), + tf_keras.metrics.Mean(name='local_loss/negative_similarity_mean'), + tf_keras.metrics.Mean(name='local_loss/negative_similarity_max'), + tf_keras.metrics.Mean(name='local_loss/negative_similarity_min'), ] return metrics @@ -189,14 +189,14 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) diff --git a/official/projects/const_cl/tasks/const_cl_test.py b/official/projects/const_cl/tasks/const_cl_test.py index 68486ff56c0..7b17bbd71e0 100644 --- a/official/projects/const_cl/tasks/const_cl_test.py +++ b/official/projects/const_cl/tasks/const_cl_test.py @@ -18,7 +18,7 @@ import random import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/projects/deepmac_maskrcnn/configs/deep_mask_head_rcnn_config_test.py b/official/projects/deepmac_maskrcnn/configs/deep_mask_head_rcnn_config_test.py index 8a1547f6971..3644c182079 100644 --- a/official/projects/deepmac_maskrcnn/configs/deep_mask_head_rcnn_config_test.py +++ b/official/projects/deepmac_maskrcnn/configs/deep_mask_head_rcnn_config_test.py @@ -14,7 +14,7 @@ """Check that the config is set correctly.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.configs import deep_mask_head_rcnn diff --git a/official/projects/deepmac_maskrcnn/modeling/heads/hourglass_network.py b/official/projects/deepmac_maskrcnn/modeling/heads/hourglass_network.py index 710f5301dd0..dfe1ef8b88d 100644 --- a/official/projects/deepmac_maskrcnn/modeling/heads/hourglass_network.py +++ b/official/projects/deepmac_maskrcnn/modeling/heads/hourglass_network.py @@ -32,14 +32,14 @@ """ -import tensorflow as tf +import tensorflow as tf, tf_keras BATCH_NORM_EPSILON = 1e-5 BATCH_NORM_MOMENTUM = 0.1 BATCH_NORM_FUSED = True -class IdentityLayer(tf.keras.layers.Layer): +class IdentityLayer(tf_keras.layers.Layer): """A layer which passes through the input as it is.""" def call(self, inputs): @@ -58,14 +58,14 @@ def _get_padding_for_kernel_size(kernel_size): def batchnorm(): try: - return tf.keras.layers.experimental.SyncBatchNormalization( + return tf_keras.layers.experimental.SyncBatchNormalization( name='batchnorm', epsilon=1e-5, momentum=0.1) except AttributeError: - return tf.keras.layers.BatchNormalization( + return tf_keras.layers.BatchNormalization( name='batchnorm', epsilon=1e-5, momentum=0.1, fused=BATCH_NORM_FUSED) -class ConvolutionalBlock(tf.keras.layers.Layer): +class ConvolutionalBlock(tf_keras.layers.Layer): """Block that aggregates Convolution + Norm layer + ReLU.""" def __init__(self, kernel_size, out_channels, stride=1, relu=True, @@ -87,18 +87,18 @@ def __init__(self, kernel_size, out_channels, stride=1, relu=True, # TODO(vighneshb) Explore if removing and using padding option in conv # layer works. - self.pad = tf.keras.layers.ZeroPadding2D(padding_size) + self.pad = tf_keras.layers.ZeroPadding2D(padding_size) else: self.pad = IdentityLayer() - self.conv = tf.keras.layers.Conv2D( + 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() + self.relu = tf_keras.layers.ReLU() else: self.relu = IdentityLayer() @@ -123,7 +123,7 @@ def __init__(self, out_channels, stride): out_channels=out_channels, kernel_size=1, stride=stride, relu=False) -class ResidualBlock(tf.keras.layers.Layer): +class ResidualBlock(tf_keras.layers.Layer): """A Residual block.""" def __init__(self, out_channels, skip_conv=False, kernel_size=3, stride=1, @@ -142,7 +142,7 @@ def __init__(self, out_channels, skip_conv=False, kernel_size=3, stride=1, self.conv_block = ConvolutionalBlock( kernel_size=kernel_size, out_channels=out_channels, stride=stride) - self.conv = tf.keras.layers.Conv2D( + self.conv = tf_keras.layers.Conv2D( filters=out_channels, kernel_size=kernel_size, use_bias=False, strides=1, padding=padding) self.norm = batchnorm() @@ -153,7 +153,7 @@ def __init__(self, out_channels, skip_conv=False, kernel_size=3, stride=1, else: self.skip = IdentityLayer() - self.relu = tf.keras.layers.ReLU() + self.relu = tf_keras.layers.ReLU() def call(self, inputs): net = self.conv_block(inputs) @@ -163,7 +163,7 @@ def call(self, inputs): return self.relu(net + net_skip) -class InputDownsampleBlock(tf.keras.layers.Layer): +class InputDownsampleBlock(tf_keras.layers.Layer): """Block for the initial feature downsampling.""" def __init__(self, out_channels_initial_conv, out_channels_residual_block): @@ -187,7 +187,7 @@ def call(self, inputs): return self.residual_block(self.conv_block(inputs)) -class InputConvBlock(tf.keras.layers.Layer): +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 @@ -283,7 +283,7 @@ def _apply_blocks(inputs, blocks): return net -class EncoderDecoderBlock(tf.keras.layers.Layer): +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, @@ -316,7 +316,7 @@ def __init__(self, num_stages, channel_dims, blocks_per_stage, self.encoder_decoder_shortcut = encoder_decoder_shortcut if encoder_decoder_shortcut: - self.merge_features = tf.keras.layers.Add() + 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) @@ -343,7 +343,7 @@ def __init__(self, num_stages, channel_dims, blocks_per_stage, residual_channels=out_channels_downsampled, out_channels=out_channels, num_blocks=blocks_per_stage[0]) - self.upsample = tf.keras.layers.UpSampling2D(initial_stride) + self.upsample = tf_keras.layers.UpSampling2D(initial_stride) def call(self, inputs): @@ -362,7 +362,7 @@ def call(self, inputs): return upsampled_outputs -class HourglassNetwork(tf.keras.Model): +class HourglassNetwork(tf_keras.Model): """The hourglass network.""" def __init__(self, num_stages, input_channel_dims, channel_dims_per_stage, @@ -437,7 +437,7 @@ def __init__(self, num_stages, input_channel_dims, channel_dims_per_stage, ResidualBlock(out_channels=channel_dims_per_stage[0]) ) - self.intermediate_relu = tf.keras.layers.ReLU() + self.intermediate_relu = tf_keras.layers.ReLU() def call(self, inputs): # pytype: disable=signature-mismatch # overriding-parameter-count-checks diff --git a/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads.py b/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads.py index 2decade0c9e..413f72771be 100644 --- a/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads.py +++ b/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads.py @@ -17,13 +17,13 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.deepmac_maskrcnn.modeling.heads import hourglass_network -class DeepMaskHead(tf.keras.layers.Layer): +class DeepMaskHead(tf_keras.layers.Layer): """Creates a mask head.""" def __init__(self, @@ -59,9 +59,9 @@ def __init__(self, normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. class_agnostic: A `bool`. If set, we use a single channel mask head that is shared between all classes. convnet_variant: A `str` denoting the architecture of network used in the @@ -86,16 +86,16 @@ def __init__(self, 'convnet_variant': convnet_variant, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 self._activation = tf_utils.get_activation(activation) def _get_conv_op_and_kwargs(self): - conv_op = (tf.keras.layers.SeparableConv2D + conv_op = (tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D) + else tf_keras.layers.Conv2D) conv_kwargs = { 'filters': self._config_dict['num_filters'], 'kernel_size': 3, @@ -103,9 +103,9 @@ def _get_conv_op_and_kwargs(self): } if self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -114,7 +114,7 @@ def _get_conv_op_and_kwargs(self): }) else: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], @@ -125,9 +125,9 @@ def _get_conv_op_and_kwargs(self): def _get_bn_op_and_kwargs(self): - bn_op = (tf.keras.layers.experimental.SyncBatchNormalization + bn_op = (tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization) + else tf_keras.layers.BatchNormalization) bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -143,12 +143,12 @@ def build(self, input_shape): self._build_convnet_variant() - self._deconv = tf.keras.layers.Conv2DTranspose( + self._deconv = tf_keras.layers.Conv2DTranspose( filters=self._config_dict['num_filters'], kernel_size=self._config_dict['upsample_factor'], strides=self._config_dict['upsample_factor'], padding='valid', - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], @@ -170,9 +170,9 @@ def build(self, input_shape): } if self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -181,7 +181,7 @@ def build(self, input_shape): }) else: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], diff --git a/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads_test.py b/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads_test.py index 7963a4d2a45..97f53759b8c 100644 --- a/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads_test.py +++ b/official/projects/deepmac_maskrcnn/modeling/heads/instance_heads_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.modeling.heads import instance_heads as deep_instance_heads diff --git a/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model.py b/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model.py index 7ad9fa5d41d..415cf4a1c09 100644 --- a/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model.py +++ b/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model.py @@ -19,7 +19,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling import maskrcnn_model from official.vision.ops import box_ops @@ -36,19 +36,19 @@ class DeepMaskRCNNModel(maskrcnn_model.MaskRCNNModel): """The Mask R-CNN model.""" def __init__(self, - backbone: tf.keras.Model, - decoder: tf.keras.Model, - rpn_head: tf.keras.layers.Layer, - detection_head: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_generator: tf.keras.layers.Layer, - roi_sampler: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_aligner: tf.keras.layers.Layer, - detection_generator: tf.keras.layers.Layer, - mask_head: Optional[tf.keras.layers.Layer] = None, - mask_sampler: Optional[tf.keras.layers.Layer] = None, - mask_roi_aligner: Optional[tf.keras.layers.Layer] = None, + backbone: tf_keras.Model, + decoder: tf_keras.Model, + rpn_head: tf_keras.layers.Layer, + detection_head: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_generator: tf_keras.layers.Layer, + roi_sampler: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_aligner: tf_keras.layers.Layer, + detection_generator: tf_keras.layers.Layer, + mask_head: Optional[tf_keras.layers.Layer] = None, + mask_sampler: Optional[tf_keras.layers.Layer] = None, + mask_roi_aligner: Optional[tf_keras.layers.Layer] = None, class_agnostic_bbox_pred: bool = False, cascade_class_ensemble: bool = False, min_level: Optional[int] = None, @@ -62,8 +62,8 @@ def __init__(self, """Initializes the Mask R-CNN model. Args: - backbone: `tf.keras.Model`, the backbone network. - decoder: `tf.keras.Model`, the decoder network. + backbone: `tf_keras.Model`, the backbone network. + decoder: `tf_keras.Model`, the decoder network. rpn_head: the RPN head. detection_head: the detection head or a list of heads. roi_generator: the ROI generator. diff --git a/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model_test.py b/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model_test.py index 293f9965be7..b2c582fbe2c 100644 --- a/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model_test.py +++ b/official/projects/deepmac_maskrcnn/modeling/maskrcnn_model_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.modeling import maskrcnn_model from official.projects.deepmac_maskrcnn.modeling.heads import instance_heads as deep_instance_heads @@ -50,7 +50,7 @@ def construct_model_and_anchors(image_size, use_gt_boxes_for_masks): image_size=image_size).multilevel_boxes num_anchors_per_location = len(aspect_ratios) * num_scales - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, 3]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, 3]) backbone = resnet.ResNet(model_id=50, input_specs=input_specs) decoder = fpn.FPN( min_level=min_level, diff --git a/official/projects/deepmac_maskrcnn/serving/detection.py b/official/projects/deepmac_maskrcnn/serving/detection.py index dd49a48bf02..1b1f105b8d3 100644 --- a/official/projects/deepmac_maskrcnn/serving/detection.py +++ b/official/projects/deepmac_maskrcnn/serving/detection.py @@ -16,7 +16,7 @@ from typing import Dict, Mapping, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.configs import deep_mask_head_rcnn as cfg from official.projects.deepmac_maskrcnn.modeling import maskrcnn_model @@ -61,7 +61,7 @@ def _build_model(self): ValueError("batch_size can't be None for detection models") if self.params.task.model.detection_generator.nms_version != 'batched': ValueError('Only batched_nms is supported.') - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[self._batch_size] + self._input_image_size + [3]) if isinstance(self.params.task.model, cfg.DeepMaskHeadRCNN): diff --git a/official/projects/deepmac_maskrcnn/serving/detection_test.py b/official/projects/deepmac_maskrcnn/serving/detection_test.py index 19fa66c7958..1f916509670 100644 --- a/official/projects/deepmac_maskrcnn/serving/detection_test.py +++ b/official/projects/deepmac_maskrcnn/serving/detection_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.projects.deepmac_maskrcnn.serving import detection diff --git a/official/projects/deepmac_maskrcnn/tasks/deep_mask_head_rcnn.py b/official/projects/deepmac_maskrcnn/tasks/deep_mask_head_rcnn.py index 0ad214f9589..ad6e634aef4 100644 --- a/official/projects/deepmac_maskrcnn/tasks/deep_mask_head_rcnn.py +++ b/official/projects/deepmac_maskrcnn/tasks/deep_mask_head_rcnn.py @@ -14,7 +14,7 @@ """Mask R-CNN variant with support for deep mask heads.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.deepmac_maskrcnn.configs import deep_mask_head_rcnn as deep_mask_head_rcnn_config @@ -33,9 +33,9 @@ # Taken from modeling/factory.py -def build_maskrcnn(input_specs: tf.keras.layers.InputSpec, +def build_maskrcnn(input_specs: tf_keras.layers.InputSpec, model_config: deep_mask_head_rcnn_config.DeepMaskHeadRCNN, - l2_regularizer: tf.keras.regularizers.Regularizer = None): # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None): # pytype: disable=annotation-type-mismatch # typed-keras """Builds Mask R-CNN model.""" norm_activation_config = model_config.norm_activation backbone = backbones.factory.build_backbone( @@ -182,14 +182,14 @@ class DeepMaskHeadRCNNTask(maskrcnn.MaskRCNNTask): def build_model(self): """Builds Mask R-CNN model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = build_maskrcnn( @@ -201,8 +201,8 @@ def build_model(self): model.backbone.trainable = False # Builds the model through warm-up call. - dummy_images = tf.keras.Input(self.task_config.model.input_size) - dummy_image_shape = tf.keras.layers.Input([2]) + dummy_images = tf_keras.Input(self.task_config.model.input_size) + dummy_image_shape = tf_keras.layers.Input([2]) _ = model(dummy_images, image_shape=dummy_image_shape, training=False) return model diff --git a/official/projects/detr/configs/detr_test.py b/official/projects/detr/configs/detr_test.py index acf0ee48992..4d9a02a8cfa 100644 --- a/official/projects/detr/configs/detr_test.py +++ b/official/projects/detr/configs/detr_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/detr/dataloaders/coco.py b/official/projects/detr/dataloaders/coco.py index cf0835b846f..de4a654d597 100644 --- a/official/projects/detr/dataloaders/coco.py +++ b/official/projects/detr/dataloaders/coco.py @@ -16,7 +16,7 @@ import dataclasses from typing import Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/projects/detr/dataloaders/coco_test.py b/official/projects/detr/dataloaders/coco_test.py index abd57743f0c..7ff090e346d 100644 --- a/official/projects/detr/dataloaders/coco_test.py +++ b/official/projects/detr/dataloaders/coco_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.projects.detr.dataloaders import coco diff --git a/official/projects/detr/dataloaders/detr_input.py b/official/projects/detr/dataloaders/detr_input.py index 4f7ea55a9cc..82256cb1321 100644 --- a/official/projects/detr/dataloaders/detr_input.py +++ b/official/projects/detr/dataloaders/detr_input.py @@ -15,7 +15,7 @@ """COCO data loader for DETR.""" from typing import Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import parser diff --git a/official/projects/detr/modeling/detr.py b/official/projects/detr/modeling/detr.py index 6542a2cb704..eb26108365f 100644 --- a/official/projects/detr/modeling/detr.py +++ b/official/projects/detr/modeling/detr.py @@ -22,7 +22,7 @@ import math from typing import Any, List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.detr.modeling import transformer @@ -124,7 +124,7 @@ def postprocess(outputs: dict[str, tf.Tensor]) -> dict[str, tf.Tensor]: return predictions -class DETR(tf.keras.Model): +class DETR(tf_keras.Model): """DETR model with Keras. DETR consists of backbone, query embedding, DETRTransformer, @@ -154,7 +154,7 @@ def __init__(self, self._backbone_endpoint_name = backbone_endpoint_name def build(self, input_shape=None): - self._input_proj = tf.keras.layers.Conv2D( + self._input_proj = tf_keras.layers.Conv2D( self._hidden_size, 1, name="detr/conv2d") self._build_detection_decoder() super().build(input_shape) @@ -168,32 +168,32 @@ def _build_detection_decoder(self): self._query_embeddings = self.add_weight( "detr/query_embeddings", shape=[self._num_queries, self._hidden_size], - initializer=tf.keras.initializers.RandomNormal(mean=0., stddev=1.), + initializer=tf_keras.initializers.RandomNormal(mean=0., stddev=1.), dtype=tf.float32) sqrt_k = math.sqrt(1.0 / self._hidden_size) - self._class_embed = tf.keras.layers.Dense( + self._class_embed = tf_keras.layers.Dense( self._num_classes, - kernel_initializer=tf.keras.initializers.RandomUniform(-sqrt_k, sqrt_k), + kernel_initializer=tf_keras.initializers.RandomUniform(-sqrt_k, sqrt_k), name="detr/cls_dense") self._bbox_embed = [ - tf.keras.layers.Dense( + tf_keras.layers.Dense( self._hidden_size, activation="relu", - kernel_initializer=tf.keras.initializers.RandomUniform( + kernel_initializer=tf_keras.initializers.RandomUniform( -sqrt_k, sqrt_k), name="detr/box_dense_0"), - tf.keras.layers.Dense( + tf_keras.layers.Dense( self._hidden_size, activation="relu", - kernel_initializer=tf.keras.initializers.RandomUniform( + kernel_initializer=tf_keras.initializers.RandomUniform( -sqrt_k, sqrt_k), name="detr/box_dense_1"), - tf.keras.layers.Dense( - 4, kernel_initializer=tf.keras.initializers.RandomUniform( + tf_keras.layers.Dense( + 4, kernel_initializer=tf_keras.initializers.RandomUniform( -sqrt_k, sqrt_k), name="detr/box_dense_2")] - self._sigmoid = tf.keras.layers.Activation("sigmoid") + self._sigmoid = tf_keras.layers.Activation("sigmoid") @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone def get_config(self): @@ -262,7 +262,7 @@ def call(self, inputs: tf.Tensor, training: bool = None) -> List[Any]: # pytype return out_list -class DETRTransformer(tf.keras.layers.Layer): +class DETRTransformer(tf_keras.layers.Layer): """Encoder and Decoder of DETR.""" def __init__(self, num_encoder_layers=6, num_decoder_layers=6, diff --git a/official/projects/detr/modeling/detr_test.py b/official/projects/detr/modeling/detr_test.py index 1b78bb10439..61778b8550a 100644 --- a/official/projects/detr/modeling/detr_test.py +++ b/official/projects/detr/modeling/detr_test.py @@ -13,7 +13,7 @@ # limitations under the License. """Tests for tensorflow_models.official.projects.detr.detr.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.detr.modeling import detr from official.vision.modeling.backbones import resnet diff --git a/official/projects/detr/modeling/transformer.py b/official/projects/detr/modeling/transformer.py index 98338242440..ba08505aa24 100644 --- a/official/projects/detr/modeling/transformer.py +++ b/official/projects/detr/modeling/transformer.py @@ -18,14 +18,14 @@ cross-attention layer. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers from official.nlp.modeling import models -class TransformerEncoder(tf.keras.layers.Layer): +class TransformerEncoder(tf_keras.layers.Layer): """Transformer encoder. Transformer encoder is made up of N identical layers. Each layer is composed @@ -62,7 +62,7 @@ def __init__(self, layers is normalized. norm_epsilon: Epsilon value to initialize normalization layers. intermediate_dropout: Dropout probability for intermediate_dropout_layer. - **kwargs: key word arguemnts passed to tf.keras.layers.Layer. + **kwargs: key word arguemnts passed to tf_keras.layers.Layer. """ super(TransformerEncoder, self).__init__(**kwargs) @@ -96,7 +96,7 @@ def build(self, input_shape): models.seq2seq_transformer.attention_initializer( input_shape[2])), name=("layer_%d" % i))) - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=self._norm_epsilon, dtype="float32") super(TransformerEncoder, self).build(input_shape) @@ -140,12 +140,12 @@ def call(self, encoder_inputs, attention_mask=None, pos_embed=None): return output_tensor -class TransformerEncoderBlock(tf.keras.layers.Layer): +class TransformerEncoderBlock(tf_keras.layers.Layer): """TransformerEncoderBlock layer. This layer implements the Transformer Encoder from "Attention Is All You Need". (https://arxiv.org/abs/1706.03762), - which combines a `tf.keras.layers.MultiHeadAttention` layer with a + which combines a `tf_keras.layers.MultiHeadAttention` layer with a two-layer feedforward network. The only difference: position embedding is added to the query and key of self-attention. @@ -221,19 +221,19 @@ def __init__(self, self._output_dropout = output_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._inner_dropout = inner_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -265,7 +265,7 @@ def build(self, input_shape): activity_regularizer=self._activity_regularizer, kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint) - self._attention_layer = tf.keras.layers.MultiHeadAttention( + self._attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self._num_heads, key_dim=self._attention_head_size, dropout=self._attention_dropout, @@ -274,42 +274,42 @@ def build(self, input_shape): attention_axes=self._attention_axes, name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, hidden_size), bias_axes="d", name="output", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -422,7 +422,7 @@ def call(self, inputs): return self._output_layer_norm(layer_output + attention_output) -class TransformerDecoder(tf.keras.layers.Layer): +class TransformerDecoder(tf_keras.layers.Layer): """Transformer decoder. Like the encoder, the decoder is made up of N identical layers. @@ -461,7 +461,7 @@ def __init__(self, layers is normalized. norm_epsilon: Epsilon value to initialize normalization layers. intermediate_dropout: Dropout probability for intermediate_dropout_layer. - **kwargs: key word arguemnts passed to tf.keras.layers.Layer. + **kwargs: key word arguemnts passed to tf_keras.layers.Layer. """ super(TransformerDecoder, self).__init__(**kwargs) self.num_layers = num_layers @@ -494,7 +494,7 @@ def build(self, input_shape): models.seq2seq_transformer.attention_initializer( input_shape[2])), name=("layer_%d" % i))) - self.output_normalization = tf.keras.layers.LayerNormalization( + self.output_normalization = tf_keras.layers.LayerNormalization( epsilon=self._norm_epsilon, dtype="float32") super(TransformerDecoder, self).build(input_shape) @@ -578,7 +578,7 @@ def call(self, return self.output_normalization(output_tensor) -class TransformerDecoderBlock(tf.keras.layers.Layer): +class TransformerDecoderBlock(tf_keras.layers.Layer): """Single transformer layer for decoder. It has three sub-layers: @@ -633,28 +633,28 @@ def __init__(self, attention_initializer: Initializer for kernels of attention layers. If set `None`, attention layers use kernel_initializer as initializer for kernel. - **kwargs: key word arguemnts passed to tf.keras.layers.Layer. + **kwargs: key word arguemnts passed to tf_keras.layers.Layer. """ super().__init__(**kwargs) self.num_attention_heads = num_attention_heads self.intermediate_size = intermediate_size - self.intermediate_activation = tf.keras.activations.get( + self.intermediate_activation = tf_keras.activations.get( intermediate_activation) self.dropout_rate = dropout_rate self.attention_dropout_rate = attention_dropout_rate - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._intermediate_dropout = intermediate_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -688,17 +688,17 @@ def build(self, input_shape): kernel_initializer=self._attention_initializer, name="self_attention", **common_kwargs) - self.self_attention_output_dense = tf.keras.layers.EinsumDense( + self.self_attention_output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="output", **common_kwargs) - self.self_attention_dropout = tf.keras.layers.Dropout( + self.self_attention_dropout = tf_keras.layers.Dropout( rate=self.dropout_rate) self.self_attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -714,36 +714,36 @@ def build(self, input_shape): name="attention/encdec", **common_kwargs) - self.encdec_attention_dropout = tf.keras.layers.Dropout( + self.encdec_attention_dropout = tf_keras.layers.Dropout( rate=self.dropout_rate) self.encdec_attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="attention/encdec_output_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype="float32")) # Feed-forward projection. - self.intermediate_dense = tf.keras.layers.EinsumDense( + self.intermediate_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, self.intermediate_size), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="intermediate", **common_kwargs) - self.intermediate_activation_layer = tf.keras.layers.Activation( + self.intermediate_activation_layer = tf_keras.layers.Activation( self.intermediate_activation) - self._intermediate_dropout_layer = tf.keras.layers.Dropout( + self._intermediate_dropout_layer = tf_keras.layers.Dropout( rate=self._intermediate_dropout) - self.output_dense = tf.keras.layers.EinsumDense( + self.output_dense = tf_keras.layers.EinsumDense( "abc,cd->abd", output_shape=(None, hidden_size), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="output", **common_kwargs) - self.output_dropout = tf.keras.layers.Dropout(rate=self.dropout_rate) - self.output_layer_norm = tf.keras.layers.LayerNormalization( + self.output_dropout = tf_keras.layers.Dropout(rate=self.dropout_rate) + self.output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, diff --git a/official/projects/detr/modeling/transformer_test.py b/official/projects/detr/modeling/transformer_test.py index f948a0c52e4..8cac49d49e8 100644 --- a/official/projects/detr/modeling/transformer_test.py +++ b/official/projects/detr/modeling/transformer_test.py @@ -14,7 +14,7 @@ """Tests for transformer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.detr.modeling import transformer diff --git a/official/projects/detr/ops/matchers.py b/official/projects/detr/ops/matchers.py index fcda929f9c2..ffc41c627dc 100644 --- a/official/projects/detr/ops/matchers.py +++ b/official/projects/detr/ops/matchers.py @@ -26,7 +26,7 @@ Based on the original implementation by Jiquan Ngiam . """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils diff --git a/official/projects/detr/ops/matchers_test.py b/official/projects/detr/ops/matchers_test.py index 09b12e1fb7b..cb6813a83a7 100644 --- a/official/projects/detr/ops/matchers_test.py +++ b/official/projects/detr/ops/matchers_test.py @@ -16,7 +16,7 @@ import numpy as np from scipy import optimize -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.detr.ops import matchers diff --git a/official/projects/detr/optimization.py b/official/projects/detr/optimization.py index 3f7ef855631..5cb4480eb0f 100644 --- a/official/projects/detr/optimization.py +++ b/official/projects/detr/optimization.py @@ -15,7 +15,7 @@ """Customized optimizer to match paper results.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import optimization from official.nlp import optimization as nlp_optimization diff --git a/official/projects/detr/serving/export_module.py b/official/projects/detr/serving/export_module.py index 3417c5fca22..95bcb2428e0 100644 --- a/official/projects/detr/serving/export_module.py +++ b/official/projects/detr/serving/export_module.py @@ -13,7 +13,7 @@ # limitations under the License. """Export module for DETR model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.detr.modeling import detr from official.vision.modeling import backbones @@ -24,8 +24,8 @@ class DETRModule(detection.DetectionModule): """DETR detection module.""" - def _build_model(self) -> tf.keras.Model: - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + + def _build_model(self) -> tf_keras.Model: + input_specs = tf_keras.layers.InputSpec(shape=[self._batch_size] + self._input_image_size + [self._num_channels]) @@ -40,7 +40,7 @@ def _build_model(self) -> tf.keras.Model: self.params.task.model.num_classes, self.params.task.model.num_encoder_layers, self.params.task.model.num_decoder_layers) - model(tf.keras.Input(input_specs.shape[1:])) + model(tf_keras.Input(input_specs.shape[1:])) return model def _build_inputs(self, image: tf.Tensor) -> tuple[tf.Tensor, tf.Tensor]: diff --git a/official/projects/detr/serving/export_module_test.py b/official/projects/detr/serving/export_module_test.py index 60b8546cd0a..0678022b5b7 100644 --- a/official/projects/detr/serving/export_module_test.py +++ b/official/projects/detr/serving/export_module_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.projects.detr.configs import detr as exp_cfg # pylint: disable=unused-import diff --git a/official/projects/detr/tasks/detection.py b/official/projects/detr/tasks/detection.py index 55806d0c7d8..bb7e0ddd791 100644 --- a/official/projects/detr/tasks/detection.py +++ b/official/projects/detr/tasks/detection.py @@ -16,7 +16,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -47,7 +47,7 @@ class DetectionTask(base_task.Task): def build_model(self): """Build DETR model.""" - input_specs = tf.keras.layers.InputSpec(shape=[None] + + input_specs = tf_keras.layers.InputSpec(shape=[None] + self._task_config.model.input_size) backbone = backbones.factory.build_backbone( @@ -64,7 +64,7 @@ def build_model(self): self._task_config.model.num_decoder_layers) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self._task_config.init_checkpoint: return @@ -229,7 +229,7 @@ def build_metrics(self, training=True): metrics = [] metric_names = ['cls_loss', 'box_loss', 'giou_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if not training: self.coco_metric = coco_evaluator.COCOEvaluator( @@ -273,13 +273,13 @@ def train_step(self, inputs, model, optimizer, metrics=None): scaled_loss = loss # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) diff --git a/official/projects/detr/tasks/detection_test.py b/official/projects/detr/tasks/detection_test.py index 1f1041765b4..6277b3207b2 100644 --- a/official/projects/detr/tasks/detection_test.py +++ b/official/projects/detr/tasks/detection_test.py @@ -15,7 +15,7 @@ """Tests for detection.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.projects.detr import optimization diff --git a/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer.py b/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer.py index caf4d44ac8b..9fbebd95bbb 100644 --- a/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer.py +++ b/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer.py @@ -19,7 +19,7 @@ from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import optimization from official.nlp import modeling @@ -65,9 +65,9 @@ def _get_distribution_losses(teacher, student): def _get_attention_loss(teacher_score, student_score): """Function to calculate attention loss for transformer layers.""" # Note that the definition of KLDivergence here is a little different from - # the original one (tf.keras.losses.KLDivergence). We adopt this approach + # the original one (tf_keras.losses.KLDivergence). We adopt this approach # to stay consistent with the TF1 implementation. - teacher_weight = tf.keras.activations.softmax(teacher_score, axis=-1) + teacher_weight = tf_keras.activations.softmax(teacher_score, axis=-1) student_log_weight = tf.nn.log_softmax(student_score, axis=-1) kl_divergence = -(teacher_weight * student_log_weight) kl_divergence = tf.math.reduce_sum(kl_divergence, axis=-1, keepdims=True) @@ -91,7 +91,7 @@ def _build_sub_encoder(encoder, stage_number): layer_output, attention_score = encoder.transformer_layers[layer_idx]( layer_output, attention_mask, return_attention_scores=True) - return tf.keras.Model( + return tf_keras.Model( inputs=[input_ids, input_mask, type_ids], outputs=[layer_output, attention_score]) @@ -145,7 +145,7 @@ def __init__(self, self.current_optimizer = self.layer_wise_optimizer # A non-trainable layer for feature normalization for transfer loss. - self._layer_norm = tf.keras.layers.LayerNormalization( + self._layer_norm = tf_keras.layers.LayerNormalization( axis=-1, beta_initializer='zeros', gamma_initializer='ones', @@ -204,7 +204,7 @@ def build_model(self): stage_number=int(self.stage * self.ratio)) teacher_output_feature, teacher_attention_score = teacher_sub_encoder( inputs) - return tf.keras.Model( + return tf_keras.Model( inputs=inputs, outputs=dict( student_output_feature=student_output_feature, @@ -216,7 +216,7 @@ def build_model(self): inputs = self.student_model.inputs student_pretrainer_outputs = self.student_model(inputs) teacher_pretrainer_outputs = self.teacher_model(inputs) - model = tf.keras.Model( + model = tf_keras.Model( inputs=inputs, outputs=dict( student_pretrainer_outputs=student_pretrainer_outputs, @@ -253,19 +253,19 @@ def build_optimizer(self, config): def build_metrics(self): """Creates metrics functions for the training.""" self.train_metrics = { - 'feature_transfer_mse': tf.keras.metrics.Mean(), - 'beta_transfer_loss': tf.keras.metrics.Mean(), - 'gamma_transfer_loss': tf.keras.metrics.Mean(), - 'attention_transfer_loss': tf.keras.metrics.Mean(), - 'masked_lm_accuracy': tf.keras.metrics.SparseCategoricalAccuracy(), - 'lm_example_loss': tf.keras.metrics.Mean(), - 'total_loss': tf.keras.metrics.Mean(), - 'next_sentence_accuracy': tf.keras.metrics.SparseCategoricalAccuracy(), - 'next_sentence_loss': tf.keras.metrics.Mean(), + 'feature_transfer_mse': tf_keras.metrics.Mean(), + 'beta_transfer_loss': tf_keras.metrics.Mean(), + 'gamma_transfer_loss': tf_keras.metrics.Mean(), + 'attention_transfer_loss': tf_keras.metrics.Mean(), + 'masked_lm_accuracy': tf_keras.metrics.SparseCategoricalAccuracy(), + 'lm_example_loss': tf_keras.metrics.Mean(), + 'total_loss': tf_keras.metrics.Mean(), + 'next_sentence_accuracy': tf_keras.metrics.SparseCategoricalAccuracy(), + 'next_sentence_loss': tf_keras.metrics.Mean(), } self.eval_metrics = { - 'masked_lm_accuracy': tf.keras.metrics.SparseCategoricalAccuracy(), - 'next_sentence_accuracy': tf.keras.metrics.SparseCategoricalAccuracy(), + 'masked_lm_accuracy': tf_keras.metrics.SparseCategoricalAccuracy(), + 'next_sentence_accuracy': tf_keras.metrics.SparseCategoricalAccuracy(), } def build_exported_ckpt_manager(self): @@ -298,7 +298,7 @@ def calculate_loss_metrics(self, labels, outputs): if self.mode == DistillationMode.LAYER_WISE: teacher_feature = outputs['teacher_output_feature'] student_feature = outputs['student_output_feature'] - feature_transfer_loss = tf.keras.losses.mean_squared_error( + feature_transfer_loss = tf_keras.losses.mean_squared_error( self._layer_norm(teacher_feature), self._layer_norm(student_feature)) # feature_transfer_loss = tf.reduce_mean(feature_transfer_loss) feature_transfer_loss *= self.layer_wise_distill_config.hidden_distill_factor @@ -349,7 +349,7 @@ def calculate_loss_metrics(self, labels, outputs): sentence_outputs = tf.cast( student_pretrainer_output['next_sentence'], dtype=tf.float32) sentence_loss = tf.reduce_mean( - tf.keras.losses.sparse_categorical_crossentropy( + tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_outputs, from_logits=True)) total_loss += sentence_loss else: diff --git a/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer_test.py b/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer_test.py index 71c78874f63..40952ee93a7 100644 --- a/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer_test.py +++ b/official/projects/edgetpu/nlp/mobilebert_edgetpu_trainer_test.py @@ -14,7 +14,7 @@ """Tests for mobilebert_edgetpu_trainer.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.nlp import mobilebert_edgetpu_trainer from official.projects.edgetpu.nlp.configs import params diff --git a/official/projects/edgetpu/nlp/modeling/edgetpu_layers.py b/official/projects/edgetpu/nlp/modeling/edgetpu_layers.py index 96fb0e869f4..2c323052398 100644 --- a/official/projects/edgetpu/nlp/modeling/edgetpu_layers.py +++ b/official/projects/edgetpu/nlp/modeling/edgetpu_layers.py @@ -24,14 +24,14 @@ import string import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers _CHR_IDX = string.ascii_lowercase -# This function is directly copied from the tf.keras.layers.MultiHeadAttention +# This function is directly copied from the tf_keras.layers.MultiHeadAttention # implementation. def _build_attention_equation(rank, attn_axes): """Builds einsum equations for the attention computation. @@ -81,8 +81,8 @@ def _build_attention_equation(rank, attn_axes): return dot_product_equation, combine_equation, attn_scores_rank -@tf.keras.utils.register_keras_serializable(package='Text') -class EdgeTPUSoftmax(tf.keras.layers.Softmax): +@tf_keras.utils.register_keras_serializable(package='Text') +class EdgeTPUSoftmax(tf_keras.layers.Softmax): """EdgeTPU/Quantization friendly implementation for the SoftMax. When export quant model, use -120 mask value. @@ -111,12 +111,12 @@ def call(self, inputs, mask=None): return tf.exp(inputs - tf.reduce_logsumexp( inputs, axis=self.axis, keepdims=True)) else: - return tf.keras.backend.softmax(inputs, axis=self.axis[0]) - return tf.keras.backend.softmax(inputs, axis=self.axis) + return tf_keras.backend.softmax(inputs, axis=self.axis[0]) + return tf_keras.backend.softmax(inputs, axis=self.axis) -@tf.keras.utils.register_keras_serializable(package='Text') -class EdgeTPUMultiHeadAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package='Text') +class EdgeTPUMultiHeadAttention(tf_keras.layers.MultiHeadAttention): """Quantization friendly implementation for the MultiHeadAttention.""" def _build_attention(self, rank): @@ -139,7 +139,7 @@ def _build_attention(self, rank): norm_axes = tuple( range(attn_scores_rank - len(self._attention_axes), attn_scores_rank)) self._softmax = EdgeTPUSoftmax(axis=norm_axes) - self._dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) + self._dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) class EdgetpuMobileBertTransformer(layers.MobileBertTransformer): diff --git a/official/projects/edgetpu/nlp/modeling/edgetpu_layers_test.py b/official/projects/edgetpu/nlp/modeling/edgetpu_layers_test.py index 8210aa19e22..84d09ce4b70 100644 --- a/official/projects/edgetpu/nlp/modeling/edgetpu_layers_test.py +++ b/official/projects/edgetpu/nlp/modeling/edgetpu_layers_test.py @@ -15,7 +15,7 @@ """Tests for custom layers used by MobileBERT-EdgeTPU.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.nlp.modeling import edgetpu_layers diff --git a/official/projects/edgetpu/nlp/modeling/encoder.py b/official/projects/edgetpu/nlp/modeling/encoder.py index c1421fbad83..44957437f58 100644 --- a/official/projects/edgetpu/nlp/modeling/encoder.py +++ b/official/projects/edgetpu/nlp/modeling/encoder.py @@ -14,15 +14,15 @@ """MobileBERT text encoder network.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp import modeling from official.nlp.modeling import layers from official.projects.edgetpu.nlp.modeling import edgetpu_layers -@tf.keras.utils.register_keras_serializable(package='Text') -class MobileBERTEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class MobileBERTEncoder(tf_keras.Model): """A Keras functional API implementation for MobileBERT encoder.""" def __init__(self, @@ -91,7 +91,7 @@ def __init__(self, **kwargs: Other keyworded and arguments. """ self._self_setattr_tracking = False - initializer = tf.keras.initializers.TruncatedNormal( + initializer = tf_keras.initializers.TruncatedNormal( stddev=initializer_range) # layer instantiation @@ -132,11 +132,11 @@ def __init__(self, self._transformer_layers.append(transformer) # input tensor - input_ids = tf.keras.layers.Input( + input_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), dtype=input_mask_dtype, name='input_mask') self.inputs = [input_ids, input_mask, type_ids] @@ -161,7 +161,7 @@ def __init__(self, first_token = tf.squeeze(prev_output[:, 0:1, :], axis=1) if classifier_activation: - self._pooler_layer = tf.keras.layers.EinsumDense( + self._pooler_layer = tf_keras.layers.EinsumDense( 'ab,bc->ac', output_shape=hidden_size, activation=tf.tanh, diff --git a/official/projects/edgetpu/nlp/modeling/model_builder.py b/official/projects/edgetpu/nlp/modeling/model_builder.py index f1b515019f6..3a0fcc81400 100644 --- a/official/projects/edgetpu/nlp/modeling/model_builder.py +++ b/official/projects/edgetpu/nlp/modeling/model_builder.py @@ -15,7 +15,7 @@ """Build MobileBERT-EdgeTPU model.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp import modeling @@ -25,10 +25,10 @@ def build_bert_pretrainer(pretrainer_cfg: params.PretrainerModelParams, - encoder: Optional[tf.keras.Model] = None, - masked_lm: Optional[tf.keras.Model] = None, + encoder: Optional[tf_keras.Model] = None, + masked_lm: Optional[tf_keras.Model] = None, quantization_friendly: Optional[bool] = False, - name: Optional[str] = None) -> tf.keras.Model: + name: Optional[str] = None) -> tf_keras.Model: """Builds pretrainer. Args: @@ -83,7 +83,7 @@ def _get_embedding_table(encoder): masked_lm = masked_lm or modeling.layers.MobileBertMaskedLM( embedding_table=_get_embedding_table(encoder), activation=tf_utils.get_activation(pretrainer_cfg.mlm_activation), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=pretrainer_cfg.mlm_initializer_range), output_weights_use_proj=pretrainer_cfg.mlm_output_weights_use_proj, name='cls/predictions') diff --git a/official/projects/edgetpu/nlp/modeling/model_builder_test.py b/official/projects/edgetpu/nlp/modeling/model_builder_test.py index 540e5f5581d..b1aaa1823dd 100644 --- a/official/projects/edgetpu/nlp/modeling/model_builder_test.py +++ b/official/projects/edgetpu/nlp/modeling/model_builder_test.py @@ -14,7 +14,7 @@ """Tests for mobilebert_edgetpu.model_builder.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp import modeling from official.nlp.configs import encoders @@ -62,7 +62,7 @@ def test_initialization_with_mlm(self): word_embed_size=128, type_vocab_size=2, output_embed_size=encoders.MobileBertEncoderConfig().hidden_size) - dummy_input = tf.keras.layers.Input( + dummy_input = tf_keras.layers.Input( shape=(None,), dtype=tf.int32) _ = embedding(dummy_input) embedding_table = embedding.word_embedding.embeddings diff --git a/official/projects/edgetpu/nlp/modeling/pretrainer.py b/official/projects/edgetpu/nlp/modeling/pretrainer.py index af511abda2a..d8f56bb095d 100644 --- a/official/projects/edgetpu/nlp/modeling/pretrainer.py +++ b/official/projects/edgetpu/nlp/modeling/pretrainer.py @@ -17,13 +17,13 @@ import copy from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class MobileBERTEdgeTPUPretrainer(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class MobileBERTEdgeTPUPretrainer(tf_keras.Model): """BERT pretraining model V2. Adds the masked language model head and optional classification heads upon the @@ -52,11 +52,11 @@ class MobileBERTEdgeTPUPretrainer(tf.keras.Model): def __init__( self, - encoder_network: tf.keras.Model, + encoder_network: tf_keras.Model, mlm_activation=None, mlm_initializer='glorot_uniform', - classification_heads: Optional[List[tf.keras.layers.Layer]] = None, - customized_masked_lm: Optional[tf.keras.layers.Layer] = None, + classification_heads: Optional[List[tf_keras.layers.Layer]] = None, + customized_masked_lm: Optional[tf_keras.layers.Layer] = None, name: str = 'bert', **kwargs): @@ -76,7 +76,7 @@ def __init__( raise ValueError('encoder_network\'s output should be either a list ' 'or a dict, but got %s' % encoder_network_outputs) - masked_lm_positions = tf.keras.layers.Input( + masked_lm_positions = tf_keras.layers.Input( shape=(None,), name='masked_lm_positions', dtype=tf.int32) inputs.append(masked_lm_positions) masked_lm_layer = customized_masked_lm or layers.MaskedLM( diff --git a/official/projects/edgetpu/nlp/modeling/pretrainer_test.py b/official/projects/edgetpu/nlp/modeling/pretrainer_test.py index 8d8f4ba7531..189b4d51c5d 100644 --- a/official/projects/edgetpu/nlp/modeling/pretrainer_test.py +++ b/official/projects/edgetpu/nlp/modeling/pretrainer_test.py @@ -16,7 +16,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.nlp.modeling import networks @@ -59,10 +59,10 @@ def test_mobilebert_edgetpu_pretrainer( num_token_predictions = 20 # Create a set of 2-dimensional inputs (the first dimension is implicit). inputs = dict( - input_word_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)) - inputs['masked_lm_positions'] = tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32)) + inputs['masked_lm_positions'] = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. @@ -109,10 +109,10 @@ def test_multiple_cls_outputs(self): num_token_predictions = 20 # Create a set of 2-dimensional inputs (the first dimension is implicit). inputs = dict( - input_word_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - masked_lm_positions=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + masked_lm_positions=tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32)) # Invoke the trainer model on the inputs. This causes the layer to be built. diff --git a/official/projects/edgetpu/nlp/run_mobilebert_edgetpu_train.py b/official/projects/edgetpu/nlp/run_mobilebert_edgetpu_train.py index 2940c66bb40..1dcb418bb8f 100644 --- a/official/projects/edgetpu/nlp/run_mobilebert_edgetpu_train.py +++ b/official/projects/edgetpu/nlp/run_mobilebert_edgetpu_train.py @@ -19,7 +19,7 @@ from absl import flags from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.common import flags as tfm_flags diff --git a/official/projects/edgetpu/nlp/serving/export_tflite_squad.py b/official/projects/edgetpu/nlp/serving/export_tflite_squad.py index 862da2c02b1..7cf0d7e3255 100644 --- a/official/projects/edgetpu/nlp/serving/export_tflite_squad.py +++ b/official/projects/edgetpu/nlp/serving/export_tflite_squad.py @@ -31,7 +31,7 @@ from absl import flags from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import flags as tfm_flags from official.nlp.data import data_loader_factory @@ -58,9 +58,9 @@ 'with random weights if path is None.') -def build_model_for_serving(model: tf.keras.Model, +def build_model_for_serving(model: tf_keras.Model, sequence_length: int = 384, - batch_size: int = 1) -> tf.keras.Model: + batch_size: int = 1) -> tf_keras.Model: """Builds MLPerf evaluation compatible models. To run the model on device, the model input/output datatype and node names @@ -73,27 +73,27 @@ def build_model_for_serving(model: tf.keras.Model, Returns: Keras model with new input/output nodes. """ - word_ids = tf.keras.Input(shape=(sequence_length,), + word_ids = tf_keras.Input(shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32, name='input_word_ids') - mask = tf.keras.Input(shape=(sequence_length,), + mask = tf_keras.Input(shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32, name='input_mask') - type_ids = tf.keras.Input(shape=(sequence_length,), + type_ids = tf_keras.Input(shape=(sequence_length,), batch_size=batch_size, dtype=tf.int32, name='input_type_ids') model_output = model([word_ids, type_ids, mask]) # Use identity layers wrapped in lambdas to explicitly name the output # tensors. - start_logits = tf.keras.layers.Lambda( + start_logits = tf_keras.layers.Lambda( tf.identity, name='start_positions')( model_output[0]) - end_logits = tf.keras.layers.Lambda( + end_logits = tf_keras.layers.Lambda( tf.identity, name='end_positions')( model_output[1]) - model = tf.keras.Model( + model = tf_keras.Model( inputs=[word_ids, type_ids, mask], outputs=[start_logits, end_logits]) @@ -127,7 +127,7 @@ def main(argv: Sequence[str]) -> None: encoder_network = pretrainer_model.encoder_network model = models.BertSpanLabeler( network=encoder_network, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01)) + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01)) # Load model weights. if FLAGS.model_checkpoint is not None: diff --git a/official/projects/edgetpu/nlp/serving/export_tflite_squad_test.py b/official/projects/edgetpu/nlp/serving/export_tflite_squad_test.py index b7bd3da4bfd..584a0cedbc3 100644 --- a/official/projects/edgetpu/nlp/serving/export_tflite_squad_test.py +++ b/official/projects/edgetpu/nlp/serving/export_tflite_squad_test.py @@ -14,7 +14,7 @@ """Tests for export_tflite_squad.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import models from official.projects.edgetpu.nlp.configs import params @@ -32,7 +32,7 @@ def setUp(self): encoder_network = pretrainer_model.encoder_network self.span_labeler = models.BertSpanLabeler( network=encoder_network, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01)) + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01)) def test_model_input_output(self): test_model = export_tflite_squad.build_model_for_serving(self.span_labeler) diff --git a/official/projects/edgetpu/nlp/utils/utils.py b/official/projects/edgetpu/nlp/utils/utils.py index 3c7bdcb2f57..933cea82184 100644 --- a/official/projects/edgetpu/nlp/utils/utils.py +++ b/official/projects/edgetpu/nlp/utils/utils.py @@ -18,7 +18,7 @@ import pprint from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.edgetpu.nlp.configs import params @@ -86,7 +86,7 @@ def get_model_dir(experiment_params, flags_obj): return flags_obj.model_dir -def load_checkpoint(model: tf.keras.Model, ckpt_path: str): +def load_checkpoint(model: tf_keras.Model, ckpt_path: str): """Initializes model with the checkpoint.""" ckpt_dir_or_file = ckpt_path diff --git a/official/projects/edgetpu/nlp/utils/utils_test.py b/official/projects/edgetpu/nlp/utils/utils_test.py index 2ae91675746..9a4f12ac12f 100644 --- a/official/projects/edgetpu/nlp/utils/utils_test.py +++ b/official/projects/edgetpu/nlp/utils/utils_test.py @@ -15,7 +15,7 @@ """Tests for utils.py.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.nlp.configs import params from official.projects.edgetpu.nlp.modeling import model_builder diff --git a/official/projects/edgetpu/vision/dataloaders/classification_input.py b/official/projects/edgetpu/vision/dataloaders/classification_input.py index de057bee305..2a5277ecc42 100644 --- a/official/projects/edgetpu/vision/dataloaders/classification_input.py +++ b/official/projects/edgetpu/vision/dataloaders/classification_input.py @@ -14,7 +14,7 @@ """Classification decoder and parser.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import classification_input from official.vision.ops import preprocess_ops diff --git a/official/projects/edgetpu/vision/dataloaders/classification_input_test.py b/official/projects/edgetpu/vision/dataloaders/classification_input_test.py index 9255272cb73..062b70052b1 100644 --- a/official/projects/edgetpu/vision/dataloaders/classification_input_test.py +++ b/official/projects/edgetpu/vision/dataloaders/classification_input_test.py @@ -15,7 +15,7 @@ """Tests classification_input.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.dataloaders import classification_input from official.vision.configs import common from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu.py b/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu.py index 21fa39c8944..1aee3134874 100644 --- a/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu.py +++ b/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu.py @@ -17,14 +17,14 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.edgetpu.vision.modeling.mobilenet_edgetpu_v1_model import MobilenetEdgeTPU from official.projects.edgetpu.vision.modeling.mobilenet_edgetpu_v2_model import MobilenetEdgeTPUV2 from official.vision.modeling.backbones import factory -layers = tf.keras.layers +layers = tf_keras.layers # MobileNet-EdgeTPU-V2 configs. MOBILENET_EDGETPU_V2_CONFIGS = frozenset([ @@ -48,7 +48,7 @@ ]) -def freeze_large_filters(model: tf.keras.Model, threshold: int): +def freeze_large_filters(model: tf_keras.Model, threshold: int): """Freezes layer with large number of filters.""" for layer in model.layers: if isinstance(layer.output_shape, tuple): @@ -59,9 +59,9 @@ def freeze_large_filters(model: tf.keras.Model, threshold: int): @factory.register_backbone_builder('mobilenet_edgetpu') -def build_mobilenet_edgetpu(input_specs: tf.keras.layers.InputSpec, +def build_mobilenet_edgetpu(input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, - **unused_kwargs) -> tf.keras.Model: + **unused_kwargs) -> tf_keras.Model: """Builds MobileNetEdgeTpu backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu_test.py b/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu_test.py index 91194d6abf4..ed3d213bad2 100644 --- a/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu_test.py +++ b/official/projects/edgetpu/vision/modeling/backbones/mobilenet_edgetpu_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling.backbones import mobilenet_edgetpu @@ -50,7 +50,7 @@ class MobileNetEdgeTPUTest(parameterized.TestCase, tf.test.TestCase): ) def test_mobilenet_creation(self, model_id, input_shape): """Test creation of MobileNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') test_model = mobilenet_edgetpu.build_mobilenet_edgetpu( input_specs=TestInputSpec(input_shape), diff --git a/official/projects/edgetpu/vision/modeling/common_modules.py b/official/projects/edgetpu/vision/modeling/common_modules.py index 4387b24b8b2..80470c4221b 100644 --- a/official/projects/edgetpu/vision/modeling/common_modules.py +++ b/official/projects/edgetpu/vision/modeling/common_modules.py @@ -16,7 +16,7 @@ from typing import Optional, Tuple # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow.compat.v1 as tf1 from tensorflow.python.tpu import tpu_function # pylint: disable=g-direct-tensorflow-import @@ -26,8 +26,8 @@ STDDEV_RGB = (0.5 * 255, 0.5 * 255, 0.5 * 255) -@tf.keras.utils.register_keras_serializable(package='Vision') -class TpuBatchNormalization(tf.keras.layers.BatchNormalization): +@tf_keras.utils.register_keras_serializable(package='Vision') +class TpuBatchNormalization(tf_keras.layers.BatchNormalization): """Cross replica batch normalization.""" def __init__(self, fused: Optional[bool] = False, **kwargs): @@ -78,7 +78,7 @@ def _moments(self, return (shard_mean, shard_variance) -def get_batch_norm(batch_norm_type: str) -> tf.keras.layers.BatchNormalization: +def get_batch_norm(batch_norm_type: str) -> tf_keras.layers.BatchNormalization: """A helper to create a batch normalization getter. Args: @@ -86,12 +86,12 @@ def get_batch_norm(batch_norm_type: str) -> tf.keras.layers.BatchNormalization: will use `TpuBatchNormalization`. Returns: - An instance of `tf.keras.layers.BatchNormalization`. + An instance of `tf_keras.layers.BatchNormalization`. """ if batch_norm_type == 'tpu': return TpuBatchNormalization - return tf.keras.layers.BatchNormalization # pytype: disable=bad-return-type # typed-keras + return tf_keras.layers.BatchNormalization # pytype: disable=bad-return-type # typed-keras def count_params(model, trainable_only=True): @@ -99,11 +99,11 @@ def count_params(model, trainable_only=True): if not trainable_only: return model.count_params() else: - return int(np.sum([tf.keras.backend.count_params(p) + return int(np.sum([tf_keras.backend.count_params(p) for p in model.trainable_weights])) -def load_weights(model: tf.keras.Model, +def load_weights(model: tf_keras.Model, model_weights_path: str, checkpoint_format: str = 'tf_checkpoint'): """Load model weights from the given file path. diff --git a/official/projects/edgetpu/vision/modeling/custom_layers.py b/official/projects/edgetpu/vision/modeling/custom_layers.py index 6e5ea6068d7..11858b7d86b 100644 --- a/official/projects/edgetpu/vision/modeling/custom_layers.py +++ b/official/projects/edgetpu/vision/modeling/custom_layers.py @@ -17,12 +17,12 @@ from collections.abc import MutableMapping import inspect from typing import Any, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class GroupConv2D(tf.keras.layers.Conv2D): +class GroupConv2D(tf_keras.layers.Conv2D): """2D group convolution as a Keras Layer.""" def __init__(self, @@ -42,10 +42,10 @@ def __init__(self, activity_regularizer: Any = None, kernel_constraint: Any = None, bias_constraint: Any = None, - batch_norm_layer: Optional[tf.keras.layers.Layer] = None, + batch_norm_layer: Optional[tf_keras.layers.Layer] = None, bn_epsilon: float = 1e-3, bn_momentum: float = 0.99, - **kwargs: Any) -> tf.keras.layers.Layer: + **kwargs: Any) -> tf_keras.layers.Layer: """Creates a 2D group convolution keras layer. Args: @@ -84,7 +84,7 @@ def __init__(self, bias_constraint: Constraint function applied to the bias vector ( see `keras.constraints`). batch_norm_layer: The batch normalization layer to use. This is typically - tf.keras.layer.BatchNormalization or a derived class. + tf_keras.layer.BatchNormalization or a derived class. bn_epsilon: Batch normalization epsilon. bn_momentum: Momentum used for moving average in batch normalization. **kwargs: Additional keyword arguments. @@ -187,7 +187,7 @@ def build(self, input_shape: tuple[int, ...]) -> None: trainable=True, dtype=self.dtype)) channel_axis = self._get_channel_axis() - self.input_spec = tf.keras.layers.InputSpec( + self.input_spec = tf_keras.layers.InputSpec( ndim=self.rank + 2, axes={channel_axis: input_channel}) self._build_conv_op_data_shape = input_shape[-(self.rank + 1):] @@ -267,19 +267,19 @@ def from_config(cls, config): return cls(**config) -class GroupConv2DKerasModel(tf.keras.Model): +class GroupConv2DKerasModel(tf_keras.Model): """2D group convolution as a keras model.""" def __init__(self, filters: int, kernel_size: tuple[int, int], groups: int, - batch_norm_layer: Optional[tf.keras.layers.Layer] = None, + batch_norm_layer: Optional[tf_keras.layers.Layer] = None, bn_epsilon: float = 1e-3, bn_momentum: float = 0.99, data_format: str = 'channels_last', padding: str = 'valid', - **kwargs: Any) -> tf.keras.Model: + **kwargs: Any) -> tf_keras.Model: """Creates a 2D group convolution layer as a keras model. Args: @@ -290,7 +290,7 @@ def __init__(self, specify the same value for all spatial dimensions. groups: The number of input/output channel groups. batch_norm_layer: The batch normalization layer to use. This is typically - tf.keras.layer.BatchNormalization or a derived class. + tf_keras.layer.BatchNormalization or a derived class. bn_epsilon: Batch normalization epsilon. bn_momentum: Momentum used for moving average in batch normalization. data_format: The ordering of the dimensions in the inputs. `channels_last` @@ -322,7 +322,7 @@ def __init__(self, self.use_batch_norm = True if 'activation' in kwargs.keys(): - self.activation = tf.keras.activations.get(kwargs['activation']) + self.activation = tf_keras.activations.get(kwargs['activation']) kwargs.pop('activation') else: self.activation = None @@ -338,7 +338,7 @@ def __init__(self, for _ in range(self._groups): # Override the activation so that batchnorm can be applied after the conv. self.conv_layers.append( - tf.keras.layers.Conv2D(per_conv_filter_size, kernel_size, **kwargs)) + tf_keras.layers.Conv2D(per_conv_filter_size, kernel_size, **kwargs)) if self.use_batch_norm: for _ in range(self._groups): @@ -446,14 +446,14 @@ def argmax(input_tensor, name=name)) -class ArgmaxKerasLayer(tf.keras.layers.Layer): +class ArgmaxKerasLayer(tf_keras.layers.Layer): """Implements argmax as a keras model.""" def __init__(self, axis=-1, name=None, output_type=tf.dtypes.int32, - **kwargs: Any) -> tf.keras.Model: + **kwargs: Any) -> tf_keras.Model: """Implements argmax as a keras model. Args: diff --git a/official/projects/edgetpu/vision/modeling/custom_layers_test.py b/official/projects/edgetpu/vision/modeling/custom_layers_test.py index 64bacf34e92..c17c977587e 100644 --- a/official/projects/edgetpu/vision/modeling/custom_layers_test.py +++ b/official/projects/edgetpu/vision/modeling/custom_layers_test.py @@ -17,7 +17,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import custom_layers GROUPS = [2, 4] @@ -25,7 +25,7 @@ OUTPUT_CHANNEL = [8, 16] USE_BATCH_NORM = [True, False] ACTIVATION = ['relu', 'linear'] -BATCH_NORM_LAYER = tf.keras.layers.BatchNormalization +BATCH_NORM_LAYER = tf_keras.layers.BatchNormalization # 2 functionally identical group conv implementations. GROUP_CONV_IMPL = { @@ -121,7 +121,7 @@ def test_equivalence(self, groups, input_channel, output_channel, use_bias=False, batch_norm_layer=batch_norm_layer, activation=activation) - gc_layer = tf.keras.Sequential([custom_layers.GroupConv2D(**kwargs)]) + gc_layer = tf_keras.Sequential([custom_layers.GroupConv2D(**kwargs)]) gc_model = custom_layers.GroupConv2DKerasModel(**kwargs) gc_layer.build(input_shape=(None, 3, 3, input_channel)) gc_model.build(input_shape=(None, 3, 3, input_channel)) diff --git a/official/projects/edgetpu/vision/modeling/heads/bifpn_head.py b/official/projects/edgetpu/vision/modeling/heads/bifpn_head.py index af5c3e8edb6..76dd4a35d66 100644 --- a/official/projects/edgetpu/vision/modeling/heads/bifpn_head.py +++ b/official/projects/edgetpu/vision/modeling/heads/bifpn_head.py @@ -21,7 +21,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import common_modules @@ -71,7 +71,7 @@ def build_batch_norm(is_training_bn: bool, if is_training_bn: batch_norm_class = common_modules.get_batch_norm(strategy) else: - batch_norm_class = tf.keras.layers.BatchNormalization + batch_norm_class = tf_keras.layers.BatchNormalization bn_layer = batch_norm_class( axis=axis, @@ -141,12 +141,12 @@ def get_conv_op(conv_type): kernel_size = int(conv_type.split('_')[-1]) if conv_type.startswith('sep'): conv_op = functools.partial( - tf.keras.layers.SeparableConv2D, + tf_keras.layers.SeparableConv2D, depth_multiplier=1, kernel_size=(kernel_size, kernel_size)) elif conv_type.startswith('conv'): conv_op = functools.partial( - tf.keras.layers.Conv2D, kernel_size=(kernel_size, kernel_size)) + tf_keras.layers.Conv2D, kernel_size=(kernel_size, kernel_size)) else: raise ValueError('Unknown conv type: {}'.format(conv_type)) return conv_op @@ -218,7 +218,7 @@ def resize(feat, return tf.cast(feat, dtype) -class ResampleFeatureMap(tf.keras.layers.Layer): +class ResampleFeatureMap(tf_keras.layers.Layer): """Resamples feature map for downsampling or upsampling.""" def __init__(self, @@ -248,14 +248,14 @@ def _pool2d(self, inputs, height, width, target_height, target_width): height_stride_size = int((height - 1) // target_height + 1) width_stride_size = int((width - 1) // target_width + 1) if self.pooling_type == 'max': - return tf.keras.layers.MaxPooling2D( + return tf_keras.layers.MaxPooling2D( pool_size=[height_stride_size + 1, width_stride_size + 1], strides=[height_stride_size, width_stride_size], padding='SAME', data_format=self.data_format)( inputs) if self.pooling_type == 'avg': - return tf.keras.layers.AveragePooling2D( + return tf_keras.layers.AveragePooling2D( pool_size=[height_stride_size + 1, width_stride_size + 1], strides=[height_stride_size, width_stride_size], padding='SAME', @@ -278,7 +278,7 @@ def _maybe_apply_1x1(self, feat, training, num_channels): def build(self, feat_shape): num_channels = self.target_num_channels or feat_shape[-1] - self.conv2d = tf.keras.layers.Conv2D( + self.conv2d = tf_keras.layers.Conv2D( num_channels, (1, 1), padding='same', data_format=self.data_format, @@ -321,7 +321,7 @@ def call(self, feat, training, all_feats): return feat -class FNode(tf.keras.layers.Layer): +class FNode(tf_keras.layers.Layer): """A Keras Layer implementing BiFPN Node.""" def __init__(self, @@ -460,7 +460,7 @@ def call(self, feats, training): return feats + [new_node] -class OpAfterCombine(tf.keras.layers.Layer): +class OpAfterCombine(tf_keras.layers.Layer): """Operation after combining input features during feature fusiong.""" def __init__(self, @@ -501,7 +501,7 @@ def call(self, new_node, training): return new_node -class FPNCells(tf.keras.layers.Layer): +class FPNCells(tf_keras.layers.Layer): """FPN cells.""" def __init__(self, @@ -565,7 +565,7 @@ def call(self, feats, training): return feats -class FPNCell(tf.keras.layers.Layer): +class FPNCell(tf_keras.layers.Layer): """A single FPN cell.""" def __init__(self, @@ -619,7 +619,7 @@ def _call(feats): return _call(feats) -class SegClassNet(tf.keras.layers.Layer): +class SegClassNet(tf_keras.layers.Layer): """Segmentation class prediction network.""" def __init__(self, @@ -703,7 +703,7 @@ def __init__(self, padding='same', activation=act_type, name='fullres_conv_%d' % i) - self.fullres_conv_transpose[str(i)] = tf.keras.layers.Conv2DTranspose( + self.fullres_conv_transpose[str(i)] = tf_keras.layers.Conv2DTranspose( filters=num_filters, data_format=data_format, kernel_size=3, @@ -727,7 +727,7 @@ def call(self, inputs, backbone_feats, training): if self.fullres_output: for i in reversed(range(self.min_level)): if self.fullres_skip_connections: - net = tf.keras.layers.Concatenate()([net, backbone_feats[i + 1]]) + net = tf_keras.layers.Concatenate()([net, backbone_feats[i + 1]]) net = self.fullres_conv[str(i)](net) net = self.fullres_conv_transpose[str(i)](net) diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model.py index b62ddcff901..a6dfd60e7ca 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model.py @@ -17,7 +17,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.modeling import mobilenet_edgetpu_v1_model_blocks @@ -34,8 +34,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobilenetEdgeTPU(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobilenetEdgeTPU(tf_keras.Model): """Wrapper class for a MobilenetEdgeTPU Keras model. Contains helper methods to build, manage, and save metadata about the model. @@ -63,7 +63,7 @@ def __init__(self, else: input_shape = (self.config.resolution, self.config.resolution, input_channels) - image_input = tf.keras.layers.Input(shape=input_shape) + image_input = tf_keras.layers.Input(shape=input_shape) output = mobilenet_edgetpu_v1_model_blocks.mobilenet_edgetpu( image_input, self.config) diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_blocks.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_blocks.py index f025c1a853d..95cec409b8a 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_blocks.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_blocks.py @@ -19,7 +19,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -150,7 +150,7 @@ def conv2d_block(inputs: tf.Tensor, batch_norm = common_modules.get_batch_norm(config.batch_norm) bn_momentum = config.bn_momentum bn_epsilon = config.bn_epsilon - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() weight_decay = config.weight_decay name = name or '' @@ -162,15 +162,15 @@ def conv2d_block(inputs: tf.Tensor, 'use_bias': use_bias, 'padding': 'same', 'name': name + '_conv2d', - 'kernel_regularizer': tf.keras.regularizers.l2(weight_decay), - 'bias_regularizer': tf.keras.regularizers.l2(weight_decay), + 'kernel_regularizer': tf_keras.regularizers.l2(weight_decay), + 'bias_regularizer': tf_keras.regularizers.l2(weight_decay), } if depthwise: - conv2d = tf.keras.layers.DepthwiseConv2D + conv2d = tf_keras.layers.DepthwiseConv2D init_kwargs.update({'depthwise_initializer': CONV_KERNEL_INITIALIZER}) else: - conv2d = tf.keras.layers.Conv2D + conv2d = tf_keras.layers.Conv2D init_kwargs.update({'filters': conv_filters, 'kernel_initializer': CONV_KERNEL_INITIALIZER}) @@ -184,7 +184,7 @@ def conv2d_block(inputs: tf.Tensor, name=name + '_bn')(x) if activation is not None: - x = tf.keras.layers.Activation(activation, + x = tf_keras.layers.Activation(activation, name=name + '_activation')(x) return x @@ -207,7 +207,7 @@ def mb_conv_block(inputs: tf.Tensor, use_se = config.use_se activation = tf_utils.get_activation(config.activation) drop_connect_rate = config.drop_connect_rate - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() use_depthwise = block.conv_type == 'depthwise' prefix = prefix or '' @@ -259,8 +259,8 @@ def mb_conv_block(inputs: tf.Tensor, else: se_shape = (1, 1, filters) - se = tf.keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x) - se = tf.keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')(se) + se = tf_keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')(x) + se = tf_keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')(se) se = conv2d_block(se, num_reduced_filters, @@ -276,7 +276,7 @@ def mb_conv_block(inputs: tf.Tensor, use_batch_norm=False, activation='sigmoid', name=prefix + 'se_expand') - x = tf.keras.layers.multiply([x, se], name=prefix + 'se_excite') + x = tf_keras.layers.multiply([x, se], name=prefix + 'se_excite') # Output phase x = conv2d_block(x, @@ -287,7 +287,7 @@ def mb_conv_block(inputs: tf.Tensor, # Add identity so that quantization-aware training can insert quantization # ops correctly. - x = tf.keras.layers.Activation('linear', name=prefix + 'id')(x) + x = tf_keras.layers.Activation('linear', name=prefix + 'id')(x) if (block.id_skip and all(s == 1 for s in block.strides) @@ -297,20 +297,20 @@ def mb_conv_block(inputs: tf.Tensor, # The only difference between dropout and dropconnect in TF is scaling by # drop_connect_rate during training. See: # https://github.com/keras-team/keras/pull/9898#issuecomment-380577612 - x = tf.keras.layers.Dropout(drop_connect_rate, + x = tf_keras.layers.Dropout(drop_connect_rate, noise_shape=(None, 1, 1, 1), name=prefix + 'drop')(x) - x = tf.keras.layers.add([x, inputs], name=prefix + 'add') + x = tf_keras.layers.add([x, inputs], name=prefix + 'add') return x -def mobilenet_edgetpu(image_input: tf.keras.layers.Input, config: ModelConfig): # pytype: disable=invalid-annotation # typed-keras +def mobilenet_edgetpu(image_input: tf_keras.layers.Input, config: ModelConfig): # pytype: disable=invalid-annotation # typed-keras """Creates a MobilenetEdgeTPU graph given the model parameters. This function is wrapped by the `MobilenetEdgeTPU` class to make a - tf.keras.Model. + tf_keras.Model. Args: image_input: the input batch of images @@ -330,14 +330,14 @@ def mobilenet_edgetpu(image_input: tf.keras.layers.Input, config: ModelConfig): num_classes = config.num_classes input_channels = config.input_channels rescale_input = config.rescale_input - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() dtype = config.dtype weight_decay = config.weight_decay x = image_input if data_format == 'channels_first': # Happens on GPU/TPU if available. - x = tf.keras.layers.Permute((3, 1, 2))(x) + x = tf_keras.layers.Permute((3, 1, 2))(x) if rescale_input: x = common_modules.normalize_images( x, num_channels=input_channels, dtype=dtype, data_format=data_format) @@ -396,18 +396,18 @@ def mobilenet_edgetpu(image_input: tf.keras.layers.Input, config: ModelConfig): # Build classifier pool_size = (x.shape.as_list()[1], x.shape.as_list()[2]) - x = tf.keras.layers.AveragePooling2D(pool_size, name='top_pool')(x) + x = tf_keras.layers.AveragePooling2D(pool_size, name='top_pool')(x) if dropout_rate and dropout_rate > 0: - x = tf.keras.layers.Dropout(dropout_rate, name='top_dropout')(x) - x = tf.keras.layers.Conv2D( + x = tf_keras.layers.Dropout(dropout_rate, name='top_dropout')(x) + x = tf_keras.layers.Conv2D( num_classes, 1, kernel_initializer=DENSE_KERNEL_INITIALIZER, - kernel_regularizer=tf.keras.regularizers.l2(weight_decay), - bias_regularizer=tf.keras.regularizers.l2(weight_decay), + kernel_regularizer=tf_keras.regularizers.l2(weight_decay), + bias_regularizer=tf_keras.regularizers.l2(weight_decay), name='logits')( x) - x = tf.keras.layers.Activation('softmax', name='probs')(x) + x = tf_keras.layers.Activation('softmax', name='probs')(x) x = tf.squeeze(x, axis=[1, 2]) return x diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_test.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_test.py index 347d4222156..d7dac3af0d7 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_test.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v1_model_test.py @@ -16,7 +16,7 @@ import os -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.image_classification import preprocessing from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.modeling import mobilenet_edgetpu_v1_model @@ -47,13 +47,13 @@ class MobilenetEdgeTPUBlocksTest(tf.test.TestCase): def setUp(self): super(tf.test.TestCase, self).setUp() # Ensure no model duplicates - tf.keras.backend.clear_session() + tf_keras.backend.clear_session() def test_bottleneck_block(self): """Test for creating a model with bottleneck block arguments.""" images = tf.zeros((4, 224, 224, 3), dtype=tf.float32) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') blocks = [ mobilenet_edgetpu_v1_model_blocks.BlockConfig.from_args( @@ -121,7 +121,7 @@ def test_fused_bottleneck_block(self): """Test for creating a model with fused bottleneck block arguments.""" images = tf.zeros((4, 224, 224, 3), dtype=tf.float32) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') blocks = [ mobilenet_edgetpu_v1_model_blocks.BlockConfig.from_args( @@ -160,7 +160,7 @@ def test_variables(self): """Test for variables in blocks to be included in `model.variables`.""" images = tf.zeros((4, 224, 224, 3), dtype=tf.float32) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') blocks = [ mobilenet_edgetpu_v1_model_blocks.BlockConfig.from_args( @@ -195,7 +195,7 @@ class MobilenetEdgeTPUBuildTest(tf.test.TestCase): def setUp(self): super(tf.test.TestCase, self).setUp() # Ensure no model duplicates - tf.keras.backend.clear_session() + tf_keras.backend.clear_session() def test_create_mobilenet_edgetpu(self): model = mobilenet_edgetpu_v1_model.MobilenetEdgeTPU() @@ -207,7 +207,7 @@ class MobilenetEdgeTPUPredictTest(tf.test.TestCase): def setUp(self): super(tf.test.TestCase, self).setUp() # Ensure no model duplicates - tf.keras.backend.clear_session() + tf_keras.backend.clear_session() def _copy_saved_model_to_local(self, model_ckpt): # Copy saved model to local first for speed diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model.py index 948f3d25a8e..f70c7a1fbe9 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model.py @@ -16,7 +16,7 @@ from typing import Any, Mapping, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.modeling import mobilenet_edgetpu_v2_model_blocks @@ -45,8 +45,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobilenetEdgeTPUV2(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobilenetEdgeTPUV2(tf_keras.Model): """Wrapper class for a MobilenetEdgeTPUV2 Keras model. Contains helper methods to build, manage, and save metadata about the model. @@ -86,7 +86,7 @@ def __init__(self, else: input_shape = (self.config.resolution, self.config.resolution, input_channels) - image_input = tf.keras.layers.Input(shape=input_shape) + image_input = tf_keras.layers.Input(shape=input_shape) output = mobilenet_edgetpu_v2_model_blocks.mobilenet_edgetpu_v2( image_input, self.config) diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks.py index 542d183cc25..69687c305e4 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks.py @@ -18,7 +18,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -26,7 +26,7 @@ from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.modeling import custom_layers -InitializerType = Optional[Union[str, tf.keras.initializers.Initializer]] +InitializerType = Optional[Union[str, tf_keras.initializers.Initializer]] @dataclasses.dataclass @@ -684,12 +684,12 @@ def groupconv2d_block(conv_filters: Optional[int], use_batch_norm: bool = True, use_bias: bool = False, activation: Any = None, - name: Optional[str] = None) -> tf.keras.layers.Layer: + name: Optional[str] = None) -> tf_keras.layers.Layer: """2D group convolution with batchnorm and activation.""" batch_norm = common_modules.get_batch_norm(config.batch_norm) bn_momentum = config.bn_momentum bn_epsilon = config.bn_epsilon - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() weight_decay = config.weight_decay if group_size is None: group_size = config.group_base_size @@ -707,8 +707,8 @@ def groupconv2d_block(conv_filters: Optional[int], 'use_bias': use_bias, 'padding': 'same', 'name': name + '_groupconv2d', - 'kernel_regularizer': tf.keras.regularizers.l2(weight_decay), - 'bias_regularizer': tf.keras.regularizers.l2(weight_decay), + 'kernel_regularizer': tf_keras.regularizers.l2(weight_decay), + 'bias_regularizer': tf_keras.regularizers.l2(weight_decay), 'filters': conv_filters, 'groups': groups, 'batch_norm_layer': batch_norm if use_batch_norm else None, @@ -730,12 +730,12 @@ def conv2d_block_as_layers( activation: Any = None, depthwise: bool = False, kernel_initializer: InitializerType = None, - name: Optional[str] = None) -> List[tf.keras.layers.Layer]: + name: Optional[str] = None) -> List[tf_keras.layers.Layer]: """A conv2d followed by batch norm and an activation.""" batch_norm = common_modules.get_batch_norm(config.batch_norm) bn_momentum = config.bn_momentum bn_epsilon = config.bn_epsilon - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() weight_decay = config.weight_decay name = name or '' @@ -747,16 +747,16 @@ def conv2d_block_as_layers( 'use_bias': use_bias, 'padding': 'same', 'name': name + '_conv2d', - 'kernel_regularizer': tf.keras.regularizers.l2(weight_decay), - 'bias_regularizer': tf.keras.regularizers.l2(weight_decay), + 'kernel_regularizer': tf_keras.regularizers.l2(weight_decay), + 'bias_regularizer': tf_keras.regularizers.l2(weight_decay), } - sequential_layers: List[tf.keras.layers.Layer] = [] + sequential_layers: List[tf_keras.layers.Layer] = [] if depthwise: - conv2d = tf.keras.layers.DepthwiseConv2D + conv2d = tf_keras.layers.DepthwiseConv2D init_kwargs.update({'depthwise_initializer': kernel_initializer}) else: - conv2d = tf.keras.layers.Conv2D + conv2d = tf_keras.layers.Conv2D init_kwargs.update({ 'filters': conv_filters, 'kernel_initializer': kernel_initializer @@ -775,7 +775,7 @@ def conv2d_block_as_layers( if activation is not None: sequential_layers.append( - tf.keras.layers.Activation(activation, name=name + '_activation')) + tf_keras.layers.Activation(activation, name=name + '_activation')) return sequential_layers @@ -807,7 +807,7 @@ def conv2d_block(inputs: tf.Tensor, return x -# Do not inherit from (tf.keras.layers.Layer), will break weights loading. +# Do not inherit from (tf_keras.layers.Layer), will break weights loading. class _MbConvBlock: """Mobile Inverted Residual Bottleneck composite layer.""" @@ -819,11 +819,11 @@ def __call__(self, inputs: tf.Tensor, training=False): se = x for layer in self.squeeze_excitation: se = layer(se) - x = tf.keras.layers.multiply([x, se], name=self.name + 'se_excite') + x = tf_keras.layers.multiply([x, se], name=self.name + 'se_excite') for layer in self.project_block: x = layer(x) if self.has_skip_add: - x = tf.keras.layers.add([x, inputs], name=self.name + 'add') + x = tf_keras.layers.add([x, inputs], name=self.name + 'add') return x def __init__(self, @@ -840,7 +840,7 @@ def __init__(self, use_se = config.use_se activation = tf_utils.get_activation(config.activation) drop_connect_rate = config.drop_connect_rate - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() use_depthwise = block.conv_type == 'depthwise' use_groupconv = block.conv_type == 'group' prefix = prefix or '' @@ -851,9 +851,9 @@ def __init__(self, filters = block.input_filters * block.expand_ratio - self.expand_block: List[tf.keras.layers.Layer] = [] - self.squeeze_excitation: List[tf.keras.layers.Layer] = [] - self.project_block: List[tf.keras.layers.Layer] = [] + self.expand_block: List[tf_keras.layers.Layer] = [] + self.squeeze_excitation: List[tf_keras.layers.Layer] = [] + self.project_block: List[tf_keras.layers.Layer] = [] if block.fused_project: raise NotImplementedError('Fused projection is not supported.') @@ -927,9 +927,9 @@ def __init__(self, se_shape = (1, 1, filters) self.squeeze_excitation.append( - tf.keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')) + tf_keras.layers.GlobalAveragePooling2D(name=prefix + 'se_squeeze')) self.squeeze_excitation.append( - tf.keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')) + tf_keras.layers.Reshape(se_shape, name=prefix + 'se_reshape')) self.squeeze_excitation.extend( conv2d_block_as_layers( conv_filters=num_reduced_filters, @@ -961,7 +961,7 @@ def __init__(self, # Add identity so that quantization-aware training can insert quantization # ops correctly. self.project_block.append( - tf.keras.layers.Activation('linear', name=prefix + 'id')) + tf_keras.layers.Activation('linear', name=prefix + 'id')) self.has_skip_add = False if (block.id_skip @@ -974,7 +974,7 @@ def __init__(self, # by drop_connect_rate during training. See: # https://github.com/keras-team/keras/pull/9898#issuecomment-380577612 self.project_block.append( - tf.keras.layers.Dropout( + tf_keras.layers.Dropout( drop_connect_rate, noise_shape=(None, 1, 1, 1), name=prefix + 'drop')) @@ -998,12 +998,12 @@ def mb_conv_block(inputs: tf.Tensor, return _MbConvBlock(block, config, prefix)(inputs) -def mobilenet_edgetpu_v2(image_input: tf.keras.layers.Input, +def mobilenet_edgetpu_v2(image_input: tf_keras.layers.Input, config: ModelConfig): # pytype: disable=invalid-annotation # typed-keras """Creates a MobilenetEdgeTPUV2 graph given the model parameters. This function is wrapped by the `MobilenetEdgeTPUV2` class to make a - tf.keras.Model. + tf_keras.Model. Args: image_input: the input batch of images @@ -1030,14 +1030,14 @@ def mobilenet_edgetpu_v2(image_input: tf.keras.layers.Input, num_classes = config.num_classes input_channels = config.input_channels rescale_input = config.rescale_input - data_format = tf.keras.backend.image_data_format() + data_format = tf_keras.backend.image_data_format() dtype = config.dtype weight_decay = config.weight_decay x = image_input if data_format == 'channels_first': # Happens on GPU/TPU if available. - x = tf.keras.layers.Permute((3, 1, 2))(x) + x = tf_keras.layers.Permute((3, 1, 2))(x) if rescale_input: x = common_modules.normalize_images( x, num_channels=input_channels, dtype=dtype, data_format=data_format) @@ -1106,18 +1106,18 @@ def mobilenet_edgetpu_v2(image_input: tf.keras.layers.Input, # Build classifier pool_size = (x.shape.as_list()[1], x.shape.as_list()[2]) - x = tf.keras.layers.AveragePooling2D(pool_size, name='top_pool')(x) + x = tf_keras.layers.AveragePooling2D(pool_size, name='top_pool')(x) if dropout_rate and dropout_rate > 0: - x = tf.keras.layers.Dropout(dropout_rate, name='top_dropout')(x) - x = tf.keras.layers.Conv2D( + x = tf_keras.layers.Dropout(dropout_rate, name='top_dropout')(x) + x = tf_keras.layers.Conv2D( num_classes, 1, kernel_initializer=dense_kernel_initializer, - kernel_regularizer=tf.keras.regularizers.l2(weight_decay), - bias_regularizer=tf.keras.regularizers.l2(weight_decay), + kernel_regularizer=tf_keras.regularizers.l2(weight_decay), + bias_regularizer=tf_keras.regularizers.l2(weight_decay), name='logits')( x) - x = tf.keras.layers.Activation('softmax', name='probs')(x) + x = tf_keras.layers.Activation('softmax', name='probs')(x) x = tf.squeeze(x, axis=[1, 2]) return x diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks_test.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks_test.py index 0d68004c9b3..6447a234550 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks_test.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_blocks_test.py @@ -14,7 +14,7 @@ """Tests for mobilenet_edgetpu_v2_model_blocks.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import custom_layers from official.projects.edgetpu.vision.modeling import mobilenet_edgetpu_v2_model_blocks @@ -27,28 +27,28 @@ def setUp(self): self.model_config = mobilenet_edgetpu_v2_model_blocks.ModelConfig() def test_model_creatation(self): - model_input = tf.keras.layers.Input(shape=(224, 224, 1)) + model_input = tf_keras.layers.Input(shape=(224, 224, 1)) model_output = mobilenet_edgetpu_v2_model_blocks.mobilenet_edgetpu_v2( image_input=model_input, config=self.model_config) - test_model = tf.keras.Model(inputs=model_input, outputs=model_output) - self.assertIsInstance(test_model, tf.keras.Model) + test_model = tf_keras.Model(inputs=model_input, outputs=model_output) + self.assertIsInstance(test_model, tf_keras.Model) self.assertEqual(test_model.input.shape, (None, 224, 224, 1)) self.assertEqual(test_model.output.shape, (None, 1001)) def test_model_with_customized_kernel_initializer(self): self.model_config.conv_kernel_initializer = 'he_uniform' self.model_config.dense_kernel_initializer = 'glorot_normal' - model_input = tf.keras.layers.Input(shape=(224, 224, 1)) + model_input = tf_keras.layers.Input(shape=(224, 224, 1)) model_output = mobilenet_edgetpu_v2_model_blocks.mobilenet_edgetpu_v2( image_input=model_input, config=self.model_config) - test_model = tf.keras.Model(inputs=model_input, outputs=model_output) + test_model = tf_keras.Model(inputs=model_input, outputs=model_output) conv_layer_stack = [] for layer in test_model.layers: - if (isinstance(layer, tf.keras.layers.Conv2D) or - isinstance(layer, tf.keras.layers.DepthwiseConv2D) or + if (isinstance(layer, tf_keras.layers.Conv2D) or + isinstance(layer, tf_keras.layers.DepthwiseConv2D) or isinstance(layer, custom_layers.GroupConv2D)): conv_layer_stack.append(layer) self.assertGreater(len(conv_layer_stack), 2) @@ -56,16 +56,16 @@ def test_model_with_customized_kernel_initializer(self): for layer in conv_layer_stack[:-1]: if isinstance(layer, custom_layers.GroupConv2D): self.assertIsInstance(layer.kernel_initializer, - tf.keras.initializers.GlorotUniform) - elif isinstance(layer, tf.keras.layers.Conv2D): + tf_keras.initializers.GlorotUniform) + elif isinstance(layer, tf_keras.layers.Conv2D): self.assertIsInstance(layer.kernel_initializer, - tf.keras.initializers.HeUniform) - elif isinstance(layer, tf.keras.layers.DepthwiseConv2D): + tf_keras.initializers.HeUniform) + elif isinstance(layer, tf_keras.layers.DepthwiseConv2D): self.assertIsInstance(layer.depthwise_initializer, - tf.keras.initializers.HeUniform) + tf_keras.initializers.HeUniform) self.assertIsInstance(conv_layer_stack[-1].kernel_initializer, - tf.keras.initializers.GlorotNormal) + tf_keras.initializers.GlorotNormal) if __name__ == '__main__': diff --git a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_test.py b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_test.py index df71afdd2ad..7b3f2a54f5f 100644 --- a/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_test.py +++ b/official/projects/edgetpu/vision/modeling/mobilenet_edgetpu_v2_model_test.py @@ -17,7 +17,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.modeling import mobilenet_edgetpu_v2_model @@ -28,7 +28,7 @@ class MobilenetEdgeTPUV2BuildTest(tf.test.TestCase, parameterized.TestCase): def setUp(self): super(tf.test.TestCase, self).setUp() # Ensure no model duplicates - tf.keras.backend.clear_session() + tf_keras.backend.clear_session() def test_create_mobilenet_edgetpu(self): model = mobilenet_edgetpu_v2_model.MobilenetEdgeTPUV2() @@ -54,7 +54,7 @@ def test_model_save_load(self): first_conv_layer = model.get_layer('stem_conv2d') kernel_tensor = first_conv_layer.trainable_weights[0].numpy() model.save('/tmp/test_model') - loaded_model = tf.keras.models.load_model('/tmp/test_model') + loaded_model = tf_keras.models.load_model('/tmp/test_model') loaded_first_conv_layer = loaded_model.get_layer('stem_conv2d') loaded_kernel_tensor = loaded_first_conv_layer.trainable_weights[0].numpy() diff --git a/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer.py b/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer.py index 0059dd6b024..a8bb7be8ed3 100644 --- a/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer.py +++ b/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer.py @@ -14,7 +14,7 @@ """MultiHeadAttention layer optimized for EdgeTPU. -Compared to tf.keras.layers.MultiHeadAttention, this layer performs query-key +Compared to tf_keras.layers.MultiHeadAttention, this layer performs query-key multiplication instead of key-query multiplication to remove an unnecessary transpose. """ @@ -23,7 +23,7 @@ from typing import Optional, Tuple import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras _CHR_IDX = string.ascii_lowercase @@ -83,7 +83,7 @@ def _build_attention_equation( return dot_product_equation, combine_equation, attn_scores_rank -class OptimizedMultiHeadAttention(tf.keras.layers.MultiHeadAttention): +class OptimizedMultiHeadAttention(tf_keras.layers.MultiHeadAttention): """MultiHeadAttention with query-key multiplication. Currently, this layer only works for self-attention but not for @@ -112,8 +112,8 @@ def _build_attention(self, rank: int) -> None: rank, attn_axes=self._attention_axes) norm_axes = tuple( range(attn_scores_rank - len(self._attention_axes), attn_scores_rank)) - self._softmax = tf.keras.layers.Softmax(axis=norm_axes) - self._dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) + self._softmax = tf_keras.layers.Softmax(axis=norm_axes) + self._dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) def _compute_attention( self, diff --git a/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer_test.py b/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer_test.py index 81ee6d09f14..1648fdc41b2 100644 --- a/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer_test.py +++ b/official/projects/edgetpu/vision/modeling/optimized_multiheadattention_layer_test.py @@ -15,7 +15,7 @@ """Tests for optimized_multiheadattention_layer.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import optimized_multiheadattention_layer @@ -35,7 +35,7 @@ def test_same_output(self): input_tensor_2 = tf.random.uniform((_BATCH_SIZE, _SEQ_LEN, _EMBEDDING_SIZE)) # Instantiate layer and call with inputs to build. - orig_layer = tf.keras.layers.MultiHeadAttention( + orig_layer = tf_keras.layers.MultiHeadAttention( num_heads=_NUM_HEADS, key_dim=_KEY_DIM) _ = orig_layer(input_tensor_1, input_tensor_2) opt_layer = optimized_multiheadattention_layer.OptimizedMultiHeadAttention( diff --git a/official/projects/edgetpu/vision/serving/export_tflite.py b/official/projects/edgetpu/vision/serving/export_tflite.py index 748b7cb0b83..34625d7598d 100644 --- a/official/projects/edgetpu/vision/serving/export_tflite.py +++ b/official/projects/edgetpu/vision/serving/export_tflite.py @@ -35,7 +35,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.modeling import common_modules from official.projects.edgetpu.vision.serving import export_util @@ -53,7 +53,7 @@ flags.DEFINE_bool( 'export_keras_model', False, 'Export SavedModel format: if False, export TF SavedModel with' - 'tf.saved_model API; if True, export Keras SavedModel with tf.keras.Model' + 'tf.saved_model API; if True, export Keras SavedModel with tf_keras.Model' 'API.') flags.DEFINE_string('output_dir', None, 'Directory to output exported files.') flags.DEFINE_integer( @@ -146,15 +146,15 @@ def run_export(): 'chose an output layer.', export_config.output_layer) return output_layer = model.get_layer(export_config.output_layer) - model = tf.keras.Model(model.input, output_layer.output) + model = tf_keras.Model(model.input, output_layer.output) batch_size = 1 if FLAGS.fix_batch_size else None - model_input = tf.keras.Input( + model_input = tf_keras.Input( shape=(export_config.image_size, export_config.image_size, 3), batch_size=batch_size) model_output = export_util.finalize_serving(model(model_input), export_config) - model_for_inference = tf.keras.Model(model_input, model_output) + model_for_inference = tf_keras.Model(model_input, model_output) # Convert to tflite. Quantize if quantization parameters are specified. converter = tf.lite.TFLiteConverter.from_keras_model(model_for_inference) diff --git a/official/projects/edgetpu/vision/serving/export_tflite_test.py b/official/projects/edgetpu/vision/serving/export_tflite_test.py index 4e8221fa7c9..c6b7b8fced7 100644 --- a/official/projects/edgetpu/vision/serving/export_tflite_test.py +++ b/official/projects/edgetpu/vision/serving/export_tflite_test.py @@ -18,7 +18,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.core import task_factory @@ -49,10 +49,10 @@ def _build_experiment_model(experiment_type): def _build_model(config): model = _build_experiment_model(config.model_name) - model_input = tf.keras.Input( + model_input = tf_keras.Input( shape=(config.image_size, config.image_size, 3), batch_size=1) model_output = export_util.finalize_serving(model(model_input), config) - model_for_inference = tf.keras.Model(model_input, model_output) + model_for_inference = tf_keras.Model(model_input, model_output) return model_for_inference diff --git a/official/projects/edgetpu/vision/serving/export_util.py b/official/projects/edgetpu/vision/serving/export_util.py index 1a7edccca2b..e0e4a0d119c 100644 --- a/official/projects/edgetpu/vision/serving/export_util.py +++ b/official/projects/edgetpu/vision/serving/export_util.py @@ -17,7 +17,7 @@ import dataclasses from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.core import exp_factory diff --git a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator.py b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator.py index ea16b067263..ad1245ee497 100644 --- a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator.py +++ b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator.py @@ -19,7 +19,7 @@ from typing import Tuple from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras @dataclasses.dataclass diff --git a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_run.py b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_run.py index b9c79281e63..1756fbb7d4f 100644 --- a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_run.py +++ b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_run.py @@ -21,7 +21,7 @@ from typing import Sequence from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.projects.edgetpu.vision.serving import tflite_imagenet_evaluator diff --git a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_test.py b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_test.py index 256da3c18ed..dd4fb0ddd43 100644 --- a/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_test.py +++ b/official/projects/edgetpu/vision/serving/tflite_imagenet_evaluator_test.py @@ -15,7 +15,7 @@ """Tests for tflite_imagenet_evaluator.""" from unittest import mock -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.edgetpu.vision.serving import tflite_imagenet_evaluator diff --git a/official/projects/edgetpu/vision/tasks/image_classification.py b/official/projects/edgetpu/vision/tasks/image_classification.py index ba4ecfcaa86..51312e70613 100644 --- a/official/projects/edgetpu/vision/tasks/image_classification.py +++ b/official/projects/edgetpu/vision/tasks/image_classification.py @@ -18,7 +18,7 @@ from typing import Any, List, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -45,7 +45,7 @@ def _copy_recursively(src: str, dst: str) -> None: overwrite=True) -def get_models() -> Mapping[str, tf.keras.Model]: +def get_models() -> Mapping[str, tf_keras.Model]: """Returns the mapping from model type name to Keras model.""" model_mapping = {} @@ -63,7 +63,7 @@ def add_models(name: str, constructor: Any): return model_mapping -def load_searched_model(saved_model_path: str) -> tf.keras.Model: +def load_searched_model(saved_model_path: str) -> tf_keras.Model: """Loads saved model from file. Excepting loading MobileNet-EdgeTPU-V1/V2 models, we can also load searched @@ -83,7 +83,7 @@ def load_searched_model(saved_model_path: str) -> tf.keras.Model: raise ValueError('Saved model path is invalid.') load_options = tf.saved_model.LoadOptions( experimental_io_device='/job:localhost') - model = tf.keras.models.load_model(load_path, options=load_options) + model = tf_keras.models.load_model(load_path, options=load_options) return model @@ -115,7 +115,7 @@ def build_model(self): return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -190,7 +190,7 @@ def build_losses(self, Args: labels: Input groundtruth labels. model_outputs: Output logits of the classifier. - aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf.keras.Model. + aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf_keras.Model. Returns: The total loss tensor. @@ -200,13 +200,13 @@ def build_losses(self, if not is_multilabel: if losses_config.one_hot: - total_loss = tf.keras.losses.categorical_crossentropy( + total_loss = tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=False, label_smoothing=losses_config.label_smoothing) else: - total_loss = tf.keras.losses.sparse_categorical_crossentropy( + total_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, model_outputs, from_logits=True) else: # Multi-label weighted binary cross entropy loss. @@ -221,20 +221,20 @@ def build_losses(self, return total_loss def build_metrics(self, - training: bool = True) -> List[tf.keras.metrics.Metric]: + training: bool = True) -> List[tf_keras.metrics.Metric]: """Gets streaming metrics for training/validation.""" is_multilabel = self.task_config.train_data.is_multilabel if not is_multilabel: k = self.task_config.evaluation.top_k if self.task_config.losses.one_hot: metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k))] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k))] else: metrics = [] @@ -243,12 +243,12 @@ def build_metrics(self, # TODO(arashwan): Investigate adding following metric to train. if not training: metrics = [ - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( name='globalPR-AUC', curve='PR', multi_label=False, from_logits=True), - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( name='meanPR-AUC', curve='PR', multi_label=True, @@ -259,14 +259,14 @@ def build_metrics(self, def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. optimizer: The optimizer for this training step. metrics: A nested structure of metrics objects. @@ -292,7 +292,7 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables @@ -300,7 +300,7 @@ def train_step(self, # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -314,13 +314,13 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Runs validatation step. Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. metrics: A nested structure of metrics objects. Returns: @@ -344,6 +344,6 @@ def validation_step(self, logs.update({m.name: m.result() for m in model.metrics}) return logs - def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model): + def inference_step(self, inputs: tf.Tensor, model: tf_keras.Model): """Performs the forward step.""" return model(inputs, training=False) diff --git a/official/projects/edgetpu/vision/tasks/image_classification_test.py b/official/projects/edgetpu/vision/tasks/image_classification_test.py index 1c4997df42b..50fc4bef6cb 100644 --- a/official/projects/edgetpu/vision/tasks/image_classification_test.py +++ b/official/projects/edgetpu/vision/tasks/image_classification_test.py @@ -17,7 +17,7 @@ # pylint: disable=unused-import from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.modeling import optimization diff --git a/official/projects/edgetpu/vision/tasks/semantic_segmentation.py b/official/projects/edgetpu/vision/tasks/semantic_segmentation.py index a0b875582d2..8808516e442 100644 --- a/official/projects/edgetpu/vision/tasks/semantic_segmentation.py +++ b/official/projects/edgetpu/vision/tasks/semantic_segmentation.py @@ -16,7 +16,7 @@ from typing import Any, Mapping, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg @@ -99,7 +99,7 @@ def build_inputs(self, return dataset -class AutosegEdgeTPU(tf.keras.Model): +class AutosegEdgeTPU(tf_keras.Model): """Segmentation keras network without pre/post-processing.""" def __init__(self, @@ -232,7 +232,7 @@ def call(self, inputs, training): # pytype: disable=signature-mismatch # overr return class_outputs -def get_models() -> Mapping[str, tf.keras.Model]: +def get_models() -> Mapping[str, tf_keras.Model]: """Returns the mapping from model type name to Keras model.""" model_mapping = {} diff --git a/official/projects/edgetpu/vision/tasks/semantic_segmentation_test.py b/official/projects/edgetpu/vision/tasks/semantic_segmentation_test.py index 712edab4f13..f78427724d1 100644 --- a/official/projects/edgetpu/vision/tasks/semantic_segmentation_test.py +++ b/official/projects/edgetpu/vision/tasks/semantic_segmentation_test.py @@ -17,7 +17,7 @@ # pylint: disable=unused-import from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import exp_factory diff --git a/official/projects/fffner/fffner.py b/official/projects/fffner/fffner.py index 1ccd810cee3..75a85b18050 100644 --- a/official/projects/fffner/fffner.py +++ b/official/projects/fffner/fffner.py @@ -13,7 +13,7 @@ # limitations under the License. """The encoder used for FFFNER.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -37,7 +37,7 @@ def get_encoder(encoder_cfg: FFFNerEncoderConfig): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/projects/fffner/fffner_classifier.py b/official/projects/fffner/fffner_classifier.py index 0a780acb67a..89e5c8fd748 100644 --- a/official/projects/fffner/fffner_classifier.py +++ b/official/projects/fffner/fffner_classifier.py @@ -15,13 +15,13 @@ """FFF-NER special token classifier.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -@tf.keras.utils.register_keras_serializable(package='Text') -class FFFNerClassifier(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class FFFNerClassifier(tf_keras.Model): """Classifier model based on a BERT-style transformer-based encoder. This is an implementation of the network structure surrounding a transformer @@ -79,7 +79,7 @@ def __init__(self, cls_inputs = outputs[1] else: cls_inputs = outputs['pooled_output'] - cls_inputs = tf.keras.layers.Dropout(rate=dropout_rate)(cls_inputs) + cls_inputs = tf_keras.layers.Dropout(rate=dropout_rate)(cls_inputs) classifier_is_entity = layers.ClassificationHead( inner_dim=0 if use_encoder_pooler else cls_inputs.shape[-1], diff --git a/official/projects/fffner/fffner_dataloader.py b/official/projects/fffner/fffner_dataloader.py index ab621c5d82d..4b9bf1a393e 100644 --- a/official/projects/fffner/fffner_dataloader.py +++ b/official/projects/fffner/fffner_dataloader.py @@ -16,7 +16,7 @@ import dataclasses from typing import Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg diff --git a/official/projects/fffner/fffner_encoder.py b/official/projects/fffner/fffner_encoder.py index 8ca56e189a1..b1fad93b4d0 100644 --- a/official/projects/fffner/fffner_encoder.py +++ b/official/projects/fffner/fffner_encoder.py @@ -17,18 +17,18 @@ from typing import Any, Callable, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] _Activation = Union[str, Callable[..., Any]] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class FFFNerEncoder(tf.keras.layers.Layer): +class FFFNerEncoder(tf_keras.layers.Layer): """Transformer-based encoder network for FFFNER. The main difference is that it takes in additional positional arguments and @@ -84,11 +84,11 @@ def __init__( inner_activation: _Activation = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, with_dense_inputs: bool = False, return_attention_scores: bool = False, @@ -109,8 +109,8 @@ def __init__( self._output_range = output_range - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -136,17 +136,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -170,12 +170,12 @@ def __init__( name='transformer/layer_%d' % i) self._transformer_layers.append(layer) - self._pooler_layer_is_entity = tf.keras.layers.Dense( + self._pooler_layer_is_entity = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), name='pooler_transform_is_entity') - self._pooler_layer_entity_type = tf.keras.layers.Dense( + self._pooler_layer_entity_type = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -189,10 +189,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -202,22 +202,22 @@ def __init__( } if with_dense_inputs: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_inputs=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_inputs=tf_keras.Input( shape=(None, embedding_width), dtype=tf.float32), - dense_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - is_entity_token_pos=tf.keras.Input(shape=(None,), dtype=tf.int32), - entity_type_token_pos=tf.keras.Input(shape=(None,), dtype=tf.int32)) + dense_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + is_entity_token_pos=tf_keras.Input(shape=(None,), dtype=tf.int32), + entity_type_token_pos=tf_keras.Input(shape=(None,), dtype=tf.int32)) else: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - is_entity_token_pos=tf.keras.Input(shape=(None,), dtype=tf.int32), - entity_type_token_pos=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + is_entity_token_pos=tf_keras.Input(shape=(None,), dtype=tf.int32), + entity_type_token_pos=tf_keras.Input(shape=(None,), dtype=tf.int32)) def call(self, inputs): word_embeddings = None diff --git a/official/projects/fffner/fffner_encoder_test.py b/official/projects/fffner/fffner_encoder_test.py index 4c556a1ec56..0b72ca0e83b 100644 --- a/official/projects/fffner/fffner_encoder_test.py +++ b/official/projects/fffner/fffner_encoder_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.projects.fffner.fffner_encoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.fffner import fffner_encoder diff --git a/official/projects/fffner/fffner_prediction.py b/official/projects/fffner/fffner_prediction.py index 54c0a5d0944..6c75b1f63c8 100644 --- a/official/projects/fffner/fffner_prediction.py +++ b/official/projects/fffner/fffner_prediction.py @@ -18,7 +18,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -95,18 +95,18 @@ def build_model(self): num_classes_is_entity=self.task_config.model.num_classes_is_entity, num_classes_entity_type=self.task_config.model .num_classes_entity_type, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), use_encoder_pooler=self.task_config.model.use_encoder_pooler) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: label_ids_is_entity = labels[self.label_field_is_entity] label_ids_entity_type = labels[self.label_field_entity_type] - loss_is_entity = tf.keras.losses.sparse_categorical_crossentropy( + loss_is_entity = tf_keras.losses.sparse_categorical_crossentropy( label_ids_is_entity, tf.cast(model_outputs[0], tf.float32), from_logits=True) - loss_entity_type = tf.keras.losses.sparse_categorical_crossentropy( + loss_entity_type = tf_keras.losses.sparse_categorical_crossentropy( label_ids_entity_type, tf.cast(model_outputs[1], tf.float32), from_logits=True) @@ -144,9 +144,9 @@ def dummy_data(_): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='cls_accuracy_is_entity'), - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy( name='cls_accuracy_entity_type'), ] return metrics @@ -166,7 +166,7 @@ def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): compiled_metrics.update_state(labels[self.label_field_entity_type], model_outputs[1]) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, labels = inputs, inputs outputs = self.inference_step(features, model) loss = self.build_losses( diff --git a/official/projects/fffner/utils/convert_checkpoint_huggingface.py b/official/projects/fffner/utils/convert_checkpoint_huggingface.py index 14b5b52c983..d43e6c4df73 100644 --- a/official/projects/fffner/utils/convert_checkpoint_huggingface.py +++ b/official/projects/fffner/utils/convert_checkpoint_huggingface.py @@ -18,7 +18,7 @@ from absl import app import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import transformers from official.modeling import tf_utils @@ -47,7 +47,7 @@ def _create_fffner_model(huggingface_bert_config): attention_dropout=huggingface_bert_config.attention_probs_dropout_prob, max_sequence_length=huggingface_bert_config.max_position_embeddings, type_vocab_size=huggingface_bert_config.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=huggingface_bert_config.hidden_size, diff --git a/official/projects/fffner/utils/convert_checkpoint_tensorflow.py b/official/projects/fffner/utils/convert_checkpoint_tensorflow.py index 86dbdb6094c..8a17bfeb33c 100644 --- a/official/projects/fffner/utils/convert_checkpoint_tensorflow.py +++ b/official/projects/fffner/utils/convert_checkpoint_tensorflow.py @@ -17,7 +17,7 @@ from absl import app import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.projects.fffner.fffner import FFFNerEncoderConfig @@ -61,7 +61,7 @@ def _create_fffner_model(bert_config): inner_dim=bert_config["intermediate_size"], max_sequence_length=bert_config["max_position_embeddings"], type_vocab_size=bert_config["type_vocab_size"], - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=bert_config["hidden_size"], diff --git a/official/projects/fffner/utils/create_data.py b/official/projects/fffner/utils/create_data.py index 7dee693e6c8..429c5a0b6b3 100644 --- a/official/projects/fffner/utils/create_data.py +++ b/official/projects/fffner/utils/create_data.py @@ -20,7 +20,7 @@ import sys import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tqdm import tqdm import transformers diff --git a/official/projects/labse/export_tfhub.py b/official/projects/labse/export_tfhub.py index 911e8fab09c..e2af4c7cab4 100644 --- a/official/projects/labse/export_tfhub.py +++ b/official/projects/labse/export_tfhub.py @@ -35,7 +35,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import bert_models from official.legacy.bert import configs @@ -96,7 +96,7 @@ def _get_do_lower_case(do_lower_case, vocab_file): def create_labse_model(bert_tfhub_module: Text, bert_config: configs.BertConfig, - normalize: bool) -> tf.keras.Model: + normalize: bool) -> tf_keras.Model: """Creates a LaBSE keras core model from BERT configuration. Args: @@ -127,7 +127,7 @@ def create_labse_model(bert_tfhub_module: Text, def export_labse_model(bert_tfhub_module: Text, bert_config: configs.BertConfig, model_checkpoint_path: Text, hub_destination: Text, vocab_file: Text, do_lower_case: bool, normalize: bool): - """Restores a tf.keras.Model and saves for TF-Hub.""" + """Restores a tf_keras.Model and saves for TF-Hub.""" core_model, encoder = create_labse_model( bert_tfhub_module, bert_config, normalize) checkpoint = tf.train.Checkpoint(encoder=encoder) diff --git a/official/projects/labse/export_tfhub_test.py b/official/projects/labse/export_tfhub_test.py index daaf1b253e7..1a1d0d4a1e4 100644 --- a/official/projects/labse/export_tfhub_test.py +++ b/official/projects/labse/export_tfhub_test.py @@ -18,7 +18,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.legacy.bert import configs from official.projects.labse import export_tfhub @@ -97,9 +97,9 @@ def _dropout_mean_stddev(training, num_runs=20): self.assertGreater(_dropout_mean_stddev(training=True), 1e-3) # Test propagation of seq_length in shape inference. - input_word_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_mask = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) - input_type_ids = tf.keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_word_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_mask = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) + input_type_ids = tf_keras.layers.Input(shape=(seq_length,), dtype=tf.int32) outputs = hub_layer([input_word_ids, input_mask, input_type_ids]) self.assertEqual(outputs["pooled_output"].shape.as_list(), [None, hidden_size]) diff --git a/official/projects/longformer/longformer.py b/official/projects/longformer/longformer.py index dc08d3978f1..49ea1ec369f 100644 --- a/official/projects/longformer/longformer.py +++ b/official/projects/longformer/longformer.py @@ -16,7 +16,7 @@ import dataclasses from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -61,7 +61,7 @@ def get_encoder(encoder_cfg: LongformerEncoderConfig): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/projects/longformer/longformer_attention.py b/official/projects/longformer/longformer_attention.py index e7cde14d7ce..096f9b17a16 100644 --- a/official/projects/longformer/longformer_attention.py +++ b/official/projects/longformer/longformer_attention.py @@ -20,7 +20,7 @@ import string import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.tf_utils import get_shape_list @@ -104,8 +104,8 @@ def _get_output_shape(output_rank, known_last_dims): return [None] * (output_rank - len(known_last_dims)) + list(known_last_dims) -@tf.keras.utils.register_keras_serializable(package="Text") -class LongformerAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package="Text") +class LongformerAttention(tf_keras.layers.MultiHeadAttention): """LongformerAttention. Args: @@ -170,14 +170,14 @@ def _build_from_signature(self, query, value, key=None): free_dims = self._query_shape.rank - 1 einsum_equation, bias_axes, output_rank = _build_proj_equation( free_dims, bound_dims=1, output_dims=2) - self._query_dense = tf.keras.layers.EinsumDense( + self._query_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._key_dim]), bias_axes=bias_axes if self._use_bias else None, name="query", **common_kwargs) - self._global_query_dense = tf.keras.layers.EinsumDense( + self._global_query_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._key_dim]), @@ -186,14 +186,14 @@ def _build_from_signature(self, query, value, key=None): **common_kwargs) einsum_equation, bias_axes, output_rank = _build_proj_equation( self._key_shape.rank - 1, bound_dims=1, output_dims=2) - self._key_dense = tf.keras.layers.EinsumDense( + self._key_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._key_dim]), bias_axes=bias_axes if self._use_bias else None, name="key", **common_kwargs) - self._global_key_dense = tf.keras.layers.EinsumDense( + self._global_key_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._key_dim]), @@ -202,14 +202,14 @@ def _build_from_signature(self, query, value, key=None): **common_kwargs) einsum_equation, bias_axes, output_rank = _build_proj_equation( self._value_shape.rank - 1, bound_dims=1, output_dims=2) - self._value_dense = tf.keras.layers.EinsumDense( + self._value_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._value_dim]), bias_axes=bias_axes if self._use_bias else None, name="value", **common_kwargs) - self._global_value_dense = tf.keras.layers.EinsumDense( + self._global_value_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=_get_output_shape(output_rank - 1, [self._num_heads, self._value_dim]), @@ -221,10 +221,10 @@ def _build_from_signature(self, query, value, key=None): # These computations could be wrapped into the keras attention layer once # it support mult-head einsum computations. self._build_attention(output_rank) - self._global_dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) + self._global_dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) # self._output_dense = self._make_output_dense( # free_dims, common_kwargs, "attention_output") - self._output_dense = tf.keras.layers.Dense( + self._output_dense = tf_keras.layers.Dense( units=self._num_heads * self._key_dim, name="dense", **common_kwargs) def call(self, diff --git a/official/projects/longformer/longformer_attention_test.py b/official/projects/longformer/longformer_attention_test.py index 805c1d75196..ff1ad61ce00 100644 --- a/official/projects/longformer/longformer_attention_test.py +++ b/official/projects/longformer/longformer_attention_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.projects.longformer.longformer_attention.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.tf_utils import get_shape_list from official.projects.longformer import longformer_attention diff --git a/official/projects/longformer/longformer_encoder.py b/official/projects/longformer/longformer_encoder.py index feb21a4f72b..05d86e5e4b5 100644 --- a/official/projects/longformer/longformer_encoder.py +++ b/official/projects/longformer/longformer_encoder.py @@ -19,18 +19,18 @@ from typing import Any, Callable, List, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.tf_utils import get_shape_list from official.nlp.modeling import layers from official.projects.longformer.longformer_encoder_block import LongformerEncoderBlock -_Initializer = Union[str, tf.keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_Initializer = Union[str, tf_keras.initializers.Initializer] +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class LongformerEncoder(tf.keras.layers.Layer): +class LongformerEncoder(tf_keras.layers.Layer): """LongformerEncoder. Args: @@ -86,11 +86,11 @@ def __init__( inner_activation: Callable[..., Any] = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, **kwargs): super().__init__(**kwargs) @@ -99,8 +99,8 @@ def __init__( self._global_attention_size = global_attention_size self._pad_token_id = pad_token_id - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -126,17 +126,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -162,7 +162,7 @@ def __init__( name=f'transformer/layer_{i}') self._transformer_layers.append(layer) - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=initializer, @@ -176,10 +176,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -189,9 +189,9 @@ def __init__( 'pad_token_id': pad_token_id, } self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32)) def call(self, inputs): word_embeddings = None diff --git a/official/projects/longformer/longformer_encoder_block.py b/official/projects/longformer/longformer_encoder_block.py index c38a5486e51..93268a005b0 100644 --- a/official/projects/longformer/longformer_encoder_block.py +++ b/official/projects/longformer/longformer_encoder_block.py @@ -14,12 +14,12 @@ """Longformer attention layer. Modified From huggingface/transformers.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.longformer.longformer_attention import LongformerAttention -@tf.keras.utils.register_keras_serializable(package="Text") -class LongformerEncoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class LongformerEncoderBlock(tf_keras.layers.Layer): """LongformerEncoderBlock. Args: @@ -96,19 +96,19 @@ def __init__( self._output_dropout = output_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._inner_dropout = inner_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = self._kernel_initializer @@ -154,39 +154,39 @@ def build(self, input_shape): name="self_attention", **common_kwargs) # TFLongformerSelfOutput.dropout - self._attention_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. # TFLongformerSelfOutput.Layernorm self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) # TFLongformerIntermediate # TFLongformerIntermediate.dense - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", kernel_initializer=self._kernel_initializer, name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 # TFLongformerIntermediate.intermediate_act_fn - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) # TFLongformerOutput # TFLongformerOutput.dense - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, hidden_size), bias_axes="d", @@ -194,10 +194,10 @@ def build(self, input_shape): kernel_initializer=self._kernel_initializer, **common_kwargs) # TFLongformerOutput.dropout - self._output_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # TFLongformerOutput.layernorm - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -220,19 +220,19 @@ def get_config(self): "output_range": self._output_range, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "use_bias": self._use_bias, "norm_first": @@ -242,7 +242,7 @@ def get_config(self): "inner_dropout": self._inner_dropout, "attention_initializer": - tf.keras.initializers.serialize(self._attention_initializer), + tf_keras.initializers.serialize(self._attention_initializer), "attention_axes": self._attention_axes, } diff --git a/official/projects/longformer/longformer_encoder_test.py b/official/projects/longformer/longformer_encoder_test.py index 7c5db96bec7..e24124ecfe3 100644 --- a/official/projects/longformer/longformer_encoder_test.py +++ b/official/projects/longformer/longformer_encoder_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.projects.longformer.longformer_encoder import LongformerEncoder diff --git a/official/projects/longformer/utils/convert_pretrained_pytorch_checkpoint_to_tf.py b/official/projects/longformer/utils/convert_pretrained_pytorch_checkpoint_to_tf.py index a9671ac2e0d..a8aa14607a2 100644 --- a/official/projects/longformer/utils/convert_pretrained_pytorch_checkpoint_to_tf.py +++ b/official/projects/longformer/utils/convert_pretrained_pytorch_checkpoint_to_tf.py @@ -18,7 +18,7 @@ from absl import app import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import transformers from official.modeling import tf_utils @@ -54,7 +54,7 @@ def _create_longformer_model(): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/projects/longformer/utils/longformer_tokenizer_to_tfrecord.py b/official/projects/longformer/utils/longformer_tokenizer_to_tfrecord.py index 4b305f369b7..f14904802b0 100644 --- a/official/projects/longformer/utils/longformer_tokenizer_to_tfrecord.py +++ b/official/projects/longformer/utils/longformer_tokenizer_to_tfrecord.py @@ -17,7 +17,7 @@ import os import datasets -import tensorflow as tf +import tensorflow as tf, tf_keras import transformers pretrained_lm = "allenai/longformer-base-4096" diff --git a/official/projects/lra/exponential_moving_average.py b/official/projects/lra/exponential_moving_average.py index d0bc9ac8e07..e406d928009 100644 --- a/official/projects/lra/exponential_moving_average.py +++ b/official/projects/lra/exponential_moving_average.py @@ -15,10 +15,10 @@ """Keras-based MegaEncoder block layer.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras -class MultiHeadEMA(tf.keras.layers.Layer): +class MultiHeadEMA(tf_keras.layers.Layer): """Exponential Moving Average Layer. See "https://arxiv.org/abs/2209.10655" for more details. diff --git a/official/projects/lra/linformer.py b/official/projects/lra/linformer.py index 743012cba12..7830f34ef82 100644 --- a/official/projects/lra/linformer.py +++ b/official/projects/lra/linformer.py @@ -15,7 +15,7 @@ """Linformer model configurations and instantiation methods.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -58,7 +58,7 @@ def get_encoder(encoder_cfg: LinformerEncoderConfig): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range ), output_range=encoder_cfg.output_range, diff --git a/official/projects/lra/linformer_encoder.py b/official/projects/lra/linformer_encoder.py index 144e6431d4a..9a25e76e7c4 100644 --- a/official/projects/lra/linformer_encoder.py +++ b/official/projects/lra/linformer_encoder.py @@ -19,7 +19,7 @@ from typing import Any, Callable, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm from official.modeling import tf_utils @@ -27,11 +27,11 @@ layers = tfm.nlp.layers -_Initializer = Union[str, tf.keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_Initializer = Union[str, tf_keras.initializers.Initializer] +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class LinformerEncoder(tf.keras.layers.Layer): +class LinformerEncoder(tf_keras.layers.Layer): """LinformerEncoder. Args: @@ -83,12 +83,12 @@ def __init__( inner_activation: Callable[..., Any] = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02 ), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, **kwargs ): @@ -96,8 +96,8 @@ def __init__( # Linformer args self._low_rank_features = low_rank_features - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -126,11 +126,11 @@ def __init__( name='type_embeddings', ) - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32 ) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout' ) @@ -138,7 +138,7 @@ def __init__( # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -166,7 +166,7 @@ def __init__( self._transformer_layers.append(layer) self._num_layers = num_layers - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=initializer, @@ -182,19 +182,19 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, 'norm_first': norm_first, } self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) def call(self, inputs): diff --git a/official/projects/lra/linformer_encoder_block.py b/official/projects/lra/linformer_encoder_block.py index 637ef101e81..d5a822a7555 100644 --- a/official/projects/lra/linformer_encoder_block.py +++ b/official/projects/lra/linformer_encoder_block.py @@ -17,14 +17,14 @@ from typing import Any, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package="Text") -class LinformerEncoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class LinformerEncoderBlock(tf_keras.layers.Layer): """LinformerEncoderBlock layer. This layer implements the Linformer Encoder from @@ -117,9 +117,9 @@ def __init__( attention_axes: axes over which the attention is applied. `None` means attention over all axes, but batch, heads, and features. use_query_residual: Toggle to execute residual connection after attention. - key_dim: `key_dim` for the `tf.keras.layers.MultiHeadAttention`. If + key_dim: `key_dim` for the `tf_keras.layers.MultiHeadAttention`. If `None`, we use the first `input_shape`'s last dim. - value_dim: `value_dim` for the `tf.keras.layers.MultiHeadAttention`. + value_dim: `value_dim` for the `tf_keras.layers.MultiHeadAttention`. output_last_dim: Final dimension of the output of this module. This also dictates the value for the final dimension of the multi-head-attention. When it's `None`, we use, in order of decreasing precedence, `key_dim` * @@ -142,13 +142,13 @@ def __init__( self._inner_activation = inner_activation self._attention_dropout_rate = attention_dropout self._output_dropout_rate = output_dropout - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon @@ -160,7 +160,7 @@ def __init__( self._diff_q_kv_att_layer_norm = diff_q_kv_att_layer_norm self._return_attention_scores = return_attention_scores if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer ) else: @@ -211,7 +211,7 @@ def build(self, input_shape): kernel_constraint=self._kernel_constraint, bias_constraint=self._bias_constraint, ) - self._key_projection = tf.keras.layers.Dense( + self._key_projection = tf_keras.layers.Dense( self._low_rank_features, activation=None, use_bias=False, @@ -220,7 +220,7 @@ def build(self, input_shape): name="key_low_rank_projection", **common_kwargs ) - self._value_projection = tf.keras.layers.Dense( + self._value_projection = tf_keras.layers.Dense( self._low_rank_features, activation=None, use_bias=False, @@ -229,7 +229,7 @@ def build(self, input_shape): name="value_low_rank_projection", **common_kwargs ) - self._attention_layer = tf.keras.layers.MultiHeadAttention( + self._attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=self._num_heads, key_dim=self._low_rank_features, value_dim=self._low_rank_features, @@ -242,12 +242,12 @@ def build(self, input_shape): name="self_attention", **common_kwargs ) - self._attention_dropout = tf.keras.layers.Dropout( + self._attention_dropout = tf_keras.layers.Dropout( rate=self._attention_dropout_rate ) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. - self._attention_layer_norm = tf.keras.layers.LayerNormalization( + self._attention_layer_norm = tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -255,14 +255,14 @@ def build(self, input_shape): ) self._attention_layer_norm_kv = self._attention_layer_norm if self._diff_q_kv_att_layer_norm: - self._attention_layer_norm_kv = tf.keras.layers.LayerNormalization( + self._attention_layer_norm_kv = tf_keras.layers.LayerNormalization( name="self_attention_layer_norm_kv", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32, ) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", @@ -271,19 +271,19 @@ def build(self, input_shape): name="intermediate", **common_kwargs ) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy ) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout ) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, last_output_shape), bias_axes="d", @@ -292,11 +292,11 @@ def build(self, input_shape): bias_initializer=tf_utils.clone_initializer(self._bias_initializer), **common_kwargs ) - self._output_dropout = tf.keras.layers.Dropout( + self._output_dropout = tf_keras.layers.Dropout( rate=self._output_dropout_rate ) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -313,32 +313,32 @@ def get_config(self): "inner_activation": self._inner_activation, "output_dropout": self._output_dropout_rate, "attention_dropout": self._attention_dropout_rate, - "kernel_initializer": tf.keras.initializers.serialize( + "kernel_initializer": tf_keras.initializers.serialize( self._kernel_initializer ), - "bias_initializer": tf.keras.initializers.serialize( + "bias_initializer": tf_keras.initializers.serialize( self._bias_initializer ), - "kernel_regularizer": tf.keras.regularizers.serialize( + "kernel_regularizer": tf_keras.regularizers.serialize( self._kernel_regularizer ), - "bias_regularizer": tf.keras.regularizers.serialize( + "bias_regularizer": tf_keras.regularizers.serialize( self._bias_regularizer ), - "activity_regularizer": tf.keras.regularizers.serialize( + "activity_regularizer": tf_keras.regularizers.serialize( self._activity_regularizer ), - "kernel_constraint": tf.keras.constraints.serialize( + "kernel_constraint": tf_keras.constraints.serialize( self._kernel_constraint ), - "bias_constraint": tf.keras.constraints.serialize( + "bias_constraint": tf_keras.constraints.serialize( self._bias_constraint ), "use_bias": self._use_bias, "norm_first": self._norm_first, "norm_epsilon": self._norm_epsilon, "inner_dropout": self._inner_dropout, - "attention_initializer": tf.keras.initializers.serialize( + "attention_initializer": tf_keras.initializers.serialize( self._attention_initializer ), "attention_axes": self._attention_axes, diff --git a/official/projects/lra/lra_dual_encoder.py b/official/projects/lra/lra_dual_encoder.py index e9beb8bd191..20419da69ba 100644 --- a/official/projects/lra/lra_dual_encoder.py +++ b/official/projects/lra/lra_dual_encoder.py @@ -15,13 +15,13 @@ """Trainer network for dual encoder style models.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm -@tf.keras.utils.register_keras_serializable(package='Text') -class LRADualEncoder(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class LRADualEncoder(tf_keras.layers.Layer): """A dual encoder model based on a transformer-based encoder. This is an implementation of the dual encoder network structure based on the diff --git a/official/projects/lra/lra_dual_encoder_dataloader.py b/official/projects/lra/lra_dual_encoder_dataloader.py index 74adf4a5de5..eda6fa13dbe 100644 --- a/official/projects/lra/lra_dual_encoder_dataloader.py +++ b/official/projects/lra/lra_dual_encoder_dataloader.py @@ -17,7 +17,7 @@ import dataclasses from typing import Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg diff --git a/official/projects/lra/lra_dual_encoder_task.py b/official/projects/lra/lra_dual_encoder_task.py index c4a60133327..d5bec9a9d57 100644 --- a/official/projects/lra/lra_dual_encoder_task.py +++ b/official/projects/lra/lra_dual_encoder_task.py @@ -22,7 +22,7 @@ import orbit from scipy import stats from sklearn import metrics as sklearn_metrics -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -98,7 +98,7 @@ def build_model(self): network=encoder_network, max_seq_length=self.task_config.model.max_seq_length, num_classes=self.task_config.model.num_classes, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range ), use_encoder_pooler=self.task_config.model.use_encoder_pooler, @@ -108,9 +108,9 @@ def build_model(self): def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: label_ids = labels[self.label_field] if self.task_config.model.num_classes == 1: - loss = tf.keras.losses.mean_squared_error(label_ids, model_outputs) + loss = tf_keras.losses.mean_squared_error(label_ids, model_outputs) else: - loss = tf.keras.losses.sparse_categorical_crossentropy( + loss = tf_keras.losses.sparse_categorical_crossentropy( label_ids, tf.cast(model_outputs, tf.float32), from_logits=True ) @@ -150,15 +150,15 @@ def dummy_data(_): def build_metrics(self, training=None): del training if self.task_config.model.num_classes == 1: - metrics = [tf.keras.metrics.MeanSquaredError()] + metrics = [tf_keras.metrics.MeanSquaredError()] elif self.task_config.model.num_classes == 2: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), - tf.keras.metrics.AUC(name='auc', curve='PR'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.AUC(name='auc', curve='PR'), ] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), ] return metrics @@ -176,7 +176,7 @@ def process_metrics(self, metrics, labels, model_outputs): def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): compiled_metrics.update_state(labels[self.label_field], model_outputs) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, labels = inputs, inputs outputs = self.inference_step(features, model) loss = self.build_losses( @@ -276,7 +276,7 @@ def initialize(self, model): def predict( task: DualEncoderTask, params: cfg.DataConfig, - model: tf.keras.Model, + model: tf_keras.Model, params_aug: Optional[cfg.DataConfig] = None, test_time_aug_wgt: float = 0.3, ) -> List[Union[int, float]]: diff --git a/official/projects/lra/mega.py b/official/projects/lra/mega.py index 0cbf41e8d76..8907040d150 100644 --- a/official/projects/lra/mega.py +++ b/official/projects/lra/mega.py @@ -15,7 +15,7 @@ """Mega model configurations and instantiation methods.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -66,7 +66,7 @@ def get_encoder(encoder_cfg: MegaEncoderConfig): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range ), output_range=encoder_cfg.output_range, diff --git a/official/projects/lra/mega_encoder.py b/official/projects/lra/mega_encoder.py index 6393a3da51b..74b35819741 100644 --- a/official/projects/lra/mega_encoder.py +++ b/official/projects/lra/mega_encoder.py @@ -19,7 +19,7 @@ from typing import Any, Callable, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm from official.modeling import tf_utils @@ -28,12 +28,12 @@ layers = tfm.nlp.layers -_Initializer = Union[str, tf.keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_Initializer = Union[str, tf_keras.initializers.Initializer] +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -@tf.keras.utils.register_keras_serializable(package='Text') -class MegaEncoder(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class MegaEncoder(tf_keras.layers.Layer): """MegaEncoder. Args: @@ -86,18 +86,18 @@ def __init__( attention_dropout: float = 0.0, hidden_dropout: float = 0.0, inner_activation: Callable[..., Any] = _approx_gelu, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02 ), output_range: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, hidden_size: Optional[int] = None, **kwargs ): super().__init__(**kwargs) # Mega args - initializer = tf.keras.initializers.get(initializer) + initializer = tf_keras.initializers.get(initializer) if embedding_layer is None: self._embedding_layer = layers.OnDeviceEmbedding( @@ -123,11 +123,11 @@ def __init__( name='type_embeddings', ) - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32 ) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=dropout, name='embedding_dropout' ) @@ -156,7 +156,7 @@ def __init__( ) self._transformer_layers.append(layer) self._num_layers = num_layers - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=embedding_width, activation='silu', kernel_initializer=initializer, @@ -175,17 +175,17 @@ def __init__( 'dropout': dropout, 'attention_dropout': attention_dropout, 'hidden_dropout': hidden_dropout, - 'inner_activation': tf.keras.activations.serialize(inner_activation), - 'initializer': tf.keras.initializers.serialize(initializer), + 'inner_activation': tf_keras.activations.serialize(inner_activation), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, 'norm_first': norm_first, } self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) def call(self, inputs): diff --git a/official/projects/lra/mega_encoder_test.py b/official/projects/lra/mega_encoder_test.py index 94a9c8c2a91..253a4d7b5e3 100644 --- a/official/projects/lra/mega_encoder_test.py +++ b/official/projects/lra/mega_encoder_test.py @@ -15,7 +15,7 @@ """Tests for official.nlp.projects.lra.mega_encoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.lra import mega_encoder diff --git a/official/projects/lra/moving_average_gated_attention.py b/official/projects/lra/moving_average_gated_attention.py index 5632cac4d82..8abdf1a3135 100644 --- a/official/projects/lra/moving_average_gated_attention.py +++ b/official/projects/lra/moving_average_gated_attention.py @@ -16,7 +16,7 @@ from typing import Any -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.lra.exponential_moving_average import MultiHeadEMA @@ -33,7 +33,7 @@ def get_activation_fn(activation): return -class RelativePositionBias(tf.keras.layers.Layer): +class RelativePositionBias(tf_keras.layers.Layer): """Relative position embedding layer with bias.""" def __init__(self, max_positions): @@ -41,7 +41,7 @@ def __init__(self, max_positions): self.max_positions = max_positions def build(self, input_shape): - gauss_init = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.02) + gauss_init = tf_keras.initializers.RandomNormal(mean=0.0, stddev=0.02) self.rel_pos_bias = tf.Variable( gauss_init(shape=[2 * self.max_positions - 1], dtype=tf.float32), trainable=True, @@ -69,7 +69,7 @@ def call(self, seq_len): return t -class MovingAverageGatedAttention(tf.keras.layers.Layer): +class MovingAverageGatedAttention(tf_keras.layers.Layer): """MegaEncoderBlock layer. This layer implements the Mega Encoder from @@ -114,24 +114,24 @@ def __init__( self.inner_activation = inner_activation self.scaling = self.zdim**-0.5 - self.dropout = tf.keras.layers.Dropout(rate=dropout) - self.hidden_dropout = tf.keras.layers.Dropout(rate=hidden_dropout) + self.dropout = tf_keras.layers.Dropout(rate=dropout) + self.hidden_dropout = tf_keras.layers.Dropout(rate=hidden_dropout) self.attention_dropout_rate = attention_dropout - self.attention_dropout = tf.keras.layers.Dropout(rate=attention_dropout) + self.attention_dropout = tf_keras.layers.Dropout(rate=attention_dropout) - self.ffn_intermediate_dropout = tf.keras.layers.Dropout(rate=hidden_dropout) - self.output_dropout = tf.keras.layers.Dropout(rate=hidden_dropout) + self.ffn_intermediate_dropout = tf_keras.layers.Dropout(rate=hidden_dropout) + self.output_dropout = tf_keras.layers.Dropout(rate=hidden_dropout) - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer ) else: @@ -143,8 +143,8 @@ def __init__( self.return_attention_scores = return_attention_scores self.prenorm = prenorm - self.norm = tf.keras.layers.LayerNormalization(axis=-1) - self.ffn_norm = tf.keras.layers.LayerNormalization(axis=-1) + self.norm = tf_keras.layers.LayerNormalization(axis=-1) + self.ffn_norm = tf_keras.layers.LayerNormalization(axis=-1) self.move = MultiHeadEMA( embed_dim, ndim=ndim, bidirectional=bidirectional, truncation=truncation @@ -154,10 +154,10 @@ def __init__( super().__init__() def build(self, input_shape): - gauss_init = tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.02) - zero_init = tf.keras.initializers.Zeros() + gauss_init = tf_keras.initializers.RandomNormal(mean=0.0, stddev=0.02) + zero_init = tf_keras.initializers.Zeros() - self.v_proj = tf.keras.layers.Dense( + self.v_proj = tf_keras.layers.Dense( self.hdim, activation=None, use_bias=True, @@ -166,7 +166,7 @@ def build(self, input_shape): name="v_proj", ) - self.mx_proj = tf.keras.layers.Dense( + self.mx_proj = tf_keras.layers.Dense( self.zdim + self.hdim + 2 * self.embed_dim, activation=None, use_bias=True, @@ -175,7 +175,7 @@ def build(self, input_shape): name="mx_proj", ) - self.h_proj = tf.keras.layers.Dense( + self.h_proj = tf_keras.layers.Dense( self.embed_dim, activation=None, use_bias=True, @@ -184,14 +184,14 @@ def build(self, input_shape): name="h_proj", ) - self._intermediate_dense = tf.keras.layers.Dense( + self._intermediate_dense = tf_keras.layers.Dense( self.inner_dim, use_bias=True ) - self._output_dense = tf.keras.layers.Dense(self.embed_dim, use_bias=True) + self._output_dense = tf_keras.layers.Dense(self.embed_dim, use_bias=True) - policy = tf.keras.mixed_precision.global_policy() - self._intermediate_activation_layer = tf.keras.layers.Activation( + policy = tf_keras.mixed_precision.global_policy() + self._intermediate_activation_layer = tf_keras.layers.Activation( self.inner_activation, dtype=policy ) @@ -214,16 +214,16 @@ def get_config(self): "hdim": self.hdim, "dropout": self.dropout, "attention_dropout": self.attention_dropout_rate, - "kernel_initializer": tf.keras.initializers.serialize( + "kernel_initializer": tf_keras.initializers.serialize( self._kernel_initializer ), - "bias_initializer": tf.keras.initializers.serialize( + "bias_initializer": tf_keras.initializers.serialize( self._bias_initializer ), "use_bias": self._use_bias, "prenorm": self.prenorm, "max_positions": self.max_positions, - "attention_initializer": tf.keras.initializers.serialize( + "attention_initializer": tf_keras.initializers.serialize( self._attention_initializer ), "attention_axes": self._attention_axes, diff --git a/official/projects/lra/transformer.py b/official/projects/lra/transformer.py index 9aebd9660c2..fc62c715aee 100644 --- a/official/projects/lra/transformer.py +++ b/official/projects/lra/transformer.py @@ -14,7 +14,7 @@ """Longformer model configurations and instantiation methods.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -51,7 +51,7 @@ def get_encoder(encoder_cfg: TransformerEncoderConfig): attention_dropout=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range ), output_range=encoder_cfg.output_range, diff --git a/official/projects/lra/transformer_encoder.py b/official/projects/lra/transformer_encoder.py index f166ecac937..8feda28c256 100644 --- a/official/projects/lra/transformer_encoder.py +++ b/official/projects/lra/transformer_encoder.py @@ -19,18 +19,18 @@ from typing import Any, Callable, Optional, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm from official.modeling import tf_utils layers = tfm.nlp.layers -_Initializer = Union[str, tf.keras.initializers.Initializer] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_Initializer = Union[str, tf_keras.initializers.Initializer] +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class TransformerEncoder(tf.keras.layers.Layer): +class TransformerEncoder(tf_keras.layers.Layer): """TransformerEncoder. Args: @@ -81,19 +81,19 @@ def __init__( inner_activation: Callable[..., Any] = _approx_gelu, output_dropout: float = 0.1, attention_dropout: float = 0.1, - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02 ), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, **kwargs ): super().__init__(**kwargs) - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -122,11 +122,11 @@ def __init__( name='type_embeddings', ) - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32 ) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout' ) @@ -134,7 +134,7 @@ def __init__( # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -161,7 +161,7 @@ def __init__( self._transformer_layers.append(layer) self._num_layers = num_layers - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=initializer, @@ -175,19 +175,19 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, 'norm_first': norm_first, } self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) def call(self, inputs): diff --git a/official/projects/mae/modeling/masked_ae.py b/official/projects/mae/modeling/masked_ae.py index a37a6a77b8b..92f7ba3c673 100644 --- a/official/projects/mae/modeling/masked_ae.py +++ b/official/projects/mae/modeling/masked_ae.py @@ -14,13 +14,13 @@ """Models for MAE.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mae.modeling import utils from official.vision.modeling.backbones import vit -class MaskedAE(tf.keras.Model): +class MaskedAE(tf_keras.Model): """MAE model.""" def __init__(self, @@ -42,9 +42,9 @@ def build(self, input_shape): ) self.mask = self.add_weight( 'mask', (1, 1, 512), - initializer=tf.keras.initializers.RandomNormal(stddev=0.02)) - self.to_pixels = tf.keras.layers.Dense(self.pixels_per_patch) - self.linear = tf.keras.layers.Dense(512) + initializer=tf_keras.initializers.RandomNormal(stddev=0.02)) + self.to_pixels = tf_keras.layers.Dense(self.pixels_per_patch) + self.linear = tf_keras.layers.Dense(512) super().build(input_shape) def add_position_embed(self, patch_embeds, num_rows, num_cols): diff --git a/official/projects/mae/modeling/utils.py b/official/projects/mae/modeling/utils.py index e2cc3042f41..9bc1213c5b6 100644 --- a/official/projects/mae/modeling/utils.py +++ b/official/projects/mae/modeling/utils.py @@ -15,7 +15,7 @@ """Utils for MAE.""" import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils diff --git a/official/projects/mae/modeling/vit.py b/official/projects/mae/modeling/vit.py index 32cab549aac..566eb704813 100644 --- a/official/projects/mae/modeling/vit.py +++ b/official/projects/mae/modeling/vit.py @@ -14,7 +14,7 @@ """Models for ViT.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.mae.modeling import utils @@ -33,34 +33,34 @@ def to_patch(images, patch_height, patch_width): return x -class ViTClassifier(tf.keras.Model): +class ViTClassifier(tf_keras.Model): """ViT classifier for finetune.""" def __init__(self, encoder, num_classes, **kwargs): super().__init__(**kwargs) self.encoder = encoder - self.linear = tf.keras.layers.Dense( + self.linear = tf_keras.layers.Dense( num_classes, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=2e-5)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=2e-5)) def call(self, inputs): # pytype: disable=signature-mismatch # overriding-parameter-count-checks encoded = self.encoder({'images': inputs}) return self.linear(encoded[:, 0]) -class ViTLinearClassifier(tf.keras.Model): +class ViTLinearClassifier(tf_keras.Model): """ViT classifier for linear probing.""" def __init__(self, encoder, num_classes, use_sync_bn=True, **kwargs): super().__init__(**kwargs) self.encoder = encoder - self.linear = tf.keras.layers.Dense( + self.linear = tf_keras.layers.Dense( num_classes, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01)) if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization self.batch_norm = self._norm( axis=-1, epsilon=1e-6, center=False, scale=False, momentum=0.9) @@ -70,7 +70,7 @@ def call(self, inputs, training=False): # pytype: disable=signature-mismatch # return self.linear(features) -class VisionTransformer(tf.keras.Model): +class VisionTransformer(tf_keras.Model): """ViT backbone.""" def __init__(self, @@ -84,7 +84,7 @@ def __init__(self, self.init_stochastic_depth_rate = init_stochastic_depth_rate def build(self, input_shape): - self.patch_to_embed = tf.keras.layers.Dense(1024) + self.patch_to_embed = tf_keras.layers.Dense(1024) # ViT-L self.encoder = vit.Encoder( num_layers=24, diff --git a/official/projects/mae/optimization.py b/official/projects/mae/optimization.py index e3c18ed4640..943f1f314d3 100644 --- a/official/projects/mae/optimization.py +++ b/official/projects/mae/optimization.py @@ -19,7 +19,7 @@ from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import optimization from official.nlp import optimization as nlp_optimization diff --git a/official/projects/mae/tasks/image_classification.py b/official/projects/mae/tasks/image_classification.py index 6cdd2dfbb61..1a2503470cf 100644 --- a/official/projects/mae/tasks/image_classification.py +++ b/official/projects/mae/tasks/image_classification.py @@ -16,7 +16,7 @@ import dataclasses from typing import Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -47,7 +47,7 @@ class ViTConfig(cfg.TaskConfig): class ViTClassificationTask(base_task.Task): """Image classificaiton with ViT and load checkpoint if exists.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: encoder = vit.VisionTransformer( self.task_config.patch_h, self.task_config.patch_w, @@ -97,7 +97,7 @@ def build_inputs(self, dataset = reader.read(input_context=input_context) return dataset - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Load encoder if checkpoint exists. Args: @@ -117,12 +117,12 @@ def initialize(self, model: tf.keras.Model): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), ] return metrics def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - return tf.keras.losses.categorical_crossentropy( + return tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=True) diff --git a/official/projects/mae/tasks/image_classification_test.py b/official/projects/mae/tasks/image_classification_test.py index e5e38d765d6..f858f014692 100644 --- a/official/projects/mae/tasks/image_classification_test.py +++ b/official/projects/mae/tasks/image_classification_test.py @@ -15,7 +15,7 @@ """Tests for image_classification.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.modeling import optimization diff --git a/official/projects/mae/tasks/linear_probe.py b/official/projects/mae/tasks/linear_probe.py index 749594b4797..d543f03c08e 100644 --- a/official/projects/mae/tasks/linear_probe.py +++ b/official/projects/mae/tasks/linear_probe.py @@ -15,7 +15,7 @@ """Image classification task with ViT and linear probe.""" import dataclasses from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import input_reader @@ -35,7 +35,7 @@ class ViTLinearProbeConfig(image_classification.ViTConfig): class ViTLinearProbeTask(base_task.Task): """Image classificaiton with ViT and load checkpoint if exists.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: encoder = vit.VisionTransformer( self.task_config.patch_h, self.task_config.patch_w, @@ -84,7 +84,7 @@ def build_inputs( dataset = reader.read(input_context=input_context) return dataset - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Load encoder if checkpoint exists. Args: @@ -104,11 +104,11 @@ def initialize(self, model: tf.keras.Model): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), ] return metrics def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - return tf.keras.losses.categorical_crossentropy( + return tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=True ) diff --git a/official/projects/mae/tasks/linear_probe_test.py b/official/projects/mae/tasks/linear_probe_test.py index fd230a15068..805ce92d723 100644 --- a/official/projects/mae/tasks/linear_probe_test.py +++ b/official/projects/mae/tasks/linear_probe_test.py @@ -15,7 +15,7 @@ """Tests for image_classification.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.modeling import optimization diff --git a/official/projects/mae/tasks/masked_ae.py b/official/projects/mae/tasks/masked_ae.py index 4c2b762efa2..cf1501febac 100644 --- a/official/projects/mae/tasks/masked_ae.py +++ b/official/projects/mae/tasks/masked_ae.py @@ -15,7 +15,7 @@ """Task for masked autoencoder pretraining.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import input_reader @@ -32,7 +32,7 @@ class MaskedAETask(base_task.Task): """Task for masked autoencoder training.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: encoder = vit.VisionTransformer( self.task_config.patch_h, self.task_config.patch_w, @@ -102,5 +102,5 @@ def patch_and_mask(images, labels): return dataset def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - return tf.keras.metrics.mean_squared_error( + return tf_keras.metrics.mean_squared_error( labels, model_outputs) diff --git a/official/projects/mae/tasks/masked_ae_test.py b/official/projects/mae/tasks/masked_ae_test.py index 5e858ccde2b..930513ade5e 100644 --- a/official/projects/mae/tasks/masked_ae_test.py +++ b/official/projects/mae/tasks/masked_ae_test.py @@ -15,7 +15,7 @@ """Tests for masked_ae.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.modeling import optimization diff --git a/official/projects/maxvit/configs/backbones.py b/official/projects/maxvit/configs/backbones.py index e80d7d1f3b3..af427f6512c 100644 --- a/official/projects/maxvit/configs/backbones.py +++ b/official/projects/maxvit/configs/backbones.py @@ -16,7 +16,7 @@ import dataclasses from typing import Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.vision.configs import backbones diff --git a/official/projects/maxvit/configs/image_classification_test.py b/official/projects/maxvit/configs/image_classification_test.py index aa731377377..fa4a8768cec 100644 --- a/official/projects/maxvit/configs/image_classification_test.py +++ b/official/projects/maxvit/configs/image_classification_test.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/maxvit/configs/rcnn_test.py b/official/projects/maxvit/configs/rcnn_test.py index e524b28a335..94f17203655 100644 --- a/official/projects/maxvit/configs/rcnn_test.py +++ b/official/projects/maxvit/configs/rcnn_test.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/maxvit/configs/retinanet_test.py b/official/projects/maxvit/configs/retinanet_test.py index ebcada558db..96e73da74f3 100644 --- a/official/projects/maxvit/configs/retinanet_test.py +++ b/official/projects/maxvit/configs/retinanet_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/maxvit/configs/semantic_segmentation_test.py b/official/projects/maxvit/configs/semantic_segmentation_test.py index 1973af2ba73..ceb15972acc 100644 --- a/official/projects/maxvit/configs/semantic_segmentation_test.py +++ b/official/projects/maxvit/configs/semantic_segmentation_test.py @@ -14,7 +14,7 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official import vision diff --git a/official/projects/maxvit/modeling/common_ops.py b/official/projects/maxvit/modeling/common_ops.py index d4ce5406534..139baddf4f9 100644 --- a/official/projects/maxvit/modeling/common_ops.py +++ b/official/projects/maxvit/modeling/common_ops.py @@ -20,7 +20,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras def activation_fn(features: tf.Tensor, act_fn: str): @@ -73,9 +73,9 @@ def pooling_2d(inputs, pool_type, stride, **kwargs): """Perform 2D pooling.""" if stride > 1: if pool_type == 'max': - pool_op = tf.keras.layers.MaxPool2D + pool_op = tf_keras.layers.MaxPool2D elif pool_type == 'avg': - pool_op = tf.keras.layers.AveragePooling2D + pool_op = tf_keras.layers.AveragePooling2D else: raise ValueError('Unsurpported pool_type %s' % pool_type) output = pool_op( diff --git a/official/projects/maxvit/modeling/layers.py b/official/projects/maxvit/modeling/layers.py index 8cb90a29808..275adf1b613 100644 --- a/official/projects/maxvit/modeling/layers.py +++ b/official/projects/maxvit/modeling/layers.py @@ -19,12 +19,12 @@ from typing import Any, Callable, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.maxvit.modeling import common_ops -class TrailDense(tf.keras.layers.Layer): +class TrailDense(tf_keras.layers.Layer): """Dense module that projects multiple trailing dimensions.""" def __init__( @@ -105,7 +105,7 @@ def call(self, inputs: tf.Tensor) -> tf.Tensor: return output -class Attention(tf.keras.layers.Layer): +class Attention(tf_keras.layers.Layer): """Multi-headed attention module.""" def __init__( @@ -300,7 +300,7 @@ def call( attn_probs = common_ops.float32_softmax(attn_logits, axis=-1) if self.dropatt: - attn_probs = tf.keras.layers.Dropout(self.dropatt, name='attn_prob_drop')( + attn_probs = tf_keras.layers.Dropout(self.dropatt, name='attn_prob_drop')( attn_probs, training=training ) @@ -312,7 +312,7 @@ def call( return output -class FFN(tf.keras.layers.Layer): +class FFN(tf_keras.layers.Layer): """Positionwise feed-forward network.""" def __init__( @@ -352,7 +352,7 @@ def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: output = self._expand_dense(output) output = self._activation_fn(output) if self.dropout: - output = tf.keras.layers.Dropout(self.dropout, name='nonlinearity_drop')( + output = tf_keras.layers.Dropout(self.dropout, name='nonlinearity_drop')( output, training=training ) output = self._shrink_dense(output) @@ -360,7 +360,7 @@ def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: return output -class TransformerBlock(tf.keras.layers.Layer): +class TransformerBlock(tf_keras.layers.Layer): """Transformer block = Attention + FFN.""" def __init__( @@ -432,7 +432,7 @@ def build(self, input_shape: tf.TensorShape) -> None: else: self._shortcut_proj = None - self._attn_layer_norm = tf.keras.layers.LayerNormalization( + self._attn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, @@ -452,7 +452,7 @@ def build(self, input_shape: tf.TensorShape) -> None: bias_initializer=self._bias_initializer, ) - self._ffn_layer_norm = tf.keras.layers.LayerNormalization( + self._ffn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, @@ -544,7 +544,7 @@ def call( shortcut = self.shortcut_branch(inputs) output = self.attn_branch(inputs, training, attn_mask) if self._dropout: - output = tf.keras.layers.Dropout(self._dropout, name='after_attn_drop')( + output = tf_keras.layers.Dropout(self._dropout, name='after_attn_drop')( output, training=training ) output = common_ops.residual_add( @@ -554,7 +554,7 @@ def call( shortcut = output output = self.ffn_branch(output, training) if self._dropout: - output = tf.keras.layers.Dropout(self._dropout, name='after_ffn_drop')( + output = tf_keras.layers.Dropout(self._dropout, name='after_ffn_drop')( output, training=training ) output = common_ops.residual_add( @@ -564,7 +564,7 @@ def call( return output -class SqueezeAndExcitation(tf.keras.layers.Layer): +class SqueezeAndExcitation(tf_keras.layers.Layer): """Squeeze-and-excitation layer.""" def __init__( @@ -585,7 +585,7 @@ def __init__( self._activation_fn = common_ops.get_act_fn(activation) # Squeeze and Excitation layer. - self._se_reduce = tf.keras.layers.Conv2D( + self._se_reduce = tf_keras.layers.Conv2D( se_filters, kernel_size=[1, 1], strides=[1, 1], @@ -596,7 +596,7 @@ def __init__( bias_initializer=bias_initializer, name='reduce_conv2d', ) - self._se_expand = tf.keras.layers.Conv2D( + self._se_expand = tf_keras.layers.Conv2D( output_filters, kernel_size=[1, 1], strides=[1, 1], @@ -633,17 +633,17 @@ def _config_batch_norm( if norm_type == 'layer_norm': return functools.partial( - tf.keras.layers.LayerNormalization, epsilon=ln_epsilon + tf_keras.layers.LayerNormalization, epsilon=ln_epsilon ) elif norm_type == 'batch_norm': return functools.partial( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, momentum=bn_momentum, epsilon=bn_epsilon, ) elif norm_type == 'sync_batch_norm': return functools.partial( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, momentum=bn_momentum, epsilon=bn_epsilon, synchronized=True, @@ -654,17 +654,17 @@ def _config_batch_norm( def _build_downsample_layer( pool_type: str, pool_stride: int, data_format: str = 'channels_last' -) -> tf.keras.layers.Layer: +) -> tf_keras.layers.Layer: """Builds a downsample layer for MbConv based on pool type.""" if pool_type == 'max': - return tf.keras.layers.MaxPooling2D( + return tf_keras.layers.MaxPooling2D( pool_size=(pool_stride, pool_stride), strides=(pool_stride, pool_stride), padding='same', data_format=data_format, ) elif pool_type == 'avg': - return tf.keras.layers.AveragePooling2D( + return tf_keras.layers.AveragePooling2D( pool_size=(pool_stride, pool_stride), strides=(pool_stride, pool_stride), padding='same', @@ -674,7 +674,7 @@ def _build_downsample_layer( raise ValueError(f'Unsurpported pool_type {pool_type}') -class MBConvBlock(tf.keras.layers.Layer): +class MBConvBlock(tf_keras.layers.Layer): """Mobile Inverted Residual Bottleneck (https://arxiv.org/abs/1905.02244).""" def __init__( @@ -734,7 +734,7 @@ def build(self, input_shape: tf.TensorShape) -> None: # Shortcut projection. if input_size != self._hidden_size: - self._shortcut_conv = tf.keras.layers.Conv2D( + self._shortcut_conv = tf_keras.layers.Conv2D( filters=self._hidden_size, kernel_size=1, strides=1, @@ -754,7 +754,7 @@ def build(self, input_shape: tf.TensorShape) -> None: # Expansion phase. Called if not using fused convolutions and expansion # phase is necessary. if self._expansion_rate != 1: - self._expand_conv = tf.keras.layers.Conv2D( + self._expand_conv = tf_keras.layers.Conv2D( filters=inner_size, kernel_size=1, strides=( @@ -769,7 +769,7 @@ def build(self, input_shape: tf.TensorShape) -> None: self._expand_norm = norm_cls(name='expand_norm') # Depth-wise convolution phase. Called if not using fused convolutions. - self._depthwise_conv = tf.keras.layers.DepthwiseConv2D( + self._depthwise_conv = tf_keras.layers.DepthwiseConv2D( kernel_size=self._kernel_size, strides=( self._pool_stride if self._downsample_loc == 'depth_conv' else 1 @@ -796,7 +796,7 @@ def build(self, input_shape: tf.TensorShape) -> None: self._se = None # Output phase. - self._shrink_conv = tf.keras.layers.Conv2D( + self._shrink_conv = tf_keras.layers.Conv2D( filters=self._hidden_size, kernel_size=1, strides=1, @@ -837,7 +837,7 @@ def residual_branch(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: logging.debug('DConv shape: %s', output.shape) if self._dropcnn: - output = tf.keras.layers.Dropout(self._dropcnn, 'after_dconv_drop')( + output = tf_keras.layers.Dropout(self._dropcnn, 'after_dconv_drop')( output, training=training ) diff --git a/official/projects/maxvit/modeling/maxvit.py b/official/projects/maxvit/modeling/maxvit.py index e013179f215..a0b959574ea 100644 --- a/official/projects/maxvit/modeling/maxvit.py +++ b/official/projects/maxvit/modeling/maxvit.py @@ -19,7 +19,7 @@ from typing import Any, Mapping, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.maxvit.modeling import common_ops as ops from official.projects.maxvit.modeling import layers @@ -72,7 +72,7 @@ } -class MaxViTBlock(tf.keras.layers.Layer): +class MaxViTBlock(tf_keras.layers.Layer): """MaxViT block = MBConv + Block-Attention + FFN + Grid-Attention + FFN.""" def __init__( @@ -147,14 +147,14 @@ def build(self, input_shape: tf.TensorShape) -> None: else: self._shortcut_proj = None - self._block_attn_layer_norm = tf.keras.layers.LayerNormalization( + self._block_attn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, name='attn_layer_norm', ) - self._grid_attn_layer_norm = tf.keras.layers.LayerNormalization( + self._grid_attn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, @@ -185,14 +185,14 @@ def build(self, input_shape: tf.TensorShape) -> None: name='attention_1', ) - self._block_ffn_layer_norm = tf.keras.layers.LayerNormalization( + self._block_ffn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, name='ffn_layer_norm', ) - self._grid_ffn_layer_norm = tf.keras.layers.LayerNormalization( + self._grid_ffn_layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=self._ln_epsilon, dtype=self._ln_dtype, @@ -414,7 +414,7 @@ def call( shortcut = output output = self.block_attn_branch(output, training, attn_mask) if self._dropout: - output = tf.keras.layers.Dropout( + output = tf_keras.layers.Dropout( self._dropout, name='after_block_attn_drop' )(output, training=training) output = ops.residual_add(output, shortcut, self._survival_prob, training) @@ -422,7 +422,7 @@ def call( shortcut = output output = self.block_ffn_branch(output, training) if self._dropout: - output = tf.keras.layers.Dropout( + output = tf_keras.layers.Dropout( self._dropout, name='after_block_ffn_drop_1' )(output, training=training) output = ops.residual_add(output, shortcut, self._survival_prob, training) @@ -431,7 +431,7 @@ def call( shortcut = output output = self.grid_attn_branch(output, training, attn_mask) if self._dropout: - output = tf.keras.layers.Dropout( + output = tf_keras.layers.Dropout( self._dropout, name='after_grid_attn_drop' )(output, training=training) output = ops.residual_add(output, shortcut, self._survival_prob, training) @@ -439,7 +439,7 @@ def call( shortcut = output output = self.grid_ffn_branch(output, training) if self._dropout: - output = tf.keras.layers.Dropout( + output = tf_keras.layers.Dropout( self._dropout, name='after_grid_ffn_drop' )(output, training=training) output = ops.residual_add(output, shortcut, self._survival_prob, training) @@ -447,7 +447,7 @@ def call( return output -class MaxViT(tf.keras.Model): +class MaxViT(tf_keras.Model): """MaxViT's backbone that outputs the pre-global-pooled features.""" def __init__( @@ -571,17 +571,17 @@ def __init__( def build(self, input_shape: tf.TensorShape) -> None: if self._norm_type == 'layer_norm': bn_class = functools.partial( - tf.keras.layers.LayerNormalization, epsilon=self._ln_epsilon + tf_keras.layers.LayerNormalization, epsilon=self._ln_epsilon ) elif self._norm_type == 'batch_norm': bn_class = functools.partial( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, momentum=self._bn_momentum, epsilon=self._bn_epsilon, ) elif self._norm_type == 'sync_batch_norm': bn_class = functools.partial( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, momentum=self._bn_momentum, epsilon=self._bn_epsilon, synchronized=True, @@ -597,7 +597,7 @@ def build(self, input_shape: tf.TensorShape) -> None: # Stem stem_layers = [] for i, _ in enumerate(self._stem_hsize): - conv_layer = tf.keras.layers.Conv2D( + conv_layer = tf_keras.layers.Conv2D( filters=self._stem_hsize[i], kernel_size=self._kernel_size, strides=2 if i == 0 else 1, @@ -612,11 +612,11 @@ def build(self, input_shape: tf.TensorShape) -> None: if i < len(self._stem_hsize) - 1: stem_layers.append(bn_class(name='norm_{}'.format(i))) stem_layers.append( - tf.keras.layers.Activation( + tf_keras.layers.Activation( ops.get_act_fn(self._activation), name=f'act_{i}' ) ) - self._stem = tf.keras.Sequential(layers=stem_layers, name='stem') + self._stem = tf_keras.Sequential(layers=stem_layers, name='stem') # Backbone self._blocks = [] @@ -731,10 +731,10 @@ def build(self, input_shape: tf.TensorShape) -> None: bid += 1 if self._representation_size and self._representation_size > 0: - self._dense = tf.keras.layers.Dense( + self._dense = tf_keras.layers.Dense( self._representation_size, name='pre_logits') if self._add_gap_layer_norm: - self._final_layer_norm = tf.keras.layers.LayerNormalization( + self._final_layer_norm = tf_keras.layers.LayerNormalization( epsilon=self._ln_epsilon, name='final_layer_norm') def _add_absolute_position_encoding(self, inputs: tf.Tensor) -> tf.Tensor: @@ -811,7 +811,7 @@ def call( if self._representation_size and self._representation_size > 0: # Backbone's output is [batch_size, height, weight, channel_size]. - output = tf.keras.layers.GlobalAveragePooling2D()(output) + output = tf_keras.layers.GlobalAveragePooling2D()(output) # Maybe add a layer_norm after global average pooling. if self._add_gap_layer_norm: output = self._final_layer_norm(output) @@ -928,6 +928,6 @@ def build_maxvit( norm_activation_config=norm_activation_config, ) # Build the backbone to get a proper `output_specs`. - dummy_inputs = tf.keras.Input(input_specs.shape[1:]) + dummy_inputs = tf_keras.Input(input_specs.shape[1:]) _ = maxvit(dummy_inputs, training=False) return maxvit diff --git a/official/projects/maxvit/modeling/maxvit_test.py b/official/projects/maxvit/modeling/maxvit_test.py index 1645798a154..73a3f79c59b 100644 --- a/official/projects/maxvit/modeling/maxvit_test.py +++ b/official/projects/maxvit/modeling/maxvit_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.maxvit.configs import backbones from official.projects.maxvit.modeling import maxvit @@ -134,7 +134,7 @@ def testBuildMaxViTWithConfig(self): ), ) backbone = maxvit.build_maxvit( - input_specs=tf.keras.layers.InputSpec(shape=[None] + [64, 64, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None] + [64, 64, 3]), backbone_config=backbone_config, norm_activation_config=common.NormActivation(), ) diff --git a/official/projects/maxvit/train_test.py b/official/projects/maxvit/train_test.py index 7446c3580f6..c4d4c2e9e14 100644 --- a/official/projects/maxvit/train_test.py +++ b/official/projects/maxvit/train_test.py @@ -18,7 +18,7 @@ from absl import flags from absl.testing import flagsaver import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.maxvit import train as train_lib from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/mobilebert/distillation.py b/official/projects/mobilebert/distillation.py index dbe9dcc0aa0..9353a784678 100644 --- a/official/projects/mobilebert/distillation.py +++ b/official/projects/mobilebert/distillation.py @@ -18,7 +18,7 @@ from absl import logging import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg from official.modeling import optimization @@ -118,7 +118,7 @@ def build_sub_encoder(encoder, target_layer_id): layer_output, attention_score = encoder.transformer_layers[layer_idx]( layer_output, attention_mask, return_attention_scores=True) - return tf.keras.Model( + return tf_keras.Model( inputs=[input_ids, input_mask, type_ids], outputs=[layer_output, attention_score]) @@ -164,7 +164,7 @@ def __init__(self, raise ValueError('distill_ground_truth_ratio has to be within [0, 1].') # A non-trainable layer for feature normalization for transfer loss - self._layer_norm = tf.keras.layers.LayerNormalization( + self._layer_norm = tf_keras.layers.LayerNormalization( axis=-1, beta_initializer='zeros', gamma_initializer='ones', @@ -194,7 +194,7 @@ def _build_pretrainer(self, pretrainer_cfg: bert.PretrainerConfig, name: str): masked_lm = layers.MobileBertMaskedLM( embedding_table=encoder.get_embedding_table(), activation=tf_utils.get_activation(pretrainer_cfg.mlm_activation), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=pretrainer_cfg.mlm_initializer_range), name='cls/predictions') @@ -219,7 +219,7 @@ def num_steps(self, stage_id) -> int: return self._progressive_config.pretrain_distill_config.num_steps # override policies.ProgressivePolicy - def get_model(self, stage_id, old_model=None) -> tf.keras.Model: + def get_model(self, stage_id, old_model=None) -> tf_keras.Model: del old_model return self.build_model(stage_id) @@ -250,8 +250,8 @@ def get_optimizer(self, stage_id): }) opt_factory = optimization.OptimizerFactory(params) optimizer = opt_factory.build_optimizer(opt_factory.build_learning_rate()) - if isinstance(optimizer, tf.keras.optimizers.experimental.Optimizer): - optimizer = tf.keras.__internal__.optimizers.convert_to_legacy_optimizer( + if isinstance(optimizer, tf_keras.optimizers.experimental.Optimizer): + optimizer = tf_keras.__internal__.optimizers.convert_to_legacy_optimizer( optimizer) return optimizer @@ -274,7 +274,7 @@ def get_eval_dataset(self, stage_id): return self._the_only_eval_dataset # override base_task.task - def build_model(self, stage_id) -> tf.keras.Model: + def build_model(self, stage_id) -> tf_keras.Model: """Build teacher/student keras models with outputs for current stage.""" # Freeze the teacher model. self._teacher_pretrainer.trainable = False @@ -307,7 +307,7 @@ def build_model(self, stage_id) -> tf.keras.Model: for i in range(stage_id): student_encoder.transformer_layers[i].trainable = False - return tf.keras.Model( + return tf_keras.Model( inputs=inputs, outputs=dict( student_output_feature=student_output_feature, @@ -326,7 +326,7 @@ def build_model(self, stage_id) -> tf.keras.Model: for layer in student_encoder.transformer_layers: layer.trainable = True - model = tf.keras.Model( + model = tf_keras.Model( inputs=inputs, outputs=dict( student_pretrainer_output=student_pretrainer_output, @@ -378,9 +378,9 @@ def _get_distribution_losses(self, teacher, student): def _get_attention_loss(self, teacher_score, student_score): # Note that the definition of KLDivergence here is a little different from - # the original one (tf.keras.losses.KLDivergence). We adopt this approach + # the original one (tf_keras.losses.KLDivergence). We adopt this approach # to stay consistent with the TF1 implementation. - teacher_weight = tf.keras.activations.softmax(teacher_score, axis=-1) + teacher_weight = tf_keras.activations.softmax(teacher_score, axis=-1) student_log_weight = tf.nn.log_softmax(student_score, axis=-1) kl_divergence = -(teacher_weight * student_log_weight) kl_divergence = tf.math.reduce_sum(kl_divergence, axis=-1, keepdims=True) @@ -398,7 +398,7 @@ def build_losses(self, labels, outputs, metrics) -> tf.Tensor: teacher_feature = outputs['teacher_output_feature'] student_feature = outputs['student_output_feature'] - feature_transfer_loss = tf.keras.losses.mean_squared_error( + feature_transfer_loss = tf_keras.losses.mean_squared_error( self._layer_norm(teacher_feature), self._layer_norm(student_feature)) feature_transfer_loss *= distill_config.hidden_distill_factor beta_loss, gamma_loss = self._get_distribution_losses(teacher_feature, @@ -453,7 +453,7 @@ def build_losses(self, labels, outputs, metrics) -> tf.Tensor: sentence_outputs = tf.cast( student_pretrainer_output['next_sentence'], dtype=tf.float32) sentence_loss = tf.reduce_mean( - tf.keras.losses.sparse_categorical_crossentropy( + tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_outputs, from_logits=True)) total_loss += sentence_loss @@ -479,18 +479,18 @@ def build_losses(self, labels, outputs, metrics) -> tf.Tensor: def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.Mean(name='feature_transfer_mse'), - tf.keras.metrics.Mean(name='beta_transfer_loss'), - tf.keras.metrics.Mean(name='gamma_transfer_loss'), - tf.keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), - tf.keras.metrics.Mean(name='lm_example_loss'), - tf.keras.metrics.Mean(name='total_loss')] + tf_keras.metrics.Mean(name='feature_transfer_mse'), + tf_keras.metrics.Mean(name='beta_transfer_loss'), + tf_keras.metrics.Mean(name='gamma_transfer_loss'), + tf_keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), + tf_keras.metrics.Mean(name='lm_example_loss'), + tf_keras.metrics.Mean(name='total_loss')] if self._progressive_config.layer_wise_distill_config.if_transfer_attention: - metrics.append(tf.keras.metrics.Mean(name='attention_transfer_loss')) + metrics.append(tf_keras.metrics.Mean(name='attention_transfer_loss')) if self._task_config.train_data.use_next_sentence_label: - metrics.append(tf.keras.metrics.SparseCategoricalAccuracy( + metrics.append(tf_keras.metrics.SparseCategoricalAccuracy( name='next_sentence_accuracy')) - metrics.append(tf.keras.metrics.Mean(name='next_sentence_loss')) + metrics.append(tf_keras.metrics.Mean(name='next_sentence_loss')) return metrics @@ -510,8 +510,8 @@ def process_metrics(self, metrics, labels, student_pretrainer_output): student_pretrainer_output['next_sentence']) # overrides base_task.Task - def train_step(self, inputs, model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, metrics): + def train_step(self, inputs, model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics): """Does forward and backward. Args: @@ -548,7 +548,7 @@ def train_step(self, inputs, model: tf.keras.Model, return {self.loss: loss} # overrides base_task.Task - def validation_step(self, inputs, model: tf.keras.Model, metrics): + def validation_step(self, inputs, model: tf_keras.Model, metrics): """Validatation step. Args: diff --git a/official/projects/mobilebert/distillation_test.py b/official/projects/mobilebert/distillation_test.py index 6d3241a8a53..3b28b0b7c4a 100644 --- a/official/projects/mobilebert/distillation_test.py +++ b/official/projects/mobilebert/distillation_test.py @@ -17,7 +17,7 @@ from absl import logging from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.modeling import optimization @@ -119,7 +119,7 @@ def prepare_config(self, teacher_block_num, student_block_num, masked_lm = layers.MobileBertMaskedLM( embedding_table=teacher_encoder.get_embedding_table(), activation=tf_utils.get_activation(pretrainer_config.mlm_activation), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=pretrainer_config.mlm_initializer_range), name='cls/predictions') teacher_pretrainer = models.BertPretrainerV2( @@ -153,7 +153,7 @@ def test_task(self, teacher_block_num, student_block_num, eval_dataset = bert_distillation_task.get_eval_dataset(stage_id=0) eval_iterator = iter(eval_dataset) - optimizer = tf.keras.optimizers.legacy.SGD(learning_rate=0.1) + optimizer = tf_keras.optimizers.legacy.SGD(learning_rate=0.1) # test train/val step for all stages, including the last pretraining stage for stage in range(student_block_num + 1): diff --git a/official/projects/mobilebert/export_tfhub.py b/official/projects/mobilebert/export_tfhub.py index a5cbb7f9a80..57255b20a52 100644 --- a/official/projects/mobilebert/export_tfhub.py +++ b/official/projects/mobilebert/export_tfhub.py @@ -16,7 +16,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mobilebert import model_utils @@ -43,12 +43,12 @@ def create_mobilebert_model(bert_config): # For interchangeability with other text representations, # add "default" as an alias for MobileBERT's whole-input reptesentations. encoder_output_dict["default"] = encoder_output_dict["pooled_output"] - core_model = tf.keras.Model( + core_model = tf_keras.Model( inputs=encoder_inputs_dict, outputs=encoder_output_dict) pretrainer_inputs_dict = {x.name: x for x in pretrainer.inputs} pretrainer_output_dict = pretrainer(pretrainer_inputs_dict) - mlm_model = tf.keras.Model( + mlm_model = tf_keras.Model( inputs=pretrainer_inputs_dict, outputs=pretrainer_output_dict) # Set `_auto_track_sub_layers` to False, so that the additional weights # from `mlm` sub-object will not be included in the core model. @@ -60,7 +60,7 @@ def create_mobilebert_model(bert_config): def export_bert_tfhub(bert_config, model_checkpoint_path, hub_destination, vocab_file, do_lower_case): - """Restores a tf.keras.Model and saves for TF-Hub.""" + """Restores a tf_keras.Model and saves for TF-Hub.""" core_model, pretrainer = create_mobilebert_model(bert_config) checkpoint = tf.train.Checkpoint(**pretrainer.checkpoint_items) diff --git a/official/projects/mobilebert/model_utils.py b/official/projects/mobilebert/model_utils.py index b696f3e60a6..85207aec0d9 100644 --- a/official/projects/mobilebert/model_utils.py +++ b/official/projects/mobilebert/model_utils.py @@ -159,7 +159,7 @@ def create_mobilebert_pretrainer(bert_config): masked_lm = layers.MobileBertMaskedLM( embedding_table=mobilebert_encoder.get_embedding_table(), activation=tf_utils.get_activation(bert_config.hidden_act), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), name="cls/predictions") diff --git a/official/projects/mosaic/modeling/mosaic_blocks.py b/official/projects/mosaic/modeling/mosaic_blocks.py index c2c0c6dd8d3..066bfb4810b 100644 --- a/official/projects/mosaic/modeling/mosaic_blocks.py +++ b/official/projects/mosaic/modeling/mosaic_blocks.py @@ -21,13 +21,13 @@ from typing import Any, Dict, List, Optional, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class MultiKernelGroupConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MultiKernelGroupConvBlock(tf_keras.layers.Layer): """A multi-kernel grouped convolution block. This block is used in the segmentation neck introduced in MOSAIC. @@ -45,7 +45,7 @@ def __init__( batchnorm_epsilon: float = 0.001, activation: str = 'relu', kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_depthwise_convolution: bool = True, **kwargs): """Initializes a Multi-kernel Grouped Convolution Block. @@ -90,11 +90,11 @@ def __init__( # helps quantization where conv+bn+activation are fused into a single op. self._activation_fn = tf_utils.get_activation(activation) if self._use_sync_bn: - self._bn_op = tf.keras.layers.experimental.SyncBatchNormalization + self._bn_op = tf_keras.layers.experimental.SyncBatchNormalization else: - self._bn_op = tf.keras.layers.BatchNormalization + self._bn_op = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 self._group_split_axis = -1 else: @@ -110,7 +110,7 @@ def build(self, input_shape: tf.TensorShape) -> None: self._conv_branches = [] if self._use_depthwise_convolution: for i, conv_kernel_size in enumerate(self._kernel_sizes): - depthwise_conv = tf.keras.layers.DepthwiseConv2D( + depthwise_conv = tf_keras.layers.DepthwiseConv2D( kernel_size=(conv_kernel_size, conv_kernel_size), depth_multiplier=1, padding='same', @@ -123,7 +123,7 @@ def build(self, input_shape: tf.TensorShape) -> None: momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) activation_depthwise = self._activation_fn - feature_conv = tf.keras.layers.Conv2D( + feature_conv = tf_keras.layers.Conv2D( filters=self._output_filter_depths[i], kernel_size=(1, 1), padding='same', @@ -136,8 +136,8 @@ def build(self, input_shape: tf.TensorShape) -> None: momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) # Use list manually as current QAT API does not support sequential model - # within a tf.keras.Sequential block, e.g. conv_branch = - # tf.keras.Sequential([depthwise_conv, feature_conv, batchnorm_op,]) + # within a tf_keras.Sequential block, e.g. conv_branch = + # tf_keras.Sequential([depthwise_conv, feature_conv, batchnorm_op,]) conv_branch = [ depthwise_conv, batchnorm_op_depthwise, @@ -148,7 +148,7 @@ def build(self, input_shape: tf.TensorShape) -> None: self._conv_branches.append(conv_branch) else: for i, conv_kernel_size in enumerate(self._kernel_sizes): - norm_conv = tf.keras.layers.Conv2D( + norm_conv = tf_keras.layers.Conv2D( filters=self._output_filter_depths[i], kernel_size=(conv_kernel_size, conv_kernel_size), padding='same', @@ -162,7 +162,7 @@ def build(self, input_shape: tf.TensorShape) -> None: epsilon=self._batchnorm_epsilon) conv_branch = [norm_conv, batchnorm_op] self._conv_branches.append(conv_branch) - self._concat_groups = tf.keras.layers.Concatenate( + self._concat_groups = tf_keras.layers.Concatenate( axis=self._group_split_axis) def call(self, @@ -177,7 +177,7 @@ def call(self, conv_branch = self._conv_branches[i] # Apply layers sequentially and manually. for layer in conv_branch: - if isinstance(layer, tf.keras.layers.Layer): + if isinstance(layer, tf_keras.layers.Layer): x = layer(x, training=training) else: x = layer(x) @@ -207,8 +207,8 @@ def get_config(self) -> Dict[str, Any]: return base_config -@tf.keras.utils.register_keras_serializable(package='Vision') -class MosaicEncoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MosaicEncoderBlock(tf_keras.layers.Layer): """Implements the encoder module/block of MOSAIC model. Spatial Pyramid Pooling and Multi-kernel Conv layer @@ -230,7 +230,7 @@ def __init__( activation: str = 'relu', dropout_rate: float = 0.1, kernel_initializer: str = 'glorot_uniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', use_depthwise_convolution: bool = True, **kwargs): @@ -286,18 +286,18 @@ def __init__( self._activation_fn = tf_utils.get_activation(activation) if self._use_sync_bn: - self._bn_op = tf.keras.layers.experimental.SyncBatchNormalization + self._bn_op = tf_keras.layers.experimental.SyncBatchNormalization else: - self._bn_op = tf.keras.layers.BatchNormalization + self._bn_op = tf_keras.layers.BatchNormalization self._dropout_rate = dropout_rate if dropout_rate: - self._encoder_end_dropout_layer = tf.keras.layers.Dropout( + self._encoder_end_dropout_layer = tf_keras.layers.Dropout( rate=dropout_rate) else: self._encoder_end_dropout_layer = None - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 self._channel_axis = -1 else: @@ -329,7 +329,7 @@ def build( input_shape = ( input_shape[self._encoder_input_level] if isinstance(input_shape, dict) else input_shape) - self._data_format = tf.keras.backend.image_data_format() + self._data_format = tf_keras.backend.image_data_format() if self._data_format == 'channels_last': height = input_shape[1] width = input_shape[2] @@ -342,9 +342,9 @@ def build( for pyramid_pool_bin_num in self._pyramid_pool_bin_nums: if pyramid_pool_bin_num == 1: - global_pool = tf.keras.layers.GlobalAveragePooling2D( + global_pool = tf_keras.layers.GlobalAveragePooling2D( data_format=self._data_format, keepdims=True) - global_projection = tf.keras.layers.Conv2D( + global_projection = tf_keras.layers.Conv2D( filters=max(self._branch_filter_depths), kernel_size=(1, 1), padding='same', @@ -356,7 +356,7 @@ def build( axis=self._bn_axis, momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) - # Use list manually instead of tf.keras.Sequential([]) + # Use list manually instead of tf_keras.Sequential([]) self._global_pool_branch = [ global_pool, global_projection, @@ -373,7 +373,7 @@ def build( height, pyramid_pool_bin_num) pool_width, stride_width = self._get_bin_pool_kernel_and_stride( width, pyramid_pool_bin_num) - bin_pool_level = tf.keras.layers.AveragePooling2D( + bin_pool_level = tf_keras.layers.AveragePooling2D( pool_size=(pool_height, pool_width), strides=(stride_height, stride_width), padding='valid', @@ -397,9 +397,9 @@ def build( # enlarge the projection #channels to the sum of the filter depths of # branches. self._output_channels = sum(self._branch_filter_depths) - # Use list manually instead of tf.keras.Sequential([]). + # Use list manually instead of tf_keras.Sequential([]). self._encoder_projection = [ - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( filters=self._output_channels, kernel_size=(1, 1), padding='same', @@ -413,19 +413,19 @@ def build( epsilon=self._batchnorm_epsilon), ] # Use the TF2 default feature alignment rule for bilinear resizing. - self._upsample = tf.keras.layers.Resizing( + self._upsample = tf_keras.layers.Resizing( height, width, interpolation=self._interpolation, crop_to_aspect_ratio=False) - self._concat_layer = tf.keras.layers.Concatenate(axis=self._channel_axis) + self._concat_layer = tf_keras.layers.Concatenate(axis=self._channel_axis) def call(self, inputs: Union[tf.Tensor, Dict[str, tf.Tensor]], training: Optional[bool] = None) -> tf.Tensor: """Calls this MOSAIC encoder block with the given input.""" if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() input_from_backbone_output = ( inputs[self._encoder_input_level] if isinstance(inputs, dict) else inputs) @@ -476,8 +476,8 @@ def get_config(self) -> Dict[str, Any]: return base_config -@tf.keras.utils.register_keras_serializable(package='Vision') -class DecoderSumMergeBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DecoderSumMergeBlock(tf_keras.layers.Layer): """Implements the decoder feature sum merge block of MOSAIC model. This block is used in the decoder of segmentation head introduced in MOSAIC. @@ -494,7 +494,7 @@ def __init__( batchnorm_epsilon: float = 0.001, activation: str = 'relu', kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', **kwargs): """Initialize a sum-merge block for one decoder stage. @@ -538,17 +538,17 @@ def __init__( # helps quantization where conv+bn+activation are fused into a single op. self._activation_fn = tf_utils.get_activation(activation) if self._use_sync_bn: - self._bn_op = tf.keras.layers.experimental.SyncBatchNormalization + self._bn_op = tf_keras.layers.experimental.SyncBatchNormalization else: - self._bn_op = tf.keras.layers.BatchNormalization + self._bn_op = tf_keras.layers.BatchNormalization self._bn_axis = ( -1 - if tf.keras.backend.image_data_format() == 'channels_last' else 1) + if tf_keras.backend.image_data_format() == 'channels_last' else 1) self._channel_axis = ( -1 - if tf.keras.backend.image_data_format() == 'channels_last' else 1) - self._add_layer = tf.keras.layers.Add() + if tf_keras.backend.image_data_format() == 'channels_last' else 1) + self._add_layer = tf_keras.layers.Add() def build( self, @@ -561,7 +561,7 @@ def build( high_res_channels = high_res_input_shape[self._channel_axis] if low_res_channels != self._decoder_projected_depth: - low_res_feature_conv = tf.keras.layers.Conv2D( + low_res_feature_conv = tf_keras.layers.Conv2D( filters=self._decoder_projected_depth, kernel_size=(1, 1), padding='same', @@ -578,7 +578,7 @@ def build( batchnorm_op, ]) if high_res_channels != self._decoder_projected_depth: - high_res_feature_conv = tf.keras.layers.Conv2D( + high_res_feature_conv = tf_keras.layers.Conv2D( filters=self._decoder_projected_depth, kernel_size=(1, 1), padding='same', @@ -595,7 +595,7 @@ def build( batchnorm_op_high, ]) # Resize feature maps. - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': low_res_height = low_res_input_shape[1] low_res_width = low_res_input_shape[2] high_res_height = high_res_input_shape[1] @@ -609,14 +609,14 @@ def build( self._output_size = (high_res_height, high_res_width) if (low_res_height != self._output_size[0] or low_res_width != self._output_size[1]): - self._upsample_low_res = tf.keras.layers.Resizing( + self._upsample_low_res = tf_keras.layers.Resizing( self._output_size[0], self._output_size[1], interpolation=self._interpolation, crop_to_aspect_ratio=False) if (high_res_height != self._output_size[0] or high_res_width != self._output_size[1]): - self._upsample_high_res = tf.keras.layers.Resizing( + self._upsample_high_res = tf_keras.layers.Resizing( self._output_size[0], self._output_size[1], interpolation=self._interpolation, @@ -639,7 +639,7 @@ def call(self, A tensor representing the sum-merged decoder feature map. """ if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() x_low_res = inputs[0] x_high_res = inputs[1] if self._low_res_branch: @@ -675,8 +675,8 @@ def get_config(self) -> Dict[str, Any]: return base_config -@tf.keras.utils.register_keras_serializable(package='Vision') -class DecoderConcatMergeBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DecoderConcatMergeBlock(tf_keras.layers.Layer): """Implements the decoder feature concat merge block of MOSAIC model. This block is used in the decoder of segmentation head introduced in MOSAIC. @@ -694,7 +694,7 @@ def __init__( batchnorm_epsilon: float = 0.001, activation: str = 'relu', kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', **kwargs): """Initializes a concat-merge block for one decoder stage. @@ -739,11 +739,11 @@ def __init__( # helps quantization where conv+bn+activation are fused into a single op. self._activation_fn = tf_utils.get_activation(activation) if self._use_sync_bn: - self._bn_op = tf.keras.layers.experimental.SyncBatchNormalization + self._bn_op = tf_keras.layers.experimental.SyncBatchNormalization else: - self._bn_op = tf.keras.layers.BatchNormalization + self._bn_op = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 self._channel_axis = -1 else: @@ -758,7 +758,7 @@ def build( low_res_input_shape = input_shape[0] high_res_input_shape = input_shape[1] # Set up resizing feature maps before concat. - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': low_res_height = low_res_input_shape[1] low_res_width = low_res_input_shape[2] high_res_height = high_res_input_shape[1] @@ -772,21 +772,21 @@ def build( self._output_size = (high_res_height, high_res_width) if (low_res_height != self._output_size[0] or low_res_width != self._output_size[1]): - self._upsample_low_res = tf.keras.layers.Resizing( + self._upsample_low_res = tf_keras.layers.Resizing( self._output_size[0], self._output_size[1], interpolation=self._interpolation, crop_to_aspect_ratio=False) if (high_res_height != self._output_size[0] or high_res_width != self._output_size[1]): - self._upsample_high_res = tf.keras.layers.Resizing( + self._upsample_high_res = tf_keras.layers.Resizing( self._output_size[0], self._output_size[1], interpolation=self._interpolation, crop_to_aspect_ratio=False) # Set up a 3-layer separable convolution blocks, i.e. # 1x1->BN->RELU + Depthwise->BN->RELU + 1x1->BN->RELU. - initial_feature_conv = tf.keras.layers.Conv2D( + initial_feature_conv = tf_keras.layers.Conv2D( filters=self._decoder_internal_depth, kernel_size=(1, 1), padding='same', @@ -799,7 +799,7 @@ def build( momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) activation1 = self._activation_fn - depthwise_conv = tf.keras.layers.DepthwiseConv2D( + depthwise_conv = tf_keras.layers.DepthwiseConv2D( kernel_size=(3, 3), depth_multiplier=1, padding='same', @@ -811,7 +811,7 @@ def build( momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) activation2 = self._activation_fn - project_feature_conv = tf.keras.layers.Conv2D( + project_feature_conv = tf_keras.layers.Conv2D( filters=self._decoder_projected_depth, kernel_size=(1, 1), padding='same', @@ -835,7 +835,7 @@ def build( batchnorm_op3, activation3, ] - self._concat_layer = tf.keras.layers.Concatenate(axis=self._channel_axis) + self._concat_layer = tf_keras.layers.Concatenate(axis=self._channel_axis) def call(self, inputs: Tuple[tf.Tensor, tf.Tensor], @@ -860,7 +860,7 @@ def call(self, decoder_feature_list = [low_res_input, high_res_input] x = self._concat_layer(decoder_feature_list) for layer in self._feature_fusion_block: - if isinstance(layer, tf.keras.layers.Layer): + if isinstance(layer, tf_keras.layers.Layer): x = layer(x, training=training) else: x = layer(x) diff --git a/official/projects/mosaic/modeling/mosaic_blocks_test.py b/official/projects/mosaic/modeling/mosaic_blocks_test.py index 66911a3c98b..f1509892705 100644 --- a/official/projects/mosaic/modeling/mosaic_blocks_test.py +++ b/official/projects/mosaic/modeling/mosaic_blocks_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.modeling import mosaic_blocks diff --git a/official/projects/mosaic/modeling/mosaic_head.py b/official/projects/mosaic/modeling/mosaic_head.py index 3df5e2866c2..72f57301905 100644 --- a/official/projects/mosaic/modeling/mosaic_head.py +++ b/official/projects/mosaic/modeling/mosaic_head.py @@ -15,14 +15,14 @@ """Contains definitions of segmentation head of the MOSAIC model.""" from typing import Any, Dict, List, Mapping, Optional, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.mosaic.modeling import mosaic_blocks -@tf.keras.utils.register_keras_serializable(package='Vision') -class MosaicDecoderHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MosaicDecoderHead(tf_keras.layers.Layer): """Creates a MOSAIC decoder in segmentation head. Reference: @@ -45,9 +45,9 @@ def __init__( batchnorm_momentum: float = 0.99, batchnorm_epsilon: float = 0.001, kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a MOSAIC segmentation head. @@ -81,11 +81,11 @@ def __init__( batchnorm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: Kernel initializer for conv layers. Defaults to `glorot_uniform`. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. interpolation: The interpolation method for upsampling. Defaults to `bilinear`. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(MosaicDecoderHead, self).__init__(**kwargs) @@ -154,13 +154,13 @@ def __init__( if use_additional_classifier_layer: # This additional classification layer uses different kernel # initializers and bias compared to earlier blocks. - self._pixelwise_classifier = tf.keras.layers.Conv2D( + self._pixelwise_classifier = tf_keras.layers.Conv2D( name='pixelwise_classifier', filters=num_classes, kernel_size=classifier_kernel_size, padding='same', bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer, use_bias=True) diff --git a/official/projects/mosaic/modeling/mosaic_head_test.py b/official/projects/mosaic/modeling/mosaic_head_test.py index b8f8378ac92..f04a92bf280 100644 --- a/official/projects/mosaic/modeling/mosaic_head_test.py +++ b/official/projects/mosaic/modeling/mosaic_head_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.modeling import mosaic_head diff --git a/official/projects/mosaic/modeling/mosaic_model.py b/official/projects/mosaic/modeling/mosaic_model.py index 045a70a2b0f..549688b89ca 100644 --- a/official/projects/mosaic/modeling/mosaic_model.py +++ b/official/projects/mosaic/modeling/mosaic_model.py @@ -15,7 +15,7 @@ """Builds the overall MOSAIC segmentation models.""" from typing import Any, Dict, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.configs import mosaic_config from official.projects.mosaic.modeling import mosaic_blocks @@ -24,8 +24,8 @@ from official.vision.modeling.heads import segmentation_heads -@tf.keras.utils.register_keras_serializable(package='Vision') -class MosaicSegmentationModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MosaicSegmentationModel(tf_keras.Model): """A model class for segmentation using MOSAIC. Input images are passed through a backbone first. A MOSAIC neck encoder @@ -39,10 +39,10 @@ class MosaicSegmentationModel(tf.keras.Model): """ def __init__(self, - backbone: tf.keras.Model, - head: tf.keras.layers.Layer, - neck: Optional[tf.keras.layers.Layer] = None, - mask_scoring_head: Optional[tf.keras.layers.Layer] = None, + backbone: tf_keras.Model, + head: tf_keras.layers.Layer, + neck: Optional[tf_keras.layers.Layer] = None, + mask_scoring_head: Optional[tf_keras.layers.Layer] = None, **kwargs): """Segmentation initialization function. @@ -87,7 +87,7 @@ def call(self, # pytype: disable=signature-mismatch # overriding-parameter-cou @property def checkpoint_items( - self) -> Dict[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Dict[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.neck is not None: @@ -109,12 +109,12 @@ def from_config(cls, config, custom_objects=None): def build_mosaic_segmentation_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: mosaic_config.MosaicSemanticSegmentationModel, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - backbone: Optional[tf.keras.Model] = None, - neck: Optional[tf.keras.layers.Layer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + backbone: Optional[tf_keras.Model] = None, + neck: Optional[tf_keras.layers.Layer] = None +) -> tf_keras.Model: """Builds MOSAIC Segmentation model.""" norm_activation_config = model_config.norm_activation if backbone is None: diff --git a/official/projects/mosaic/modeling/mosaic_model_test.py b/official/projects/mosaic/modeling/mosaic_model_test.py index 563d6f55a99..3601f8f6234 100644 --- a/official/projects/mosaic/modeling/mosaic_model_test.py +++ b/official/projects/mosaic/modeling/mosaic_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.modeling import mosaic_blocks from official.projects.mosaic.modeling import mosaic_head @@ -45,7 +45,7 @@ def test_mosaic_segmentation_model(self, """Test for building and calling of a MOSAIC segmentation network.""" num_classes = 32 inputs = np.random.rand(2, input_size, input_size, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.MobileNet(model_id='MobileNetMultiAVGSeg') encoder_input_level = 4 diff --git a/official/projects/mosaic/mosaic_tasks.py b/official/projects/mosaic/mosaic_tasks.py index 09007bb5954..04beec75016 100644 --- a/official/projects/mosaic/mosaic_tasks.py +++ b/official/projects/mosaic/mosaic_tasks.py @@ -15,7 +15,7 @@ """Task definition for image semantic segmentation with MOSAIC models.""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.mosaic.configs import mosaic_config @@ -33,16 +33,16 @@ class MosaicSemanticSegmentationTask(seg_tasks.SemanticSegmentationTask): # `input_shape` if the model will be trained and evaluated in different # `input_shape`. For example, the model is trained with cropping but # evaluated with original shape. - def build_model(self, training: bool = True) -> tf.keras.Model: + def build_model(self, training: bool = True) -> tf_keras.Model: """Builds MOSAIC segmentation model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = mosaic_model.build_mosaic_segmentation_model( @@ -73,7 +73,7 @@ def build_model(self, training: bool = True) -> tf.keras.Model: return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return diff --git a/official/projects/mosaic/mosaic_tasks_test.py b/official/projects/mosaic/mosaic_tasks_test.py index b6e364fbad6..dcfeb708f49 100644 --- a/official/projects/mosaic/mosaic_tasks_test.py +++ b/official/projects/mosaic/mosaic_tasks_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import exp_factory diff --git a/official/projects/mosaic/qat/configs/mosaic_config_test.py b/official/projects/mosaic/qat/configs/mosaic_config_test.py index 9220af7571f..bd608a9a843 100644 --- a/official/projects/mosaic/qat/configs/mosaic_config_test.py +++ b/official/projects/mosaic/qat/configs/mosaic_config_test.py @@ -15,7 +15,7 @@ """Tests for mosaic.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/mosaic/qat/modeling/factory.py b/official/projects/mosaic/qat/modeling/factory.py index 57437c51056..fc920716682 100644 --- a/official/projects/mosaic/qat/modeling/factory.py +++ b/official/projects/mosaic/qat/modeling/factory.py @@ -15,7 +15,7 @@ """Factory methods to build models.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.mosaic.modeling import mosaic_blocks @@ -30,9 +30,9 @@ def build_qat_mosaic_model( - model: tf.keras.Model, + model: tf_keras.Model, quantization: common.Quantization, - input_specs: tf.keras.layers.InputSpec) -> tf.keras.Model: + input_specs: tf_keras.layers.InputSpec) -> tf_keras.Model: """Applies quantization aware training for mosaic segmentation model. Args: @@ -51,11 +51,11 @@ def build_qat_mosaic_model( status.expect_partial().assert_existing_objects_matched() scope_dict = { - 'L2': tf.keras.regularizers.l2, + 'L2': tf_keras.regularizers.l2, } model.use_legacy_config = True # Ensures old Keras serialization format - # Apply QAT to backbone (a tf.keras.Model) first, and then neck and head. + # Apply QAT to backbone (a tf_keras.Model) first, and then neck and head. with tfmot.quantization.keras.quantize_scope(scope_dict): annotated_backbone = tfmot.quantization.keras.quantize_annotate_model( model.backbone) diff --git a/official/projects/mosaic/qat/modeling/factory_test.py b/official/projects/mosaic/qat/modeling/factory_test.py index 20f62eb0ae0..866c5188c07 100644 --- a/official/projects/mosaic/qat/modeling/factory_test.py +++ b/official/projects/mosaic/qat/modeling/factory_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.modeling import mosaic_blocks from official.projects.mosaic.modeling import mosaic_head @@ -46,7 +46,7 @@ def test_mosaic_segmentation_model(self, input_size, pyramid_pool_bin_nums, decoder_stage_merge_styles): """Test for building and calling of a MOSAIC segmentation network.""" num_classes = 32 - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.MobileNet(model_id='MobileNetMultiAVGSeg') encoder_input_level = 4 @@ -79,7 +79,7 @@ def test_mosaic_segmentation_model(self, input_size, pyramid_pool_bin_nums, ) inputs = np.random.rand(2, input_size, input_size, 3) - input_specs = tf.keras.layers.InputSpec(shape=inputs.shape) + input_specs = tf_keras.layers.InputSpec(shape=inputs.shape) expected_outputs = model(inputs) # Create a quantized MOSAIC model from the regular FP32 model instance. diff --git a/official/projects/mosaic/qat/modeling/heads/mosaic_head.py b/official/projects/mosaic/qat/modeling/heads/mosaic_head.py index 66feb48a7bd..fa4236cde0c 100644 --- a/official/projects/mosaic/qat/modeling/heads/mosaic_head.py +++ b/official/projects/mosaic/qat/modeling/heads/mosaic_head.py @@ -15,7 +15,7 @@ """Contains definitions of segmentation head of the MOSAIC model.""" from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -25,7 +25,7 @@ from official.projects.qat.vision.quantization import helper -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class MosaicDecoderHeadQuantized(mosaic_head.MosaicDecoderHead): """Creates a quantized MOSAIC decoder in segmentation head. @@ -49,9 +49,9 @@ def __init__( batchnorm_momentum: float = 0.99, batchnorm_epsilon: float = 0.001, kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a MOSAIC segmentation head. @@ -85,11 +85,11 @@ def __init__( batchnorm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: Kernel initializer for conv layers. Defaults to `glorot_uniform`. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. interpolation: The interpolation method for upsampling. Defaults to `bilinear`. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super().__init__( @@ -181,7 +181,7 @@ def __init__( kernel_size=classifier_kernel_size, padding='same', bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer, activation=helper.NoOpActivation(), diff --git a/official/projects/mosaic/qat/modeling/heads/mosaic_head_test.py b/official/projects/mosaic/qat/modeling/heads/mosaic_head_test.py index 0b2b0297f68..51672620072 100644 --- a/official/projects/mosaic/qat/modeling/heads/mosaic_head_test.py +++ b/official/projects/mosaic/qat/modeling/heads/mosaic_head_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.qat.modeling.heads import mosaic_head diff --git a/official/projects/mosaic/qat/modeling/layers/nn_blocks.py b/official/projects/mosaic/qat/modeling/layers/nn_blocks.py index fa3810f6f10..091de08d878 100644 --- a/official/projects/mosaic/qat/modeling/layers/nn_blocks.py +++ b/official/projects/mosaic/qat/modeling/layers/nn_blocks.py @@ -16,7 +16,7 @@ from typing import Dict, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -25,7 +25,7 @@ from official.projects.qat.vision.quantization import helper -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class MultiKernelGroupConvBlockQuantized(mosaic_blocks.MultiKernelGroupConvBlock ): """A quantized multi-kernel grouped convolution block. @@ -48,8 +48,8 @@ def build(self, input_shape: tf.TensorShape) -> None: tf_utils.get_activation(self._activation, use_keras_layer=True), configs.Default8BitActivationQuantizeConfig()) norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if self._use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if self._use_sync_bn else tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) self._bn_op = helper.norm_by_activation( @@ -85,8 +85,8 @@ def build(self, input_shape: tf.TensorShape) -> None: momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) # Use list manually as current QAT API does not support sequential model - # within a tf.keras.Sequential block, e.g. conv_branch = - # tf.keras.Sequential([depthwise_conv, feature_conv, batchnorm_op,]) + # within a tf_keras.Sequential block, e.g. conv_branch = + # tf_keras.Sequential([depthwise_conv, feature_conv, batchnorm_op,]) conv_branch = [ depthwise_conv, batchnorm_op_depthwise, @@ -116,7 +116,7 @@ def build(self, input_shape: tf.TensorShape) -> None: axis=self._group_split_axis) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class MosaicEncoderBlockQuantized(mosaic_blocks.MosaicEncoderBlock): """Implements the encoder module/block of MOSAIC model. @@ -134,7 +134,7 @@ def build( input_shape = ( input_shape[self._encoder_input_level] if isinstance(input_shape, dict) else input_shape) - self._data_format = tf.keras.backend.image_data_format() + self._data_format = tf_keras.backend.image_data_format() if self._data_format == 'channels_last': height = input_shape[1] width = input_shape[2] @@ -150,8 +150,8 @@ def build( tf_utils.get_activation(self._activation, use_keras_layer=True), configs.Default8BitActivationQuantizeConfig()) norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if self._use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if self._use_sync_bn else tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) self._bn_op = helper.norm_by_activation( @@ -174,7 +174,7 @@ def build( axis=self._bn_axis, momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) - # Use list manually instead of tf.keras.Sequential([]) + # Use list manually instead of tf_keras.Sequential([]) self._global_pool_branch = [ global_pool, global_projection, @@ -215,7 +215,7 @@ def build( # enlarge the projection #channels to the sum of the filter depths of # branches. self._output_channels = sum(self._branch_filter_depths) - # Use list manually instead of tf.keras.Sequential([]). + # Use list manually instead of tf_keras.Sequential([]). self._encoder_projection = [ helper.Conv2DQuantized( filters=self._output_channels, @@ -239,7 +239,7 @@ def build( self._concat_layer = helper.ConcatenateQuantized(axis=self._channel_axis) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class DecoderSumMergeBlockQuantized(mosaic_blocks.DecoderSumMergeBlock): """Implements the decoder feature sum merge block of MOSAIC model. @@ -263,8 +263,8 @@ def build( tf_utils.get_activation(self._activation, use_keras_layer=True), configs.Default8BitActivationQuantizeConfig()) norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if self._use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if self._use_sync_bn else tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) self._bn_op = helper.norm_by_activation( @@ -305,7 +305,7 @@ def build( batchnorm_op_high, ] # Resize feature maps. - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': low_res_height = low_res_input_shape[1] low_res_width = low_res_input_shape[2] high_res_height = high_res_input_shape[1] @@ -332,10 +332,10 @@ def build( interpolation=self._interpolation, crop_to_aspect_ratio=False) self._add_layer = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) + tf_keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class DecoderConcatMergeBlockQuantized(mosaic_blocks.DecoderConcatMergeBlock): """Implements the decoder feature concat merge block of MOSAIC model. @@ -352,7 +352,7 @@ def build( low_res_input_shape = input_shape[0] high_res_input_shape = input_shape[1] # Set up resizing feature maps before concat. - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': low_res_height = low_res_input_shape[1] low_res_width = low_res_input_shape[2] high_res_height = high_res_input_shape[1] @@ -370,8 +370,8 @@ def build( tf_utils.get_activation(self._activation, use_keras_layer=True), configs.Default8BitActivationQuantizeConfig()) norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if self._use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if self._use_sync_bn else tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) self._bn_op = helper.norm_by_activation( diff --git a/official/projects/mosaic/qat/modeling/layers/nn_blocks_test.py b/official/projects/mosaic/qat/modeling/layers/nn_blocks_test.py index d46d4f9d8c3..5d0fc2b6866 100644 --- a/official/projects/mosaic/qat/modeling/layers/nn_blocks_test.py +++ b/official/projects/mosaic/qat/modeling/layers/nn_blocks_test.py @@ -17,7 +17,7 @@ from typing import Any, Iterable, Tuple # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -44,7 +44,7 @@ class NNBlocksTest(parameterized.TestCase, tf.test.TestCase): def test_multi_kernel_grouped_convolution_block_creation( self, block_fn, output_filter_depths): input_size = 32 - inputs = tf.keras.Input(shape=(input_size, input_size, 16), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 16), batch_size=1) block = block_fn( output_filter_depths=output_filter_depths, kernel_sizes=[3, 3]) @@ -64,7 +64,7 @@ def test_mosaic_encoder_block_creation(self, block_fn, branch_filter_depths, pyramid_pool_bin_nums): input_size = 128 in_filters = 24 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, in_filters), batch_size=1) block = block_fn( branch_filter_depths=branch_filter_depths, @@ -83,8 +83,8 @@ def test_mosaic_encoder_block_creation(self, block_fn, branch_filter_depths, def test_decoder_sum_merge_block_creation(self, block_fn, decoder_projected_depth, output_size): - inputs = (tf.keras.Input(shape=(64, 64, 128), batch_size=1), - tf.keras.Input(shape=(16, 16, 256), batch_size=1)) + inputs = (tf_keras.Input(shape=(64, 64, 128), batch_size=1), + tf_keras.Input(shape=(16, 16, 256), batch_size=1)) block = block_fn( decoder_projected_depth=decoder_projected_depth, output_size=output_size) @@ -103,8 +103,8 @@ def test_decoder_concat_merge_block_creation(self, block_fn, decoder_internal_depth, decoder_projected_depth, output_size): - inputs = (tf.keras.Input(shape=(64, 64, 128), batch_size=1), - tf.keras.Input(shape=(16, 16, 256), batch_size=1)) + inputs = (tf_keras.Input(shape=(64, 64, 128), batch_size=1), + tf_keras.Input(shape=(16, 16, 256), batch_size=1)) block = block_fn( decoder_internal_depth=decoder_internal_depth, decoder_projected_depth=decoder_projected_depth, diff --git a/official/projects/mosaic/qat/serving/export_module.py b/official/projects/mosaic/qat/serving/export_module.py index 4742d37cfea..d3d250922bd 100644 --- a/official/projects/mosaic/qat/serving/export_module.py +++ b/official/projects/mosaic/qat/serving/export_module.py @@ -14,7 +14,7 @@ """Export modules for QAT model serving/inference.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.mosaic.modeling import mosaic_model from official.projects.mosaic.qat.modeling import factory as qat_factory @@ -24,8 +24,8 @@ class MosaicModule(semantic_segmentation.SegmentationModule): """MOSAIC Module.""" - def _build_model(self) -> tf.keras.Model: - input_specs = tf.keras.layers.InputSpec(shape=[1] + + def _build_model(self) -> tf_keras.Model: + input_specs = tf_keras.layers.InputSpec(shape=[1] + self._input_image_size + [3]) model = mosaic_model.build_mosaic_segmentation_model( diff --git a/official/projects/mosaic/qat/tasks/mosaic_tasks.py b/official/projects/mosaic/qat/tasks/mosaic_tasks.py index d2f22810b1a..9d6ad8fc9d2 100644 --- a/official/projects/mosaic/qat/tasks/mosaic_tasks.py +++ b/official/projects/mosaic/qat/tasks/mosaic_tasks.py @@ -13,7 +13,7 @@ # limitations under the License. """Semantic segmentation task definition.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.mosaic import mosaic_tasks @@ -26,7 +26,7 @@ class MosaicSemanticSegmentationTask(mosaic_tasks.MosaicSemanticSegmentationTask ): """A task for semantic segmentation with QAT.""" - def build_model(self, training=True) -> tf.keras.Model: + def build_model(self, training=True) -> tf_keras.Model: """Builds semantic segmentation model with QAT.""" model = super().build_model(training) if training: @@ -36,7 +36,7 @@ def build_model(self, training=True) -> tf.keras.Model: input_size = crop_size else: input_size = self.task_config.validation_data.output_size - input_specs = tf.keras.layers.InputSpec(shape=[None] + input_size + [3]) + input_specs = tf_keras.layers.InputSpec(shape=[None] + input_size + [3]) if self.task_config.quantization: model = factory.build_qat_mosaic_model( model, self.task_config.quantization, input_specs) diff --git a/official/projects/mosaic/qat/tasks/mosaic_tasks_test.py b/official/projects/mosaic/qat/tasks/mosaic_tasks_test.py index 63b587e85f1..226e8b867d1 100644 --- a/official/projects/mosaic/qat/tasks/mosaic_tasks_test.py +++ b/official/projects/mosaic/qat/tasks/mosaic_tasks_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import exp_factory diff --git a/official/projects/movinet/configs/movinet_test.py b/official/projects/movinet/configs/movinet_test.py index 1176369b2e0..f0b713e5706 100644 --- a/official/projects/movinet/configs/movinet_test.py +++ b/official/projects/movinet/configs/movinet_test.py @@ -15,7 +15,7 @@ """Tests for movinet video classification.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/movinet/modeling/movinet.py b/official/projects/movinet/modeling/movinet.py index 402dba6f680..ee39c097c71 100644 --- a/official/projects/movinet/modeling/movinet.py +++ b/official/projects/movinet/modeling/movinet.py @@ -21,7 +21,7 @@ from typing import Dict, Mapping, Optional, Sequence, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.movinet.modeling import movinet_layers @@ -297,8 +297,8 @@ class HeadSpec(BlockSpec): } -@tf.keras.utils.register_keras_serializable(package='Vision') -class Movinet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Movinet(tf_keras.Model): """Class to build Movinet family model. Reference: https://arxiv.org/pdf/2103.11511.pdf @@ -310,7 +310,7 @@ def __init__(self, use_positional_encoding: bool = False, conv_type: str = '3d', se_type: str = '3d', - input_specs: Optional[tf.keras.layers.InputSpec] = None, + input_specs: Optional[tf_keras.layers.InputSpec] = None, activation: str = 'swish', gating_activation: str = 'sigmoid', use_sync_bn: bool = True, @@ -350,9 +350,9 @@ def __init__(self, norm_epsilon: small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Defaults to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Defaults to None. stochastic_depth_drop_rate: the base rate for stochastic depth. use_external_states: if True, expects states to be passed as additional @@ -367,7 +367,7 @@ def __init__(self, """ block_specs = BLOCK_SPECS[model_id] if input_specs is None: - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, None, 3]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, None, 3]) if conv_type not in ('3d', '2plus1d', '3d_2plus1d'): raise ValueError('Unknown conv type: {}'.format(conv_type)) @@ -386,7 +386,7 @@ def __init__(self, self._gating_activation = gating_activation self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer @@ -418,8 +418,8 @@ def __init__(self, def _build_network( self, - input_specs: tf.keras.layers.InputSpec, - state_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + input_specs: tf_keras.layers.InputSpec, + state_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, ) -> Tuple[TensorMap, Union[TensorMap, Tuple[TensorMap, TensorMap]]]: """Builds the model network. @@ -435,10 +435,10 @@ def _build_network( """ state_specs = state_specs if state_specs is not None else {} - image_input = tf.keras.Input(shape=input_specs.shape[1:], name='inputs') + image_input = tf_keras.Input(shape=input_specs.shape[1:], name='inputs') states = { - name: tf.keras.Input(shape=spec.shape[1:], dtype=spec.dtype, name=name) + name: tf_keras.Input(shape=spec.shape[1:], dtype=spec.dtype, name=name) for name, spec in state_specs.items() } @@ -640,7 +640,7 @@ def _get_state_dtype(self, name: str) -> str: return self.dtype def initial_state_specs( - self, input_shape: Sequence[int]) -> Dict[str, tf.keras.layers.InputSpec]: + self, input_shape: Sequence[int]) -> Dict[str, tf_keras.layers.InputSpec]: """Creates a mapping of state name to InputSpec from the input shape.""" state_shapes = self._get_initial_state_shapes( self._block_specs, @@ -648,7 +648,7 @@ def initial_state_specs( use_positional_encoding=self._use_positional_encoding) return { - name: tf.keras.layers.InputSpec( + name: tf_keras.layers.InputSpec( shape=shape, dtype=self._get_state_dtype(name)) for name, shape in state_shapes.items() } @@ -707,10 +707,10 @@ def from_config(cls, config, custom_objects=None): @factory.register_backbone_builder('movinet') def build_movinet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds MoViNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/projects/movinet/modeling/movinet_layers.py b/official/projects/movinet/modeling/movinet_layers.py index 167190ab5b7..3a222557118 100644 --- a/official/projects/movinet/modeling/movinet_layers.py +++ b/official/projects/movinet/modeling/movinet_layers.py @@ -19,7 +19,7 @@ from typing import Any, Mapping, Optional, Sequence, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.modeling.layers import nn_layers @@ -65,8 +65,8 @@ def normalize_tuple(value: Union[int, Tuple[int, ...]], size: int, name: str): return value_tuple -@tf.keras.utils.register_keras_serializable(package='Vision') -class Squeeze3D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Squeeze3D(tf_keras.layers.Layer): """Squeeze3D layer to remove singular dimensions.""" def call(self, inputs): @@ -74,8 +74,8 @@ def call(self, inputs): return tf.squeeze(inputs, axis=(1, 2, 3)) -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobileConv2D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobileConv2D(tf_keras.layers.Layer): """Conv2D layer with extra options to support mobile devices. Reshapes 5D video tensor inputs to 4D, allowing Conv2D to run across @@ -95,11 +95,11 @@ def __init__( use_bias: bool = True, kernel_initializer: str = 'glorot_uniform', bias_initializer: str = 'zeros', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - activity_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - kernel_constraint: Optional[tf.keras.constraints.Constraint] = None, - bias_constraint: Optional[tf.keras.constraints.Constraint] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + activity_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + kernel_constraint: Optional[tf_keras.constraints.Constraint] = None, + bias_constraint: Optional[tf_keras.constraints.Constraint] = None, use_depthwise: bool = False, use_temporal: bool = False, use_buffered_input: bool = False, # pytype: disable=annotation-type-mismatch # typed-keras @@ -108,7 +108,7 @@ def __init__( **kwargs): # pylint: disable=g-doc-args """Initializes mobile conv2d. - For the majority of arguments, see tf.keras.layers.Conv2D. + For the majority of arguments, see tf_keras.layers.Conv2D. Args: use_depthwise: if True, use DepthwiseConv2D instead of Conv2D @@ -255,8 +255,8 @@ def call(self, inputs): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class ConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ConvBlock(tf_keras.layers.Layer): """A Conv followed by optional BatchNorm and Activation.""" def __init__( @@ -267,12 +267,12 @@ def __init__( depthwise: bool = False, causal: bool = False, use_bias: bool = False, - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = - tf.keras.regularizers.L2(KERNEL_WEIGHT_DECAY), + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = + tf_keras.regularizers.L2(KERNEL_WEIGHT_DECAY), use_batch_norm: bool = True, - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, use_sync_bn: bool = False, @@ -475,8 +475,8 @@ def call(self, inputs): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class StreamBuffer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class StreamBuffer(tf_keras.layers.Layer): """Stream buffer wrapper which caches activations of previous frames.""" def __init__(self, @@ -550,7 +550,7 @@ def call( return full_inputs, states -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class StreamConvBlock(ConvBlock): """ConvBlock with StreamBuffer.""" @@ -562,12 +562,12 @@ def __init__( depthwise: bool = False, causal: bool = False, use_bias: bool = False, - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = tf.keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = tf.keras .regularizers.L2(KERNEL_WEIGHT_DECAY), use_batch_norm: bool = True, - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, use_sync_bn: bool = False, @@ -684,8 +684,8 @@ def call(self, return x, states -@tf.keras.utils.register_keras_serializable(package='Vision') -class StreamSqueezeExcitation(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class StreamSqueezeExcitation(tf_keras.layers.Layer): """Squeeze and excitation layer with causal mode. Reference: https://arxiv.org/pdf/1709.01507.pdf @@ -699,8 +699,8 @@ def __init__( gating_activation: nn_layers.Activation = 'sigmoid', causal: bool = False, conv_type: str = '3d', - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = tf.keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = tf.keras .regularizers.L2(KERNEL_WEIGHT_DECAY), use_positional_encoding: bool = False, state_prefix: Optional[str] = None, # pytype: disable=annotation-type-mismatch # typed-keras @@ -837,8 +837,8 @@ def call(self, return x * inputs, states -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobileBottleneck(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobileBottleneck(tf_keras.layers.Layer): """A depthwise inverted bottleneck block. Uses dependency injection to allow flexible definition of different layers @@ -846,11 +846,11 @@ class MobileBottleneck(tf.keras.layers.Layer): """ def __init__(self, - expansion_layer: tf.keras.layers.Layer, - feature_layer: tf.keras.layers.Layer, - projection_layer: tf.keras.layers.Layer, - attention_layer: Optional[tf.keras.layers.Layer] = None, - skip_layer: Optional[tf.keras.layers.Layer] = None, + expansion_layer: tf_keras.layers.Layer, + feature_layer: tf_keras.layers.Layer, + projection_layer: tf_keras.layers.Layer, + attention_layer: Optional[tf_keras.layers.Layer] = None, + skip_layer: Optional[tf_keras.layers.Layer] = None, stochastic_depth_drop_rate: Optional[float] = None, **kwargs): """Implementation for mobile bottleneck. @@ -872,7 +872,7 @@ def __init__(self, self._attention_layer = attention_layer self._skip_layer = skip_layer self._stochastic_depth_drop_rate = stochastic_depth_drop_rate - self._identity = tf.keras.layers.Activation(tf.identity) + self._identity = tf_keras.layers.Activation(tf.identity) self._rezero = nn_layers.Scale(initializer='zeros', name='rezero') if stochastic_depth_drop_rate: @@ -930,8 +930,8 @@ def call(self, return x + skip, states -@tf.keras.utils.register_keras_serializable(package='Vision') -class SkipBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SkipBlock(tf_keras.layers.Layer): """Skip block for bottleneck blocks.""" def __init__( @@ -939,11 +939,11 @@ def __init__( out_filters: int, downsample: bool = False, conv_type: str = '3d', - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = - tf.keras.regularizers.L2(KERNEL_WEIGHT_DECAY), - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = + tf_keras.regularizers.L2(KERNEL_WEIGHT_DECAY), + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, # pytype: disable=annotation-type-mismatch # typed-keras use_sync_bn: bool = False, @@ -993,13 +993,13 @@ def __init__( if downsample: if self._conv_type == '2plus1d': - self._pool = tf.keras.layers.AveragePooling2D( + self._pool = tf_keras.layers.AveragePooling2D( pool_size=(3, 3), strides=(2, 2), padding='same', name='skip_pool') else: - self._pool = tf.keras.layers.AveragePooling3D( + self._pool = tf_keras.layers.AveragePooling3D( pool_size=(1, 3, 3), strides=(1, 2, 2), padding='same', @@ -1039,8 +1039,8 @@ def call(self, inputs): return self._projection(x) -@tf.keras.utils.register_keras_serializable(package='Vision') -class MovinetBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MovinetBlock(tf_keras.layers.Layer): """A basic block for MoViNets. Applies a mobile inverted bottleneck with pointwise expansion, 3D depthwise @@ -1061,11 +1061,11 @@ def __init__( conv_type: str = '3d', se_type: str = '3d', use_positional_encoding: bool = False, - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = tf.keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = tf.keras .regularizers.L2(KERNEL_WEIGHT_DECAY), - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, use_sync_bn: bool = False, @@ -1255,8 +1255,8 @@ def call(self, return self._mobile_bottleneck(inputs, states=states) -@tf.keras.utils.register_keras_serializable(package='Vision') -class Stem(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Stem(tf_keras.layers.Layer): """Stem layer for video networks. Applies an initial convolution block operation. @@ -1270,11 +1270,11 @@ def __init__( causal: bool = False, conv_type: str = '3d', activation: nn_layers.Activation = 'swish', - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = tf.keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = tf.keras .regularizers.L2(KERNEL_WEIGHT_DECAY), - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, use_sync_bn: bool = False, @@ -1371,8 +1371,8 @@ def call(self, return self._stem(inputs, states=states) -@tf.keras.utils.register_keras_serializable(package='Vision') -class Head(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Head(tf_keras.layers.Layer): """Head layer for video networks. Applies pointwise projection and global pooling. @@ -1383,11 +1383,11 @@ def __init__( project_filters: int, conv_type: str = '3d', activation: nn_layers.Activation = 'swish', - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = tf.keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = tf.keras .regularizers.L2(KERNEL_WEIGHT_DECAY), - batch_norm_layer: tf.keras.layers.Layer = - tf.keras.layers.BatchNormalization, + batch_norm_layer: tf_keras.layers.Layer = + tf_keras.layers.BatchNormalization, batch_norm_momentum: float = 0.99, batch_norm_epsilon: float = 1e-3, use_sync_bn: bool = False, @@ -1490,8 +1490,8 @@ def call( return outputs -@tf.keras.utils.register_keras_serializable(package='Vision') -class ClassifierHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ClassifierHead(tf_keras.layers.Layer): """Head layer for video networks. Applies dense projection, dropout, and classifier projection. Expects input @@ -1507,9 +1507,9 @@ def __init__( activation: nn_layers.Activation = 'swish', output_activation: Optional[nn_layers.Activation] = None, max_pool_predictions: bool = False, - kernel_initializer: tf.keras.initializers.Initializer = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = - tf.keras.regularizers.L2(KERNEL_WEIGHT_DECAY), # pytype: disable=annotation-type-mismatch # typed-keras + kernel_initializer: tf_keras.initializers.Initializer = 'HeNormal', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = + tf_keras.regularizers.L2(KERNEL_WEIGHT_DECAY), # pytype: disable=annotation-type-mismatch # typed-keras **kwargs): """Implementation for video model classifier head. @@ -1542,7 +1542,7 @@ def __init__( self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer - self._dropout = tf.keras.layers.Dropout(dropout_rate) + self._dropout = tf_keras.layers.Dropout(dropout_rate) self._head = ConvBlock( filters=head_filters, kernel_size=1, @@ -1556,7 +1556,7 @@ def __init__( self._classifier = ConvBlock( filters=num_classes, kernel_size=1, - kernel_initializer=tf.keras.initializers.random_normal(stddev=0.01), + kernel_initializer=tf_keras.initializers.random_normal(stddev=0.01), kernel_regularizer=None, use_bias=True, use_batch_norm=False, @@ -1566,7 +1566,7 @@ def __init__( self._squeeze = Squeeze3D() output_activation = output_activation if output_activation else 'linear' - self._cast = tf.keras.layers.Activation( + self._cast = tf_keras.layers.Activation( output_activation, dtype='float32', name='cast') def get_config(self): diff --git a/official/projects/movinet/modeling/movinet_layers_test.py b/official/projects/movinet/modeling/movinet_layers_test.py index b16db558df4..18a5a65d7ea 100644 --- a/official/projects/movinet/modeling/movinet_layers_test.py +++ b/official/projects/movinet/modeling/movinet_layers_test.py @@ -15,7 +15,7 @@ """Tests for movinet_layers.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet_layers from official.vision.modeling.layers import nn_layers @@ -64,7 +64,7 @@ def test_mobile_conv2d(self): self.assertAllClose(predicted, expected) def test_mobile_conv2d_bn(self): - batch_norm_op = tf.keras.layers.BatchNormalization( + batch_norm_op = tf_keras.layers.BatchNormalization( momentum=0.9, epsilon=1., name='bn') diff --git a/official/projects/movinet/modeling/movinet_model.py b/official/projects/movinet/modeling/movinet_model.py index 7b7e9859492..e19aa59ef51 100644 --- a/official/projects/movinet/modeling/movinet_model.py +++ b/official/projects/movinet/modeling/movinet_model.py @@ -19,7 +19,7 @@ from typing import Any, Dict, Mapping, Optional, Sequence, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.configs import movinet as cfg from official.projects.movinet.modeling import movinet_layers @@ -27,20 +27,20 @@ from official.vision.modeling import factory_3d as model_factory -@tf.keras.utils.register_keras_serializable(package='Vision') -class MovinetClassifier(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MovinetClassifier(tf_keras.Model): """A video classification class builder.""" def __init__( self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: int, - input_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + input_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, activation: str = 'swish', dropout_rate: float = 0.0, kernel_initializer: str = 'HeNormal', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, output_states: bool = False, **kwargs): """Movinet initialization function. @@ -62,7 +62,7 @@ def __init__( """ if not input_specs: input_specs = { - 'image': tf.keras.layers.InputSpec(shape=[None, None, None, None, 3]) + 'image': tf_keras.layers.InputSpec(shape=[None, None, None, None, 3]) } self._num_classes = num_classes @@ -90,9 +90,9 @@ def __init__( def _build_backbone( self, - backbone: tf.keras.Model, - input_specs: Mapping[str, tf.keras.layers.InputSpec], - state_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + backbone: tf_keras.Model, + input_specs: Mapping[str, tf_keras.layers.InputSpec], + state_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, ) -> Tuple[Mapping[str, Any], Any, Any]: """Builds the backbone network and gets states and endpoints. @@ -110,10 +110,10 @@ def _build_backbone( state_specs = state_specs if state_specs is not None else {} states = { - name: tf.keras.Input(shape=spec.shape[1:], dtype=spec.dtype, name=name) + name: tf_keras.Input(shape=spec.shape[1:], dtype=spec.dtype, name=name) for name, spec in state_specs.items() } - image = tf.keras.Input(shape=input_specs['image'].shape[1:], name='image') + image = tf_keras.Input(shape=input_specs['image'].shape[1:], name='image') inputs = {**states, 'image': image} if backbone.use_external_states: @@ -148,10 +148,10 @@ def _build_backbone( def _build_network( self, - backbone: tf.keras.Model, - input_specs: Mapping[str, tf.keras.layers.InputSpec], - state_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, - ) -> Tuple[Mapping[str, tf.keras.Input], Union[Tuple[Mapping[ # pytype: disable=invalid-annotation # typed-keras + backbone: tf_keras.Model, + input_specs: Mapping[str, tf_keras.layers.InputSpec], + state_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, + ) -> Tuple[Mapping[str, tf_keras.Input], Union[Tuple[Mapping[ # pytype: disable=invalid-annotation # typed-keras str, tf.Tensor], Mapping[str, tf.Tensor]], Mapping[str, tf.Tensor]]]: """Builds the model network. @@ -185,7 +185,7 @@ def _build_network( return inputs, outputs def initial_state_specs( - self, input_shape: Sequence[int]) -> Dict[str, tf.keras.layers.InputSpec]: + self, input_shape: Sequence[int]) -> Dict[str, tf_keras.layers.InputSpec]: return self._backbone.initial_state_specs(input_shape=input_shape) @tf.function @@ -199,7 +199,7 @@ def checkpoint_items(self) -> Dict[str, Any]: return dict(backbone=self.backbone) @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: """Returns the backbone of the model.""" return self._backbone @@ -221,21 +221,21 @@ def get_config(self): def from_config(cls, config, custom_objects=None): # Each InputSpec may need to be deserialized # This handles the case where we want to load a saved_model loaded with - # `tf.keras.models.load_model` + # `tf_keras.models.load_model` if config['input_specs']: for name in config['input_specs']: if isinstance(config['input_specs'][name], dict): - config['input_specs'][name] = tf.keras.layers.deserialize( + config['input_specs'][name] = tf_keras.layers.deserialize( config['input_specs'][name]) return cls(**config) @model_factory.register_model_builder('movinet') def build_movinet_model( - input_specs: Mapping[str, tf.keras.layers.InputSpec], + input_specs: Mapping[str, tf_keras.layers.InputSpec], model_config: cfg.MovinetModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds movinet model.""" logging.info('Building movinet model with num classes: %s', num_classes) if l2_regularizer is not None: diff --git a/official/projects/movinet/modeling/movinet_model_test.py b/official/projects/movinet/modeling/movinet_model_test.py index f786da1efac..33c5b885c25 100644 --- a/official/projects/movinet/modeling/movinet_model_test.py +++ b/official/projects/movinet/modeling/movinet_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet from official.projects.movinet.modeling import movinet_model @@ -29,9 +29,9 @@ def test_movinet_classifier_creation(self, is_training): """Test for creation of a Movinet classifier.""" temporal_size = 16 spatial_size = 224 - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, temporal_size, spatial_size, spatial_size, 3]) backbone = movinet.Movinet(model_id='a0', input_specs=input_specs) @@ -48,7 +48,7 @@ def test_movinet_classifier_creation(self, is_training): def test_movinet_classifier_stream(self): """Test if the classifier can be run in streaming mode.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -75,7 +75,7 @@ def test_movinet_classifier_stream(self): def test_movinet_classifier_stream_pos_enc(self): """Test if the classifier can be run in streaming mode with pos encoding.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -103,7 +103,7 @@ def test_movinet_classifier_stream_pos_enc(self): def test_movinet_classifier_stream_pos_enc_2plus1d(self): """Test if the model can run in streaming mode with pos encoding, (2+1)D.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -132,7 +132,7 @@ def test_movinet_classifier_stream_pos_enc_2plus1d(self): def test_movinet_classifier_mobile(self): """Test if the model can run with mobile parameters.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -184,8 +184,8 @@ def test_saved_model_save_load(self): model.build([1, 5, 172, 172, 3]) model.compile(metrics=['acc']) - tf.keras.models.save_model(model, '/tmp/movinet/') - loaded_model = tf.keras.models.load_model('/tmp/movinet/') + tf_keras.models.save_model(model, '/tmp/movinet/') + loaded_model = tf_keras.models.load_model('/tmp/movinet/') output = loaded_model(dict(image=tf.ones([1, 1, 1, 1, 3]))) @@ -202,7 +202,7 @@ def test_saved_model_save_load(self): ) def test_movinet_models(self, model_id, expected_params_millions): """Test creation of MoViNet family models with states.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') model = movinet_model.MovinetClassifier( backbone=movinet.Movinet( @@ -216,7 +216,7 @@ def test_movinet_models(self, model_id, expected_params_millions): def test_movinet_a0_2plus1d(self): """Test creation of MoViNet with 2plus1d configuration.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') model_2plus1d = movinet_model.MovinetClassifier( backbone=movinet.Movinet( diff --git a/official/projects/movinet/modeling/movinet_test.py b/official/projects/movinet/modeling/movinet_test.py index fd413417f33..8a3c34c49e0 100644 --- a/official/projects/movinet/modeling/movinet_test.py +++ b/official/projects/movinet/modeling/movinet_test.py @@ -15,7 +15,7 @@ """Tests for movinet.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet @@ -24,13 +24,13 @@ class MoViNetTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self): """Test creation of MoViNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = movinet.Movinet( model_id='a0', causal=True, ) - inputs = tf.keras.Input(shape=(8, 128, 128, 3), batch_size=1) + inputs = tf_keras.Input(shape=(8, 128, 128, 3), batch_size=1) endpoints, states = network(inputs) self.assertAllEqual(endpoints['stem'].shape, [1, 8, 64, 64, 8]) @@ -45,7 +45,7 @@ def test_network_creation(self): def test_network_with_states(self): """Test creation of MoViNet family models with states.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -70,7 +70,7 @@ def test_network_with_states(self): def test_movinet_stream(self): """Test if the backbone can be run in streaming mode.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -100,7 +100,7 @@ def test_movinet_stream(self): def test_movinet_stream_nse(self): """Test if the backbone can be run in streaming mode w/o SE layer.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -142,7 +142,7 @@ def test_movinet_stream_nse(self): msg=f'Expecting stream_buffer only, found {state_key}') def test_movinet_2plus1d_stream(self): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', @@ -172,7 +172,7 @@ def test_movinet_2plus1d_stream(self): self.assertAllClose(predicted, expected, 1e-5, 1e-5) def test_movinet_3d_2plus1d_stream(self): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = movinet.Movinet( model_id='a0', diff --git a/official/projects/movinet/tools/convert_3d_2plus1d.py b/official/projects/movinet/tools/convert_3d_2plus1d.py index b52311fc3d2..177e492b45a 100644 --- a/official/projects/movinet/tools/convert_3d_2plus1d.py +++ b/official/projects/movinet/tools/convert_3d_2plus1d.py @@ -16,7 +16,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet from official.projects.movinet.modeling import movinet_model diff --git a/official/projects/movinet/tools/convert_3d_2plus1d_test.py b/official/projects/movinet/tools/convert_3d_2plus1d_test.py index 92d32dee891..88f86e48c32 100644 --- a/official/projects/movinet/tools/convert_3d_2plus1d_test.py +++ b/official/projects/movinet/tools/convert_3d_2plus1d_test.py @@ -17,7 +17,7 @@ import os from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet from official.projects.movinet.modeling import movinet_model diff --git a/official/projects/movinet/tools/export_saved_model.py b/official/projects/movinet/tools/export_saved_model.py index 42c0801bdd4..e5a4b9ba1fc 100644 --- a/official/projects/movinet/tools/export_saved_model.py +++ b/official/projects/movinet/tools/export_saved_model.py @@ -54,7 +54,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet.modeling import movinet from official.projects.movinet.modeling import movinet_model @@ -120,7 +120,7 @@ def export_saved_model( - model: tf.keras.Model, + model: tf_keras.Model, input_shape: Tuple[int, int, int, int, int], export_path: str = '/tmp/movinet/', causal: bool = False, @@ -131,7 +131,7 @@ def export_saved_model( """Exports a MoViNet model to a saved model. Args: - model: the tf.keras.Model to export. + model: the tf_keras.Model to export. input_shape: The 5D spatiotemporal input shape of size [batch_size, num_frames, image_height, image_width, num_channels]. Set the field or a shape position in the field to None for dynamic input. @@ -195,11 +195,11 @@ def predict(inputs): else: signatures = predict_fn - tf.keras.models.save_model( + tf_keras.models.save_model( model, export_path, signatures=signatures) else: _ = model(tf.ones(input_shape_concrete)) - tf.keras.models.save_model(model, export_path) + tf_keras.models.save_model(model, export_path) def build_and_export_saved_model( @@ -252,7 +252,7 @@ def build_and_export_saved_model( exactly match those of the model. """ - input_specs = tf.keras.layers.InputSpec(shape=input_shape) + input_specs = tf_keras.layers.InputSpec(shape=input_shape) # Override swish activation implementation to remove custom gradients if activation == 'swish': diff --git a/official/projects/movinet/tools/export_saved_model_test.py b/official/projects/movinet/tools/export_saved_model_test.py index 1334717ea41..6295481d928 100644 --- a/official/projects/movinet/tools/export_saved_model_test.py +++ b/official/projects/movinet/tools/export_saved_model_test.py @@ -15,7 +15,7 @@ """Tests for export_saved_model.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_hub as hub from official.projects.movinet.tools import export_saved_model @@ -37,13 +37,13 @@ def test_movinet_export_a0_base_with_tfhub(self): encoder = hub.KerasLayer(saved_model_path, trainable=True) - inputs = tf.keras.layers.Input( + inputs = tf_keras.layers.Input( shape=[None, None, None, 3], dtype=tf.float32) outputs = encoder(dict(image=inputs)) - model = tf.keras.Model(inputs, outputs) + model = tf_keras.Model(inputs, outputs) example_input = tf.ones([1, 8, 172, 172, 3]) outputs = model(example_input) @@ -62,7 +62,7 @@ def test_movinet_export_a0_stream_with_tfhub(self): encoder = hub.KerasLayer(saved_model_path, trainable=True) - image_input = tf.keras.layers.Input( + image_input = tf_keras.layers.Input( shape=[None, None, None, 3], dtype=tf.float32, name='image') @@ -73,7 +73,7 @@ def test_movinet_export_a0_stream_with_tfhub(self): for name, state in init_states_fn(tf.constant([0, 0, 0, 0, 3])).items() } states_input = { - name: tf.keras.Input(shape[1:], dtype=dtype, name=name) + name: tf_keras.Input(shape[1:], dtype=dtype, name=name) for name, (shape, dtype) in state_shapes.items() } @@ -81,7 +81,7 @@ def test_movinet_export_a0_stream_with_tfhub(self): outputs = encoder(inputs) - model = tf.keras.Model(inputs, outputs) + model = tf_keras.Model(inputs, outputs) example_input = tf.ones([1, 8, 172, 172, 3]) frames = tf.split(example_input, example_input.shape[1], axis=1) diff --git a/official/projects/movinet/tools/quantize_movinet.py b/official/projects/movinet/tools/quantize_movinet.py index e75f08e81b7..82d9dc5fd12 100644 --- a/official/projects/movinet/tools/quantize_movinet.py +++ b/official/projects/movinet/tools/quantize_movinet.py @@ -172,7 +172,7 @@ def get_dataset() -> tf.data.Dataset: def stateful_representative_dataset_generator( - model: tf.keras.Model, + model: tf_keras.Model, dataset_iter: Any, init_states: Mapping[str, tf.Tensor], save_dataset_to_tfrecords: bool = False, @@ -270,7 +270,7 @@ def quantize_movinet(dataset_fn): # Load model encoder = hub.KerasLayer(FLAGS.saved_model_with_states_dir, trainable=False) - inputs = tf.keras.layers.Input( + inputs = tf_keras.layers.Input( shape=[1, FLAGS.image_size, FLAGS.image_size, 3], dtype=tf.float32, name='image') @@ -283,14 +283,14 @@ def quantize_movinet(dataset_fn): tf.constant([1, 1, FLAGS.image_size, FLAGS.image_size, 3])).items() } states_input = { - name: tf.keras.Input(shape[1:], dtype=dtype, name=name) + name: tf_keras.Input(shape[1:], dtype=dtype, name=name) for name, (shape, dtype) in state_shapes.items() } # The inputs to the model are the states and the video inputs = {**states_input, 'image': inputs} outputs = encoder(inputs) - model = tf.keras.Model(inputs, outputs, name='movinet_stream') + model = tf_keras.Model(inputs, outputs, name='movinet_stream') input_shape = tf.constant( [1, FLAGS.num_frames, FLAGS.image_size, FLAGS.image_size, 3]) init_states = init_states_fn(input_shape) diff --git a/official/projects/movinet/train_test.py b/official/projects/movinet/train_test.py index 0dc75502fcb..b2cf96abb5e 100644 --- a/official/projects/movinet/train_test.py +++ b/official/projects/movinet/train_test.py @@ -21,7 +21,7 @@ from absl import flags from absl import logging from absl.testing import flagsaver -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.movinet import train as train_lib from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/nhnet/configs_test.py b/official/projects/nhnet/configs_test.py index c8c18345771..b8bb0944a13 100644 --- a/official/projects/nhnet/configs_test.py +++ b/official/projects/nhnet/configs_test.py @@ -14,7 +14,7 @@ """Tests for configs.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.nhnet import configs BERT2BERT_CONFIG = { diff --git a/official/projects/nhnet/decoder.py b/official/projects/nhnet/decoder.py index 6b8c80cadd3..2ccd573ba69 100644 --- a/official/projects/nhnet/decoder.py +++ b/official/projects/nhnet/decoder.py @@ -14,14 +14,14 @@ """Transformer decoder that mimics a BERT encoder, to load BERT checkpoints.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import model_utils as transformer_utils from official.modeling import tf_utils from official.nlp.modeling import layers -class TransformerDecoder(tf.keras.layers.Layer): +class TransformerDecoder(tf_keras.layers.Layer): """Transformer decoder stack.""" def __init__(self, @@ -60,7 +60,7 @@ def build(self, unused_input_shapes): intermediate_activation=self.intermediate_activation, dropout_rate=self.hidden_dropout_prob, attention_dropout_rate=self.attention_probs_dropout_prob, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=self.initializer_range), multi_channel_cross_attention=self.multi_channel_cross_attention, name=("layer_%d" % i))) @@ -163,7 +163,7 @@ def get_attention_bias(input_tensor, return tf.where(bias < 0, tf.zeros_like(bias), tf.ones_like(bias)) -class AttentionBias(tf.keras.layers.Layer): +class AttentionBias(tf_keras.layers.Layer): def __init__(self, bias_type, **kwargs): super(AttentionBias, self).__init__(**kwargs) @@ -173,7 +173,7 @@ def call(self, inputs): return get_attention_bias(inputs, self.bias_type) -class EmbeddingPostprocessor(tf.keras.layers.Layer): +class EmbeddingPostprocessor(tf_keras.layers.Layer): """Performs various post-processing on a word embedding tensor.""" def __init__(self, @@ -194,7 +194,7 @@ def __init__(self, self.initializer_range = initializer_range if not initializer: - self.initializer = tf.keras.initializers.TruncatedNormal( + self.initializer = tf_keras.initializers.TruncatedNormal( stddev=initializer_range) else: self.initializer = initializer @@ -212,7 +212,7 @@ def build(self, input_shapes): self.type_embeddings = self.add_weight( "type_embeddings", shape=[self.token_type_vocab_size, width], - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self.initializer_range), dtype=self.dtype) @@ -221,13 +221,13 @@ def build(self, input_shapes): self.position_embeddings = self.add_weight( "position_embeddings", shape=[self.max_position_embeddings, width], - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self.initializer_range), dtype=self.dtype) - self.output_layer_norm = tf.keras.layers.LayerNormalization( + self.output_layer_norm = tf_keras.layers.LayerNormalization( name="layer_norm", axis=-1, epsilon=1e-12, dtype=tf.float32) - self.output_dropout = tf.keras.layers.Dropout( + self.output_dropout = tf_keras.layers.Dropout( rate=self.dropout_prob, dtype=tf.float32) super(EmbeddingPostprocessor, self).build(input_shapes) @@ -267,7 +267,7 @@ def call(self, inputs): return output -class Decoder(tf.keras.layers.Layer): +class Decoder(tf_keras.layers.Layer): """The decoder network which can reuse encoder embeddings for target.""" def __init__(self, config, embedding_lookup=None, **kwargs): @@ -284,7 +284,7 @@ def build(self, unused_input_shapes): self.embedding_lookup = layers.OnDeviceEmbedding( vocab_size=self.config.vocab_size, embedding_width=self.config.hidden_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self.config.initializer_range), name="target_embeddings") self.embedding_postprocessor = EmbeddingPostprocessor( @@ -292,7 +292,7 @@ def build(self, unused_input_shapes): use_position_embeddings=True, max_position_embeddings=self.config.max_position_embeddings, dropout_prob=self.config.hidden_dropout_prob, - initializer=tf.keras.initializers.VarianceScaling( + initializer=tf_keras.initializers.VarianceScaling( scale=self.config.initializer_gain, mode="fan_avg", distribution="uniform"), diff --git a/official/projects/nhnet/decoder_test.py b/official/projects/nhnet/decoder_test.py index 75f7c65e4f2..3ef628e4cb9 100644 --- a/official/projects/nhnet/decoder_test.py +++ b/official/projects/nhnet/decoder_test.py @@ -15,7 +15,7 @@ """Tests for projects.nhnet.decoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.projects.nhnet import configs from official.projects.nhnet import decoder @@ -43,18 +43,18 @@ def test_transformer_decoder(self): def test_bert_decoder(self): seq_length = 10 - encoder_input_ids = tf.keras.layers.Input( + encoder_input_ids = tf_keras.layers.Input( shape=(seq_length,), name="encoder_input_ids", dtype=tf.int32) - target_ids = tf.keras.layers.Input( + target_ids = tf_keras.layers.Input( shape=(seq_length,), name="target_ids", dtype=tf.int32) - encoder_outputs = tf.keras.layers.Input( + encoder_outputs = tf_keras.layers.Input( shape=(seq_length, self._config.hidden_size), name="all_encoder_outputs", dtype=tf.float32) embedding_lookup = layers.OnDeviceEmbedding( vocab_size=self._config.vocab_size, embedding_width=self._config.hidden_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self._config.initializer_range), name="word_embeddings") cross_attention_bias = decoder.AttentionBias(bias_type="single_cross")( @@ -72,7 +72,7 @@ def test_bert_decoder(self): encoder_input_ids=encoder_input_ids, target_ids=target_ids, all_encoder_outputs=encoder_outputs) - model = tf.keras.Model(inputs=model_inputs, outputs=outputs, name="test") + model = tf_keras.Model(inputs=model_inputs, outputs=outputs, name="test") self.assertLen(decoder_layer.trainable_weights, 30) # Forward path. fake_inputs = { @@ -87,21 +87,21 @@ def test_multi_doc_decoder(self): self._config = utils.get_test_params(cls=configs.NHNetConfig) seq_length = 10 num_docs = 5 - encoder_input_ids = tf.keras.layers.Input( + encoder_input_ids = tf_keras.layers.Input( shape=(num_docs, seq_length), name="encoder_input_ids", dtype=tf.int32) - target_ids = tf.keras.layers.Input( + target_ids = tf_keras.layers.Input( shape=(seq_length,), name="target_ids", dtype=tf.int32) - encoder_outputs = tf.keras.layers.Input( + encoder_outputs = tf_keras.layers.Input( shape=(num_docs, seq_length, self._config.hidden_size), name="all_encoder_outputs", dtype=tf.float32) embedding_lookup = layers.OnDeviceEmbedding( vocab_size=self._config.vocab_size, embedding_width=self._config.hidden_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self._config.initializer_range), name="word_embeddings") - doc_attention_probs = tf.keras.layers.Input( + doc_attention_probs = tf_keras.layers.Input( shape=(self._config.num_decoder_attn_heads, seq_length, num_docs), name="doc_attention_probs", dtype=tf.float32) @@ -124,7 +124,7 @@ def test_multi_doc_decoder(self): target_ids=target_ids, all_encoder_outputs=encoder_outputs, doc_attention_probs=doc_attention_probs) - model = tf.keras.Model(inputs=model_inputs, outputs=outputs, name="test") + model = tf_keras.Model(inputs=model_inputs, outputs=outputs, name="test") self.assertLen(decoder_layer.trainable_weights, 30) # Forward path. fake_inputs = { diff --git a/official/projects/nhnet/evaluation.py b/official/projects/nhnet/evaluation.py index 459426f0e6d..e592f92b961 100644 --- a/official/projects/nhnet/evaluation.py +++ b/official/projects/nhnet/evaluation.py @@ -20,7 +20,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.transformer import metrics as metrics_v2 from official.legacy.transformer.utils import metrics @@ -135,10 +135,10 @@ def _test_step_fn(inputs): return tf.nest.map_structure(strategy.experimental_local_results, outputs) metrics_and_funcs = [ - (tf.keras.metrics.Mean("bleu", dtype=tf.float32), bleu_score), - (tf.keras.metrics.Mean("rouge_2_fscore", + (tf_keras.metrics.Mean("bleu", dtype=tf.float32), bleu_score), + (tf_keras.metrics.Mean("rouge_2_fscore", dtype=tf.float32), rouge_2_fscore), - (tf.keras.metrics.Mean("rouge_l_fscore", + (tf_keras.metrics.Mean("rouge_l_fscore", dtype=tf.float32), rouge_l_fscore), ] eval_results = {} diff --git a/official/projects/nhnet/input_pipeline.py b/official/projects/nhnet/input_pipeline.py index f016fb2c53a..0684f5c72a0 100644 --- a/official/projects/nhnet/input_pipeline.py +++ b/official/projects/nhnet/input_pipeline.py @@ -14,7 +14,7 @@ """Input pipelines.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def decode_record(record, name_to_features): diff --git a/official/projects/nhnet/models.py b/official/projects/nhnet/models.py index 5c0bed58d26..e9e7306ff8d 100644 --- a/official/projects/nhnet/models.py +++ b/official/projects/nhnet/models.py @@ -17,7 +17,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import params_dict @@ -66,7 +66,7 @@ def remove_sos_from_seq(seq, pad_token_id): return targets -class Bert2Bert(tf.keras.Model): +class Bert2Bert(tf_keras.Model): """Bert2Bert encoder decoder model for training.""" def __init__(self, params, bert_layer, decoder_layer, name=None): @@ -390,13 +390,13 @@ def get_bert2bert_layers(params: configs.BERT2BERTConfig): Returns: two keras Layers, bert_model_layer and decoder_layer """ - input_ids = tf.keras.layers.Input( + input_ids = tf_keras.layers.Input( shape=(None,), name="input_ids", dtype=tf.int32) - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), name="input_mask", dtype=tf.int32) - segment_ids = tf.keras.layers.Input( + segment_ids = tf_keras.layers.Input( shape=(None,), name="segment_ids", dtype=tf.int32) - target_ids = tf.keras.layers.Input( + target_ids = tf_keras.layers.Input( shape=(None,), name="target_ids", dtype=tf.int32) bert_config = utils.get_bert_config_from_params(params) bert_model_layer = networks.BertEncoder( @@ -410,7 +410,7 @@ def get_bert2bert_layers(params: configs.BERT2BERTConfig): attention_dropout_rate=bert_config.attention_probs_dropout_prob, max_sequence_length=bert_config.max_position_embeddings, type_vocab_size=bert_config.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), return_all_encoder_outputs=True, name="bert_encoder") @@ -442,11 +442,11 @@ def get_nhnet_layers(params: configs.NHNetConfig): Returns: two keras Layers, bert_model_layer and decoder_layer """ - input_ids = tf.keras.layers.Input( + input_ids = tf_keras.layers.Input( shape=(None,), name="input_ids", dtype=tf.int32) - input_mask = tf.keras.layers.Input( + input_mask = tf_keras.layers.Input( shape=(None,), name="input_mask", dtype=tf.int32) - segment_ids = tf.keras.layers.Input( + segment_ids = tf_keras.layers.Input( shape=(None,), name="segment_ids", dtype=tf.int32) bert_config = utils.get_bert_config_from_params(params) bert_model_layer = networks.BertEncoder( @@ -460,19 +460,19 @@ def get_nhnet_layers(params: configs.NHNetConfig): attention_dropout_rate=bert_config.attention_probs_dropout_prob, max_sequence_length=bert_config.max_position_embeddings, type_vocab_size=bert_config.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), return_all_encoder_outputs=True, name="bert_encoder") bert_model_layer([input_ids, input_mask, segment_ids]) - input_ids = tf.keras.layers.Input( + input_ids = tf_keras.layers.Input( shape=(None, None), name="input_ids", dtype=tf.int32) - all_encoder_outputs = tf.keras.layers.Input((None, None, params.hidden_size), + all_encoder_outputs = tf_keras.layers.Input((None, None, params.hidden_size), dtype=tf.float32) - target_ids = tf.keras.layers.Input( + target_ids = tf_keras.layers.Input( shape=(None,), name="target_ids", dtype=tf.int32) - doc_attention_probs = tf.keras.layers.Input( + doc_attention_probs = tf_keras.layers.Input( (params.num_decoder_attn_heads, None, None), dtype=tf.float32) # pylint: disable=protected-access decoder_layer = decoder.Decoder(params, bert_model_layer._embedding_layer) @@ -494,7 +494,7 @@ def get_nhnet_layers(params: configs.NHNetConfig): def create_transformer_model(params, init_checkpoint: Optional[Text] = None - ) -> tf.keras.Model: + ) -> tf_keras.Model: """A helper to create Transformer model.""" bert_layer, decoder_layer = get_bert2bert_layers(params=params) model = Bert2Bert( @@ -516,7 +516,7 @@ def create_transformer_model(params, def create_bert2bert_model( params: configs.BERT2BERTConfig, cls=Bert2Bert, - init_checkpoint: Optional[Text] = None) -> tf.keras.Model: + init_checkpoint: Optional[Text] = None) -> tf_keras.Model: """A helper to create Bert2Bert model.""" bert_layer, decoder_layer = get_bert2bert_layers(params=params) if init_checkpoint: @@ -532,7 +532,7 @@ def create_bert2bert_model( def create_nhnet_model( params: configs.NHNetConfig, cls=NHNet, - init_checkpoint: Optional[Text] = None) -> tf.keras.Model: + init_checkpoint: Optional[Text] = None) -> tf_keras.Model: """A helper to create NHNet model.""" bert_layer, decoder_layer = get_nhnet_layers(params=params) model = cls( diff --git a/official/projects/nhnet/models_test.py b/official/projects/nhnet/models_test.py index d900326a448..20612034c75 100644 --- a/official/projects/nhnet/models_test.py +++ b/official/projects/nhnet/models_test.py @@ -19,7 +19,7 @@ from absl import logging from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import from tensorflow.python.distribute import combinations @@ -224,7 +224,7 @@ def _count_params(self, layer, trainable_only=True): else: return int( np.sum([ - tf.keras.backend.count_params(p) for p in layer.trainable_weights + tf_keras.backend.count_params(p) for p in layer.trainable_weights ])) def test_create_nhnet_layers(self): diff --git a/official/projects/nhnet/optimizer.py b/official/projects/nhnet/optimizer.py index d66c0050e85..b8ccf02ed53 100644 --- a/official/projects/nhnet/optimizer.py +++ b/official/projects/nhnet/optimizer.py @@ -14,12 +14,12 @@ """Optimizer and learning rate scheduler.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.hyperparams import params_dict -class LearningRateSchedule(tf.keras.optimizers.schedules.LearningRateSchedule): +class LearningRateSchedule(tf_keras.optimizers.schedules.LearningRateSchedule): """Learning rate schedule.""" def __init__(self, initial_learning_rate, hidden_size, warmup_steps): @@ -68,7 +68,7 @@ def create_optimizer(params: params_dict.ParamsDict): """Creates optimizer.""" lr_schedule = LearningRateSchedule(params.learning_rate, params.hidden_size, params.learning_rate_warmup_steps) - return tf.keras.optimizers.Adam( + return tf_keras.optimizers.Adam( learning_rate=lr_schedule, beta_1=params.adam_beta1, beta_2=params.adam_beta2, diff --git a/official/projects/nhnet/raw_data_processor.py b/official/projects/nhnet/raw_data_processor.py index 451fd5f2065..adb25ac0d3c 100644 --- a/official/projects/nhnet/raw_data_processor.py +++ b/official/projects/nhnet/raw_data_processor.py @@ -20,7 +20,7 @@ import os import urllib.parse -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import classifier_data_lib from official.nlp.tools import tokenization diff --git a/official/projects/nhnet/trainer.py b/official/projects/nhnet/trainer.py index fcd29ed2931..57b53b24c40 100644 --- a/official/projects/nhnet/trainer.py +++ b/official/projects/nhnet/trainer.py @@ -22,7 +22,7 @@ from absl import flags from absl import logging from six.moves import zip -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.legacy.transformer import metrics as transformer_metrics @@ -91,7 +91,7 @@ def define_flags(): # pylint: disable=protected-access -class Trainer(tf.keras.Model): +class Trainer(tf_keras.Model): """A training only model.""" def __init__(self, model, params): @@ -120,7 +120,7 @@ def train_step(self, inputs): tvars = self.trainable_variables grads = tape.gradient(scaled_loss, tvars) self.optimizer.apply_gradients(list(zip(grads, tvars))) - if isinstance(self.optimizer, tf.keras.optimizers.experimental.Optimizer): + if isinstance(self.optimizer, tf_keras.optimizers.experimental.Optimizer): learning_rate = self.optimizer.learning_rate else: learning_rate = self.optimizer._decayed_lr(var_dtype=tf.float32) @@ -151,7 +151,7 @@ def train(params, strategy, dataset=None): optimizer=opt, steps_per_execution=FLAGS.steps_per_loop) summary_dir = os.path.join(FLAGS.model_dir, "summaries") - summary_callback = tf.keras.callbacks.TensorBoard( + summary_callback = tf_keras.callbacks.TensorBoard( summary_dir, update_freq=max(100, FLAGS.steps_per_loop)) checkpoint = tf.train.Checkpoint( model=model, optimizer=opt, global_step=opt.iterations) diff --git a/official/projects/nhnet/trainer_test.py b/official/projects/nhnet/trainer_test.py index bbd4af1f338..1a8e009d572 100644 --- a/official/projects/nhnet/trainer_test.py +++ b/official/projects/nhnet/trainer_test.py @@ -18,7 +18,7 @@ from absl import flags from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import from tensorflow.python.distribute import combinations diff --git a/official/projects/nhnet/utils.py b/official/projects/nhnet/utils.py index a0d730c2ed4..c80450e48dc 100644 --- a/official/projects/nhnet/utils.py +++ b/official/projects/nhnet/utils.py @@ -16,7 +16,7 @@ from typing import Optional, Text from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.legacy.bert import configs from official.modeling.hyperparams import params_dict @@ -47,8 +47,8 @@ def encoder_common_layers(transformer_block): def initialize_bert2bert_from_pretrained_bert( - bert_encoder: tf.keras.layers.Layer, - bert_decoder: tf.keras.layers.Layer, + bert_encoder: tf_keras.layers.Layer, + bert_decoder: tf_keras.layers.Layer, init_checkpoint: Optional[Text] = None) -> None: """Helper function to initialze Bert2Bert from Bert pretrained checkpoint.""" ckpt = tf.train.Checkpoint(model=bert_encoder) diff --git a/official/projects/panoptic/dataloaders/panoptic_deeplab_input.py b/official/projects/panoptic/dataloaders/panoptic_deeplab_input.py index 6f64001e3bd..8117365f87e 100644 --- a/official/projects/panoptic/dataloaders/panoptic_deeplab_input.py +++ b/official/projects/panoptic/dataloaders/panoptic_deeplab_input.py @@ -17,7 +17,7 @@ from typing import List, Optional import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import common from official.vision.dataloaders import parser diff --git a/official/projects/panoptic/dataloaders/panoptic_maskrcnn_input.py b/official/projects/panoptic/dataloaders/panoptic_maskrcnn_input.py index 7366aa872f9..c69c599f3b6 100644 --- a/official/projects/panoptic/dataloaders/panoptic_maskrcnn_input.py +++ b/official/projects/panoptic/dataloaders/panoptic_maskrcnn_input.py @@ -14,7 +14,7 @@ """Data parser and processing for Panoptic Mask R-CNN.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import maskrcnn_input from official.vision.dataloaders import tf_example_decoder diff --git a/official/projects/panoptic/losses/panoptic_deeplab_losses.py b/official/projects/panoptic/losses/panoptic_deeplab_losses.py index 448cc8bce97..81668622889 100644 --- a/official/projects/panoptic/losses/panoptic_deeplab_losses.py +++ b/official/projects/panoptic/losses/panoptic_deeplab_losses.py @@ -14,7 +14,7 @@ """Losses used for panoptic deeplab model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.panoptic.ops import mask_ops diff --git a/official/projects/panoptic/modeling/factory.py b/official/projects/panoptic/modeling/factory.py index 7887dccf8b6..2239570e308 100644 --- a/official/projects/panoptic/modeling/factory.py +++ b/official/projects/panoptic/modeling/factory.py @@ -15,7 +15,7 @@ """Factory method to build panoptic segmentation model.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.tasks import deep_mask_head_rcnn from official.projects.panoptic.configs import panoptic_deeplab as panoptic_deeplab_cfg @@ -31,9 +31,9 @@ def build_panoptic_maskrcnn( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: panoptic_maskrcnn_cfg.PanopticMaskRCNN, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds Panoptic Mask R-CNN model. This factory function builds the mask rcnn first, builds the non-shared @@ -41,12 +41,12 @@ def build_panoptic_maskrcnn( the panoptic segmentation model. Args: - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. model_config: Config instance for the panoptic maskrcnn model. - l2_regularizer: Optional `tf.keras.regularizers.Regularizer`, if specified, + l2_regularizer: Optional `tf_keras.regularizers.Regularizer`, if specified, the model is built with the provided regularization layer. Returns: - tf.keras.Model for the panoptic segmentation model. + tf_keras.Model for the panoptic segmentation model. """ norm_activation_config = model_config.norm_activation segmentation_config = model_config.segmentation_model @@ -153,20 +153,20 @@ def build_panoptic_maskrcnn( def build_panoptic_deeplab( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: panoptic_deeplab_cfg.PanopticDeeplab, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds Panoptic Deeplab model. Args: - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. model_config: Config instance for the panoptic deeplab model. - l2_regularizer: Optional `tf.keras.regularizers.Regularizer`, if specified, + l2_regularizer: Optional `tf_keras.regularizers.Regularizer`, if specified, the model is built with the provided regularization layer. Returns: - tf.keras.Model for the panoptic segmentation model. + tf_keras.Model for the panoptic segmentation model. """ norm_activation_config = model_config.norm_activation backbone = backbones.factory.build_backbone( diff --git a/official/projects/panoptic/modeling/heads/panoptic_deeplab_heads.py b/official/projects/panoptic/modeling/heads/panoptic_deeplab_heads.py index 0f749fc756e..3fcd788174f 100644 --- a/official/projects/panoptic/modeling/heads/panoptic_deeplab_heads.py +++ b/official/projects/panoptic/modeling/heads/panoptic_deeplab_heads.py @@ -15,14 +15,14 @@ """Contains definitions for Panoptic Deeplab heads.""" from typing import List, Mapping, Optional, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.panoptic.modeling.layers import fusion_layers from official.vision.ops import spatial_transform_ops -class PanopticDeeplabHead(tf.keras.layers.Layer): +class PanopticDeeplabHead(tf_keras.layers.Layer): """Creates a panoptic deeplab head.""" def __init__( @@ -40,8 +40,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a panoptic deeplab head. @@ -70,9 +70,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(PanopticDeeplabHead, self).__init__(**kwargs) @@ -94,7 +94,7 @@ def __init__( 'kernel_regularizer': kernel_regularizer, 'bias_regularizer': bias_regularizer } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -104,8 +104,8 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the head.""" kernel_size = self._config_dict['kernel_size'] use_depthwise_convolution = self._config_dict['use_depthwise_convolution'] - random_initializer = tf.keras.initializers.RandomNormal(stddev=0.01) - conv_op = tf.keras.layers.Conv2D + random_initializer = tf_keras.initializers.RandomNormal(stddev=0.01) + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'kernel_size': kernel_size if not use_depthwise_convolution else 1, 'padding': 'same', @@ -113,9 +113,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): 'kernel_initializer': random_initializer, 'kernel_regularizer': self._config_dict['kernel_regularizer'], } - bn_op = (tf.keras.layers.experimental.SyncBatchNormalization + bn_op = (tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization) + else tf_keras.layers.BatchNormalization) bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -142,7 +142,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): for i in range(self._config_dict['num_convs']): if use_depthwise_convolution: self._convs.append( - tf.keras.layers.DepthwiseConv2D( + tf_keras.layers.DepthwiseConv2D( name='panoptic_deeplab_head_depthwise_conv_{}'.format(i), kernel_size=kernel_size, padding='same', @@ -186,7 +186,7 @@ def call(self, inputs: Tuple[Union[tf.Tensor, Mapping[str, tf.Tensor]], A `tf.Tensor` of the fused backbone and decoder features. """ if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() x = self._panoptic_deeplab_fusion(inputs, training=training) @@ -210,7 +210,7 @@ def from_config(cls, config): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class SemanticHead(PanopticDeeplabHead): """Creates a semantic head.""" @@ -231,8 +231,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a instance center head. @@ -265,9 +265,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(SemanticHead, self).__init__( @@ -294,13 +294,13 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the semantic head.""" super(SemanticHead, self).build(input_shape) - self._classifier = tf.keras.layers.Conv2D( + self._classifier = tf_keras.layers.Conv2D( name='semantic_output', filters=self._config_dict['num_classes'], kernel_size=self._config_dict['prediction_kernel_size'], padding='same', bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer']) @@ -310,13 +310,13 @@ def call(self, inputs: Tuple[Union[tf.Tensor, Mapping[str, tf.Tensor]], """Forward pass of the head.""" if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() x = super(SemanticHead, self).call(inputs, training=training) outputs = self._classifier(x) return outputs -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class InstanceHead(PanopticDeeplabHead): """Creates a instance head.""" @@ -336,8 +336,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a instance center head. @@ -368,9 +368,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(InstanceHead, self).__init__( @@ -396,23 +396,23 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the instance head.""" super(InstanceHead, self).build(input_shape) - self._instance_center_prediction_conv = tf.keras.layers.Conv2D( + self._instance_center_prediction_conv = tf_keras.layers.Conv2D( name='instance_centers_heatmap', filters=1, kernel_size=self._config_dict['prediction_kernel_size'], padding='same', bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer']) - self._instance_center_regression_conv = tf.keras.layers.Conv2D( + self._instance_center_regression_conv = tf_keras.layers.Conv2D( name='instance_centers_offset', filters=2, kernel_size=self._config_dict['prediction_kernel_size'], padding='same', bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer']) @@ -422,7 +422,7 @@ def call(self, inputs: Tuple[Union[tf.Tensor, Mapping[str, tf.Tensor]], """Forward pass of the head.""" if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() x = super(InstanceHead, self).call(inputs, training=training) instance_centers_heatmap = self._instance_center_prediction_conv(x) diff --git a/official/projects/panoptic/modeling/layers/fusion_layers.py b/official/projects/panoptic/modeling/layers/fusion_layers.py index 28a6ef9d23d..68f6b03980e 100644 --- a/official/projects/panoptic/modeling/layers/fusion_layers.py +++ b/official/projects/panoptic/modeling/layers/fusion_layers.py @@ -15,7 +15,7 @@ """Contains feature fusion blocks for panoptic segmentation models.""" from typing import Any, Callable, Dict, List, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils @@ -25,7 +25,7 @@ Activation = Union[str, Callable] -class PanopticDeepLabFusion(tf.keras.layers.Layer): +class PanopticDeepLabFusion(tf_keras.layers.Layer): """Creates a Panoptic DeepLab feature Fusion layer. This implements the feature fusion introduced in the paper: @@ -44,8 +44,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', **kwargs): """Initializes panoptic FPN feature fusion layer. @@ -63,9 +63,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. interpolation: A `str` interpolation method for upsampling. Defaults to `bilinear`. **kwargs: Additional keyword arguments to be passed. @@ -89,23 +89,23 @@ def __init__( 'bias_regularizer': bias_regularizer, 'interpolation': interpolation } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._channel_axis = -1 else: self._channel_axis = 1 self._activation = tf_utils.get_activation(activation) def build(self, input_shape: List[tf.TensorShape]): - conv_op = tf.keras.layers.Conv2D + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'padding': 'same', 'use_bias': True, 'kernel_initializer': tf.initializers.VarianceScaling(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], } - bn_op = (tf.keras.layers.experimental.SyncBatchNormalization + bn_op = (tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization) + else tf_keras.layers.BatchNormalization) bn_kwargs = { 'axis': self._channel_axis, 'momentum': self._config_dict['norm_momentum'], @@ -123,9 +123,9 @@ def build(self, input_shape: List[tf.TensorShape]): kernel_size=1, **conv_kwargs)) if self._config_dict['use_depthwise_convolution']: - depthwise_initializer = tf.keras.initializers.RandomNormal(stddev=0.01) - fusion_conv = tf.keras.Sequential([ - tf.keras.layers.DepthwiseConv2D( + depthwise_initializer = tf_keras.initializers.RandomNormal(stddev=0.01) + fusion_conv = tf_keras.Sequential([ + tf_keras.layers.DepthwiseConv2D( kernel_size=5, padding='same', use_bias=True, @@ -148,7 +148,7 @@ def build(self, input_shape: List[tf.TensorShape]): def call(self, inputs, training=None): if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() backbone_output = inputs[0] decoder_output = inputs[1][str(self._config_dict['level'])] diff --git a/official/projects/panoptic/modeling/layers/panoptic_deeplab_merge.py b/official/projects/panoptic/modeling/layers/panoptic_deeplab_merge.py index 25cd04fa018..ecc39195d51 100644 --- a/official/projects/panoptic/modeling/layers/panoptic_deeplab_merge.py +++ b/official/projects/panoptic/modeling/layers/panoptic_deeplab_merge.py @@ -23,7 +23,7 @@ import functools from typing import Dict, List, Text, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.panoptic.ops import mask_ops @@ -82,7 +82,7 @@ def _get_instance_centers_from_heatmap( # Non-maximum suppression. padded_map = _add_zero_padding(center_heatmap, nms_kernel_size, rank=3) - pooled_center_heatmap = tf.keras.backend.pool2d( + pooled_center_heatmap = tf_keras.backend.pool2d( tf.expand_dims(padded_map, 0), pool_size=(nms_kernel_size, nms_kernel_size), strides=(1, 1), @@ -370,7 +370,7 @@ def _merge_semantic_and_instance_maps( return panoptic_prediction -class PostProcessor(tf.keras.layers.Layer): +class PostProcessor(tf_keras.layers.Layer): """This class contains code of a Panoptic-Deeplab post-processor.""" def __init__( diff --git a/official/projects/panoptic/modeling/layers/panoptic_segmentation_generator.py b/official/projects/panoptic/modeling/layers/panoptic_segmentation_generator.py index f9b1599a8d8..19ed652912a 100644 --- a/official/projects/panoptic/modeling/layers/panoptic_segmentation_generator.py +++ b/official/projects/panoptic/modeling/layers/panoptic_segmentation_generator.py @@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.panoptic.modeling.layers import paste_masks from official.vision.ops import spatial_transform_ops @@ -43,7 +43,7 @@ def _batch_count_ones(masks: tf.Tensor, return tf.reduce_sum(tf.cast(masks, dtype), axis=[-2, -1]) -class PanopticSegmentationGenerator(tf.keras.layers.Layer): +class PanopticSegmentationGenerator(tf_keras.layers.Layer): """Panoptic segmentation generator layer.""" def __init__( @@ -349,7 +349,7 @@ def from_config(cls, config: Dict[str, return cls(**config) -class PanopticSegmentationGeneratorV2(tf.keras.layers.Layer): +class PanopticSegmentationGeneratorV2(tf_keras.layers.Layer): """Panoptic segmentation generator layer V2.""" def __init__(self, diff --git a/official/projects/panoptic/modeling/layers/paste_masks.py b/official/projects/panoptic/modeling/layers/paste_masks.py index ac2cf0024ff..3d5a4fe6b38 100644 --- a/official/projects/panoptic/modeling/layers/paste_masks.py +++ b/official/projects/panoptic/modeling/layers/paste_masks.py @@ -16,10 +16,10 @@ from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras -class BilinearGridSampler(tf.keras.layers.Layer): +class BilinearGridSampler(tf_keras.layers.Layer): """Bilinear Grid Sampling layer.""" def __init__(self, align_corners: bool = False, **kwargs): @@ -127,7 +127,7 @@ def from_config(cls, config): return cls(**config) -class PasteMasks(tf.keras.layers.Layer): +class PasteMasks(tf_keras.layers.Layer): """Layer to paste instance masks.""" def __init__(self, output_size: List[int], diff --git a/official/projects/panoptic/modeling/panoptic_deeplab_model.py b/official/projects/panoptic/modeling/panoptic_deeplab_model.py index 1a58d06d4ea..ae0824b2f5b 100644 --- a/official/projects/panoptic/modeling/panoptic_deeplab_model.py +++ b/official/projects/panoptic/modeling/panoptic_deeplab_model.py @@ -15,21 +15,21 @@ """Build Panoptic Deeplab model.""" from typing import Any, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.panoptic.modeling.layers import panoptic_deeplab_merge -@tf.keras.utils.register_keras_serializable(package='Vision') -class PanopticDeeplabModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class PanopticDeeplabModel(tf_keras.Model): """Panoptic Deeplab model.""" def __init__( self, - backbone: tf.keras.Model, - semantic_decoder: tf.keras.Model, - semantic_head: tf.keras.layers.Layer, - instance_head: tf.keras.layers.Layer, - instance_decoder: Optional[tf.keras.Model] = None, + backbone: tf_keras.Model, + semantic_decoder: tf_keras.Model, + semantic_head: tf_keras.layers.Layer, + instance_head: tf_keras.layers.Layer, + instance_decoder: Optional[tf_keras.Model] = None, post_processor: Optional[panoptic_deeplab_merge.PostProcessor] = None, **kwargs): """Panoptic deeplab model initializer. @@ -65,7 +65,7 @@ def call( # pytype: disable=signature-mismatch # overriding-parameter-count-ch image_info: tf.Tensor, training: bool = None): if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() backbone_features = self.backbone(inputs, training=training) @@ -102,7 +102,7 @@ def call( # pytype: disable=signature-mismatch # overriding-parameter-count-ch @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict( backbone=self.backbone, diff --git a/official/projects/panoptic/modeling/panoptic_maskrcnn_model.py b/official/projects/panoptic/modeling/panoptic_maskrcnn_model.py index 066e1daf7ad..f271fe62862 100644 --- a/official/projects/panoptic/modeling/panoptic_maskrcnn_model.py +++ b/official/projects/panoptic/modeling/panoptic_maskrcnn_model.py @@ -16,7 +16,7 @@ from typing import List, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.deepmac_maskrcnn.modeling import maskrcnn_model @@ -26,23 +26,23 @@ class PanopticMaskRCNNModel(maskrcnn_model.DeepMaskRCNNModel): def __init__( self, - backbone: tf.keras.Model, - decoder: tf.keras.Model, - rpn_head: tf.keras.layers.Layer, - detection_head: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_generator: tf.keras.layers.Layer, - roi_sampler: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_aligner: tf.keras.layers.Layer, - detection_generator: tf.keras.layers.Layer, - panoptic_segmentation_generator: Optional[tf.keras.layers.Layer] = None, - mask_head: Optional[tf.keras.layers.Layer] = None, - mask_sampler: Optional[tf.keras.layers.Layer] = None, - mask_roi_aligner: Optional[tf.keras.layers.Layer] = None, - segmentation_backbone: Optional[tf.keras.Model] = None, - segmentation_decoder: Optional[tf.keras.Model] = None, - segmentation_head: tf.keras.layers.Layer = None, + backbone: tf_keras.Model, + decoder: tf_keras.Model, + rpn_head: tf_keras.layers.Layer, + detection_head: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_generator: tf_keras.layers.Layer, + roi_sampler: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_aligner: tf_keras.layers.Layer, + detection_generator: tf_keras.layers.Layer, + panoptic_segmentation_generator: Optional[tf_keras.layers.Layer] = None, + mask_head: Optional[tf_keras.layers.Layer] = None, + mask_sampler: Optional[tf_keras.layers.Layer] = None, + mask_roi_aligner: Optional[tf_keras.layers.Layer] = None, + segmentation_backbone: Optional[tf_keras.Model] = None, + segmentation_decoder: Optional[tf_keras.Model] = None, + segmentation_head: tf_keras.layers.Layer = None, class_agnostic_bbox_pred: bool = False, cascade_class_ensemble: bool = False, min_level: Optional[int] = None, @@ -56,8 +56,8 @@ def __init__( """Initializes the Panoptic Mask R-CNN model. Args: - backbone: `tf.keras.Model`, the backbone network. - decoder: `tf.keras.Model`, the decoder network. + backbone: `tf_keras.Model`, the backbone network. + decoder: `tf_keras.Model`, the decoder network. rpn_head: the RPN head. detection_head: the detection head or a list of heads. roi_generator: the ROI generator. @@ -70,12 +70,12 @@ def __init__( mask_head: the mask head. mask_sampler: the mask sampler. mask_roi_aligner: the ROI alginer for mask prediction. - segmentation_backbone: `tf.keras.Model`, the backbone network for the + segmentation_backbone: `tf_keras.Model`, the backbone network for the segmentation head for panoptic task. Providing `segmentation_backbone` will allow the segmentation head to use a standlone backbone. Setting `segmentation_backbone=None` would enable backbone sharing between the MaskRCNN model and segmentation head. - segmentation_decoder: `tf.keras.Model`, the decoder network for the + segmentation_decoder: `tf_keras.Model`, the decoder network for the segmentation head for panoptic task. Providing `segmentation_decoder` will allow the segmentation head to use a standlone decoder. Setting `segmentation_decoder=None` would enable decoder sharing between the @@ -197,7 +197,7 @@ def call(self, @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = super().checkpoint_items if self.segmentation_backbone is not None: diff --git a/official/projects/panoptic/ops/mask_ops.py b/official/projects/panoptic/ops/mask_ops.py index 778acba6b3c..58544052bc4 100644 --- a/official/projects/panoptic/ops/mask_ops.py +++ b/official/projects/panoptic/ops/mask_ops.py @@ -14,7 +14,7 @@ """Utility functions for masks.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def resize_and_rescale_offsets(input_tensor: tf.Tensor, target_size): diff --git a/official/projects/panoptic/serving/export_saved_model.py b/official/projects/panoptic/serving/export_saved_model.py index 047bfaa677e..47f1f71b76f 100644 --- a/official/projects/panoptic/serving/export_saved_model.py +++ b/official/projects/panoptic/serving/export_saved_model.py @@ -35,7 +35,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.modeling import hyperparams @@ -96,7 +96,7 @@ def main(_): params.lock() input_image_size = [int(x) for x in FLAGS.input_image_size.split(',')] - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[FLAGS.batch_size, *input_image_size, 3]) if FLAGS.model == 'panoptic_deeplab': diff --git a/official/projects/panoptic/serving/panoptic_deeplab.py b/official/projects/panoptic/serving/panoptic_deeplab.py index cf292a13ea9..8a589d5dc9a 100644 --- a/official/projects/panoptic/serving/panoptic_deeplab.py +++ b/official/projects/panoptic/serving/panoptic_deeplab.py @@ -16,7 +16,7 @@ from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.projects.panoptic.modeling import factory @@ -31,7 +31,7 @@ class PanopticSegmentationModule( def __init__(self, params: cfg.ExperimentConfig, *, - model: tf.keras.Model, + model: tf_keras.Model, batch_size: int, input_image_size: List[int], num_channels: int = 3): @@ -52,7 +52,7 @@ def __init__(self, num_channels=num_channels) def _build_model(self): - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[self._batch_size] + self._input_image_size + [3]) return factory.build_panoptic_deeplab( diff --git a/official/projects/panoptic/serving/panoptic_maskrcnn.py b/official/projects/panoptic/serving/panoptic_maskrcnn.py index 72be9e600fd..5c64f833ff2 100644 --- a/official/projects/panoptic/serving/panoptic_maskrcnn.py +++ b/official/projects/panoptic/serving/panoptic_maskrcnn.py @@ -16,7 +16,7 @@ from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.projects.panoptic.modeling import panoptic_maskrcnn_model @@ -29,7 +29,7 @@ class PanopticSegmentationModule(detection.DetectionModule): def __init__(self, params: cfg.ExperimentConfig, *, - model: tf.keras.Model, + model: tf_keras.Model, batch_size: int, input_image_size: List[int], num_channels: int = 3): diff --git a/official/projects/panoptic/tasks/panoptic_deeplab.py b/official/projects/panoptic/tasks/panoptic_deeplab.py index 127369f8fce..61d3d794141 100644 --- a/official/projects/panoptic/tasks/panoptic_deeplab.py +++ b/official/projects/panoptic/tasks/panoptic_deeplab.py @@ -16,7 +16,7 @@ from typing import Any, Dict, List, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -36,14 +36,14 @@ class PanopticDeeplabTask(base_task.Task): def build_model(self): """Builds panoptic deeplab model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_panoptic_deeplab( @@ -52,13 +52,13 @@ def build_model(self): l2_regularizer=l2_regularizer) # Builds the model through warm-up call. - dummy_images = tf.keras.Input(self.task_config.model.input_size) + dummy_images = tf_keras.Input(self.task_config.model.input_size) # Note that image_info is always in the shape of [4, 2]. - dummy_image_info = tf.keras.layers.Input([4, 2]) + dummy_image_info = tf_keras.layers.Input([4, 2]) _ = model(dummy_images, dummy_image_info, training=False) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -192,7 +192,7 @@ def build_losses(self, return losses def build_metrics(self, training: bool = True) -> List[ - tf.keras.metrics.Metric]: + tf_keras.metrics.Metric]: """Build metrics.""" eval_config = self.task_config.evaluation metrics = [] @@ -204,7 +204,7 @@ def build_metrics(self, training: bool = True) -> List[ 'instance_center_offset_loss', 'model_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if eval_config.report_train_mean_iou: self.train_mean_iou = segmentation_metrics.MeanIoU( @@ -237,8 +237,8 @@ def build_metrics(self, training: bool = True) -> List[ def train_step( self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None) -> Dict[str, Any]: """Does forward and backward. @@ -271,13 +271,13 @@ def train_step( # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -307,7 +307,7 @@ def train_step( def validation_step( self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None) -> Dict[str, Any]: """Validatation step. diff --git a/official/projects/panoptic/tasks/panoptic_maskrcnn.py b/official/projects/panoptic/tasks/panoptic_maskrcnn.py index 20b8ef3c380..ddadd031697 100644 --- a/official/projects/panoptic/tasks/panoptic_maskrcnn.py +++ b/official/projects/panoptic/tasks/panoptic_maskrcnn.py @@ -16,7 +16,7 @@ from typing import Any, Dict, List, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import task_factory @@ -50,17 +50,17 @@ def __init__(self, self.segmentation_perclass_iou_metric = None self.panoptic_quality_metric = None - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds Panoptic Mask R-CNN model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_panoptic_maskrcnn( @@ -72,14 +72,14 @@ def build_model(self) -> tf.keras.Model: model.backbone.trainable = False # Builds the model through warm-up call. - dummy_images = tf.keras.Input(self.task_config.model.input_size) + dummy_images = tf_keras.Input(self.task_config.model.input_size) # Note that image_info is always in the shape of [4, 2]. - dummy_image_info = tf.keras.layers.Input([4, 2]) + dummy_image_info = tf_keras.layers.Input([4, 2]) _ = model(dummy_images, image_info=dummy_image_info, training=False) return model - def initialize(self, model: tf.keras.Model) -> None: + def initialize(self, model: tf_keras.Model) -> None: """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: @@ -252,14 +252,14 @@ def build_losses(self, def build_metrics( self, training: bool = True - ) -> List[tf.keras.metrics.Metric]: + ) -> List[tf_keras.metrics.Metric]: """Builds detection metrics.""" metrics = super().build_metrics(training) if training: metric_names = ['maskrcnn_loss', 'segmentation_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if self.task_config.segmentation_evaluation.report_train_mean_iou: self.segmentation_train_mean_iou = segmentation_metrics.MeanIoU( @@ -300,8 +300,8 @@ def build_metrics( def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None) -> Dict[str, Any]: """Does forward and backward. @@ -340,13 +340,13 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -400,7 +400,7 @@ def _update_metrics(self, labels, outputs, logs): def validation_step( self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None, ) -> Dict[str, Any]: """Validatation step. diff --git a/official/projects/perceiver/configs/perceiver_test.py b/official/projects/perceiver/configs/perceiver_test.py index 31647233bed..643a724b22f 100644 --- a/official/projects/perceiver/configs/perceiver_test.py +++ b/official/projects/perceiver/configs/perceiver_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.tasks.masked_lm.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import pretrain_dataloader from official.nlp.data import sentence_prediction_dataloader diff --git a/official/projects/perceiver/modeling/layers/decoder.py b/official/projects/perceiver/modeling/layers/decoder.py index ae882974141..73ee983dc65 100644 --- a/official/projects/perceiver/modeling/layers/decoder.py +++ b/official/projects/perceiver/modeling/layers/decoder.py @@ -16,13 +16,13 @@ import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.projects.perceiver.modeling.layers import utils -class Decoder(tf.keras.layers.Layer): +class Decoder(tf_keras.layers.Layer): """Perceiver Decoder layer. Uses cross attention decoder layer. @@ -66,9 +66,9 @@ def __init__(self, num_heads: Number of attention heads for the `TransformerEncoderBlock`. name: - Sets the `tf.keras.layers.Layer` name. + Sets the `tf_keras.layers.Layer` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.layers.Layer`. + Any keyword arguments to pass through to `tf_keras.layers.Layer`. """ super().__init__(name=name, **kwargs) diff --git a/official/projects/perceiver/modeling/layers/decoder_test.py b/official/projects/perceiver/modeling/layers/decoder_test.py index 74c5e52f164..6fb7af1643a 100644 --- a/official/projects/perceiver/modeling/layers/decoder_test.py +++ b/official/projects/perceiver/modeling/layers/decoder_test.py @@ -15,7 +15,7 @@ """Tests for decoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.perceiver.modeling.layers import decoder @@ -30,9 +30,9 @@ def test_layer_creation(self): num_heads=8) lantent_length = 8 latent_width = 80 - query_input = tf.keras.Input( + query_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) output_tensor = test_layer((query_input, latent_input)) @@ -48,11 +48,11 @@ def test_layer_creation_with_mask(self): num_heads=8) lantent_length = 8 latent_width = 80 - query_input = tf.keras.Input( + query_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) - mask_tensor = tf.keras.Input( + mask_tensor = tf_keras.Input( shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer( @@ -70,11 +70,11 @@ def test_layer_invocation(self): num_heads=8) lantent_length = 8 latent_width = 80 - query_input = tf.keras.Input( + query_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) - mask_tensor = tf.keras.Input( + mask_tensor = tf_keras.Input( shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer( @@ -82,7 +82,7 @@ def test_layer_invocation(self): query_mask=mask_tensor) # Create a model from the test layer. - model = tf.keras.Model( + model = tf_keras.Model( ((query_input, latent_input), mask_tensor), output_tensor) diff --git a/official/projects/perceiver/modeling/layers/encoder.py b/official/projects/perceiver/modeling/layers/encoder.py index aab94794e49..a892856e323 100644 --- a/official/projects/perceiver/modeling/layers/encoder.py +++ b/official/projects/perceiver/modeling/layers/encoder.py @@ -14,13 +14,13 @@ """Perceiver encode processor.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.projects.perceiver.modeling.layers import utils -class Encoder(tf.keras.layers.Layer): +class Encoder(tf_keras.layers.Layer): """Perceiver Encoder and Processor(s) layer. This layer implements the Perceiver Encoder and Processor stack from @@ -84,17 +84,17 @@ def __init__(self, dropout_attn_prob: Dropout probability for within the attention layer. att_init_scale: - Scale for the `tf.keras.initializers.VarianceScaling` used in attention + Scale for the `tf_keras.initializers.VarianceScaling` used in attention kernel. dense_init_scale: - Scale for the `tf.keras.initializers.VarianceScaling` used in MLP + Scale for the `tf_keras.initializers.VarianceScaling` used in MLP kernel. norm_epsilon: Epsilon value to initialize normalization layers. name: - Sets the `tf.keras.layers.Layer` name. + Sets the `tf_keras.layers.Layer` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.layers.Layer`. + Any keyword arguments to pass through to `tf_keras.layers.Layer`. """ super().__init__(name=name, **kwargs) diff --git a/official/projects/perceiver/modeling/layers/encoder_test.py b/official/projects/perceiver/modeling/layers/encoder_test.py index 926393766ec..be868133ae6 100644 --- a/official/projects/perceiver/modeling/layers/encoder_test.py +++ b/official/projects/perceiver/modeling/layers/encoder_test.py @@ -15,7 +15,7 @@ """Tests for encoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.perceiver.modeling.layers import encoder @@ -30,9 +30,9 @@ def test_layer_creation(self): embedding_width = 800 lantent_length = 8 latent_width = 80 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) output_tensor = test_layer((data_input, latent_input)) @@ -48,11 +48,11 @@ def test_layer_creation_with_mask(self): embedding_width = 800 lantent_length = 8 latent_width = 80 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) - mask_tensor = tf.keras.Input( + mask_tensor = tf_keras.Input( shape=(sequence_length), dtype=tf.int32) output_tensor = test_layer( @@ -70,11 +70,11 @@ def test_layer_invocation(self): embedding_width = 800 lantent_length = 8 latent_width = 80 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(sequence_length, embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(lantent_length, latent_width)) - mask_tensor = tf.keras.Input( + mask_tensor = tf_keras.Input( shape=(sequence_length), dtype=tf.int32) @@ -83,7 +83,7 @@ def test_layer_invocation(self): input_mask=mask_tensor) # Create a model from the test layer. - model = tf.keras.Model( + model = tf_keras.Model( ((data_input, latent_input), mask_tensor), output_tensor) @@ -108,11 +108,11 @@ def test_self_attention_widening_factor(self): some_embedding_width = 800 some_lantent_length = 8 some_latent_width = last_dim - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(some_sequence_length, some_embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(some_lantent_length, some_latent_width)) - mask_tensor = tf.keras.Input(shape=(some_sequence_length), dtype=tf.int32) + mask_tensor = tf_keras.Input(shape=(some_sequence_length), dtype=tf.int32) test_layer((data_input, latent_input), input_mask=mask_tensor) value = test_layer._self_attention_encoder_blocks[ 0]._intermediate_dense.get_config()['output_shape'].pop() @@ -129,11 +129,11 @@ def test_cross_attention_widening_factor(self): some_embedding_width = 800 some_lantent_length = 8 some_latent_width = last_dim - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(some_sequence_length, some_embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(some_lantent_length, some_latent_width)) - mask_tensor = tf.keras.Input(shape=(some_sequence_length), dtype=tf.int32) + mask_tensor = tf_keras.Input(shape=(some_sequence_length), dtype=tf.int32) test_layer((data_input, latent_input), input_mask=mask_tensor) value = test_layer._cross_attention_encoder_block._intermediate_dense.get_config( )['output_shape'].pop() @@ -149,11 +149,11 @@ def test_self_attention_num_heads(self): some_embedding_width = 800 some_lantent_length = 8 some_latent_width = 64 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(some_sequence_length, some_embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(some_lantent_length, some_latent_width)) - mask_tensor = tf.keras.Input(shape=(some_sequence_length), dtype=tf.int32) + mask_tensor = tf_keras.Input(shape=(some_sequence_length), dtype=tf.int32) test_layer((data_input, latent_input), input_mask=mask_tensor) value = test_layer._self_attention_encoder_blocks[ 0]._attention_layer.get_config()['num_heads'] @@ -169,11 +169,11 @@ def test_cross_attention_num_heads(self): some_embedding_width = 800 some_lantent_length = 8 some_latent_width = 64 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(some_sequence_length, some_embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(some_lantent_length, some_latent_width)) - mask_tensor = tf.keras.Input(shape=(some_sequence_length), dtype=tf.int32) + mask_tensor = tf_keras.Input(shape=(some_sequence_length), dtype=tf.int32) test_layer((data_input, latent_input), input_mask=mask_tensor) value = test_layer._cross_attention_encoder_block._attention_layer.get_config( )['num_heads'] @@ -189,11 +189,11 @@ def test_num_self_attends_per_block(self): some_embedding_width = 800 some_lantent_length = 8 some_latent_width = 64 - data_input = tf.keras.Input( + data_input = tf_keras.Input( shape=(some_sequence_length, some_embedding_width)) - latent_input = tf.keras.Input( + latent_input = tf_keras.Input( shape=(some_lantent_length, some_latent_width)) - mask_tensor = tf.keras.Input(shape=(some_sequence_length), dtype=tf.int32) + mask_tensor = tf_keras.Input(shape=(some_sequence_length), dtype=tf.int32) test_layer((data_input, latent_input), input_mask=mask_tensor) self.assertLen( test_layer._self_attention_encoder_blocks, diff --git a/official/projects/perceiver/modeling/layers/utils.py b/official/projects/perceiver/modeling/layers/utils.py index 1e16c2d5dbf..258ff74671f 100644 --- a/official/projects/perceiver/modeling/layers/utils.py +++ b/official/projects/perceiver/modeling/layers/utils.py @@ -15,7 +15,7 @@ """Perceiver modeling utils.""" import functools -import tensorflow as tf +import tensorflow as tf, tf_keras def make_cross_attention_mask(query_mask, kv_mask): @@ -55,7 +55,7 @@ def build_cross_attention_block_args( `inner_activation` is set to gelu. `kernel_initializer` and `attention_initializer` are both - `tf.keras.initializers.VarianceScaling`. + `tf_keras.initializers.VarianceScaling`. Args: input_shape: @@ -165,7 +165,7 @@ def build_self_attention_block_args( `inner_activation` is set to gelu. `kernel_initializer` and `attention_initializer` are both - `tf.keras.initializers.VarianceScaling`. + `tf_keras.initializers.VarianceScaling`. Args: input_shape: @@ -238,12 +238,12 @@ def _build_transformer_encoder_block_args( `inner_activation` is set to gelu. `kernel_initializer` and `attention_initializer` are both - `tf.keras.initializers.VarianceScaling`. + `tf_keras.initializers.VarianceScaling`. Args: input_shape: input shape(s). Usually passed through `build` method in - `tf.keras.layers.Layer`. + `tf_keras.layers.Layer`. widening_factor: Multiplier used to widen on the inner layer of the MLP step within a transformer attention block. @@ -254,10 +254,10 @@ def _build_transformer_encoder_block_args( num_heads: Number of attention heads. att_init_scale: - Scale for the `tf.keras.initializers.VarianceScaling` used in attention + Scale for the `tf_keras.initializers.VarianceScaling` used in attention kernel. dense_init_scale: - Scale for the `tf.keras.initializers.VarianceScaling` used in MLP kernel. + Scale for the `tf_keras.initializers.VarianceScaling` used in MLP kernel. use_query_residual: Toggle to execute residual connection after attention. norm_epsilon: @@ -323,11 +323,11 @@ def _build_transformer_encoder_block_args( "inner_dim": output_last_dim * widening_factor, "inner_activation": - functools.partial(tf.keras.activations.gelu, approximate=True), + functools.partial(tf_keras.activations.gelu, approximate=True), "kernel_initializer": - tf.keras.initializers.VarianceScaling(scale=dense_init_scale), + tf_keras.initializers.VarianceScaling(scale=dense_init_scale), "attention_initializer": - tf.keras.initializers.VarianceScaling(scale=att_init_scale), + tf_keras.initializers.VarianceScaling(scale=att_init_scale), "norm_first": True, "norm_epsilon": diff --git a/official/projects/perceiver/modeling/layers/utils_test.py b/official/projects/perceiver/modeling/layers/utils_test.py index 7da83215365..40270d2ba0d 100644 --- a/official/projects/perceiver/modeling/layers/utils_test.py +++ b/official/projects/perceiver/modeling/layers/utils_test.py @@ -14,7 +14,7 @@ """Tests for utils.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.perceiver.modeling.layers import utils diff --git a/official/projects/perceiver/modeling/models/classifier.py b/official/projects/perceiver/modeling/models/classifier.py index 97cf85a7770..ca09d227b50 100644 --- a/official/projects/perceiver/modeling/models/classifier.py +++ b/official/projects/perceiver/modeling/models/classifier.py @@ -15,12 +15,12 @@ """Perceiver classifier.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -class Classifier(tf.keras.Model): +class Classifier(tf_keras.Model): """Classifier model based on a shared encoder and optional decoder. This is an implementation of the network structure surrounding a transformer @@ -43,14 +43,14 @@ class Classifier(tf.keras.Model): num_classes: Number of classes outputted by classification head. inputs: - A `Dict[str, tf.keras.Input]` with `input_word_ids`, `input_mask`, and + A `Dict[str, tf_keras.Input]` with `input_word_ids`, `input_mask`, and `input_type_ids`. The shapes are all `(None)` with dtype `tf.int32`. head_name: Name of the classification head. classifier: Classification head layer. initializer: - `tf.keras.initializers.Initializer` used for classification head layer. + `tf_keras.initializers.Initializer` used for classification head layer. """ def __init__(self, @@ -88,9 +88,9 @@ def __init__(self, If set, the arguments ('num_classes', 'initializer', 'dropout_rate', 'use_encoder_pooler', 'head_name') will be ignored. name: - Sets the `tf.keras.Model` name. + Sets the `tf_keras.Model` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.Model`. + Any keyword arguments to pass through to `tf_keras.Model`. """ super().__init__(name=name, **kwargs) @@ -133,7 +133,7 @@ def __init__(self, if initializer is None: stddev = 1. / np.sqrt(cls_inputs.shape[-1]) - initializer = tf.keras.initializers.TruncatedNormal(stddev=stddev) + initializer = tf_keras.initializers.TruncatedNormal(stddev=stddev) if cls_head: classifier = cls_head @@ -157,7 +157,7 @@ def call(self, inputs): # pytype: disable=signature-mismatch # overriding-para Accepts inputs as dictionary of tensors. Args: inputs: - A `Dict[str, tf.keras.Input]` with `input_word_ids`, `input_mask`, and + A `Dict[str, tf_keras.Input]` with `input_word_ids`, `input_mask`, and `input_type_ids`. The shapes are all `(None)` with dtype `tf.int32`. Returns: diff --git a/official/projects/perceiver/modeling/models/classifier_test.py b/official/projects/perceiver/modeling/models/classifier_test.py index 24ecc5d65be..424e4798807 100644 --- a/official/projects/perceiver/modeling/models/classifier_test.py +++ b/official/projects/perceiver/modeling/models/classifier_test.py @@ -15,7 +15,7 @@ """Tests for classifier.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.projects.perceiver.configs import encoders @@ -73,9 +73,9 @@ def test_perceiver_trainer(self, num_classes): num_classes=num_classes) # Create a set of 2-dimensional inputs (the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. cls_outs = trainer_model({ diff --git a/official/projects/perceiver/modeling/models/pretrainer.py b/official/projects/perceiver/modeling/models/pretrainer.py index 2038dc04d5e..eedd34e333d 100644 --- a/official/projects/perceiver/modeling/models/pretrainer.py +++ b/official/projects/perceiver/modeling/models/pretrainer.py @@ -16,12 +16,12 @@ import copy -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -class Pretrainer(tf.keras.Model): +class Pretrainer(tf_keras.Model): """Perceiver Pretrainer. Adds the masked language model head upon the encoder output. Optionally @@ -38,7 +38,7 @@ class Pretrainer(tf.keras.Model): Masked language model network head for language modeling with encoder and optionally decoded output. inputs: - A `Dict[str, tf.keras.Input]` with `input_word_ids`, `input_mask`, and + A `Dict[str, tf_keras.Input]` with `input_word_ids`, `input_mask`, and `input_type_ids`. The shapes are all `(None)` with dtype `tf.int32`. If `masked_lm_positions` is included, it will run masked language modeling layer to return sequence of logits. @@ -76,9 +76,9 @@ def __init__(self, specified masked_lm layer. Above arguments `mlm_activation` and `mlm_initializer` will be ignored. name: - Sets the `tf.keras.Model` name. + Sets the `tf_keras.Model` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.Model`. + Any keyword arguments to pass through to `tf_keras.Model`. """ super().__init__(**kwargs, name=name) @@ -123,7 +123,7 @@ def __init__(self, activation=mlm_activation, initializer=mlm_initializer, name='cls/predictions') - masked_lm_positions = tf.keras.layers.Input( + masked_lm_positions = tf_keras.layers.Input( shape=(None,), name='masked_lm_positions', dtype=tf.int32) if isinstance(inputs, dict): @@ -138,7 +138,7 @@ def call(self, inputs): # pytype: disable=signature-mismatch # overriding-para Accepts inputs as dictionary of tensors. Args: inputs: - A `Dict[str, tf.keras.Input]` with `input_word_ids`, `input_mask`, and + A `Dict[str, tf_keras.Input]` with `input_word_ids`, `input_mask`, and `input_type_ids`. The shapes are all `(None)` with dtype `tf.int32`. If `masked_lm_positions` is included, it will run masked language modeling layer to return sequence of logits. diff --git a/official/projects/perceiver/modeling/models/pretrainer_test.py b/official/projects/perceiver/modeling/models/pretrainer_test.py index c0347cb9737..e1fe49562b3 100644 --- a/official/projects/perceiver/modeling/models/pretrainer_test.py +++ b/official/projects/perceiver/modeling/models/pretrainer_test.py @@ -16,7 +16,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers from official.projects.perceiver.configs import encoders @@ -85,11 +85,11 @@ def test_perceiver_pretrainer(self, use_customized_masked_lm, num_token_predictions = 20 # Create a set of 2-dimensional inputs (the first dimension is implicit). inputs = dict( - input_word_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(sequence_length,), dtype=tf.int32)) if has_masked_lm_positions: - inputs['masked_lm_positions'] = tf.keras.Input( + inputs['masked_lm_positions'] = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) # Invoke the trainer model on the inputs. This causes the layer to be built. diff --git a/official/projects/perceiver/modeling/networks/positional_decoder.py b/official/projects/perceiver/modeling/networks/positional_decoder.py index 4429f3a5e08..4adfde6e872 100644 --- a/official/projects/perceiver/modeling/networks/positional_decoder.py +++ b/official/projects/perceiver/modeling/networks/positional_decoder.py @@ -14,12 +14,12 @@ """Perceiver networks.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -class PositionalDecoder(tf.keras.layers.Layer): +class PositionalDecoder(tf_keras.layers.Layer): """Perceiver Positional Decoder Network. Creates a position encoding for queries and composes basic decoder. @@ -31,7 +31,7 @@ class PositionalDecoder(tf.keras.layers.Layer): Use `self.inputs` for inputs. Attributes: - inputs: A `Dict[Text, tf.keras.Input]` with `latent_output` and + inputs: A `Dict[Text, tf_keras.Input]` with `latent_output` and `input_mask`. The shape of `latent_output` is shape `(z_index_dim, d_latents)` with dtype `tf.float32` and `input_mask` is shape `(None)` with dtype `tf.int32`. @@ -60,12 +60,12 @@ def __init__(self, d_model: Model last dimension. position_encoding_intializer_stddev: - `stddev` of `tf.keras.initializers.TruncatedNormal` used for the + `stddev` of `tf_keras.initializers.TruncatedNormal` used for the learned position embedding table kernel initializer. name: - Sets the `tf.keras.layers.Layer` name. + Sets the `tf_keras.layers.Layer` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.layers.Layer`. + Any keyword arguments to pass through to `tf_keras.layers.Layer`. """ super().__init__(**kwargs, name=name) @@ -79,17 +79,17 @@ def __init__(self, position_encoding_intializer_stddev) self.inputs = dict( - latent_output=tf.keras.Input( + latent_output=tf_keras.Input( shape=(self._z_index_dim, self._d_latents), dtype=tf.float32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32)) def _create_decoder_query(self, position_encoding_intializer_stddev): """Create the position encoding for the output query.""" return layers.PositionEmbedding( max_length=self._output_index_dim, name='decoder_pos_enc', - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=position_encoding_intializer_stddev)) def call(self, inputs, training=None): @@ -99,7 +99,7 @@ def call(self, inputs, training=None): `latent_output` as key-value for the decoder. Args: inputs: - A `Dict[Text, tf.keras.Input]` with `latent_output` and + A `Dict[Text, tf_keras.Input]` with `latent_output` and `input_mask`. The shape of `latent_output` is shape `(z_index_dim, d_latents)` with dtype `tf.float32` and `input_mask` is shape `(None)` with dtype `tf.int32`. diff --git a/official/projects/perceiver/modeling/networks/positional_decoder_test.py b/official/projects/perceiver/modeling/networks/positional_decoder_test.py index c23a0986a36..47dfb9602e3 100644 --- a/official/projects/perceiver/modeling/networks/positional_decoder_test.py +++ b/official/projects/perceiver/modeling/networks/positional_decoder_test.py @@ -14,7 +14,7 @@ """Tests for positional_decoder.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.perceiver.configs import perceiver as cfg from official.projects.perceiver.modeling.layers import decoder @@ -48,9 +48,9 @@ def test_dict_outputs_network_creation(self): d_model=positional_decoder_cfg.d_model) # Create the inputs (note that the first dimension is implicit). - latent_output = tf.keras.Input( + latent_output = tf_keras.Input( shape=(z_index_dim, d_latents), dtype=tf.float32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = mlm_decoder( dict(latent_output=latent_output, input_mask=mask)) data = dict_outputs["sequence_output"] @@ -87,22 +87,22 @@ def test_serialize_deserialize(self): d_model=positional_decoder_cfg.d_model) # Create the inputs (note that the first dimension is implicit). - latent_output = tf.keras.Input( + latent_output = tf_keras.Input( shape=(z_index_dim, d_latents), dtype=tf.float32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = mlm_decoder( dict(latent_output=latent_output, input_mask=mask)) data = dict_outputs["sequence_output"] # Create a model based off of this network: # model = - _ = tf.keras.Model([latent_output, mask], [data]) + _ = tf_keras.Model([latent_output, mask], [data]) # TODO(b/222634115) make save work. # Tests model saving/loading. # model_path = self.get_temp_dir() + "/model" # model.save(model_path) - # _ = tf.keras.models.load_model(model_path) + # _ = tf_keras.models.load_model(model_path) # TODO(b/222634115) add test coverage. diff --git a/official/projects/perceiver/modeling/networks/sequence_encoder.py b/official/projects/perceiver/modeling/networks/sequence_encoder.py index 4cf90b11889..b406b0b344a 100644 --- a/official/projects/perceiver/modeling/networks/sequence_encoder.py +++ b/official/projects/perceiver/modeling/networks/sequence_encoder.py @@ -16,12 +16,12 @@ from typing import Optional, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling import layers -class SequenceEncoder(tf.keras.layers.Layer): +class SequenceEncoder(tf_keras.layers.Layer): """Perceiver encoder for sequences. Assumes positional learned encoding for latent inputs and embeddings. Creates @@ -33,7 +33,7 @@ class SequenceEncoder(tf.keras.layers.Layer): """ def __init__(self, - encoder: tf.keras.layers.Layer, + encoder: tf_keras.layers.Layer, d_model: int, d_latents: int, z_index_dim: int, @@ -70,15 +70,15 @@ def __init__(self, embedding_width: Embedding dimension of the embedding table. embedding_initializer_stddev: - `stddev` of `tf.keras.initializers.TruncatedNormal` used for the + `stddev` of `tf_keras.initializers.TruncatedNormal` used for the embedding table kernel initializer. input_position_encoding_intializer_stddev: - `stddev` of `tf.keras.initializers.TruncatedNormal` used for the + `stddev` of `tf_keras.initializers.TruncatedNormal` used for the learned position embedding table kernel initializer. name: - Sets the `tf.keras.layers.Layer` name. + Sets the `tf_keras.layers.Layer` name. **kwargs: - Any keyword arguments to pass through to `tf.keras.layers.Layer`. + Any keyword arguments to pass through to `tf_keras.layers.Layer`. """ super().__init__(**kwargs, name=name) @@ -96,28 +96,28 @@ def __init__(self, self._embedding_layer = layers.OnDeviceEmbedding( vocab_size=vocab_size, embedding_width=self._embedding_width, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=embedding_initializer_stddev), name='word_embeddings') # Construct the input positional encoding layer. self._input_pos_encoding = layers.PositionEmbedding( max_length=max_seq_len, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=input_position_encoding_intializer_stddev), name='input_pos_encoding') # Construct the latent array initial state. self._z_pos_enc = layers.PositionEmbedding( max_length=z_index_dim, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=z_pos_enc_init_scale), name='z_pos_enc') self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32)) def get_embedding_table(self) -> tf.Variable: """Get embedding table.""" diff --git a/official/projects/perceiver/modeling/networks/sequence_encoder_test.py b/official/projects/perceiver/modeling/networks/sequence_encoder_test.py index 53978bf644d..448c5286653 100644 --- a/official/projects/perceiver/modeling/networks/sequence_encoder_test.py +++ b/official/projects/perceiver/modeling/networks/sequence_encoder_test.py @@ -15,7 +15,7 @@ """Tests for sequence_encoder.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.perceiver.configs import encoders from official.projects.perceiver.configs import perceiver @@ -54,9 +54,9 @@ def test_dict_outputs_network_creation(self): z_index_dim=z_index_dim, d_latents=d_latents) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["latent_output"] @@ -79,15 +79,15 @@ def test_dict_outputs_network_invocation(self): d_latents=d_latents, vocab_size=vocab_size) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["latent_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data]) + model = tf_keras.Model([word_ids, mask, type_ids], [data]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -134,9 +134,9 @@ def test_serialize_deserialize(self): input_position_encoding_intializer_stddev=sequence_encoder_config .input_position_encoding_intializer_stddev) - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) @@ -144,13 +144,13 @@ def test_serialize_deserialize(self): # Create a model based off of this network: # model = - _ = tf.keras.Model([word_ids, mask, type_ids], [data]) + _ = tf_keras.Model([word_ids, mask, type_ids], [data]) # TODO(b/222634115) make save work. # Tests model saving/loading. # model_path = self.get_temp_dir() + "/model" # model.save(model_path) - # _ = tf.keras.models.load_model(model_path) + # _ = tf_keras.models.load_model(model_path) # TODO(b/222634115) add test coverage. diff --git a/official/projects/perceiver/tasks/pretrain.py b/official/projects/perceiver/tasks/pretrain.py index a0d45cc7bb5..796dd604f26 100644 --- a/official/projects/perceiver/tasks/pretrain.py +++ b/official/projects/perceiver/tasks/pretrain.py @@ -14,7 +14,7 @@ """Task for perceiver wordpiece tokenized masked language model (MLM).""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.modeling import tf_utils @@ -55,7 +55,7 @@ def build_model(self, params=None): .position_encoding_intializer_stddev) return pretrainer.Pretrainer( mlm_activation=tf_utils.get_activation(config.mlm_activation), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=config.mlm_initializer_range), encoder=encoder_network, decoder=mlm_decoder) diff --git a/official/projects/perceiver/tasks/pretrain_test.py b/official/projects/perceiver/tasks/pretrain_test.py index ff86cf55a52..6ce765e2dff 100644 --- a/official/projects/perceiver/tasks/pretrain_test.py +++ b/official/projects/perceiver/tasks/pretrain_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.tasks.masked_lm.""" -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.nlp.data import pretrain_dataloader @@ -91,7 +91,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/projects/perceiver/tasks/sentence_prediction_test.py b/official/projects/perceiver/tasks/sentence_prediction_test.py index 158593eaf2f..f7dd7ec2900 100644 --- a/official/projects/perceiver/tasks/sentence_prediction_test.py +++ b/official/projects/perceiver/tasks/sentence_prediction_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.data import sentence_prediction_dataloader from official.nlp.tasks import sentence_prediction @@ -98,7 +98,7 @@ def _run_task(self, config): functools.partial(task.build_inputs, config.train_data)) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) # model.save(os.path.join(self.get_temp_dir(), "saved_model")) # TODO(b/222634115) fix save @@ -131,7 +131,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.initialize(model) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) @@ -144,7 +144,7 @@ def test_task(self): 1, "expected_loss_predicate": lambda loss: loss > 1.0, - "metric": tf.keras.metrics.MeanSquaredError, + "metric": tf_keras.metrics.MeanSquaredError, }, { "testcase_name": @@ -153,7 +153,7 @@ def test_task(self): 2, "expected_loss_predicate": lambda loss: loss < 1.0, - "metric": tf.keras.metrics.SparseCategoricalAccuracy + "metric": tf_keras.metrics.SparseCategoricalAccuracy }, ) def test_metrics_and_losses(self, num_classes, expected_loss_predicate, @@ -169,7 +169,7 @@ def test_metrics_and_losses(self, num_classes, expected_loss_predicate, dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) logs = task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/projects/pix2seq/configs/pix2seq_test.py b/official/projects/pix2seq/configs/pix2seq_test.py index dc877cae541..6751adf3175 100644 --- a/official/projects/pix2seq/configs/pix2seq_test.py +++ b/official/projects/pix2seq/configs/pix2seq_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/pix2seq/dataloaders/pix2seq_input.py b/official/projects/pix2seq/dataloaders/pix2seq_input.py index 3d617a339c6..39e5840606e 100644 --- a/official/projects/pix2seq/dataloaders/pix2seq_input.py +++ b/official/projects/pix2seq/dataloaders/pix2seq_input.py @@ -15,7 +15,7 @@ """COCO data loader for Pix2Seq.""" from typing import Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pix2seq import utils from official.projects.pix2seq.configs import pix2seq as pix2seq_cfg diff --git a/official/projects/pix2seq/dataloaders/pix2seq_input_test.py b/official/projects/pix2seq/dataloaders/pix2seq_input_test.py index c71d9747f59..1dddf311e04 100644 --- a/official/projects/pix2seq/dataloaders/pix2seq_input_test.py +++ b/official/projects/pix2seq/dataloaders/pix2seq_input_test.py @@ -18,7 +18,7 @@ # Import libraries import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pix2seq.dataloaders import pix2seq_input from official.vision.dataloaders import tf_example_decoder diff --git a/official/projects/pix2seq/modeling/pix2seq_model.py b/official/projects/pix2seq/modeling/pix2seq_model.py index 4d1e29ce036..9eaf105901c 100644 --- a/official/projects/pix2seq/modeling/pix2seq_model.py +++ b/official/projects/pix2seq/modeling/pix2seq_model.py @@ -22,7 +22,7 @@ import math from typing import Any, List, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.pix2seq.modeling import transformer @@ -36,7 +36,7 @@ def get_shape(x): def get_variable_initializer(name=None): if name is None: - return tf.keras.initializers.TruncatedNormal(mean=0.0, stddev=0.02) + return tf_keras.initializers.TruncatedNormal(mean=0.0, stddev=0.02) def add_seq_pos_emb( @@ -218,7 +218,7 @@ def top_logits( return logits -class Pix2Seq(tf.keras.Model): +class Pix2Seq(tf_keras.Model): """Pix2Seq model with Keras. Pix2Seq consists of backbone, input token embedding, Pix2SeqTransformer. @@ -257,11 +257,11 @@ def __init__( if hidden_size % 2 != 0: raise ValueError("hidden_size must be a multiple of 2.") - self._dropout = tf.keras.layers.Dropout(self._drop_units) - self._stem_projection = tf.keras.layers.Dense( + self._dropout = tf_keras.layers.Dropout(self._drop_units) + self._stem_projection = tf_keras.layers.Dense( self._hidden_size, name="stem_projection" ) - self._stem_ln = tf.keras.layers.LayerNormalization( + self._stem_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, name="stem_ln" ) @@ -282,11 +282,11 @@ def __init__( self._top_p = top_p @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone @property - def transformer(self) -> tf.keras.Model: + def transformer(self) -> tf_keras.Model: return self._transformer def get_config(self): @@ -313,7 +313,7 @@ def from_config(cls, config): @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, transformer=self.transformer) return items @@ -374,7 +374,7 @@ def call( return [tokens, logits] -class Pix2SeqTransformer(tf.keras.layers.Layer): +class Pix2SeqTransformer(tf_keras.layers.Layer): """Encoder and Decoder of Pix2Seq.""" def __init__( @@ -431,12 +431,12 @@ def __init__( else: self._encoder = None - self._output_ln_enc = tf.keras.layers.LayerNormalization( + self._output_ln_enc = tf_keras.layers.LayerNormalization( epsilon=1e-6, name="output_ln_enc" ) - self._proj = tf.keras.layers.Dense(self._hidden_size, name="proj/linear") - self._proj_ln = tf.keras.layers.LayerNormalization( + self._proj = tf_keras.layers.Dense(self._hidden_size, name="proj/linear") + self._proj_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, name="proj/ln" ) self._proj_mlp = transformer.MLP( @@ -457,7 +457,7 @@ def __init__( drop_units=self._drop_units, drop_att=self._drop_att, ) - self._output_ln_dec = tf.keras.layers.LayerNormalization( + self._output_ln_dec = tf_keras.layers.LayerNormalization( epsilon=1e-6, name="output_ln_dec" ) diff --git a/official/projects/pix2seq/modeling/pix2seq_model_test.py b/official/projects/pix2seq/modeling/pix2seq_model_test.py index 784f43c32da..245d12539d7 100644 --- a/official/projects/pix2seq/modeling/pix2seq_model_test.py +++ b/official/projects/pix2seq/modeling/pix2seq_model_test.py @@ -13,7 +13,7 @@ # limitations under the License. """Tests for Pix2Seq model.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pix2seq.modeling import pix2seq_model from official.vision.modeling.backbones import resnet diff --git a/official/projects/pix2seq/modeling/transformer.py b/official/projects/pix2seq/modeling/transformer.py index 14111ce03ec..afce3fd4e4a 100644 --- a/official/projects/pix2seq/modeling/transformer.py +++ b/official/projects/pix2seq/modeling/transformer.py @@ -18,10 +18,10 @@ cross-attention layer. """ -import tensorflow as tf +import tensorflow as tf, tf_keras -class TransformerEncoder(tf.keras.layers.Layer): +class TransformerEncoder(tf_keras.layers.Layer): """Transformer encoder.""" def __init__( @@ -91,7 +91,7 @@ def get_config(self): return config -class TransformerEncoderLayer(tf.keras.layers.Layer): # pylint: disable=missing-docstring +class TransformerEncoderLayer(tf_keras.layers.Layer): # pylint: disable=missing-docstring def __init__( self, @@ -118,13 +118,13 @@ def __init__( self._ln_scale_shift = ln_scale_shift if self_attention: - self.mha_ln = tf.keras.layers.LayerNormalization( + self.mha_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, name='mha/ln', ) - self.mha = tf.keras.layers.MultiHeadAttention( + self.mha = tf_keras.layers.MultiHeadAttention( num_heads, dim // num_heads, dropout=drop_att, name='mha' ) self.mlp = MLP( @@ -170,7 +170,7 @@ def suffix_id(i): return '' if i == 0 else '_%d' % i -class DropPath(tf.keras.layers.Layer): +class DropPath(tf_keras.layers.Layer): """For stochastic depth.""" def __init__(self, drop_rate=0.0, **kwargs): @@ -211,7 +211,7 @@ def get_config(self): return config -class FeedForwardLayer(tf.keras.layers.Layer): # pylint: disable=missing-docstring +class FeedForwardLayer(tf_keras.layers.Layer): # pylint: disable=missing-docstring def __init__( self, @@ -229,13 +229,13 @@ def __init__( self._use_ln = use_ln self._ln_scale_shift = ln_scale_shift - self.dense1 = tf.keras.layers.Dense( + self.dense1 = tf_keras.layers.Dense( dim_mlp, activation=tf.nn.gelu, name='dense1' ) - self.dropout = tf.keras.layers.Dropout(drop_units) - self.dense2 = tf.keras.layers.Dense(dim_att, name='dense2') + self.dropout = tf_keras.layers.Dropout(drop_units) + self.dense2 = tf_keras.layers.Dense(dim_att, name='dense2') if use_ln: - self.ln = tf.keras.layers.LayerNormalization( + self.ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, @@ -260,7 +260,7 @@ def get_config(self): return config -class MLP(tf.keras.layers.Layer): # pylint: disable=missing-docstring +class MLP(tf_keras.layers.Layer): # pylint: disable=missing-docstring def __init__( self, @@ -296,7 +296,7 @@ def __init__( ) ) self.layernorms.append( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, @@ -328,7 +328,7 @@ def get_config(self): return config -class TransformerDecoderLayer(tf.keras.layers.Layer): # pylint: disable=missing-docstring +class TransformerDecoderLayer(tf_keras.layers.Layer): # pylint: disable=missing-docstring def __init__( self, @@ -363,24 +363,24 @@ def __init__( self._ln_scale_shift = ln_scale_shift if self_attention: - self.self_ln = tf.keras.layers.LayerNormalization( + self.self_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, name='self_mha/ln', ) - self.self_mha = tf.keras.layers.MultiHeadAttention( + self.self_mha = tf_keras.layers.MultiHeadAttention( num_heads, dim // num_heads, dropout=drop_att, name='self_mha' ) if cross_attention: - self.cross_ln = tf.keras.layers.LayerNormalization( + self.cross_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, name='cross_mha/ln', ) if use_enc_ln: - self.enc_ln = tf.keras.layers.LayerNormalization( + self.enc_ln = tf_keras.layers.LayerNormalization( epsilon=1e-6, center=ln_scale_shift, scale=ln_scale_shift, @@ -389,7 +389,7 @@ def __init__( else: self.enc_ln = lambda x: x dim_x_att = dim if dim_x_att is None else dim_x_att - self.cross_mha = tf.keras.layers.MultiHeadAttention( + self.cross_mha = tf_keras.layers.MultiHeadAttention( num_heads, dim_x_att // num_heads, dropout=drop_att, name='cross_mha' ) if use_mlp: @@ -446,7 +446,7 @@ def get_config(self): return config -class TransformerDecoder(tf.keras.layers.Layer): # pylint: disable=missing-docstring +class TransformerDecoder(tf_keras.layers.Layer): # pylint: disable=missing-docstring def __init__( self, diff --git a/official/projects/pix2seq/modeling/transformer_test.py b/official/projects/pix2seq/modeling/transformer_test.py index 58bdb0089b2..f0951e08bd7 100644 --- a/official/projects/pix2seq/modeling/transformer_test.py +++ b/official/projects/pix2seq/modeling/transformer_test.py @@ -14,7 +14,7 @@ """Tests for transformer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pix2seq.modeling import transformer diff --git a/official/projects/pix2seq/tasks/pix2seq_task.py b/official/projects/pix2seq/tasks/pix2seq_task.py index fecba47e592..d8b492b4416 100644 --- a/official/projects/pix2seq/tasks/pix2seq_task.py +++ b/official/projects/pix2seq/tasks/pix2seq_task.py @@ -17,7 +17,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -48,7 +48,7 @@ def build_model(self): """Build Pix2Seq model.""" config: pix2seq_cfg.Pix2Seq = self._task_config.model - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + config.input_size ) @@ -76,7 +76,7 @@ def build_model(self): ) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self._task_config.init_checkpoint: return @@ -155,8 +155,8 @@ def build_losses(self, outputs, labels, aux_losses=None): targets = tf.one_hot(targets, self._task_config.model.vocab_size) - loss = tf.keras.losses.CategoricalCrossentropy( - from_logits=True, reduction=tf.keras.losses.Reduction.NONE + loss = tf_keras.losses.CategoricalCrossentropy( + from_logits=True, reduction=tf_keras.losses.Reduction.NONE )(targets, outputs) weights = tf.cast(weights, loss.dtype) @@ -172,7 +172,7 @@ def build_metrics(self, training=True): metrics = [] metric_names = ['loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if not training: self.coco_metric = coco_evaluator.COCOEvaluator( @@ -209,13 +209,13 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) diff --git a/official/projects/pix2seq/utils.py b/official/projects/pix2seq/utils.py index bafb54558bb..a715bee606c 100644 --- a/official/projects/pix2seq/utils.py +++ b/official/projects/pix2seq/utils.py @@ -15,7 +15,7 @@ """Pix2Seq required utility library.""" import copy -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pix2seq.configs import pix2seq as pix2seq_cfg diff --git a/official/projects/pixel/data_loader.py b/official/projects/pixel/data_loader.py index 197f8e9b69e..5d7f238060f 100644 --- a/official/projects/pixel/data_loader.py +++ b/official/projects/pixel/data_loader.py @@ -16,7 +16,7 @@ import dataclasses from typing import Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import config_definitions as cfg diff --git a/official/projects/pixel/modeling/pixel.py b/official/projects/pixel/modeling/pixel.py index 76ce78044f8..38da5e05aa5 100644 --- a/official/projects/pixel/modeling/pixel.py +++ b/official/projects/pixel/modeling/pixel.py @@ -14,11 +14,11 @@ """Pixel models.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import vit -layers = tf.keras.layers +layers = tf_keras.layers class ViTEncoder(vit.Encoder): @@ -41,7 +41,7 @@ def call(self, inputs, training=None): return x -class VisionTransformer(tf.keras.layers.Layer): +class VisionTransformer(tf_keras.layers.Layer): """ViT backbone.""" def __init__( @@ -70,7 +70,7 @@ def __init__( self.init_stochastic_depth_rate = init_stochastic_depth_rate def build(self, input_shape): - self.patch_to_embed = tf.keras.layers.Conv2D( + self.patch_to_embed = tf_keras.layers.Conv2D( filters=self.filters, kernel_size=(self.patch_h, self.patch_w), strides=(self.patch_h, self.patch_w), @@ -125,15 +125,15 @@ def call(self, inputs): # pylint:disable=signature-mismatch return self.encoder((patch_embeds, attention_mask)) -class PixelClassifier(tf.keras.layers.Layer): +class PixelClassifier(tf_keras.layers.Layer): """Pixel classifier for finetuning. Uses the cls token.""" def __init__(self, encoder, num_classes, **kwargs): super().__init__(**kwargs) self.encoder = encoder - self.linear = tf.keras.layers.Dense( + self.linear = tf_keras.layers.Dense( num_classes, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01), ) def call(self, inputs): @@ -141,7 +141,7 @@ def call(self, inputs): return self.linear(encoded[:, 0]) -class PixelLinearClassifier(tf.keras.layers.Layer): +class PixelLinearClassifier(tf_keras.layers.Layer): """Pixel classifier for finetuning. This is a layer with additional layer norm and linear layer in the @@ -152,24 +152,24 @@ def __init__(self, encoder, num_classes, num_filters, **kwargs): super().__init__(**kwargs) self.encoder = encoder self.num_filters = num_filters - self.linear_clas = tf.keras.layers.Dense( + self.linear_clas = tf_keras.layers.Dense( num_classes, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01), ) - self.norm = tf.keras.layers.LayerNormalization( + self.norm = tf_keras.layers.LayerNormalization( name='classification_layer_norm', axis=-1, epsilon=1e-6, dtype=tf.float32, ) - self.linear_trans = tf.keras.layers.Dense( + self.linear_trans = tf_keras.layers.Dense( num_filters, - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.01), ) - self.activation = tf.keras.layers.Activation('gelu') - self.dropout = tf.keras.layers.Dropout(0.1) + self.activation = tf_keras.layers.Activation('gelu') + self.dropout = tf_keras.layers.Dropout(0.1) def call(self, inputs, training=False): attention_mask = inputs.get('attention_mask') diff --git a/official/projects/pixel/tasks/classification.py b/official/projects/pixel/tasks/classification.py index 301adac1558..16727c9ef57 100644 --- a/official/projects/pixel/tasks/classification.py +++ b/official/projects/pixel/tasks/classification.py @@ -20,7 +20,7 @@ import numpy as np from scipy import stats from sklearn import metrics as sklearn_metrics -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -65,7 +65,7 @@ class PixelClassificationTask(base_task.Task): label_field: str = 'label' metric_type: str = 'accuracy' - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: encoder = pixel.VisionTransformer( self.task_config.patch_h, self.task_config.patch_w, @@ -95,9 +95,9 @@ def build_inputs(self, params, input_context=None): def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: label_ids = labels[self.label_field] if self.task_config.num_classes == 1: - loss = tf.keras.losses.mean_squared_error(label_ids, model_outputs) + loss = tf_keras.losses.mean_squared_error(label_ids, model_outputs) else: - loss = tf.keras.losses.sparse_categorical_crossentropy( + loss = tf_keras.losses.sparse_categorical_crossentropy( label_ids, tf.cast(model_outputs, tf.float32), from_logits=True ) @@ -105,7 +105,7 @@ def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: loss += tf.add_n(aux_losses) return tf_utils.safe_mean(loss) - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Load encoder if checkpoint exists. Args: @@ -124,15 +124,15 @@ def initialize(self, model: tf.keras.Model): def build_metrics(self, training=None): del training if self.task_config.num_classes == 1: - metrics = [tf.keras.metrics.MeanSquaredError()] + metrics = [tf_keras.metrics.MeanSquaredError()] elif self.task_config.num_classes == 2: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), - tf.keras.metrics.AUC(name='auc', curve='PR'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.AUC(name='auc', curve='PR'), ] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), + tf_keras.metrics.SparseCategoricalAccuracy(name='cls_accuracy'), ] return metrics @@ -150,7 +150,7 @@ def process_metrics(self, metrics, labels, model_outputs): def process_compiled_metrics(self, compiled_metrics, labels, model_outputs): compiled_metrics.update_state(labels[self.label_field], model_outputs) - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): features, labels = inputs, inputs outputs = self.inference_step(features, model) loss = self.build_losses( diff --git a/official/projects/pixel/utils/convert_numpy_weights_to_tf.py b/official/projects/pixel/utils/convert_numpy_weights_to_tf.py index 98aac7f63fe..66365d401c1 100644 --- a/official/projects/pixel/utils/convert_numpy_weights_to_tf.py +++ b/official/projects/pixel/utils/convert_numpy_weights_to_tf.py @@ -17,7 +17,7 @@ import sys import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pixel.tasks import classification diff --git a/official/projects/pointpillars/configs/pointpillars_test.py b/official/projects/pointpillars/configs/pointpillars_test.py index d48bcee9029..ec827585b44 100644 --- a/official/projects/pointpillars/configs/pointpillars_test.py +++ b/official/projects/pointpillars/configs/pointpillars_test.py @@ -15,7 +15,7 @@ """Tests for pointpillars.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/pointpillars/dataloaders/decoders.py b/official/projects/pointpillars/dataloaders/decoders.py index ea2d8dc9ce3..1595da3f4bf 100644 --- a/official/projects/pointpillars/dataloaders/decoders.py +++ b/official/projects/pointpillars/dataloaders/decoders.py @@ -16,7 +16,7 @@ from typing import Any, Mapping, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg from official.vision.dataloaders import decoder diff --git a/official/projects/pointpillars/dataloaders/decoders_test.py b/official/projects/pointpillars/dataloaders/decoders_test.py index be452b73561..d739fdef3ec 100644 --- a/official/projects/pointpillars/dataloaders/decoders_test.py +++ b/official/projects/pointpillars/dataloaders/decoders_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg from official.projects.pointpillars.dataloaders import decoders diff --git a/official/projects/pointpillars/dataloaders/parsers.py b/official/projects/pointpillars/dataloaders/parsers.py index 484ff438c33..699d92b7e62 100644 --- a/official/projects/pointpillars/dataloaders/parsers.py +++ b/official/projects/pointpillars/dataloaders/parsers.py @@ -16,7 +16,7 @@ from typing import Any, Dict, List, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.utils import utils from official.vision.dataloaders import parser diff --git a/official/projects/pointpillars/dataloaders/parsers_test.py b/official/projects/pointpillars/dataloaders/parsers_test.py index 0c05b6b7cf4..8b0d161c3d1 100644 --- a/official/projects/pointpillars/dataloaders/parsers_test.py +++ b/official/projects/pointpillars/dataloaders/parsers_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.dataloaders import parsers diff --git a/official/projects/pointpillars/modeling/backbones.py b/official/projects/pointpillars/modeling/backbones.py index b6b072cb8db..7174c4bb333 100644 --- a/official/projects/pointpillars/modeling/backbones.py +++ b/official/projects/pointpillars/modeling/backbones.py @@ -15,14 +15,14 @@ """Backbone models for Pointpillars.""" from typing import Any, Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import layers from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class Backbone(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Backbone(tf_keras.Model): """The backbone to extract features from BEV pseudo image. The implementation is from the network architecture of PointPillars @@ -36,7 +36,7 @@ def __init__( min_level: int = 1, max_level: int = 3, num_convs: int = 4, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize the backbone. @@ -50,7 +50,7 @@ def __init__( min_level: An `int` of min level for output multiscale features. max_level: An `int` of max level for output multiscale features. num_convs: An `int` number of convolution layers in a downsample group. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. @@ -73,7 +73,7 @@ def __init__( 'The min_level must be >= 1, but {} found.'.format(min_level)) input_channels = input_specs[-1] - inputs = tf.keras.Input(shape=input_specs[1:]) + inputs = tf_keras.Input(shape=input_specs[1:]) # build the net x = inputs @@ -123,7 +123,7 @@ def get_config(self) -> Mapping[str, Any]: return self._config_dict @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.Model: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.Model: return cls(**config) @property diff --git a/official/projects/pointpillars/modeling/backbones_test.py b/official/projects/pointpillars/modeling/backbones_test.py index a250566d1d2..0985760204a 100644 --- a/official/projects/pointpillars/modeling/backbones_test.py +++ b/official/projects/pointpillars/modeling/backbones_test.py @@ -15,7 +15,7 @@ """Tests for backbones.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import backbones @@ -28,7 +28,7 @@ class BackboneTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, input_shape, min_level, max_level): batch_size = input_shape[0] - inputs = tf.keras.Input(shape=input_shape[1:], batch_size=batch_size) + inputs = tf_keras.Input(shape=input_shape[1:], batch_size=batch_size) backbone = backbones.Backbone(input_shape, min_level, max_level) endpoints = backbone(inputs) _, h, w, c = input_shape diff --git a/official/projects/pointpillars/modeling/decoders.py b/official/projects/pointpillars/modeling/decoders.py index 82507b4aea3..876c0a31b8f 100644 --- a/official/projects/pointpillars/modeling/decoders.py +++ b/official/projects/pointpillars/modeling/decoders.py @@ -16,14 +16,14 @@ from typing import Any, Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import layers from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class Decoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Decoder(tf_keras.Model): """The decoder to process feature maps learned by a backbone. The implementation is from the network architecture of PointPillars @@ -34,13 +34,13 @@ class Decoder(tf.keras.Model): def __init__( self, input_specs: Mapping[str, tf.TensorShape], - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize the Decoder. Args: input_specs: A dict of {level: tf.TensorShape} of the input tensor. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. @@ -67,7 +67,7 @@ def __init__( # Set num_filters as 2c if the channels of backbone output level is c. if int(level) == output_level: num_filters = 2 * shape[-1] - inputs[level] = tf.keras.Input(shape=shape[1:]) + inputs[level] = tf_keras.Input(shape=shape[1:]) # Build lateral features lateral_feats = {} @@ -88,7 +88,7 @@ def __init__( # Fuse all levels feature into the output level. endpoints = {} - endpoints[str(output_level)] = tf.keras.layers.Concatenate(axis=-1)(feats) + endpoints[str(output_level)] = tf_keras.layers.Concatenate(axis=-1)(feats) self._output_specs = {l: endpoints[l].get_shape() for l in endpoints} super(Decoder, self).__init__(inputs=inputs, outputs=endpoints, **kwargs) @@ -97,7 +97,7 @@ def get_config(self) -> Mapping[str, Any]: return self._config_dict @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.Model: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.Model: return cls(**config) @property diff --git a/official/projects/pointpillars/modeling/decoders_test.py b/official/projects/pointpillars/modeling/decoders_test.py index 87dbe1f0bcc..2f03f4b64ba 100644 --- a/official/projects/pointpillars/modeling/decoders_test.py +++ b/official/projects/pointpillars/modeling/decoders_test.py @@ -15,7 +15,7 @@ """Tests for decoders.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import decoders @@ -35,7 +35,7 @@ def test_network_creation(self, input_shape, min_level, max_level): for k, v in input_shape.items(): if k == str(min_level): batch_size, height, width, _ = v - inputs[k] = tf.keras.Input(shape=v[1:], batch_size=batch_size) + inputs[k] = tf_keras.Input(shape=v[1:], batch_size=batch_size) decoder = decoders.Decoder(input_shape) endpoints = decoder(inputs) diff --git a/official/projects/pointpillars/modeling/factory.py b/official/projects/pointpillars/modeling/factory.py index 8e27cf12488..b387d8bb31c 100644 --- a/official/projects/pointpillars/modeling/factory.py +++ b/official/projects/pointpillars/modeling/factory.py @@ -17,7 +17,7 @@ from typing import Mapping, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg from official.projects.pointpillars.modeling import backbones @@ -29,12 +29,12 @@ def build_pointpillars( - input_specs: Mapping[str, tf.keras.layers.InputSpec], + input_specs: Mapping[str, tf_keras.layers.InputSpec], model_config: cfg.PointPillarsModel, train_batch_size: int, eval_batch_size: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Build the PointPillars model. Args: @@ -50,7 +50,7 @@ def build_pointpillars( # Build inputs inputs = {} for k, v in input_specs.items(): - inputs[k] = tf.keras.Input(shape=v.shape[1:], dtype=v.dtype) + inputs[k] = tf_keras.Input(shape=v.shape[1:], dtype=v.dtype) # Build featurizer image_size = (model_config.image.height, model_config.image.width) diff --git a/official/projects/pointpillars/modeling/factory_test.py b/official/projects/pointpillars/modeling/factory_test.py index 646a2704bb1..6e003904977 100644 --- a/official/projects/pointpillars/modeling/factory_test.py +++ b/official/projects/pointpillars/modeling/factory_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg @@ -37,12 +37,12 @@ def test_builder(self, train_batch_size, eval_batch_size): pillars_config = model_config.pillars input_specs = { 'pillars': - tf.keras.layers.InputSpec( + tf_keras.layers.InputSpec( shape=(None, pillars_config.num_pillars, pillars_config.num_points_per_pillar, pillars_config.num_features_per_point)), 'indices': - tf.keras.layers.InputSpec( + tf_keras.layers.InputSpec( shape=(None, pillars_config.num_pillars, 2), dtype='int32'), } model = factory.build_pointpillars( diff --git a/official/projects/pointpillars/modeling/featurizers.py b/official/projects/pointpillars/modeling/featurizers.py index 5645362092e..34dd59dc937 100644 --- a/official/projects/pointpillars/modeling/featurizers.py +++ b/official/projects/pointpillars/modeling/featurizers.py @@ -17,14 +17,14 @@ from typing import Any, List, Mapping, Optional, Tuple import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import layers from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class Featurizer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Featurizer(tf_keras.layers.Layer): """The featurizer to convert pillars to a BEV pseudo image. The implementation is from the network architecture of PointPillars @@ -49,7 +49,7 @@ def __init__( eval_batch_size: int, num_blocks: int, num_channels: int, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize the featurizer. @@ -60,7 +60,7 @@ def __init__( eval_batch_size: An `int` evaluation batch size per replica. num_blocks: An `int` number of blocks for extracting features. num_channels: An `int` number channels of the BEV image. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for block layers. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -158,7 +158,7 @@ def get_config(self) -> Mapping[str, Any]: return self._config_dict @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.Model: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.Model: return cls(**config) @property diff --git a/official/projects/pointpillars/modeling/featurizers_test.py b/official/projects/pointpillars/modeling/featurizers_test.py index 139ba5ffe08..09491e01ec8 100644 --- a/official/projects/pointpillars/modeling/featurizers_test.py +++ b/official/projects/pointpillars/modeling/featurizers_test.py @@ -15,7 +15,7 @@ """Tests for backbones.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import featurizers @@ -36,24 +36,24 @@ def test_network_creation(self, image_size, pillars_size, train_batch_size, num_blocks, num_channels) # Train mode. - pillars = tf.keras.Input(shape=pillars_size, batch_size=train_batch_size) - indices = tf.keras.Input( + pillars = tf_keras.Input(shape=pillars_size, batch_size=train_batch_size) + indices = tf_keras.Input( shape=[n, 2], batch_size=train_batch_size, dtype=tf.int32) image = featurizer(pillars, indices, training=True) self.assertAllEqual([train_batch_size, h, w, num_channels], image.shape.as_list()) # Evaluation mode. - pillars = tf.keras.Input(shape=pillars_size, batch_size=eval_batch_size) - indices = tf.keras.Input( + pillars = tf_keras.Input(shape=pillars_size, batch_size=eval_batch_size) + indices = tf_keras.Input( shape=[n, 2], batch_size=eval_batch_size, dtype=tf.int32) image = featurizer(pillars, indices, training=False) self.assertAllEqual([eval_batch_size, h, w, num_channels], image.shape.as_list()) # Test mode, batch size must be 1. - pillars = tf.keras.Input(shape=pillars_size, batch_size=1) - indices = tf.keras.Input( + pillars = tf_keras.Input(shape=pillars_size, batch_size=1) + indices = tf_keras.Input( shape=[n, 2], batch_size=1, dtype=tf.int32) image = featurizer(pillars, indices, training=None) self.assertAllEqual([1, h, w, num_channels], diff --git a/official/projects/pointpillars/modeling/heads.py b/official/projects/pointpillars/modeling/heads.py index 03d0c927c1b..9dc89c2aaa0 100644 --- a/official/projects/pointpillars/modeling/heads.py +++ b/official/projects/pointpillars/modeling/heads.py @@ -17,14 +17,14 @@ from typing import Any, Dict, List, Mapping, Optional, Tuple import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import layers from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class SSDHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SSDHead(tf_keras.layers.Layer): """A SSD head for PointPillars detection.""" def __init__( @@ -35,7 +35,7 @@ def __init__( attribute_heads: Optional[List[Dict[str, Any]]] = None, min_level: int = 1, max_level: int = 3, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialize the SSD Head. @@ -49,7 +49,7 @@ def __init__( of predicted values for each instance). min_level: An `int` of min level for output mutiscale features. max_level: An `int` of max level for output mutiscale features. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. @@ -91,22 +91,22 @@ def build(self, input_specs: Mapping[str, tf.TensorShape]): kernel_regularizer=self._config_dict['kernel_regularizer']) # Detection convs, share weights across multi levels. - self._classifier = tf.keras.layers.Conv2D( + self._classifier = tf_keras.layers.Conv2D( filters=(self._config_dict['num_classes'] * self._config_dict['num_anchors_per_location']), kernel_size=3, strides=1, padding='same', - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-5), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=1e-5), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_initializer=tf.constant_initializer(-np.log((1 - 0.01) / 0.01))) - self._box_regressor = tf.keras.layers.Conv2D( + self._box_regressor = tf_keras.layers.Conv2D( filters=(self._config_dict['num_params_per_anchor'] * self._config_dict['num_anchors_per_location']), kernel_size=3, strides=1, padding='same', - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-5), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=1e-5), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_initializer=tf.zeros_initializer()) if self._config_dict['attribute_heads']: @@ -117,12 +117,12 @@ def build(self, input_specs: Mapping[str, tf.TensorShape]): att_size = att_config['size'] if att_type != 'regression': raise ValueError('Unsupported head type: {}'.format(att_type)) - self._att_predictors[att_name] = tf.keras.layers.Conv2D( + self._att_predictors[att_name] = tf_keras.layers.Conv2D( filters=(att_size * self._config_dict['num_anchors_per_location']), kernel_size=3, strides=1, padding='same', - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=1e-5), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=1e-5), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_initializer=tf.zeros_initializer()) @@ -171,5 +171,5 @@ def get_config(self) -> Mapping[str, Any]: return self._config_dict @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.layers.Layer: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.layers.Layer: return cls(**config) diff --git a/official/projects/pointpillars/modeling/heads_test.py b/official/projects/pointpillars/modeling/heads_test.py index ef4802598f1..7fea2287321 100644 --- a/official/projects/pointpillars/modeling/heads_test.py +++ b/official/projects/pointpillars/modeling/heads_test.py @@ -15,7 +15,7 @@ """Tests for decoders.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import heads @@ -32,7 +32,7 @@ def test_network_creation(self, num_classes, attribute_heads, min_level, n, h, w, c = 1, 32, 32, 4 num_anchors_per_location = 3 num_params_per_anchor = 4 - inputs = {'1': tf.keras.Input(shape=[h, w, c], batch_size=n)} + inputs = {'1': tf_keras.Input(shape=[h, w, c], batch_size=n)} head = heads.SSDHead(num_classes, num_anchors_per_location, num_params_per_anchor, attribute_heads, min_level, diff --git a/official/projects/pointpillars/modeling/layers.py b/official/projects/pointpillars/modeling/layers.py index af0752c3708..5ba7ddb9bd3 100644 --- a/official/projects/pointpillars/modeling/layers.py +++ b/official/projects/pointpillars/modeling/layers.py @@ -16,14 +16,14 @@ from typing import Any, Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class ConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ConvBlock(tf_keras.layers.Layer): """A conv2d followed by a norm then an activation.""" def __init__( @@ -32,13 +32,13 @@ def __init__( kernel_size: int, strides: int, use_transpose_conv: bool = False, - kernel_initializer: Optional[tf.keras.initializers.Initializer] = tf.keras + kernel_initializer: Optional[tf_keras.initializers.Initializer] = tf.keras .initializers.VarianceScaling(), - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_bias: bool = False, - bias_initializer: Optional[tf.keras.initializers.Initializer] = tf.keras + bias_initializer: Optional[tf_keras.initializers.Initializer] = tf.keras .initializers.Zeros(), - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_sync_bn: bool = True, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, @@ -90,9 +90,9 @@ def build(self, input_shape: tf.TensorShape): """Creates variables for the block.""" # Config conv if self._use_transpose_conv: - conv_op = tf.keras.layers.Conv2DTranspose + conv_op = tf_keras.layers.Conv2DTranspose else: - conv_op = tf.keras.layers.Conv2D + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'filters': self._filters, 'kernel_size': self._kernel_size, @@ -108,9 +108,9 @@ def build(self, input_shape: tf.TensorShape): # Config norm if self._use_sync_bn: - bn_op = tf.keras.layers.experimental.SyncBatchNormalization + bn_op = tf_keras.layers.experimental.SyncBatchNormalization else: - bn_op = tf.keras.layers.BatchNormalization + bn_op = tf_keras.layers.BatchNormalization bn_kwargs = { 'axis': -1, 'momentum': self._norm_momentum, @@ -147,5 +147,5 @@ def get_config(self) -> Mapping[str, Any]: return config @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.Model: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.Model: return cls(**config) diff --git a/official/projects/pointpillars/modeling/layers_test.py b/official/projects/pointpillars/modeling/layers_test.py index d7dbe84bf11..9aef812a440 100644 --- a/official/projects/pointpillars/modeling/layers_test.py +++ b/official/projects/pointpillars/modeling/layers_test.py @@ -15,7 +15,7 @@ """Tests for backbones.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.modeling import layers @@ -32,7 +32,7 @@ def test_creation(self, input_shape, filters, strides, use_transpose_conv): kernel_size = 3 n, h, w, _ = input_shape - inputs = tf.keras.Input(shape=input_shape[1:], batch_size=n) + inputs = tf_keras.Input(shape=input_shape[1:], batch_size=n) block = layers.ConvBlock(filters, kernel_size, strides, use_transpose_conv) outputs = block(inputs) diff --git a/official/projects/pointpillars/modeling/models.py b/official/projects/pointpillars/modeling/models.py index ad3631b344b..15330ad2a50 100644 --- a/official/projects/pointpillars/modeling/models.py +++ b/official/projects/pointpillars/modeling/models.py @@ -15,21 +15,21 @@ """PointPillars Model.""" from typing import Any, Dict, List, Mapping, Optional, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.utils import utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class PointPillarsModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class PointPillarsModel(tf_keras.Model): """The PointPillars model class.""" def __init__(self, - featurizer: tf.keras.layers.Layer, - backbone: tf.keras.Model, - decoder: tf.keras.Model, - head: tf.keras.layers.Layer, - detection_generator: tf.keras.layers.Layer, + featurizer: tf_keras.layers.Layer, + backbone: tf_keras.Model, + decoder: tf_keras.Model, + head: tf_keras.layers.Layer, + detection_generator: tf_keras.layers.Layer, min_level: int, max_level: int, image_size: Tuple[int, int], @@ -38,11 +38,11 @@ def __init__(self, """Initialize the model class. Args: - featurizer: A `tf.keras.layers.Layer` to extract features from pillars. - backbone: A `tf.keras.Model` to downsample feature images. - decoder: A `tf.keras.Model` to upsample feature images. - head: A `tf.keras.layers.Layer` to predict targets. - detection_generator: A `tf.keras.layers.Layer` to generate detections. + featurizer: A `tf_keras.layers.Layer` to extract features from pillars. + backbone: A `tf_keras.Model` to downsample feature images. + decoder: A `tf_keras.Model` to upsample feature images. + head: A `tf_keras.layers.Layer` to predict targets. + detection_generator: A `tf_keras.layers.Layer` to generate detections. min_level: An `int` minimum level of multiscale outputs. max_level: An `int` maximum level of multiscale outputs. image_size: A tuple (height, width) of image size. @@ -170,7 +170,7 @@ def call(self, # pytype: disable=signature-mismatch # overriding-parameter-cou @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(featurizer=self.featurizer, backbone=self.backbone, @@ -179,23 +179,23 @@ def checkpoint_items( return items @property - def featurizer(self) -> tf.keras.layers.Layer: + def featurizer(self) -> tf_keras.layers.Layer: return self._featurizer @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone @property - def decoder(self) -> tf.keras.Model: + def decoder(self) -> tf_keras.Model: return self._decoder @property - def head(self) -> tf.keras.layers.Layer: + def head(self) -> tf_keras.layers.Layer: return self._head @property - def detection_generator(self) -> tf.keras.layers.Layer: + def detection_generator(self) -> tf_keras.layers.Layer: return self._detection_generator def get_config(self) -> Mapping[str, Any]: @@ -213,5 +213,5 @@ def get_config(self) -> Mapping[str, Any]: return config_dict @classmethod - def from_config(cls, config: Mapping[str, Any]) -> tf.keras.Model: + def from_config(cls, config: Mapping[str, Any]) -> tf_keras.Model: return cls(**config) diff --git a/official/projects/pointpillars/modeling/models_test.py b/official/projects/pointpillars/modeling/models_test.py index 03deb9db5f9..cdfa96c5afc 100644 --- a/official/projects/pointpillars/modeling/models_test.py +++ b/official/projects/pointpillars/modeling/models_test.py @@ -15,7 +15,7 @@ """Tests for PointPillars models.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -41,7 +41,7 @@ class PointpillarsTest(parameterized.TestCase, tf.test.TestCase): training=[True, False], )) def test_all(self, strategy, training): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') num_classes = 2 h, w, c = 8, 8, 2 @@ -60,8 +60,8 @@ def test_all(self, strategy, training): global_batch_size = 4 num_replicas = tf.distribute.get_strategy().num_replicas_in_sync batch_size = int(global_batch_size / num_replicas) - pillars = tf.keras.Input(shape=pillars_size, batch_size=batch_size) - indices = tf.keras.Input( + pillars = tf_keras.Input(shape=pillars_size, batch_size=batch_size) + indices = tf_keras.Input( shape=indices_size, batch_size=batch_size, dtype=tf.int32) image_shape = tf.tile(tf.expand_dims([h, w], axis=0), [batch_size, 1]) max_num_detections = 4 diff --git a/official/projects/pointpillars/tasks/pointpillars.py b/official/projects/pointpillars/tasks/pointpillars.py index 9a5672e1071..41e39de4ad6 100644 --- a/official/projects/pointpillars/tasks/pointpillars.py +++ b/official/projects/pointpillars/tasks/pointpillars.py @@ -18,7 +18,7 @@ from typing import Any, List, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import task_factory @@ -67,7 +67,7 @@ def __init__(self, self._model = None self._attribute_heads = self.task_config.model.head.attribute_heads - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: # Create only one model instance if this function is called multiple times. if self._model is not None: return self._model @@ -75,12 +75,12 @@ def build_model(self) -> tf.keras.Model: pillars_config = self.task_config.model.pillars input_specs = { 'pillars': - tf.keras.layers.InputSpec( + tf_keras.layers.InputSpec( shape=(None, pillars_config.num_pillars, pillars_config.num_points_per_pillar, pillars_config.num_features_per_point)), 'indices': - tf.keras.layers.InputSpec( + tf_keras.layers.InputSpec( shape=(None, pillars_config.num_pillars, 2), dtype='int32'), } @@ -90,7 +90,7 @@ def build_model(self) -> tf.keras.Model: self.task_config.validation_data.global_batch_size) l2_weight_decay = self.task_config.losses.l2_weight_decay - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) self._model = factory.build_pointpillars( @@ -101,7 +101,7 @@ def build_model(self) -> tf.keras.Model: l2_regularizer=l2_regularizer) return self._model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -171,9 +171,9 @@ def compute_attribute_losses( labels: Mapping[str, Any], box_sample_weight: tf.Tensor) -> Mapping[str, float]: """Computes attribute loss.""" - att_loss_fn = tf.keras.losses.Huber( + att_loss_fn = tf_keras.losses.Huber( self.task_config.losses.huber_loss_delta, - reduction=tf.keras.losses.Reduction.SUM) + reduction=tf_keras.losses.Reduction.SUM) losses = {} total_loss = 0.0 @@ -215,10 +215,10 @@ def compute_losses( cls_loss_fn = focal_loss.FocalLoss( alpha=params.losses.focal_loss_alpha, gamma=params.losses.focal_loss_gamma, - reduction=tf.keras.losses.Reduction.SUM) - box_loss_fn = tf.keras.losses.Huber( + reduction=tf_keras.losses.Reduction.SUM) + box_loss_fn = tf_keras.losses.Huber( params.losses.huber_loss_delta, - reduction=tf.keras.losses.Reduction.SUM) + reduction=tf_keras.losses.Reduction.SUM) # Sums all positives in a batch for normalization and avoids zero # num_positives_sum, which would lead to inf loss during training @@ -275,7 +275,7 @@ def build_metrics(self, training: bool = True) -> List[tf.metrics.Metric]: loss_names.append(head.name + '_loss') metrics = [] for name in loss_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) # Use a separate metric for WOD validation. if not training: @@ -299,8 +299,8 @@ def build_metrics(self, training: bool = True) -> List[tf.metrics.Metric]: def train_step( self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[tf.metrics.Metric]] = None) -> Mapping[str, Any]: """Does forward and backward.""" features, labels = inputs @@ -317,13 +317,13 @@ def train_step( # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -338,7 +338,7 @@ def train_step( def validation_step( self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[tf.metrics.Metric]] = None) -> Mapping[str, Any]: """Validatation step.""" features, labels = inputs diff --git a/official/projects/pointpillars/tasks/pointpillars_test.py b/official/projects/pointpillars/tasks/pointpillars_test.py index fdf62dccdaf..2c588351d0e 100644 --- a/official/projects/pointpillars/tasks/pointpillars_test.py +++ b/official/projects/pointpillars/tasks/pointpillars_test.py @@ -15,7 +15,7 @@ """Tests for pointpillars.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.modeling import optimization diff --git a/official/projects/pointpillars/tools/process_wod.py b/official/projects/pointpillars/tools/process_wod.py index ca66527d5af..bb2dc5941e6 100644 --- a/official/projects/pointpillars/tools/process_wod.py +++ b/official/projects/pointpillars/tools/process_wod.py @@ -21,7 +21,7 @@ from absl import logging import apache_beam as beam from apache_beam.io import tfrecordio -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.pointpillars.configs import pointpillars diff --git a/official/projects/pointpillars/train.py b/official/projects/pointpillars/train.py index 39ab68094c4..7d913b71bab 100644 --- a/official/projects/pointpillars/train.py +++ b/official/projects/pointpillars/train.py @@ -21,7 +21,7 @@ from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.common import flags as tfm_flags diff --git a/official/projects/pointpillars/utils/model_exporter.py b/official/projects/pointpillars/utils/model_exporter.py index 6eb47b8da54..a901e0e1377 100644 --- a/official/projects/pointpillars/utils/model_exporter.py +++ b/official/projects/pointpillars/utils/model_exporter.py @@ -18,7 +18,7 @@ from typing import Any, Dict, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import export_base @@ -56,7 +56,7 @@ def export_inference_graph( params=params, batch_size=batch_size) # Disable custom_gradients to make trt-converter be able to work. - # Consider to use tf.keras.models.save_model/load_model APIs to fix + # Consider to use tf_keras.models.save_model/load_model APIs to fix # the custom gradients saving problem. # https://github.com/tensorflow/tensorflow/issues/40166 save_options = tf.saved_model.SaveOptions(experimental_custom_gradients=False) @@ -140,22 +140,22 @@ def __init__(self, params: cfg.ExperimentConfig, batch_size: int): super().__init__(params=params, model=model) def _build_input_specs( - self) -> Tuple[tf.keras.layers.InputSpec, tf.keras.layers.InputSpec]: + self) -> Tuple[tf_keras.layers.InputSpec, tf_keras.layers.InputSpec]: pillars_config = self._params.task.model.pillars - pillars_spec = tf.keras.layers.InputSpec( + pillars_spec = tf_keras.layers.InputSpec( shape=(self._batch_size, pillars_config.num_pillars, pillars_config.num_points_per_pillar, pillars_config.num_features_per_point), dtype='float32') - indices_spec = tf.keras.layers.InputSpec( + indices_spec = tf_keras.layers.InputSpec( shape=(self._batch_size, pillars_config.num_pillars, 2), dtype='int32') return pillars_spec, indices_spec - def _build_model(self) -> tf.keras.Model: + def _build_model(self) -> tf_keras.Model: logging.info('Building PointPillars model.') input_specs = { 'pillars': self._pillars_spec, 'indices': self._indices_spec diff --git a/official/projects/pointpillars/utils/utils.py b/official/projects/pointpillars/utils/utils.py index 538023ac20d..659afc5814e 100644 --- a/official/projects/pointpillars/utils/utils.py +++ b/official/projects/pointpillars/utils/utils.py @@ -18,7 +18,7 @@ from typing import Any, List, Mapping, Tuple import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras CLASSES = {'vehicle': 1, 'pedestrian': 2, 'cyclist': 3} @@ -31,7 +31,7 @@ def assert_shape(x: np.ndarray, shape: List[int]): def assert_channels_last(): - if tf.keras.backend.image_data_format() != 'channels_last': + if tf_keras.backend.image_data_format() != 'channels_last': raise ValueError('Only "channels_last" mode is supported') diff --git a/official/projects/pointpillars/utils/utils_test.py b/official/projects/pointpillars/utils/utils_test.py index 4047595d92e..30232a77f62 100644 --- a/official/projects/pointpillars/utils/utils_test.py +++ b/official/projects/pointpillars/utils/utils_test.py @@ -17,7 +17,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.utils import utils diff --git a/official/projects/pointpillars/utils/wod_detection_evaluator.py b/official/projects/pointpillars/utils/wod_detection_evaluator.py index 6f20afb88ea..e10566dc873 100644 --- a/official/projects/pointpillars/utils/wod_detection_evaluator.py +++ b/official/projects/pointpillars/utils/wod_detection_evaluator.py @@ -19,7 +19,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg from official.projects.pointpillars.utils import utils diff --git a/official/projects/pointpillars/utils/wod_processor.py b/official/projects/pointpillars/utils/wod_processor.py index 07a403360eb..92dd85eac7b 100644 --- a/official/projects/pointpillars/utils/wod_processor.py +++ b/official/projects/pointpillars/utils/wod_processor.py @@ -18,7 +18,7 @@ import zlib import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.pointpillars.configs import pointpillars as cfg from official.projects.pointpillars.utils import utils diff --git a/official/projects/pruning/configs/image_classification_test.py b/official/projects/pruning/configs/image_classification_test.py index d1c0e382444..c4ebe364e98 100644 --- a/official/projects/pruning/configs/image_classification_test.py +++ b/official/projects/pruning/configs/image_classification_test.py @@ -15,7 +15,7 @@ """Tests for image_classification.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/pruning/tasks/image_classification.py b/official/projects/pruning/tasks/image_classification.py index 76845f91790..3e08cc85d96 100644 --- a/official/projects/pruning/tasks/image_classification.py +++ b/official/projects/pruning/tasks/image_classification.py @@ -14,7 +14,7 @@ """Image classification task definition.""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.core import task_factory @@ -49,7 +49,7 @@ class ImageClassificationTask(image_classification.ImageClassificationTask): ), } - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds classification model with pruning.""" model = super(ImageClassificationTask, self).build_model() if self.task_config.pruning is None: @@ -57,7 +57,7 @@ def build_model(self) -> tf.keras.Model: pruning_cfg = self.task_config.pruning - prunable_model = tf.keras.models.clone_model( + prunable_model = tf_keras.models.clone_model( model, clone_function=self._make_block_prunable, ) @@ -113,9 +113,9 @@ def build_model(self) -> tf.keras.Model: return pruned_model def _make_block_prunable( - self, layer: tf.keras.layers.Layer) -> tf.keras.layers.Layer: - if isinstance(layer, tf.keras.Model): - return tf.keras.models.clone_model( + self, layer: tf_keras.layers.Layer) -> tf_keras.layers.Layer: + if isinstance(layer, tf_keras.Model): + return tf_keras.models.clone_model( layer, input_tensors=None, clone_function=self._make_block_prunable) if layer.__class__ not in self._BLOCK_LAYER_SUFFIX_MAP: @@ -139,7 +139,7 @@ def collect_prunable_layers(model): """Recursively collect the prunable layers in the model.""" prunable_layers = [] for layer in model.layers: - if isinstance(layer, tf.keras.Model): + if isinstance(layer, tf_keras.Model): prunable_layers += collect_prunable_layers(layer) if layer.__class__.__name__ == 'PruneLowMagnitude': prunable_layers.append(layer) diff --git a/official/projects/pruning/tasks/image_classification_test.py b/official/projects/pruning/tasks/image_classification_test.py index 203993c53c0..94cf0b38056 100644 --- a/official/projects/pruning/tasks/image_classification_test.py +++ b/official/projects/pruning/tasks/image_classification_test.py @@ -21,7 +21,7 @@ from absl.testing import parameterized import numpy as np import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official import vision diff --git a/official/projects/qat/nlp/modeling/layers/mobile_bert_layers.py b/official/projects/qat/nlp/modeling/layers/mobile_bert_layers.py index e373d524262..54ce2251f47 100644 --- a/official/projects/qat/nlp/modeling/layers/mobile_bert_layers.py +++ b/official/projects/qat/nlp/modeling/layers/mobile_bert_layers.py @@ -13,7 +13,7 @@ # limitations under the License. """MobileBERT embedding and transformer layers.""" -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.nlp import modeling @@ -30,7 +30,7 @@ def _quantized_multi_head_attention(*args, **kwargs): def _quantized_einsum_dense(*args, **kwargs): - layer = tf.keras.layers.EinsumDense(*args, **kwargs) + layer = tf_keras.layers.EinsumDense(*args, **kwargs) return tfmot.quantization.keras.QuantizeWrapperV2( layer, configs.DefaultEinsumDenseQuantizeConfig()) @@ -40,8 +40,8 @@ def _output_quantize(layer): layer, configs.Default8BitOutputQuantizeConfig()) -@tf.keras.utils.register_keras_serializable(package='Text') -class NoNormQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Text') +class NoNormQuantized(tf_keras.layers.Layer): """Apply element-wise linear transformation to the last dimension.""" def __init__(self, name=None): @@ -56,7 +56,7 @@ def build(self, shape): shape=[kernal_size], initializer='ones') self.multiply = _output_quantize( - tf.keras.layers.Multiply()) + tf_keras.layers.Multiply()) def call(self, feature): broadcast_shape = tf.shape(feature) @@ -79,7 +79,7 @@ def _get_norm_layer(normalization_type='no_norm', name=None): if normalization_type == 'no_norm': layer = NoNormQuantized(name=name) elif normalization_type == 'layer_norm': - layer = tf.keras.layers.LayerNormalization( + layer = tf_keras.layers.LayerNormalization( name=name, axis=-1, epsilon=1e-12, @@ -90,7 +90,7 @@ def _get_norm_layer(normalization_type='no_norm', name=None): class MobileBertEmbeddingQuantized(helper.LayerQuantizerHelper, - tf.keras.layers.Layer): + tf_keras.layers.Layer): """Performs an embedding lookup for MobileBERT. This layer includes word embedding, token type embedding, position embedding. @@ -103,7 +103,7 @@ def __init__(self, output_embed_size, max_sequence_length=512, normalization_type='no_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), dropout_rate=0.1, **kwargs): """Class initialization. @@ -128,7 +128,7 @@ def __init__(self, self.output_embed_size = output_embed_size self.max_sequence_length = max_sequence_length self.normalization_type = normalization_type - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) self.dropout_rate = dropout_rate self.word_embedding = modeling.layers.OnDeviceEmbedding( @@ -151,13 +151,13 @@ def __init__(self, kernel_initializer=initializer, bias_axes='d', name='embedding_projection') - self.embedding_out_add_pos = _output_quantize(tf.keras.layers.Add()) + self.embedding_out_add_pos = _output_quantize(tf_keras.layers.Add()) self.layer_norm = _output_quantize( _get_norm_layer(normalization_type, 'embedding_norm')) - self.dropout_layer = tf.keras.layers.Dropout( + self.dropout_layer = tf_keras.layers.Dropout( self.dropout_rate, name='embedding_dropout') - self.embedding_out_add_type = _output_quantize(tf.keras.layers.Add()) + self.embedding_out_add_type = _output_quantize(tf_keras.layers.Add()) def build(self, input_shape): self._add_quantizer('word_embedding_out') @@ -174,7 +174,7 @@ def get_config(self): 'output_embed_size': self.output_embed_size, 'max_sequence_length': self.max_sequence_length, 'normalization_type': self.normalization_type, - 'initializer': tf.keras.initializers.serialize(self.initializer), + 'initializer': tf_keras.initializers.serialize(self.initializer), 'dropout_rate': self.dropout_rate } base_config = super().get_config() @@ -208,7 +208,7 @@ def call(self, input_ids, token_type_ids=None, training=None): return embedding_out -class MobileBertTransformerQuantized(tf.keras.layers.Layer): +class MobileBertTransformerQuantized(tf_keras.layers.Layer): """Transformer block for MobileBERT. An implementation of one layer (block) of Transformer with bottleneck and @@ -230,7 +230,7 @@ def __init__(self, key_query_shared_bottleneck=True, num_feedforward_networks=4, normalization_type='no_norm', - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), **kwargs): """Class initialization. @@ -274,7 +274,7 @@ def __init__(self, self.key_query_shared_bottleneck = key_query_shared_bottleneck self.num_feedforward_networks = num_feedforward_networks self.normalization_type = normalization_type - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) if intra_bottleneck_size % num_attention_heads != 0: raise ValueError( @@ -352,7 +352,7 @@ def __init__(self, output_layer, layer_norm]) self.ffn_add_layers.append(_output_quantize( - tf.keras.layers.Add())) + tf_keras.layers.Add())) # add output bottleneck bottleneck = _quantized_einsum_dense( @@ -362,7 +362,7 @@ def __init__(self, bias_axes='d', kernel_initializer=initializer, name='bottleneck_output/dense') - dropout_layer = tf.keras.layers.Dropout( + dropout_layer = tf_keras.layers.Dropout( self.hidden_dropout_prob, name='bottleneck_output/dropout') layer_norm = _output_quantize( @@ -372,9 +372,9 @@ def __init__(self, dropout_layer, layer_norm] self.attention_output_add = _output_quantize( - tf.keras.layers.Add()) + tf_keras.layers.Add()) self.output_add = _output_quantize( - tf.keras.layers.Add()) + tf_keras.layers.Add()) def get_config(self): config = { @@ -389,7 +389,7 @@ def get_config(self): 'key_query_shared_bottleneck': self.key_query_shared_bottleneck, 'num_feedforward_networks': self.num_feedforward_networks, 'normalization_type': self.normalization_type, - 'initializer': tf.keras.initializers.serialize(self.initializer), + 'initializer': tf_keras.initializers.serialize(self.initializer), } base_config = super().get_config() return dict(list(base_config.items()) + list(config.items())) diff --git a/official/projects/qat/nlp/modeling/layers/multi_head_attention.py b/official/projects/qat/nlp/modeling/layers/multi_head_attention.py index ccfd1b141c8..c505a8fcc37 100644 --- a/official/projects/qat/nlp/modeling/layers/multi_head_attention.py +++ b/official/projects/qat/nlp/modeling/layers/multi_head_attention.py @@ -15,7 +15,7 @@ """Quantized multi head attention layer.""" import math -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.ops import array_ops from tensorflow.python.ops import math_ops @@ -28,7 +28,7 @@ class MultiHeadAttentionQuantized(helper.LayerQuantizerHelper, - tf.keras.layers.MultiHeadAttention): + tf_keras.layers.MultiHeadAttention): """Quantized multi head attention layer. This layer only quantized _compute_attention part. EinsumDense child layers diff --git a/official/projects/qat/nlp/modeling/layers/transformer_encoder_block.py b/official/projects/qat/nlp/modeling/layers/transformer_encoder_block.py index e999595c62f..dc8d79863ed 100644 --- a/official/projects/qat/nlp/modeling/layers/transformer_encoder_block.py +++ b/official/projects/qat/nlp/modeling/layers/transformer_encoder_block.py @@ -16,7 +16,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.nlp.modeling.layers.multi_head_attention import MultiHeadAttentionQuantized @@ -31,7 +31,7 @@ def _quantized_multi_head_attention(*args, **kwargs): def _quantized_einsum_dense(*args, **kwargs): - layer = tf.keras.layers.EinsumDense(*args, **kwargs) + layer = tf_keras.layers.EinsumDense(*args, **kwargs) return tfmot.quantization.keras.QuantizeWrapperV2( layer, configs.DefaultEinsumDenseQuantizeConfig()) @@ -41,12 +41,12 @@ def _output_quantize(layer): layer, configs.Default8BitOutputQuantizeConfig()) -class TransformerEncoderBlockQuantized(tf.keras.layers.Layer): +class TransformerEncoderBlockQuantized(tf_keras.layers.Layer): """TransformerEncoderBlock layer. This layer implements the Transformer Encoder from "Attention Is All You Need". (https://arxiv.org/abs/1706.03762), - which combines a `tf.keras.layers.MultiHeadAttention` layer with a + which combines a `tf_keras.layers.MultiHeadAttention` layer with a two-layer feedforward network. References: @@ -125,19 +125,19 @@ def __init__(self, self._output_dropout = output_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon self._inner_dropout = inner_dropout if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = self._kernel_initializer @@ -177,11 +177,11 @@ def build(self, input_shape): attention_axes=self._attention_axes, name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = _output_quantize( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -193,16 +193,16 @@ def build(self, input_shape): kernel_initializer=self._kernel_initializer, name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 self._intermediate_activation_layer = _output_quantize( - tf.keras.layers.Activation( + tf_keras.layers.Activation( self._inner_activation, dtype=policy)) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) self._output_dense = _quantized_einsum_dense( "abc,cd->abd", @@ -211,16 +211,16 @@ def build(self, input_shape): name="output", kernel_initializer=self._kernel_initializer, **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. self._output_layer_norm = _output_quantize( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) - self._add = _output_quantize(tf.keras.layers.Add()) - self._output_add = tf.keras.layers.Add() + self._add = _output_quantize(tf_keras.layers.Add()) + self._output_add = tf_keras.layers.Add() super().build(input_shape) @@ -239,19 +239,19 @@ def get_config(self): "output_range": self._output_range, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "use_bias": self._use_bias, "norm_first": @@ -261,7 +261,7 @@ def get_config(self): "inner_dropout": self._inner_dropout, "attention_initializer": - tf.keras.initializers.serialize(self._attention_initializer), + tf_keras.initializers.serialize(self._attention_initializer), "attention_axes": self._attention_axes, } base_config = super().get_config() diff --git a/official/projects/qat/nlp/modeling/layers/transformer_encoder_block_test.py b/official/projects/qat/nlp/modeling/layers/transformer_encoder_block_test.py index 8a6dced9135..8621d938eb4 100644 --- a/official/projects/qat/nlp/modeling/layers/transformer_encoder_block_test.py +++ b/official/projects/qat/nlp/modeling/layers/transformer_encoder_block_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.nlp.modeling.layers.transformer_encoder_block import TransformerEncoderBlockQuantized @@ -28,7 +28,7 @@ class TransformerEncoderBlockQuantizedLayerTest( def tearDown(self): super(TransformerEncoderBlockQuantizedLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self, transformer_cls): test_layer = transformer_cls( @@ -36,7 +36,7 @@ def test_layer_creation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -47,9 +47,9 @@ def test_layer_creation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -60,11 +60,11 @@ def test_layer_invocation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -79,13 +79,13 @@ def test_layer_invocation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -180,11 +180,11 @@ def test_transform_with_initializer(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -194,12 +194,12 @@ def test_dynamic_layer_sequence(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). width = 30 - input_tensor = tf.keras.Input(shape=(None, width)) + input_tensor = tf_keras.Input(shape=(None, width)) output_tensor = test_layer(input_tensor) - model = tf.keras.Model(input_tensor, output_tensor) + model = tf_keras.Model(input_tensor, output_tensor) input_length = 17 input_data = np.ones((1, input_length, width)) @@ -212,7 +212,7 @@ def test_separate_qkv(self, transformer_cls): num_attention_heads=2, inner_dim=128, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Forward path. q_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) kv_tensor = tf.zeros([2, 8, 16], dtype=tf.float32) diff --git a/official/projects/qat/nlp/modeling/models/bert_span_labeler.py b/official/projects/qat/nlp/modeling/models/bert_span_labeler.py index d9a991126e3..1865ef4f5ac 100644 --- a/official/projects/qat/nlp/modeling/models/bert_span_labeler.py +++ b/official/projects/qat/nlp/modeling/models/bert_span_labeler.py @@ -15,13 +15,13 @@ """BERT Question Answering model.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.nlp.modeling.networks import span_labeling -@tf.keras.utils.register_keras_serializable(package='Text') -class BertSpanLabelerQuantized(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class BertSpanLabelerQuantized(tf_keras.Model): """Span labeler model based on a BERT-style transformer-based encoder. This is an implementation of the network structure surrounding a transformer @@ -80,10 +80,10 @@ def __init__(self, # Use identity layers wrapped in lambdas to explicitly name the output # tensors. This allows us to use string-keyed dicts in Keras fit/predict/ # evaluate calls. - start_logits = tf.keras.layers.Lambda( + start_logits = tf_keras.layers.Lambda( tf.identity, name='start_positions')( start_logits) - end_logits = tf.keras.layers.Lambda( + end_logits = tf_keras.layers.Lambda( tf.identity, name='end_positions')( end_logits) diff --git a/official/projects/qat/nlp/modeling/networks/span_labeling.py b/official/projects/qat/nlp/modeling/networks/span_labeling.py index 15ed0ed3407..c4a95301581 100644 --- a/official/projects/qat/nlp/modeling/networks/span_labeling.py +++ b/official/projects/qat/nlp/modeling/networks/span_labeling.py @@ -15,7 +15,7 @@ """Span labeling network.""" # pylint: disable=g-classes-have-attributes import collections -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.nlp.quantization import configs @@ -27,8 +27,8 @@ def _apply_paragraph_mask(logits, paragraph_mask): return tf.nn.log_softmax(masked_logits, -1), masked_logits -@tf.keras.utils.register_keras_serializable(package='Text') -class SpanLabelingQuantized(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class SpanLabelingQuantized(tf_keras.Model): """Span labeling network head for BERT modeling. This network implements a simple single-span labeler based on a dense layer. @@ -51,10 +51,10 @@ def __init__(self, output='logits', **kwargs): - sequence_data = tf.keras.layers.Input( + sequence_data = tf_keras.layers.Input( shape=(None, input_width), name='sequence_data', dtype=tf.float32) - logits_layer = tf.keras.layers.Dense( + logits_layer = tf_keras.layers.Dense( 2, # This layer predicts start location and end location. activation=activation, kernel_initializer=initializer, @@ -65,9 +65,9 @@ def __init__(self, intermediate_logits = logits_layer(sequence_data) start_logits, end_logits = self._split_output_tensor(intermediate_logits) - start_predictions = tf.keras.layers.Activation(tf.nn.log_softmax)( + start_predictions = tf_keras.layers.Activation(tf.nn.log_softmax)( start_logits) - end_predictions = tf.keras.layers.Activation(tf.nn.log_softmax)(end_logits) + end_predictions = tf_keras.layers.Activation(tf.nn.log_softmax)(end_logits) if output == 'logits': output_tensors = [start_logits, end_logits] diff --git a/official/projects/qat/nlp/pretrained_checkpoint_converter.py b/official/projects/qat/nlp/pretrained_checkpoint_converter.py index d4a341e61ea..3e8de49f964 100644 --- a/official/projects/qat/nlp/pretrained_checkpoint_converter.py +++ b/official/projects/qat/nlp/pretrained_checkpoint_converter.py @@ -19,7 +19,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/projects/qat/nlp/quantization/configs.py b/official/projects/qat/nlp/quantization/configs.py index bf100a5c078..4c421440f42 100644 --- a/official/projects/qat/nlp/quantization/configs.py +++ b/official/projects/qat/nlp/quantization/configs.py @@ -15,12 +15,12 @@ """Custom quantize configs.""" from typing import Sequence, Callable, Tuple, Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot Quantizer = tfmot.quantization.keras.quantizers.Quantizer -Layer = tf.keras.layers.Layer +Layer = tf_keras.layers.Layer Activation = Callable[[tf.Tensor], tf.Tensor] WeightAndQuantizer = Tuple[tf.Variable, Quantizer] ActivationAndQuantizer = Tuple[Activation, Quantizer] @@ -44,12 +44,12 @@ def _add_range_weights(self, layer, name, per_axis=False, tensor_shape=None): min_weight = layer.add_weight( name + '_min', - initializer=tf.keras.initializers.Constant(-6.0), + initializer=tf_keras.initializers.Constant(-6.0), trainable=False, shape=shape) max_weight = layer.add_weight( name + '_max', - initializer=tf.keras.initializers.Constant(6.0), + initializer=tf_keras.initializers.Constant(6.0), trainable=False, shape=shape) @@ -220,7 +220,7 @@ class Default8BitActivationQuantizeConfig( """ def _assert_activation_layer(self, layer: Layer): - if not isinstance(layer, tf.keras.layers.Activation): + if not isinstance(layer, tf_keras.layers.Activation): raise RuntimeError( 'Default8BitActivationQuantizeConfig can only be used with ' '`keras.layers.Activation`.') diff --git a/official/projects/qat/nlp/quantization/configs_test.py b/official/projects/qat/nlp/quantization/configs_test.py index 2296692f174..98b9dd80d78 100644 --- a/official/projects/qat/nlp/quantization/configs_test.py +++ b/official/projects/qat/nlp/quantization/configs_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot @@ -70,7 +70,7 @@ def _assert_kernel_equality(self, a, b): class Default8BitQuantizeConfigTest(tf.test.TestCase, _TestHelper): def _simple_dense_layer(self): - layer = tf.keras.layers.Dense(2) + layer = tf_keras.layers.Dense(2) layer.build(input_shape=(3,)) return layer @@ -98,7 +98,7 @@ def testGetsQuantizeActivationsAndQuantizers(self): def testSetsQuantizeWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) quantize_config = configs.Default8BitQuantizeConfig( @@ -109,7 +109,7 @@ def testSetsQuantizeWeights(self): def testSetsQuantizeActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) @@ -119,7 +119,7 @@ def testSetsQuantizeActivations(self): def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) quantize_config = configs.Default8BitQuantizeConfig( @@ -134,7 +134,7 @@ def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable(np.ones([1, 2])) + quantize_kernel = tf_keras.backend.variable(np.ones([1, 2])) quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) @@ -144,7 +144,7 @@ def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): def testSetsQuantizeActivations_ErrorOnWrongNumberOfActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) @@ -211,7 +211,7 @@ def testSerialization(self): class QuantizersTest(tf.test.TestCase, parameterized.TestCase): def _simple_dense_layer(self): - layer = tf.keras.layers.Dense(2) + layer = tf_keras.layers.Dense(2) layer.build(input_shape=(3,)) return layer diff --git a/official/projects/qat/nlp/quantization/schemes.py b/official/projects/qat/nlp/quantization/schemes.py index a3cdc55cb51..8d2e6baa41c 100644 --- a/official/projects/qat/nlp/quantization/schemes.py +++ b/official/projects/qat/nlp/quantization/schemes.py @@ -16,7 +16,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot diff --git a/official/projects/qat/nlp/tasks/question_answering.py b/official/projects/qat/nlp/tasks/question_answering.py index f3cfdfe0108..fc2fd829f9f 100644 --- a/official/projects/qat/nlp/tasks/question_answering.py +++ b/official/projects/qat/nlp/tasks/question_answering.py @@ -15,7 +15,7 @@ """Question/Answering configuration definition.""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.core import task_factory @@ -45,7 +45,7 @@ def build_model(self): with tfmot.quantization.keras.quantize_scope({ 'TruncatedNormal': - tf.keras.initializers.TruncatedNormal, + tf_keras.initializers.TruncatedNormal, 'MobileBertTransformerQuantized': mobile_bert_layers.MobileBertTransformerQuantized, 'MobileBertEmbeddingQuantized': @@ -56,11 +56,11 @@ def build_model(self): configs.NoQuantizeConfig, }): def quantize_annotate_layer(layer): - if isinstance(layer, (tf.keras.layers.LayerNormalization)): + if isinstance(layer, (tf_keras.layers.LayerNormalization)): return tfmot.quantization.keras.quantize_annotate_layer( layer, configs.Default8BitOutputQuantizeConfig()) - if isinstance(layer, (tf.keras.layers.Dense, - tf.keras.layers.Dropout)): + if isinstance(layer, (tf_keras.layers.Dense, + tf_keras.layers.Dropout)): return tfmot.quantization.keras.quantize_annotate_layer(layer) if isinstance(layer, (modeling.layers.TransformerEncoderBlock, modeling.layers.MobileBertTransformer, @@ -69,7 +69,7 @@ def quantize_annotate_layer(layer): layer, configs.NoQuantizeConfig()) return layer - annotated_encoder_network = tf.keras.models.clone_model( + annotated_encoder_network = tf_keras.models.clone_model( encoder_network, clone_function=quantize_annotate_layer, ) @@ -79,6 +79,6 @@ def quantize_annotate_layer(layer): encoder_cfg = self.task_config.model.encoder.get() model = bert_span_labeler.BertSpanLabelerQuantized( network=quantized_encoder_network, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range)) return model diff --git a/official/projects/qat/nlp/tasks/question_answering_test.py b/official/projects/qat/nlp/tasks/question_answering_test.py index 5e5ef7c0352..a82526da7a8 100644 --- a/official/projects/qat/nlp/tasks/question_answering_test.py +++ b/official/projects/qat/nlp/tasks/question_answering_test.py @@ -17,7 +17,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import encoders from official.nlp.data import question_answering_dataloader diff --git a/official/projects/qat/vision/configs/image_classification_test.py b/official/projects/qat/vision/configs/image_classification_test.py index d384e144dc9..bf52a0c1335 100644 --- a/official/projects/qat/vision/configs/image_classification_test.py +++ b/official/projects/qat/vision/configs/image_classification_test.py @@ -15,7 +15,7 @@ """Tests for image_classification.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/qat/vision/configs/retinanet_test.py b/official/projects/qat/vision/configs/retinanet_test.py index 5c93e41c43c..d4d3bc026b2 100644 --- a/official/projects/qat/vision/configs/retinanet_test.py +++ b/official/projects/qat/vision/configs/retinanet_test.py @@ -15,7 +15,7 @@ """Tests for retinanet.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/qat/vision/configs/semantic_segmentation_test.py b/official/projects/qat/vision/configs/semantic_segmentation_test.py index 99b46a30f55..8ffacbe5967 100644 --- a/official/projects/qat/vision/configs/semantic_segmentation_test.py +++ b/official/projects/qat/vision/configs/semantic_segmentation_test.py @@ -15,7 +15,7 @@ """Tests for retinanet.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/qat/vision/modeling/factory.py b/official/projects/qat/vision/modeling/factory.py index f4d02c7df53..15b0d2ea751 100644 --- a/official/projects/qat/vision/modeling/factory.py +++ b/official/projects/qat/vision/modeling/factory.py @@ -15,7 +15,7 @@ """Factory methods to build models.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.vision.configs import common @@ -37,20 +37,20 @@ def build_qat_classification_model( - model: tf.keras.Model, + model: tf_keras.Model, quantization: common.Quantization, - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: configs.image_classification.ImageClassificationModel, - l2_regularizer: tf.keras.regularizers.Regularizer = None -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Apply model optimization techniques. Args: model: The model applying model optimization techniques. quantization: The Quantization config. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. model_config: The model config. - l2_regularizer: tf.keras.regularizers.Regularizer object. Default to None. + l2_regularizer: tf_keras.regularizers.Regularizer object. Default to None. Returns: model: The model that applied optimization techniques. @@ -64,7 +64,7 @@ def build_qat_classification_model( status.expect_partial().assert_existing_objects_matched() scope_dict = { - 'L2': tf.keras.regularizers.l2, + 'L2': tf_keras.regularizers.l2, } with tfmot.quantization.keras.quantize_scope(scope_dict): annotated_backbone = tfmot.quantization.keras.quantize_annotate_model( @@ -98,14 +98,14 @@ def build_qat_classification_model( with tfmot.quantization.keras.quantize_scope(scope_dict): def apply_quantization_to_dense(layer): - if isinstance(layer, (tf.keras.layers.Dense, - tf.keras.layers.Dropout, - tf.keras.layers.GlobalAveragePooling2D)): + if isinstance(layer, (tf_keras.layers.Dense, + tf_keras.layers.Dropout, + tf_keras.layers.GlobalAveragePooling2D)): return tfmot.quantization.keras.quantize_annotate_layer(layer) return layer backbone_optimized_model.use_legacy_config = True - annotated_model = tf.keras.models.clone_model( + annotated_model = tf_keras.models.clone_model( backbone_optimized_model, clone_function=apply_quantization_to_dense, ) @@ -127,19 +127,19 @@ def apply_quantization_to_dense(layer): def _clone_function_for_fpn(layer): if isinstance(layer, ( - tf.keras.layers.BatchNormalization, - tf.keras.layers.experimental.SyncBatchNormalization)): + tf_keras.layers.BatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization)): return tfmot.quantization.keras.quantize_annotate_layer( qat_nn_layers.BatchNormalizationWrapper(layer), qat_configs.Default8BitOutputQuantizeConfig()) - if isinstance(layer, tf.keras.layers.UpSampling2D): + if isinstance(layer, tf_keras.layers.UpSampling2D): return layer return tfmot.quantization.keras.quantize_annotate_layer(layer) def build_qat_retinanet( - model: tf.keras.Model, quantization: common.Quantization, - model_config: configs.retinanet.RetinaNet) -> tf.keras.Model: + model: tf_keras.Model, quantization: common.Quantization, + model_config: configs.retinanet.RetinaNet) -> tf_keras.Model: """Applies quantization aware training for RetinaNet model. Args: @@ -160,7 +160,7 @@ def build_qat_retinanet( status.expect_partial().assert_existing_objects_matched() scope_dict = { - 'L2': tf.keras.regularizers.l2, + 'L2': tf_keras.regularizers.l2, 'BatchNormalizationWrapper': qat_nn_layers.BatchNormalizationWrapper, } with tfmot.quantization.keras.quantize_scope(scope_dict): @@ -174,7 +174,7 @@ def build_qat_retinanet( if not isinstance(decoder, fpn.FPN): raise ValueError('Currently only supports FPN.') - decoder = tf.keras.models.clone_model( + decoder = tf_keras.models.clone_model( decoder, clone_function=_clone_function_for_fpn, ) @@ -211,8 +211,8 @@ def build_qat_retinanet( def build_qat_segmentation_model( - model: tf.keras.Model, quantization: common.Quantization, - input_specs: tf.keras.layers.InputSpec) -> tf.keras.Model: + model: tf_keras.Model, quantization: common.Quantization, + input_specs: tf_keras.layers.InputSpec) -> tf_keras.Model: """Applies quantization aware training for segmentation model. Args: @@ -235,11 +235,11 @@ def build_qat_segmentation_model( model.backbone, model.decoder, model.head, input_specs) scope_dict = { - 'L2': tf.keras.regularizers.l2, + 'L2': tf_keras.regularizers.l2, } model.use_legacy_config = True # Ensures old Keras serialization format - # Apply QAT to backbone (a tf.keras.Model) first. + # Apply QAT to backbone (a tf_keras.Model) first. with tfmot.quantization.keras.quantize_scope(scope_dict): annotated_backbone = tfmot.quantization.keras.quantize_annotate_model( model.backbone) @@ -263,7 +263,7 @@ def apply_quantization_to_layers(layer): return layer backbone_optimized_model.use_legacy_config = True - annotated_model = tf.keras.models.clone_model( + annotated_model = tf_keras.models.clone_model( backbone_optimized_model, clone_function=apply_quantization_to_layers, ) diff --git a/official/projects/qat/vision/modeling/factory_test.py b/official/projects/qat/vision/modeling/factory_test.py index d2f55ff7b78..179a1b8f2b4 100644 --- a/official/projects/qat/vision/modeling/factory_test.py +++ b/official/projects/qat/vision/modeling/factory_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.vision.configs import common from official.projects.qat.vision.modeling import factory as qat_factory @@ -46,13 +46,13 @@ class ClassificationModelBuilderTest(parameterized.TestCase, tf.test.TestCase): ) def test_builder(self, backbone_type, input_size, weight_decay): num_classes = 2 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model_config = classification_cfg.ImageClassificationModel( num_classes=num_classes, backbone=backbones.Backbone(type=backbone_type)) l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) model = factory.build_classification_model( input_specs=input_specs, model_config=model_config, @@ -82,7 +82,7 @@ def test_builder(self, quantize_detection_head, quantize_detection_decoder): num_classes = 2 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) if backbone_type == 'spinenet_mobile': @@ -126,7 +126,7 @@ def test_builder(self, attribute_heads=None, use_separable_conv=True)) - l2_regularizer = tf.keras.regularizers.l2(5e-5) + l2_regularizer = tf_keras.regularizers.l2(5e-5) # Build the original float32 retinanet model. model = factory.build_retinanet( input_specs=input_specs, @@ -171,7 +171,7 @@ class SegmentationModelBuilderTest(parameterized.TestCase, tf.test.TestCase): ('mobilenet', (512, 512), 5e-5),) def test_deeplabv3_builder(self, backbone_type, input_size, weight_decay): num_classes = 21 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model_config = semantic_segmentation_cfg.SemanticSegmentationModel( num_classes=num_classes, @@ -194,7 +194,7 @@ def test_deeplabv3_builder(self, backbone_type, input_size, weight_decay): upsample_factor=2, use_depthwise_convolution=True)) l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) model = factory.build_segmentation_model( input_specs=input_specs, model_config=model_config, @@ -207,7 +207,7 @@ def test_deeplabv3_builder(self, backbone_type, input_size, weight_decay): ('mobilenet', (512, 1024), 5e-5),) def test_deeplabv3plus_builder(self, backbone_type, input_size, weight_decay): num_classes = 19 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model_config = semantic_segmentation_cfg.SemanticSegmentationModel( num_classes=num_classes, @@ -238,7 +238,7 @@ def test_deeplabv3plus_builder(self, backbone_type, input_size, weight_decay): upsample_factor=1, num_filters=256)) l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) model = factory.build_segmentation_model( input_specs=input_specs, model_config=model_config, diff --git a/official/projects/qat/vision/modeling/heads/dense_prediction_heads.py b/official/projects/qat/vision/modeling/heads/dense_prediction_heads.py index 39106610094..876d767a55b 100644 --- a/official/projects/qat/vision/modeling/heads/dense_prediction_heads.py +++ b/official/projects/qat/vision/modeling/heads/dense_prediction_heads.py @@ -18,7 +18,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -26,8 +26,8 @@ from official.projects.qat.vision.quantization import helper -@tf.keras.utils.register_keras_serializable(package='Vision') -class RetinaNetHeadQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RetinaNetHeadQuantized(tf_keras.layers.Layer): """Creates a RetinaNet quantized head.""" def __init__( @@ -44,8 +44,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, num_params_per_anchor: int = 4, share_classification_heads: bool = False, share_level_convs: bool = True, @@ -75,9 +75,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. num_params_per_anchor: Number of parameters required to specify an anchor box. For example, `num_params_per_anchor` would be 4 for axis-aligned anchor boxes specified by their y-centers, x-centers, heights, and @@ -113,7 +113,7 @@ def __init__( 'num_params_per_anchor': num_params_per_anchor, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -127,7 +127,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): conv_op = helper.SeparableConv2DQuantized else: conv_op = helper.quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.Default8BitConvQuantizeConfig( ['kernel'], ['activation'], False)) conv_kwargs = { @@ -139,14 +139,14 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if not self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=0.01), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) - base_bn_op = (tf.keras.layers.experimental.SyncBatchNormalization + base_bn_op = (tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization) + else tf_keras.layers.BatchNormalization) bn_op = helper.norm_by_activation( self._config_dict['activation'], helper.quantize_wrapped_layer( @@ -185,7 +185,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if not self._config_dict['use_separable_conv']: classifier_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal(stddev=1e-5), + 'kernel_initializer': tf_keras.initializers.RandomNormal(stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) self._classifier = conv_op( @@ -215,7 +215,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if not self._config_dict['use_separable_conv']: box_regressor_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) @@ -273,7 +273,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): if not self._config_dict['use_separable_conv']: att_predictor_kwargs.update({ 'kernel_initializer': - tf.keras.initializers.RandomNormal(stddev=1e-5), + tf_keras.initializers.RandomNormal(stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) diff --git a/official/projects/qat/vision/modeling/heads/dense_prediction_heads_test.py b/official/projects/qat/vision/modeling/heads/dense_prediction_heads_test.py index 051653e472c..2330483cf19 100644 --- a/official/projects/qat/vision/modeling/heads/dense_prediction_heads_test.py +++ b/official/projects/qat/vision/modeling/heads/dense_prediction_heads_test.py @@ -18,7 +18,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.vision.modeling.heads import dense_prediction_heads diff --git a/official/projects/qat/vision/modeling/layers/nn_blocks.py b/official/projects/qat/vision/modeling/layers/nn_blocks.py index 93359d3f83c..4eec909fedd 100644 --- a/official/projects/qat/vision/modeling/layers/nn_blocks.py +++ b/official/projects/qat/vision/modeling/layers/nn_blocks.py @@ -18,7 +18,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -30,8 +30,8 @@ # This class is copied from modeling.layers.nn_blocks.BottleneckBlock and apply # QAT. -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckBlockQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckBlockQuantized(tf_keras.layers.Layer): """A quantized standard bottleneck block.""" def __init__(self, @@ -43,8 +43,8 @@ def __init__(self, resnetd_shortcut: bool = False, stochastic_depth_drop_rate: Optional[float] = None, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: tf.keras.regularizers.Regularizer = None, - bias_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, + bias_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -70,9 +70,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -100,12 +100,12 @@ def __init__(self, self._bias_regularizer = bias_regularizer norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if use_sync_bn else tf_keras.layers.BatchNormalization) self._norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) self._norm = helper.BatchNormalizationNoQuantized(norm_layer) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -115,7 +115,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): """Build variables and child layers to prepare for calling.""" if self._use_projection: if self._resnetd_shortcut: - self._shortcut0 = tf.keras.layers.AveragePooling2D( + self._shortcut0 = tf_keras.layers.AveragePooling2D( pool_size=2, strides=self._strides, padding='same') self._shortcut1 = helper.Conv2DQuantized( filters=self._filters * 4, @@ -216,7 +216,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): else: self._stochastic_depth = None self._add = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Add(), + tf_keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) super(BottleneckBlockQuantized, self).build(input_shape) @@ -280,8 +280,8 @@ def call( # This class is copied from modeling.backbones.mobilenet.Conv2DBNBlock and apply # QAT. -@tf.keras.utils.register_keras_serializable(package='Vision') -class Conv2DBNBlockQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Conv2DBNBlockQuantized(tf_keras.layers.Layer): """A quantized convolution block with batch normalization.""" def __init__( @@ -293,8 +293,8 @@ def __init__( use_explicit_padding: bool = False, activation: str = 'relu6', kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_normalization: bool = True, use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -316,9 +316,9 @@ def __init__( activation: A `str` name of the activation function. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. use_normalization: If True, use batch normalization. use_sync_bn: If True, use synchronized batch normalization. @@ -347,12 +347,12 @@ def __init__( self._padding = 'same' norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if use_sync_bn else tf_keras.layers.BatchNormalization) self._norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) self._norm = helper.BatchNormalizationNoQuantized(norm_layer) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -381,7 +381,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): """Build variables and child layers to prepare for calling.""" if self._use_explicit_padding and self._kernel_size > 1: padding_size = nn_layers.get_padding_for_kernel_size(self._kernel_size) - self._pad = tf.keras.layers.ZeroPadding2D(padding_size) + self._pad = tf_keras.layers.ZeroPadding2D(padding_size) conv2d_quantized = ( helper.Conv2DQuantized if self._use_normalization else helper.Conv2DOutputQuantized) @@ -421,8 +421,8 @@ def call( return self._activation_layer(x) -@tf.keras.utils.register_keras_serializable(package='Vision') -class InvertedBottleneckBlockQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class InvertedBottleneckBlockQuantized(tf_keras.layers.Layer): """A quantized inverted bottleneck block.""" def __init__(self, @@ -467,9 +467,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. se_inner_activation: A `str` name of squeeze-excitation inner activation. @@ -528,12 +528,12 @@ def __init__(self, self._output_intermediate_endpoints = output_intermediate_endpoints norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if use_sync_bn else tf_keras.layers.BatchNormalization) self._norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) self._norm = helper.BatchNormalizationNoQuantized(norm_layer) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -641,7 +641,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): else: self._stochastic_depth = None self._add = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Add(), + tf_keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) super(InvertedBottleneckBlockQuantized, self).build(input_shape) diff --git a/official/projects/qat/vision/modeling/layers/nn_blocks_test.py b/official/projects/qat/vision/modeling/layers/nn_blocks_test.py index 5ddc59dc0d4..abf2a309298 100644 --- a/official/projects/qat/vision/modeling/layers/nn_blocks_test.py +++ b/official/projects/qat/vision/modeling/layers/nn_blocks_test.py @@ -17,7 +17,7 @@ from typing import Any, Iterable, Tuple # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -45,7 +45,7 @@ def test_bottleneck_block_creation(self, block_fn, strides, use_projection, stochastic_depth_drop_rate, se_ratio): input_size = 128 filter_size = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, filter_size * 4), batch_size=1) block = block_fn( filter_size, @@ -73,7 +73,7 @@ def test_invertedbottleneck_block_creation( input_size = 128 in_filters = 24 out_filters = 40 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, in_filters), batch_size=1) block = block_fn( in_filters=in_filters, diff --git a/official/projects/qat/vision/modeling/layers/nn_layers.py b/official/projects/qat/vision/modeling/layers/nn_layers.py index a15a244b043..5b0e65221f4 100644 --- a/official/projects/qat/vision/modeling/layers/nn_layers.py +++ b/official/projects/qat/vision/modeling/layers/nn_layers.py @@ -17,7 +17,7 @@ import enum from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -41,10 +41,10 @@ class FeatureFusion(str, enum.Enum): DEEPLABV3PLUS_SUM_TO_MERGE = 'deeplabv3plus_sum_to_merge' -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class SqueezeExcitationQuantized( helper.LayerQuantizerHelper, - tf.keras.layers.Layer): + tf_keras.layers.Layer): """Creates a squeeze and excitation layer.""" def __init__(self, @@ -72,9 +72,9 @@ def __init__(self, use_3d_input: A `bool` of whether input is 2D or 3D image. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. gating_activation: A `str` name of the activation function for final @@ -96,7 +96,7 @@ def __init__(self, self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': if not use_3d_input: self._spatial_axis = [1, 2] else: @@ -166,7 +166,7 @@ def build(self, input_shape): activation=helper.NoOpActivation()) self._multiply = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Multiply(), + tf_keras.layers.Multiply(), configs.Default8BitQuantizeConfig([], [], True)) self._reduce_mean_quantizer = ( tfmot.quantization.keras.quantizers.MovingAverageQuantizer( @@ -209,8 +209,8 @@ def call(self, inputs, training=None): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class SegmentationHeadQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SegmentationHeadQuantized(tf_keras.layers.Layer): """Creates a segmentation head.""" def __init__( @@ -233,8 +233,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a segmentation head. @@ -277,9 +277,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super().__init__(**kwargs) @@ -305,7 +305,7 @@ def __init__( 'kernel_regularizer': kernel_regularizer, 'bias_regularizer': bias_regularizer, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -323,7 +323,7 @@ def build(self, input_shape: Sequence[tf.TensorShape]): # fusion type is `deeplabv3plus`. backbone_shape = input_shape[0] use_depthwise_convolution = self._config_dict['use_depthwise_convolution'] - random_initializer = tf.keras.initializers.RandomNormal(stddev=0.01) + random_initializer = tf_keras.initializers.RandomNormal(stddev=0.01) conv_kwargs = { 'kernel_size': 3 if not use_depthwise_convolution else 1, 'padding': 'same', @@ -333,9 +333,9 @@ def build(self, input_shape: Sequence[tf.TensorShape]): } norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization + tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] else - tf.keras.layers.BatchNormalization) + tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) norm = helper.norm_by_activation(self._config_dict['activation'], @@ -412,7 +412,7 @@ def build(self, input_shape: Sequence[tf.TensorShape]): self._concat_layer = helper.ConcatenateQuantized(axis=self._bn_axis) self._add_layer = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) + tf_keras.layers.Add(), configs.Default8BitQuantizeConfig([], [], True)) super().build(input_shape) @@ -483,7 +483,7 @@ def from_config(cls, config): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class SpatialPyramidPoolingQuantized(nn_layers.SpatialPyramidPooling): """Implements the quantized Atrous Spatial Pyramid Pooling. @@ -505,7 +505,7 @@ def __init__( activation: str = 'relu', dropout: float = 0.5, kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', use_depthwise_convolution: bool = False, **kwargs): @@ -561,8 +561,8 @@ def build(self, input_shape): channels = input_shape[3] norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization - if self._use_sync_bn else tf.keras.layers.BatchNormalization) + tf_keras.layers.experimental.SyncBatchNormalization + if self._use_sync_bn else tf_keras.layers.BatchNormalization) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) norm = helper.norm_by_activation(self._activation, norm_with_quantize, @@ -659,14 +659,14 @@ def build(self, input_shape): momentum=self._batchnorm_momentum, epsilon=self._batchnorm_epsilon) ] - self._dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) + self._dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) self._concat_layer = helper.ConcatenateQuantized(axis=-1) def call(self, inputs: tf.Tensor, training: Optional[bool] = None) -> tf.Tensor: if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() result = [] for i, layers in enumerate(self.aspp_layers): x = inputs @@ -687,7 +687,7 @@ def call(self, return self._dropout_layer(x) -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class ASPPQuantized(aspp.ASPP): """Creates a quantized Atrous Spatial Pyramid Pooling (ASPP) layer.""" @@ -703,7 +703,7 @@ def __init__( activation: str = 'relu', dropout_rate: float = 0.0, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', use_depthwise_convolution: bool = False, spp_layer_version: str = 'v1', @@ -725,7 +725,7 @@ def __init__( dropout_rate: A `float` rate for dropout regularization. kernel_initializer: A `str` name of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. interpolation: A `str` of interpolation method. It should be one of `bilinear`, `nearest`, `bicubic`, `area`, `lanczos3`, `lanczos5`, @@ -784,7 +784,7 @@ def call(self, inputs: Union[tf.Tensor, Mapping[str, return self.aspp(backbone_output) -class BatchNormalizationWrapper(tf.keras.layers.Wrapper): +class BatchNormalizationWrapper(tf_keras.layers.Wrapper): """A BatchNormalizationWrapper that explicitly not folded. It just added an identity depthwise conv right before the normalization. @@ -828,7 +828,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): 'padding': 'same', } conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal' ), 'bias_initializer': tf.zeros_initializer(), @@ -836,9 +836,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): 'bias_regularizer': self._config_dict['bias_regularizer'], }) norm_layer = ( - tf.keras.layers.experimental.SyncBatchNormalization + tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization + else tf_keras.layers.BatchNormalization ) norm_with_quantize = helper.BatchNormalizationQuantized(norm_layer) norm_no_quantize = helper.BatchNormalizationNoQuantized(norm_layer) @@ -861,7 +861,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): kernel_size=3, padding='same', use_bias=False, - depthwise_initializer=tf.keras.initializers.RandomNormal( + depthwise_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), depthwise_regularizer=self._config_dict['kernel_regularizer'], depth_multiplier=1, @@ -890,7 +890,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): self._fcs.append( helper.DenseQuantized( units=self._config_dict['fc_dims'], - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=1 / 3.0, mode='fan_out', distribution='uniform' ), kernel_regularizer=self._config_dict['kernel_regularizer'], @@ -904,7 +904,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): self._classifier = helper.DenseOutputQuantized( units=self._config_dict['num_classes'], - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], diff --git a/official/projects/qat/vision/modeling/layers/nn_layers_test.py b/official/projects/qat/vision/modeling/layers/nn_layers_test.py index fbd18f6c409..492f818c45d 100644 --- a/official/projects/qat/vision/modeling/layers/nn_layers_test.py +++ b/official/projects/qat/vision/modeling/layers/nn_layers_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.vision.modeling.layers import nn_layers @@ -61,7 +61,7 @@ def test_segmentation_head_creation(self, feature_fusion, upsample_factor, ) def test_spatial_pyramid_pooling_creation(self, pool_kernel_size, dilation_rates): - inputs = tf.keras.Input(shape=(64, 64, 128), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64, 128), dtype=tf.float32) layer = nn_layers.SpatialPyramidPoolingQuantized( output_channels=256, dilation_rates=dilation_rates, @@ -79,7 +79,7 @@ def test_spatial_pyramid_pooling_creation(self, pool_kernel_size, ) def test_aspp_creation(self, level, dilation_rates, num_filters): input_size = 128 // 2**level - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') endpoints = tf.random.uniform( shape=(2, input_size, input_size, 64), dtype=tf.float32) @@ -93,11 +93,11 @@ def test_aspp_creation(self, level, dilation_rates, num_filters): @parameterized.parameters(False, True) def test_bnorm_wrapper_creation(self, use_sync_bn): - inputs = tf.keras.Input(shape=(64, 64, 128), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64, 128), dtype=tf.float32) if use_sync_bn: - norm = tf.keras.layers.experimental.SyncBatchNormalization(axis=-1) + norm = tf_keras.layers.experimental.SyncBatchNormalization(axis=-1) else: - norm = tf.keras.layers.BatchNormalization(axis=-1) + norm = tf_keras.layers.BatchNormalization(axis=-1) layer = nn_layers.BatchNormalizationWrapper(norm) output = layer(inputs) self.assertAllEqual([None, 64, 64, 128], output.shape) @@ -113,7 +113,7 @@ def test_bnorm_wrapper_creation(self, use_sync_bn): def test_mask_scoring_creation( self, num_convs, num_fcs, num_filters, fc_input_size ): - inputs = tf.keras.Input(shape=(64, 64, 16), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64, 16), dtype=tf.float32) head = nn_layers.MaskScoringQuantized( num_classes=2, diff --git a/official/projects/qat/vision/modeling/segmentation_model.py b/official/projects/qat/vision/modeling/segmentation_model.py index 91b4be175df..b27512ba118 100644 --- a/official/projects/qat/vision/modeling/segmentation_model.py +++ b/official/projects/qat/vision/modeling/segmentation_model.py @@ -16,13 +16,13 @@ from typing import Any, Mapping, Union # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class SegmentationModelQuantized(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SegmentationModelQuantized(tf_keras.Model): """A Segmentation class model. Input images are passed through backbone first. Decoder network is then @@ -34,9 +34,9 @@ class SegmentationModelQuantized(tf.keras.Model): different backbones, and decoders. """ - def __init__(self, backbone: tf.keras.Model, decoder: tf.keras.layers.Layer, - head: tf.keras.layers.Layer, - input_specs: tf.keras.layers.InputSpec, **kwargs): + def __init__(self, backbone: tf_keras.Model, decoder: tf_keras.layers.Layer, + head: tf_keras.layers.Layer, + input_specs: tf_keras.layers.InputSpec, **kwargs): """Segmentation initialization function. Args: @@ -46,7 +46,7 @@ def __init__(self, backbone: tf.keras.Model, decoder: tf.keras.layers.Layer, input_specs: The shape specifications of input tensor. **kwargs: keyword arguments to be passed. """ - inputs = tf.keras.Input(shape=input_specs.shape[1:], name=input_specs.name) + inputs = tf_keras.Input(shape=input_specs.shape[1:], name=input_specs.name) backbone_features = backbone(inputs) if decoder: @@ -69,7 +69,7 @@ def __init__(self, backbone: tf.keras.Model, decoder: tf.keras.layers.Layer, @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.decoder is not None: diff --git a/official/projects/qat/vision/n_bit/configs.py b/official/projects/qat/vision/n_bit/configs.py index 061d0a3f39b..ecadc9bfef3 100644 --- a/official/projects/qat/vision/n_bit/configs.py +++ b/official/projects/qat/vision/n_bit/configs.py @@ -15,12 +15,12 @@ """Default 8-bit QuantizeConfigs.""" from typing import Sequence, Callable, Tuple, Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot Quantizer = tfmot.quantization.keras.quantizers.Quantizer -Layer = tf.keras.layers.Layer +Layer = tf_keras.layers.Layer Activation = Callable[[tf.Tensor], tf.Tensor] WeightAndQuantizer = Tuple[tf.Variable, Quantizer] ActivationAndQuantizer = Tuple[Activation, Quantizer] @@ -242,12 +242,12 @@ def build(self, min_weight = layer.add_weight( name + '_min', shape=(tensor_shape[-1],), - initializer=tf.keras.initializers.Constant(-6.0), + initializer=tf_keras.initializers.Constant(-6.0), trainable=False) max_weight = layer.add_weight( name + '_max', shape=(tensor_shape[-1],), - initializer=tf.keras.initializers.Constant(6.0), + initializer=tf_keras.initializers.Constant(6.0), trainable=False) return {'min_var': min_weight, 'max_var': max_weight} @@ -302,7 +302,7 @@ def __init__(self, num_bits_weight: int = 8, num_bits_activation: int = 8): self._num_bits_activation = num_bits_activation def _assert_activation_layer(self, layer: Layer): - if not isinstance(layer, tf.keras.layers.Activation): + if not isinstance(layer, tf_keras.layers.Activation): raise RuntimeError( 'DefaultNBitActivationQuantizeConfig can only be used with ' '`keras.layers.Activation`.') diff --git a/official/projects/qat/vision/n_bit/configs_test.py b/official/projects/qat/vision/n_bit/configs_test.py index 1c05597bea7..832774fc434 100644 --- a/official/projects/qat/vision/n_bit/configs_test.py +++ b/official/projects/qat/vision/n_bit/configs_test.py @@ -17,7 +17,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot @@ -69,7 +69,7 @@ def _assert_kernel_equality(self, a, b): class DefaultNBitQuantizeConfigTest(tf.test.TestCase, _TestHelper): def _simple_dense_layer(self): - layer = tf.keras.layers.Dense(2) + layer = tf_keras.layers.Dense(2) layer.build(input_shape=(3,)) return layer @@ -101,7 +101,7 @@ def testGetsQuantizeActivationsAndQuantizers(self): def testSetsQuantizeWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) num_bits_weight = 4 num_bits_activation = 4 @@ -114,7 +114,7 @@ def testSetsQuantizeWeights(self): def testSetsQuantizeActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu num_bits_weight = 4 num_bits_activation = 4 @@ -126,7 +126,7 @@ def testSetsQuantizeActivations(self): def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) num_bits_weight = 4 num_bits_activation = 4 @@ -143,7 +143,7 @@ def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable(np.ones([1, 2])) + quantize_kernel = tf_keras.backend.variable(np.ones([1, 2])) num_bits_weight = 4 num_bits_activation = 4 @@ -155,7 +155,7 @@ def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): def testSetsQuantizeActivations_ErrorOnWrongNumberOfActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu num_bits_weight = 4 num_bits_activation = 4 diff --git a/official/projects/qat/vision/n_bit/nn_blocks.py b/official/projects/qat/vision/n_bit/nn_blocks.py index e2d29aa129d..6f195626488 100644 --- a/official/projects/qat/vision/n_bit/nn_blocks.py +++ b/official/projects/qat/vision/n_bit/nn_blocks.py @@ -18,7 +18,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -62,8 +62,8 @@ def constructor(*arg, **kwargs): # This class is copied from modeling.layers.nn_blocks.BottleneckBlock and apply # QAT. -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckBlockNBitQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckBlockNBitQuantized(tf_keras.layers.Layer): """A quantized standard bottleneck block.""" def __init__(self, @@ -75,8 +75,8 @@ def __init__(self, resnetd_shortcut: bool = False, stochastic_depth_drop_rate: Optional[float] = None, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: tf.keras.regularizers.Regularizer = None, - bias_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, + bias_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -104,9 +104,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -138,23 +138,23 @@ def __init__(self, self._num_bits_activation = num_bits_activation if use_sync_bn: self._norm = _quantize_wrapped_layer( - tf.keras.layers.experimental.SyncBatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization, configs.NoOpQuantizeConfig()) self._norm_with_quantize = _quantize_wrapped_layer( - tf.keras.layers.experimental.SyncBatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization, configs.DefaultNBitOutputQuantizeConfig( num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) else: self._norm = _quantize_wrapped_layer( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, configs.NoOpQuantizeConfig()) self._norm_with_quantize = _quantize_wrapped_layer( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, configs.DefaultNBitOutputQuantizeConfig( num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -163,14 +163,14 @@ def __init__(self, def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): """Build variables and child layers to prepare for calling.""" conv2d_quantized = _quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.DefaultNBitConvQuantizeConfig( ['kernel'], ['activation'], False, num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) if self._use_projection: if self._resnetd_shortcut: - self._shortcut0 = tf.keras.layers.AveragePooling2D( + self._shortcut0 = tf_keras.layers.AveragePooling2D( pool_size=2, strides=self._strides, padding='same') self._shortcut1 = conv2d_quantized( filters=self._filters * 4, @@ -279,7 +279,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): else: self._stochastic_depth = None self._add = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Add(), + tf_keras.layers.Add(), configs.DefaultNBitQuantizeConfig( [], [], True, num_bits_weight=self._num_bits_weight, @@ -348,8 +348,8 @@ def call( # This class is copied from modeling.backbones.mobilenet.Conv2DBNBlock and apply # QAT. -@tf.keras.utils.register_keras_serializable(package='Vision') -class Conv2DBNBlockNBitQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Conv2DBNBlockNBitQuantized(tf_keras.layers.Layer): """A quantized convolution block with batch normalization.""" def __init__( @@ -360,8 +360,8 @@ def __init__( use_bias: bool = False, activation: str = 'relu6', kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_normalization: bool = True, use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -382,9 +382,9 @@ def __init__( activation: A `str` name of the activation function. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. use_normalization: If True, use batch normalization. use_sync_bn: If True, use synchronized batch normalization. @@ -412,13 +412,13 @@ def __init__( if use_sync_bn: self._norm = _quantize_wrapped_layer( - tf.keras.layers.experimental.SyncBatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization, configs.NoOpQuantizeConfig()) else: self._norm = _quantize_wrapped_layer( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, configs.NoOpQuantizeConfig()) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -447,7 +447,7 @@ def get_config(self) -> Dict[str, Any]: def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): """Build variables and child layers to prepare for calling.""" conv2d_quantized = _quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.DefaultNBitConvQuantizeConfig( ['kernel'], ['activation'], False, num_bits_weight=self._num_bits_weight, @@ -486,8 +486,8 @@ def call( return self._activation_layer(x) -@tf.keras.utils.register_keras_serializable(package='Vision') -class InvertedBottleneckBlockNBitQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class InvertedBottleneckBlockNBitQuantized(tf_keras.layers.Layer): """A quantized inverted bottleneck block.""" def __init__(self, @@ -532,9 +532,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. se_inner_activation: A `str` name of squeeze-excitation inner activation. @@ -592,23 +592,23 @@ def __init__(self, if use_sync_bn: self._norm = _quantize_wrapped_layer( - tf.keras.layers.experimental.SyncBatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization, configs.NoOpQuantizeConfig()) self._norm_with_quantize = _quantize_wrapped_layer( - tf.keras.layers.experimental.SyncBatchNormalization, + tf_keras.layers.experimental.SyncBatchNormalization, configs.DefaultNBitOutputQuantizeConfig( num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) else: self._norm = _quantize_wrapped_layer( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, configs.NoOpQuantizeConfig()) self._norm_with_quantize = _quantize_wrapped_layer( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, configs.DefaultNBitOutputQuantizeConfig( num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -622,13 +622,13 @@ def __init__(self, def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): """Build variables and child layers to prepare for calling.""" conv2d_quantized = _quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.DefaultNBitConvQuantizeConfig( ['kernel'], ['activation'], False, num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) depthwise_conv2d_quantized = _quantize_wrapped_layer( - tf.keras.layers.DepthwiseConv2D, + tf_keras.layers.DepthwiseConv2D, configs.DefaultNBitConvQuantizeConfig( ['depthwise_kernel'], ['activation'], False, num_bits_weight=self._num_bits_weight, @@ -729,7 +729,7 @@ def build(self, input_shape: Optional[Union[Sequence[int], tf.Tensor]]): self._stochastic_depth_drop_rate) else: self._stochastic_depth = None - self._add = tf.keras.layers.Add() + self._add = tf_keras.layers.Add() super().build(input_shape) diff --git a/official/projects/qat/vision/n_bit/nn_blocks_test.py b/official/projects/qat/vision/n_bit/nn_blocks_test.py index 37e8b5dc26e..906e250651f 100644 --- a/official/projects/qat/vision/n_bit/nn_blocks_test.py +++ b/official/projects/qat/vision/n_bit/nn_blocks_test.py @@ -17,7 +17,7 @@ from typing import Any, Iterable, Tuple # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -46,7 +46,7 @@ def test_bottleneck_block_creation(self, block_fn, strides, use_projection, num_bits_weight, num_bits_activation): input_size = 128 filter_size = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, filter_size * 4), batch_size=1) block = block_fn( filter_size, @@ -76,7 +76,7 @@ def test_invertedbottleneck_block_creation( input_size = 128 in_filters = 24 out_filters = 40 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, in_filters), batch_size=1) block = block_fn( in_filters=in_filters, diff --git a/official/projects/qat/vision/n_bit/nn_layers.py b/official/projects/qat/vision/n_bit/nn_layers.py index befd7da2501..2b77070cd60 100644 --- a/official/projects/qat/vision/n_bit/nn_layers.py +++ b/official/projects/qat/vision/n_bit/nn_layers.py @@ -16,7 +16,7 @@ from typing import Any, Callable, Dict, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils @@ -58,8 +58,8 @@ def constructor(*arg, **kwargs): return constructor -@tf.keras.utils.register_keras_serializable(package='Vision') -class SqueezeExcitationNBitQuantized(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SqueezeExcitationNBitQuantized(tf_keras.layers.Layer): """Creates a squeeze and excitation layer.""" def __init__(self, @@ -88,9 +88,9 @@ def __init__(self, use_3d_input: A `bool` of whether input is 2D or 3D image. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. gating_activation: A `str` name of the activation function for final @@ -113,7 +113,7 @@ def __init__(self, self._bias_regularizer = bias_regularizer self._num_bits_weight = num_bits_weight self._num_bits_activation = num_bits_activation - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': if not use_3d_input: self._spatial_axis = [1, 2] else: @@ -136,13 +136,13 @@ def __init__(self, def build(self, input_shape): conv2d_quantized = _quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.DefaultNBitConvQuantizeConfig( ['kernel'], ['activation'], False, num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) conv2d_quantized_output_quantized = _quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.DefaultNBitConvQuantizeConfig( ['kernel'], ['activation'], True, num_bits_weight=self._num_bits_weight, @@ -174,7 +174,7 @@ def build(self, input_shape): activation=NoOpActivation()) self._multiply = tfmot.quantization.keras.QuantizeWrapperV2( - tf.keras.layers.Multiply(), + tf_keras.layers.Multiply(), configs.DefaultNBitQuantizeConfig( [], [], True, num_bits_weight=self._num_bits_weight, num_bits_activation=self._num_bits_activation)) diff --git a/official/projects/qat/vision/n_bit/schemes.py b/official/projects/qat/vision/n_bit/schemes.py index 0ad0643f533..93596d4fb05 100644 --- a/official/projects/qat/vision/n_bit/schemes.py +++ b/official/projects/qat/vision/n_bit/schemes.py @@ -17,7 +17,7 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.vision.n_bit import configs diff --git a/official/projects/qat/vision/quantization/configs.py b/official/projects/qat/vision/quantization/configs.py index b017f93dff8..6b65992fb45 100644 --- a/official/projects/qat/vision/quantization/configs.py +++ b/official/projects/qat/vision/quantization/configs.py @@ -15,12 +15,12 @@ """Default 8-bit QuantizeConfigs.""" from typing import Sequence, Callable, Tuple, Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot Quantizer = tfmot.quantization.keras.quantizers.Quantizer -Layer = tf.keras.layers.Layer +Layer = tf_keras.layers.Layer Activation = Callable[[tf.Tensor], tf.Tensor] WeightAndQuantizer = Tuple[tf.Variable, Quantizer] ActivationAndQuantizer = Tuple[Activation, Quantizer] @@ -215,12 +215,12 @@ def build(self, min_weight = layer.add_weight( name + '_min', shape=(tensor_shape[-1],), - initializer=tf.keras.initializers.Constant(-6.0), + initializer=tf_keras.initializers.Constant(-6.0), trainable=False) max_weight = layer.add_weight( name + '_max', shape=(tensor_shape[-1],), - initializer=tf.keras.initializers.Constant(6.0), + initializer=tf_keras.initializers.Constant(6.0), trainable=False) return {'min_var': min_weight, 'max_var': max_weight} @@ -261,7 +261,7 @@ class Default8BitActivationQuantizeConfig( """ def _assert_activation_layer(self, layer: Layer): - if not isinstance(layer, tf.keras.layers.Activation): + if not isinstance(layer, tf_keras.layers.Activation): raise RuntimeError( 'Default8BitActivationQuantizeConfig can only be used with ' '`keras.layers.Activation`.') diff --git a/official/projects/qat/vision/quantization/configs_test.py b/official/projects/qat/vision/quantization/configs_test.py index ea1ac1c6b16..e835e99692c 100644 --- a/official/projects/qat/vision/quantization/configs_test.py +++ b/official/projects/qat/vision/quantization/configs_test.py @@ -17,7 +17,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot @@ -69,7 +69,7 @@ def _assert_kernel_equality(self, a, b): class Default8BitQuantizeConfigTest(tf.test.TestCase, _TestHelper): def _simple_dense_layer(self): - layer = tf.keras.layers.Dense(2) + layer = tf_keras.layers.Dense(2) layer.build(input_shape=(3,)) return layer @@ -97,7 +97,7 @@ def testGetsQuantizeActivationsAndQuantizers(self): def testSetsQuantizeWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) quantize_config = configs.Default8BitQuantizeConfig( @@ -108,7 +108,7 @@ def testSetsQuantizeWeights(self): def testSetsQuantizeActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) @@ -118,7 +118,7 @@ def testSetsQuantizeActivations(self): def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable( + quantize_kernel = tf_keras.backend.variable( np.ones(layer.kernel.shape.as_list())) quantize_config = configs.Default8BitQuantizeConfig( @@ -133,7 +133,7 @@ def testSetsQuantizeWeights_ErrorOnWrongNumberOfWeights(self): def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): layer = self._simple_dense_layer() - quantize_kernel = tf.keras.backend.variable(np.ones([1, 2])) + quantize_kernel = tf_keras.backend.variable(np.ones([1, 2])) quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) @@ -143,7 +143,7 @@ def testSetsQuantizeWeights_ErrorOnWrongShapeOfWeight(self): def testSetsQuantizeActivations_ErrorOnWrongNumberOfActivations(self): layer = self._simple_dense_layer() - quantize_activation = tf.keras.activations.relu + quantize_activation = tf_keras.activations.relu quantize_config = configs.Default8BitQuantizeConfig( ['kernel'], ['activation'], False) diff --git a/official/projects/qat/vision/quantization/helper.py b/official/projects/qat/vision/quantization/helper.py index 457df2641a9..a61e1bd9db2 100644 --- a/official/projects/qat/vision/quantization/helper.py +++ b/official/projects/qat/vision/quantization/helper.py @@ -19,7 +19,7 @@ import copy from typing import Any, Dict, List, Optional, Type, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.vision.quantization import configs @@ -74,8 +74,8 @@ def is_quantization_weight_name(name: str) -> bool: raise ValueError('Variable name {} is not supported.'.format(simple_name)) -def copy_original_weights(original_model: tf.keras.Model, - quantized_model: tf.keras.Model): +def copy_original_weights(original_model: tf_keras.Model, + quantized_model: tf_keras.Model): """Helper function that copy the original model weights to quantized model.""" original_weight_value = original_model.get_weights() weight_values = quantized_model.get_weights() @@ -167,7 +167,7 @@ def norm_by_activation(activation, norm_quantized, norm_no_quantized): return norm_no_quantized -class SeparableConv2DQuantized(tf.keras.layers.Layer): +class SeparableConv2DQuantized(tf_keras.layers.Layer): """Quantized SeperableConv2D.""" def __init__( @@ -192,11 +192,11 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the child layers of the layer.""" depthwise_conv2d_quantized = quantize_wrapped_layer( - tf.keras.layers.DepthwiseConv2D, + tf_keras.layers.DepthwiseConv2D, configs.Default8BitConvQuantizeConfig(['depthwise_kernel'], [], True), ) conv2d_quantized = quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.Default8BitConvQuantizeConfig( ['kernel'], [], self._last_quantize ), @@ -246,45 +246,45 @@ def from_config( Conv2DQuantized = quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.Default8BitConvQuantizeConfig(['kernel'], ['activation'], False)) Conv2DOutputQuantized = quantize_wrapped_layer( - tf.keras.layers.Conv2D, + tf_keras.layers.Conv2D, configs.Default8BitConvQuantizeConfig(['kernel'], ['activation'], True)) DepthwiseConv2DQuantized = quantize_wrapped_layer( - tf.keras.layers.DepthwiseConv2D, + tf_keras.layers.DepthwiseConv2D, configs.Default8BitConvQuantizeConfig(['depthwise_kernel'], ['activation'], False)) DepthwiseConv2DOutputQuantized = quantize_wrapped_layer( - tf.keras.layers.DepthwiseConv2D, + tf_keras.layers.DepthwiseConv2D, configs.Default8BitConvQuantizeConfig(['depthwise_kernel'], ['activation'], True)) GlobalAveragePooling2DQuantized = quantize_wrapped_layer( - tf.keras.layers.GlobalAveragePooling2D, + tf_keras.layers.GlobalAveragePooling2D, configs.Default8BitQuantizeConfig([], [], True)) AveragePooling2DQuantized = quantize_wrapped_layer( - tf.keras.layers.AveragePooling2D, + tf_keras.layers.AveragePooling2D, configs.Default8BitQuantizeConfig([], [], True)) ResizingQuantized = quantize_wrapped_layer( - tf.keras.layers.Resizing, configs.Default8BitQuantizeConfig([], [], True)) + tf_keras.layers.Resizing, configs.Default8BitQuantizeConfig([], [], True)) ConcatenateQuantized = quantize_wrapped_layer( - tf.keras.layers.Concatenate, configs.Default8BitQuantizeConfig([], [], + tf_keras.layers.Concatenate, configs.Default8BitQuantizeConfig([], [], True)) UpSampling2DQuantized = quantize_wrapped_layer( - tf.keras.layers.UpSampling2D, configs.Default8BitQuantizeConfig([], [], + tf_keras.layers.UpSampling2D, configs.Default8BitQuantizeConfig([], [], True)) ReshapeQuantized = quantize_wrapped_layer( - tf.keras.layers.Reshape, configs.Default8BitQuantizeConfig([], [], True)) + tf_keras.layers.Reshape, configs.Default8BitQuantizeConfig([], [], True)) DenseQuantized = quantize_wrapped_layer( - tf.keras.layers.Dense, + tf_keras.layers.Dense, configs.Default8BitQuantizeConfig(['kernel'], ['activation'], False), ) DenseOutputQuantized = quantize_wrapped_layer( - tf.keras.layers.Dense, + tf_keras.layers.Dense, configs.Default8BitQuantizeConfig(['kernel'], ['activation'], True), ) IdentityQuantized = quantize_wrapped_layer( - tf.keras.layers.Identity, configs.Default8BitQuantizeConfig([], [], True) + tf_keras.layers.Identity, configs.Default8BitQuantizeConfig([], [], True) ) # pylint:disable=g-long-lambda diff --git a/official/projects/qat/vision/quantization/helper_test.py b/official/projects/qat/vision/quantization/helper_test.py index 2538e0a100b..ac401b92e5a 100644 --- a/official/projects/qat/vision/quantization/helper_test.py +++ b/official/projects/qat/vision/quantization/helper_test.py @@ -14,7 +14,7 @@ """Tests for helper.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.projects.qat.vision.quantization import helper @@ -23,8 +23,8 @@ class HelperTest(tf.test.TestCase): def create_simple_model(self): - return tf.keras.models.Sequential([ - tf.keras.layers.Dense(8, input_shape=(16,)), + return tf_keras.models.Sequential([ + tf_keras.layers.Dense(8, input_shape=(16,)), ]) def test_copy_original_weights_for_simple_model_with_custom_weights(self): diff --git a/official/projects/qat/vision/quantization/layer_transforms.py b/official/projects/qat/vision/quantization/layer_transforms.py index 20bca63db27..bb1543b0032 100644 --- a/official/projects/qat/vision/quantization/layer_transforms.py +++ b/official/projects/qat/vision/quantization/layer_transforms.py @@ -15,7 +15,7 @@ """Contains custom quantization layer transforms.""" from typing import Any, Type, Mapping, List, Union, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_model_optimization as tfmot from official.modeling import tf_utils from official.projects.qat.vision.modeling.layers import nn_blocks as quantized_nn_blocks @@ -59,7 +59,7 @@ def _create_layer_metadata( return layer_metadata def _create_dummy_input_shape( - self, quantized_layer: tf.keras.layers.Layer + self, quantized_layer: tf_keras.layers.Layer ) -> Union[List[int], Tuple[Any, Any]]: dummy_input_shape = [1, 128, 128, 1] # SegmentationHead layer requires a tuple of 2 tensors. diff --git a/official/projects/qat/vision/serving/export_module.py b/official/projects/qat/vision/serving/export_module.py index 8ea9f87cc4e..6e56bf13641 100644 --- a/official/projects/qat/vision/serving/export_module.py +++ b/official/projects/qat/vision/serving/export_module.py @@ -13,7 +13,7 @@ # limitations under the License. """Export modules for QAT model serving/inference.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.qat.vision.modeling import factory as qat_factory from official.vision import configs @@ -27,7 +27,7 @@ class ClassificationModule(image_classification.ClassificationModule): def _build_model(self): model = super()._build_model() - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[self._batch_size] + self._input_image_size + [3]) return qat_factory.build_qat_classification_model( model, self.params.task.quantization, input_specs, @@ -39,7 +39,7 @@ class SegmentationModule(semantic_segmentation.SegmentationModule): def _build_model(self): model = super()._build_model() - input_specs = tf.keras.layers.InputSpec(shape=[self._batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[self._batch_size] + self._input_image_size + [3]) return qat_factory.build_qat_segmentation_model( model, self.params.task.quantization, input_specs) diff --git a/official/projects/qat/vision/tasks/image_classification.py b/official/projects/qat/vision/tasks/image_classification.py index 029e0bf851d..d3cc79b4a75 100644 --- a/official/projects/qat/vision/tasks/image_classification.py +++ b/official/projects/qat/vision/tasks/image_classification.py @@ -13,7 +13,7 @@ # limitations under the License. """Image classification task definition.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.qat.vision.configs import image_classification as exp_cfg @@ -25,9 +25,9 @@ class ImageClassificationTask(image_classification.ImageClassificationTask): """A task for image classification with QAT.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds classification model with QAT.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size ) @@ -36,7 +36,7 @@ def build_model(self) -> tf.keras.Model: # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / 2.0) + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None ) diff --git a/official/projects/qat/vision/tasks/image_classification_test.py b/official/projects/qat/vision/tasks/image_classification_test.py index 04d812abad8..1a3c80a652a 100644 --- a/official/projects/qat/vision/tasks/image_classification_test.py +++ b/official/projects/qat/vision/tasks/image_classification_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import exp_factory diff --git a/official/projects/qat/vision/tasks/retinanet.py b/official/projects/qat/vision/tasks/retinanet.py index 88acf8915e3..9864b8c90b3 100644 --- a/official/projects/qat/vision/tasks/retinanet.py +++ b/official/projects/qat/vision/tasks/retinanet.py @@ -13,7 +13,7 @@ # limitations under the License. """RetinaNet task definition.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.qat.vision.configs import retinanet as exp_cfg @@ -25,7 +25,7 @@ class RetinaNetTask(retinanet.RetinaNetTask): """A task for RetinaNet object detection with QAT.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds RetinaNet model with QAT.""" model = super(RetinaNetTask, self).build_model() # Call the model with dummy input to build the head part. diff --git a/official/projects/qat/vision/tasks/retinanet_test.py b/official/projects/qat/vision/tasks/retinanet_test.py index 58a984aea99..19fd645bda6 100644 --- a/official/projects/qat/vision/tasks/retinanet_test.py +++ b/official/projects/qat/vision/tasks/retinanet_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import exp_factory diff --git a/official/projects/qat/vision/tasks/semantic_segmentation.py b/official/projects/qat/vision/tasks/semantic_segmentation.py index 8d278260f63..80f178e6c38 100644 --- a/official/projects/qat/vision/tasks/semantic_segmentation.py +++ b/official/projects/qat/vision/tasks/semantic_segmentation.py @@ -13,7 +13,7 @@ # limitations under the License. """Semantic segmentation task definition.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.qat.vision.configs import semantic_segmentation as exp_cfg @@ -25,10 +25,10 @@ class SemanticSegmentationTask(semantic_segmentation.SemanticSegmentationTask): """A task for semantic segmentation with QAT.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds semantic segmentation model with QAT.""" model = super().build_model() - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size ) diff --git a/official/projects/roformer/roformer.py b/official/projects/roformer/roformer.py index b4a7dfa8cf5..6ec3c44a9c8 100644 --- a/official/projects/roformer/roformer.py +++ b/official/projects/roformer/roformer.py @@ -13,7 +13,7 @@ # limitations under the License. """Roformer model configurations and instantiation methods.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -46,7 +46,7 @@ def get_encoder(encoder_cfg: RoformerEncoderConfig): attention_dropout_rate=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/projects/roformer/roformer_attention.py b/official/projects/roformer/roformer_attention.py index e66b74fc026..5cbd72cf2a6 100644 --- a/official/projects/roformer/roformer_attention.py +++ b/official/projects/roformer/roformer_attention.py @@ -14,15 +14,15 @@ """Roformer attention layer.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras -EinsumDense = tf.keras.layers.EinsumDense -MultiHeadAttention = tf.keras.layers.MultiHeadAttention +EinsumDense = tf_keras.layers.EinsumDense +MultiHeadAttention = tf_keras.layers.MultiHeadAttention def _build_trig_vector(length, key_dim): """Builds the trig vector.""" - tf_dtype = tf.keras.mixed_precision.global_policy().compute_dtype + tf_dtype = tf_keras.mixed_precision.global_policy().compute_dtype position_ids = tf.cast(tf.range(length), dtype=tf_dtype) position_ids = tf.expand_dims(position_ids, axis=0) steps = key_dim // 2 @@ -38,8 +38,8 @@ def _build_trig_vector(length, key_dim): return sin_vec, cos_vec -@tf.keras.utils.register_keras_serializable(package='Text') -class RoformerAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package='Text') +class RoformerAttention(tf_keras.layers.MultiHeadAttention): """Roformer Attention.""" def __init__(self, diff --git a/official/projects/roformer/roformer_attention_test.py b/official/projects/roformer/roformer_attention_test.py index 529fe59de8d..623b08e4baa 100644 --- a/official/projects/roformer/roformer_attention_test.py +++ b/official/projects/roformer/roformer_attention_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.projects.roformer import roformer_attention diff --git a/official/projects/roformer/roformer_encoder.py b/official/projects/roformer/roformer_encoder.py index e43ad6b1d0f..61a1c32ac0e 100644 --- a/official/projects/roformer/roformer_encoder.py +++ b/official/projects/roformer/roformer_encoder.py @@ -17,15 +17,15 @@ import collections from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers from official.projects.roformer import roformer_encoder_block -@tf.keras.utils.register_keras_serializable(package='Text') -class RoformerEncoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class RoformerEncoder(tf_keras.Model): """Bi-directional Transformer-based encoder network with Roformer. Roformer paper: https://arxiv.org/abs/2104.09864 @@ -77,10 +77,10 @@ def __init__( max_sequence_length=512, type_vocab_size=16, inner_dim=3072, - inner_activation=lambda x: tf.keras.activations.gelu(x, approximate=True), + inner_activation=lambda x: tf_keras.activations.gelu(x, approximate=True), output_dropout=0.1, attention_dropout=0.1, - initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02), + initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02), output_range=None, embedding_width=None, embedding_layer=None, @@ -99,14 +99,14 @@ def __init__( attention_dropout = kwargs['attention_dropout_rate'] del kwargs['attention_dropout_rate'] - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) - word_ids = tf.keras.layers.Input( + word_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_word_ids') - mask = tf.keras.layers.Input( + mask = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_mask') - type_ids = tf.keras.layers.Input( + type_ids = tf_keras.layers.Input( shape=(None,), dtype=tf.int32, name='input_type_ids') if embedding_width is None: @@ -132,18 +132,18 @@ def __init__( type_embeddings = type_embedding_layer(type_ids) # Roformer does not have absolute position embedding - embeddings = tf.keras.layers.Add()([word_embeddings, type_embeddings]) + embeddings = tf_keras.layers.Add()([word_embeddings, type_embeddings]) - embedding_norm_layer = tf.keras.layers.LayerNormalization( + embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) embeddings = embedding_norm_layer(embeddings) - embeddings = (tf.keras.layers.Dropout(rate=output_dropout)(embeddings)) + embeddings = (tf_keras.layers.Dropout(rate=output_dropout)(embeddings)) # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. if embedding_width != hidden_size: - embedding_projection = tf.keras.layers.EinsumDense( + embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -183,7 +183,7 @@ def __init__( # like this will create a SliceOpLambda layer. This is better than a Lambda # layer with Python code, because that is fundamentally less portable. first_token_tensor = last_encoder_output[:, 0, :] - pooler_layer = tf.keras.layers.Dense( + pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -213,10 +213,10 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, diff --git a/official/projects/roformer/roformer_encoder_block.py b/official/projects/roformer/roformer_encoder_block.py index dc0ff61fa70..21d314b1fd0 100644 --- a/official/projects/roformer/roformer_encoder_block.py +++ b/official/projects/roformer/roformer_encoder_block.py @@ -14,13 +14,13 @@ """Roformer TransformerEncoder block layer.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.roformer import roformer_attention -@tf.keras.utils.register_keras_serializable(package="Text") -class RoformerEncoderBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package="Text") +class RoformerEncoderBlock(tf_keras.layers.Layer): """RoformerEncoderBlock layer.""" def __init__(self, @@ -95,13 +95,13 @@ def __init__(self, self._output_dropout = output_dropout self._output_dropout_rate = output_dropout self._output_range = output_range - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self._bias_initializer = tf.keras.initializers.get(bias_initializer) - self._kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) - self._bias_regularizer = tf.keras.regularizers.get(bias_regularizer) - self._activity_regularizer = tf.keras.regularizers.get(activity_regularizer) - self._kernel_constraint = tf.keras.constraints.get(kernel_constraint) - self._bias_constraint = tf.keras.constraints.get(bias_constraint) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self._bias_initializer = tf_keras.initializers.get(bias_initializer) + self._kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) + self._bias_regularizer = tf_keras.regularizers.get(bias_regularizer) + self._activity_regularizer = tf_keras.regularizers.get(activity_regularizer) + self._kernel_constraint = tf_keras.constraints.get(kernel_constraint) + self._bias_constraint = tf_keras.constraints.get(bias_constraint) self._use_bias = use_bias self._norm_first = norm_first self._norm_epsilon = norm_epsilon @@ -109,7 +109,7 @@ def __init__(self, self._q_max_sequence_length = q_max_sequence_length self._kv_max_sequence_length = kv_max_sequence_length if attention_initializer: - self._attention_initializer = tf.keras.initializers.get( + self._attention_initializer = tf_keras.initializers.get( attention_initializer) else: self._attention_initializer = tf_utils.clone_initializer( @@ -153,42 +153,42 @@ def build(self, input_shape): attention_axes=self._attention_axes, name="self_attention", **common_kwargs) - self._attention_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._attention_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. # It is probably safe in mixed_float16, but we haven't validated this yet. self._attention_layer_norm = ( - tf.keras.layers.LayerNormalization( + tf_keras.layers.LayerNormalization( name="self_attention_layer_norm", axis=-1, epsilon=self._norm_epsilon, dtype=tf.float32)) - self._intermediate_dense = tf.keras.layers.EinsumDense( + self._intermediate_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, self._inner_dim), bias_axes="d", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), name="intermediate", **common_kwargs) - policy = tf.keras.mixed_precision.global_policy() + policy = tf_keras.mixed_precision.global_policy() if policy.name == "mixed_bfloat16": # bfloat16 causes BERT with the LAMB optimizer to not converge # as well, so we use float32. # TODO(b/154538392): Investigate this. policy = tf.float32 - self._intermediate_activation_layer = tf.keras.layers.Activation( + self._intermediate_activation_layer = tf_keras.layers.Activation( self._inner_activation, dtype=policy) - self._inner_dropout_layer = tf.keras.layers.Dropout( + self._inner_dropout_layer = tf_keras.layers.Dropout( rate=self._inner_dropout) - self._output_dense = tf.keras.layers.EinsumDense( + self._output_dense = tf_keras.layers.EinsumDense( einsum_equation, output_shape=(None, hidden_size), bias_axes="d", name="output", kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), **common_kwargs) - self._output_dropout = tf.keras.layers.Dropout(rate=self._output_dropout) + self._output_dropout = tf_keras.layers.Dropout(rate=self._output_dropout) # Use float32 in layernorm for numeric stability. - self._output_layer_norm = tf.keras.layers.LayerNormalization( + self._output_layer_norm = tf_keras.layers.LayerNormalization( name="output_layer_norm", axis=-1, epsilon=self._norm_epsilon, @@ -211,19 +211,19 @@ def get_config(self): "output_range": self._output_range, "kernel_initializer": - tf.keras.initializers.serialize(self._kernel_initializer), + tf_keras.initializers.serialize(self._kernel_initializer), "bias_initializer": - tf.keras.initializers.serialize(self._bias_initializer), + tf_keras.initializers.serialize(self._bias_initializer), "kernel_regularizer": - tf.keras.regularizers.serialize(self._kernel_regularizer), + tf_keras.regularizers.serialize(self._kernel_regularizer), "bias_regularizer": - tf.keras.regularizers.serialize(self._bias_regularizer), + tf_keras.regularizers.serialize(self._bias_regularizer), "activity_regularizer": - tf.keras.regularizers.serialize(self._activity_regularizer), + tf_keras.regularizers.serialize(self._activity_regularizer), "kernel_constraint": - tf.keras.constraints.serialize(self._kernel_constraint), + tf_keras.constraints.serialize(self._kernel_constraint), "bias_constraint": - tf.keras.constraints.serialize(self._bias_constraint), + tf_keras.constraints.serialize(self._bias_constraint), "use_bias": self._use_bias, "norm_first": @@ -233,7 +233,7 @@ def get_config(self): "inner_dropout": self._inner_dropout, "attention_initializer": - tf.keras.initializers.serialize(self._attention_initializer), + tf_keras.initializers.serialize(self._attention_initializer), "attention_axes": self._attention_axes, } diff --git a/official/projects/roformer/roformer_encoder_block_test.py b/official/projects/roformer/roformer_encoder_block_test.py index 50b86b5f82f..7d1e34a7c28 100644 --- a/official/projects/roformer/roformer_encoder_block_test.py +++ b/official/projects/roformer/roformer_encoder_block_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.roformer import roformer_encoder_block @@ -27,7 +27,7 @@ class RoformerEncoderBlockTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(RoformerEncoderBlockTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') def test_layer_creation(self, transformer_cls): test_layer = transformer_cls( @@ -35,7 +35,7 @@ def test_layer_creation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -46,9 +46,9 @@ def test_layer_creation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -59,11 +59,11 @@ def test_layer_invocation(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -78,13 +78,13 @@ def test_layer_invocation_with_mask(self, transformer_cls): sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -182,19 +182,19 @@ def test_layer_output_range_with_pre_norm(self, transformer_cls): new_output_tensor, output_tensor[:, 0:1, :], atol=5e-5, rtol=0.003) def test_layer_invocation_with_float16_dtype(self, transformer_cls): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') test_layer = transformer_cls( num_attention_heads=10, inner_dim=2048, inner_activation='relu') sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -212,11 +212,11 @@ def test_transform_with_initializer(self, transformer_cls): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) sequence_length = 21 width = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -226,7 +226,7 @@ def test_separate_qkv(self, transformer_cls): num_attention_heads=2, inner_dim=128, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Forward path. q_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) kv_tensor = tf.zeros([2, 8, 16], dtype=tf.float32) @@ -251,7 +251,7 @@ def test_raises(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) def test_use_bias_norm_first(self): @@ -267,7 +267,7 @@ def test_use_bias_norm_first(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) # Forward path. dummy_tensor = tf.zeros([2, 4, 16], dtype=tf.float32) @@ -288,7 +288,7 @@ def test_get_config(self): norm_first=True, norm_epsilon=1e-6, inner_dropout=0.1, - attention_initializer=tf.keras.initializers.RandomUniform( + attention_initializer=tf_keras.initializers.RandomUniform( minval=0., maxval=1.)) encoder_block_config = encoder_block.get_config() new_encoder_block = roformer_encoder_block.RoformerEncoderBlock.from_config( @@ -312,7 +312,7 @@ def test_several_attention_axes(self, attention_axes): seq_len = 21 dimensions = 80 # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(seq_len, dimensions)) + data_tensor = tf_keras.Input(shape=(seq_len, dimensions)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) diff --git a/official/projects/roformer/roformer_encoder_test.py b/official/projects/roformer/roformer_encoder_test.py index c819762e743..72f1b816521 100644 --- a/official/projects/roformer/roformer_encoder_test.py +++ b/official/projects/roformer/roformer_encoder_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.roformer import roformer_encoder @@ -25,7 +25,7 @@ class RoformerEncoderTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(RoformerEncoderTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") def test_network_creation(self): hidden_size = 32 @@ -37,16 +37,16 @@ def test_network_creation(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -67,9 +67,9 @@ def test_all_encoder_outputs_network_creation(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) all_encoder_outputs = dict_outputs["encoder_outputs"] pooled = dict_outputs["pooled_output"] @@ -88,7 +88,7 @@ def test_all_encoder_outputs_network_creation(self): def test_network_creation_with_float16_dtype(self): hidden_size = 32 sequence_length = 21 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = roformer_encoder.RoformerEncoder( vocab_size=100, @@ -96,9 +96,9 @@ def test_network_creation_with_float16_dtype(self): num_attention_heads=2, num_layers=3) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] @@ -131,15 +131,15 @@ def test_network_invocation(self, output_range, out_seq_len): type_vocab_size=num_types, output_range=output_range) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -164,7 +164,7 @@ def test_network_invocation(self, output_range, out_seq_len): dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[1], sequence_length) @@ -180,7 +180,7 @@ def test_network_invocation(self, output_range, out_seq_len): dict_outputs = test_network([word_ids, mask, type_ids]) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -205,10 +205,10 @@ def test_serialize_deserialize(self): norm_first=False) network = roformer_encoder.RoformerEncoder(**kwargs) expected_config = dict(kwargs) - expected_config["inner_activation"] = tf.keras.activations.serialize( - tf.keras.activations.get(expected_config["inner_activation"])) - expected_config["initializer"] = tf.keras.initializers.serialize( - tf.keras.initializers.get(expected_config["initializer"])) + expected_config["inner_activation"] = tf_keras.activations.serialize( + tf_keras.activations.get(expected_config["inner_activation"])) + expected_config["initializer"] = tf_keras.initializers.serialize( + tf_keras.initializers.get(expected_config["initializer"])) self.assertEqual(network.get_config(), expected_config) # Create another network object from the first object's config. new_network = roformer_encoder.RoformerEncoder.from_config( @@ -223,7 +223,7 @@ def test_serialize_deserialize(self): # Tests model saving/loading. model_path = self.get_temp_dir() + "/model" network.save(model_path) - _ = tf.keras.models.load_model(model_path) + _ = tf_keras.models.load_model(model_path) if __name__ == "__main__": diff --git a/official/projects/s3d/modeling/inception_utils.py b/official/projects/s3d/modeling/inception_utils.py index 29e6cbb2859..3cda191839e 100644 --- a/official/projects/s3d/modeling/inception_utils.py +++ b/official/projects/s3d/modeling/inception_utils.py @@ -15,7 +15,7 @@ """Contains modules related to Inception networks.""" from typing import Callable, Dict, Optional, Sequence, Set, Text, Tuple, Type, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.s3d.modeling import net_utils @@ -48,8 +48,8 @@ ('Mixed_5c_local', [[384], [192, 384], [48, 128], [128]]), # 8x7x7x1024 ] -initializers = tf.keras.initializers -regularizers = tf.keras.regularizers +initializers = tf_keras.initializers +regularizers = tf_keras.regularizers def inception_v1_stem_cells( @@ -110,10 +110,10 @@ def inception_v1_stem_cells( if self_gating_endpoints is None: self_gating_endpoints = set() if use_sync_bn: - batch_norm = tf.keras.layers.experimental.SyncBatchNormalization + batch_norm = tf_keras.layers.experimental.SyncBatchNormalization else: - batch_norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + batch_norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = -1 else: bn_axis = 1 @@ -121,7 +121,7 @@ def inception_v1_stem_cells( end_points = {} # batch_size x 32 x 112 x 112 x 64 end_point = 'Conv2d_1a_7x7' - net = tf.keras.layers.Conv3D( + net = tf_keras.layers.Conv3D( filters=net_utils.apply_depth_multiplier(64, depth_multiplier), kernel_size=[first_temporal_kernel_size, 7, 7], strides=[2, 2, 2], @@ -145,7 +145,7 @@ def inception_v1_stem_cells( return net, end_points # batch_size x 32 x 56 x 56 x 64 end_point = 'MaxPool_2a_3x3' - net = tf.keras.layers.MaxPool3D( + net = tf_keras.layers.MaxPool3D( pool_size=[1, 3, 3], strides=[1, 2, 2], padding='same', @@ -156,7 +156,7 @@ def inception_v1_stem_cells( return net, end_points # batch_size x 32 x 56 x 56 x 64 end_point = 'Conv2d_2b_1x1' - net = tf.keras.layers.Conv3D( + net = tf_keras.layers.Conv3D( filters=net_utils.apply_depth_multiplier(64, depth_multiplier), strides=[1, 1, 1], kernel_size=[1, 1, 1], @@ -206,7 +206,7 @@ def inception_v1_stem_cells( return net, end_points # batch_size x 32 x 28 x 28 x 192 end_point = 'MaxPool_3a_3x3' - net = tf.keras.layers.MaxPool3D( + net = tf_keras.layers.MaxPool3D( pool_size=[1, 3, 3], strides=[1, 2, 2], padding='same', @@ -220,22 +220,22 @@ def _construct_branch_3_layers( channels: int, swap_pool_and_1x1x1: bool, pool_type: Text, - batch_norm_layer: tf.keras.layers.Layer, + batch_norm_layer: tf_keras.layers.Layer, kernel_initializer: Union[Text, initializers.Initializer], kernel_regularizer: Union[Text, regularizers.Regularizer], ): """Helper function for Branch 3 inside Inception module.""" kernel_size = [1, 3, 3] if pool_type == '2d' else [3] * 3 - conv = tf.keras.layers.Conv3D( + conv = tf_keras.layers.Conv3D( filters=channels, kernel_size=[1, 1, 1], padding='same', use_bias=False, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer) - activation = tf.keras.layers.Activation('relu') - pool = tf.keras.layers.MaxPool3D( + activation = tf_keras.layers.Activation('relu') + pool = tf_keras.layers.MaxPool3D( pool_size=kernel_size, strides=[1, 1, 1], padding='same') if swap_pool_and_1x1x1: branch_3_layers = [conv, batch_norm_layer, activation, pool] @@ -244,7 +244,7 @@ def _construct_branch_3_layers( return branch_3_layers -class InceptionV1CellLayer(tf.keras.layers.Layer): +class InceptionV1CellLayer(tf_keras.layers.Layer): """A single Tensorflow 2 cell used in the original I3D/S3D model.""" def __init__( @@ -314,11 +314,11 @@ def __init__( self._kernel_regularizer = kernel_regularizer self._parameterized_conv_layer = parameterized_conv_layer if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._channel_axis = -1 else: self._channel_axis = 1 @@ -460,38 +460,38 @@ def build(self, input_shape): branch_params = self._build_branch_params() self._branch_0_layers = [ - tf.keras.layers.Conv3D(**branch_params[0][0]), + tf_keras.layers.Conv3D(**branch_params[0][0]), self._norm(**branch_params[0][1]), - tf.keras.layers.Activation('relu', **branch_params[0][2]), + tf_keras.layers.Activation('relu', **branch_params[0][2]), ] self._branch_1_layers = [ - tf.keras.layers.Conv3D(**branch_params[1][0]), + tf_keras.layers.Conv3D(**branch_params[1][0]), self._norm(**branch_params[1][1]), - tf.keras.layers.Activation('relu', **branch_params[1][2]), + tf_keras.layers.Activation('relu', **branch_params[1][2]), self._parameterized_conv_layer(**branch_params[1][3]), ] self._branch_2_layers = [ - tf.keras.layers.Conv3D(**branch_params[2][0]), + tf_keras.layers.Conv3D(**branch_params[2][0]), self._norm(**branch_params[2][1]), - tf.keras.layers.Activation('relu', **branch_params[2][2]), + tf_keras.layers.Activation('relu', **branch_params[2][2]), self._parameterized_conv_layer(**branch_params[2][3]) ] if self._swap_pool_and_1x1x1: self._branch_3_layers = [ - tf.keras.layers.Conv3D(**branch_params[3][0]), + tf_keras.layers.Conv3D(**branch_params[3][0]), self._norm(**branch_params[3][1]), - tf.keras.layers.Activation('relu', **branch_params[3][2]), - tf.keras.layers.MaxPool3D(**branch_params[3][3]), + tf_keras.layers.Activation('relu', **branch_params[3][2]), + tf_keras.layers.MaxPool3D(**branch_params[3][3]), ] else: self._branch_3_layers = [ - tf.keras.layers.MaxPool3D(**branch_params[3][3]), - tf.keras.layers.Conv3D(**branch_params[3][0]), + tf_keras.layers.MaxPool3D(**branch_params[3][3]), + tf_keras.layers.Conv3D(**branch_params[3][0]), self._norm(**branch_params[3][1]), - tf.keras.layers.Activation('relu', **branch_params[3][2]), + tf_keras.layers.Activation('relu', **branch_params[3][2]), ] if self._use_self_gating_on_branch: diff --git a/official/projects/s3d/modeling/inception_utils_test.py b/official/projects/s3d/modeling/inception_utils_test.py index f1e46b800de..f4012c10ccb 100644 --- a/official/projects/s3d/modeling/inception_utils_test.py +++ b/official/projects/s3d/modeling/inception_utils_test.py @@ -14,7 +14,7 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.s3d.modeling import inception_utils @@ -30,7 +30,7 @@ def test_s3d_stem_cells(self, depth_multiplier, first_temporal_kernel_size, num_frames = 64 height, width = 224, 224 - inputs = tf.keras.layers.Input( + inputs = tf_keras.layers.Input( shape=(num_frames, height, width, 3), batch_size=batch_size) outputs, output_endpoints = inception_utils.inception_v1_stem_cells( @@ -64,7 +64,7 @@ def test_inception_v1_cell_endpoint_match(self, conv_type, channels = 128 height, width = 28, 28 - inputs = tf.keras.layers.Input( + inputs = tf_keras.layers.Input( shape=(num_frames, height, width, channels), batch_size=batch_size) inception_v1_cell_layer = inception_utils.InceptionV1CellLayer( diff --git a/official/projects/s3d/modeling/net_utils.py b/official/projects/s3d/modeling/net_utils.py index 78f474b0e94..0a2e1d8f4f3 100644 --- a/official/projects/s3d/modeling/net_utils.py +++ b/official/projects/s3d/modeling/net_utils.py @@ -15,16 +15,16 @@ """Commonly used TensorFlow 2 network blocks.""" from typing import Any, Text, Sequence, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils WEIGHT_INITIALIZER = { - 'Xavier': tf.keras.initializers.GlorotUniform, - 'Gaussian': lambda: tf.keras.initializers.RandomNormal(stddev=0.01), + 'Xavier': tf_keras.initializers.GlorotUniform, + 'Gaussian': lambda: tf_keras.initializers.RandomNormal(stddev=0.01), } -initializers = tf.keras.initializers -regularizers = tf.keras.regularizers +initializers = tf_keras.initializers +regularizers = tf_keras.regularizers def make_set_from_start_endpoint(start_endpoint: Text, @@ -45,7 +45,7 @@ def apply_depth_multiplier(d: Union[int, Sequence[Any]], return [apply_depth_multiplier(x, depth_multiplier) for x in d] -class ParameterizedConvLayer(tf.keras.layers.Layer): +class ParameterizedConvLayer(tf_keras.layers.Layer): """Convolution layer based on the input conv_type.""" def __init__( @@ -74,10 +74,10 @@ def __init__( self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._channel_axis = -1 else: self._channel_axis = 1 @@ -195,7 +195,7 @@ def _build_activation_layer_params(self, conv_param): def _append_conv_layer(self, param): """Appends conv, normalization and activation layers.""" self._parameterized_conv_layers.append( - tf.keras.layers.Conv3D( + tf_keras.layers.Conv3D( padding='same', use_bias=False, kernel_regularizer=self._kernel_regularizer, @@ -206,7 +206,7 @@ def _append_conv_layer(self, param): relu_layer_params = self._build_activation_layer_params(param) self._parameterized_conv_layers.append( - tf.keras.layers.Activation('relu', **relu_layer_params)) + tf_keras.layers.Activation('relu', **relu_layer_params)) def build(self, input_shape): self._parameterized_conv_layers = [] diff --git a/official/projects/s3d/modeling/net_utils_test.py b/official/projects/s3d/modeling/net_utils_test.py index 8fd20a31c88..edd91ca37ea 100644 --- a/official/projects/s3d/modeling/net_utils_test.py +++ b/official/projects/s3d/modeling/net_utils_test.py @@ -15,7 +15,7 @@ from absl import logging from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.s3d.modeling import net_utils @@ -52,7 +52,7 @@ def test_parameterized_conv_layer_creation(self, conv_type, strides, name = 'ParameterizedConv' - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(temporal_size, spatial_size, spatial_size, channels), batch_size=batch_size) parameterized_conv_layer = net_utils.ParameterizedConvLayer( diff --git a/official/projects/s3d/modeling/s3d.py b/official/projects/s3d/modeling/s3d.py index fd59cf33aaa..8ced6b14f17 100644 --- a/official/projects/s3d/modeling/s3d.py +++ b/official/projects/s3d/modeling/s3d.py @@ -19,7 +19,7 @@ """ from typing import Any, Dict, Mapping, Optional, Sequence, Text, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.s3d.configs import s3d as cfg @@ -28,15 +28,15 @@ from official.vision.modeling import factory_3d as model_factory from official.vision.modeling.backbones import factory as backbone_factory -initializers = tf.keras.initializers -regularizers = tf.keras.regularizers +initializers = tf_keras.initializers +regularizers = tf_keras.regularizers -class S3D(tf.keras.Model): +class S3D(tf_keras.Model): """Class to build S3D family model.""" def __init__(self, - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, final_endpoint: Text = 'Mixed_5c', first_temporal_kernel_size: int = 3, temporal_conv_start_at: Text = 'Conv2d_2c_3x3', @@ -61,7 +61,7 @@ def __init__(self, """Constructor. Args: - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. final_endpoint: Specifies the endpoint to construct the network up to. first_temporal_kernel_size: Temporal kernel size of the first convolution layer. @@ -109,7 +109,7 @@ def __init__(self, self._self_gating_endpoints = net_utils.make_set_from_start_endpoint( gating_start_at, inception_utils.INCEPTION_V1_CONV_ENDPOINTS) - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) net, end_points = inception_utils.inception_v1_stem_cells( inputs, depth_multiplier, @@ -146,9 +146,9 @@ def _s3d_cell( end_point: Text, end_points: Dict[Text, tf.Tensor], filters: Union[int, Sequence[Any]], - non_local_block: Optional[tf.keras.layers.Layer] = None, - attention_cell: Optional[tf.keras.layers.Layer] = None, - attention_cell_super_graph: Optional[tf.keras.layers.Layer] = None + non_local_block: Optional[tf_keras.layers.Layer] = None, + attention_cell: Optional[tf_keras.layers.Layer] = None, + attention_cell_super_graph: Optional[tf_keras.layers.Layer] = None ) -> Tuple[tf.Tensor, Dict[Text, tf.Tensor]]: if end_point.startswith('Mixed'): conv_type = ( @@ -180,7 +180,7 @@ def _s3d_cell( name=self._get_layer_naming_fn()(end_point))( net) else: - net = tf.keras.layers.MaxPool3D( + net = tf_keras.layers.MaxPool3D( pool_size=filters[0], strides=filters[1], padding='same', @@ -238,13 +238,13 @@ def _get_layer_naming_fn(self): return lambda end_point: None -class S3DModel(tf.keras.Model): +class S3DModel(tf_keras.Model): """An S3D model builder.""" def __init__(self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: int, - input_specs: Mapping[Text, tf.keras.layers.InputSpec], + input_specs: Mapping[Text, tf_keras.layers.InputSpec], final_endpoint: Text = 'Mixed_5c', dropout_rate: float = 0.0, **kwargs): @@ -253,7 +253,7 @@ def __init__(self, Args: backbone: S3D backbone Keras Model. num_classes: `int` number of possible classes for video classification. - input_specs: input_specs: `tf.keras.layers.InputSpec` specs of the input + input_specs: input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. final_endpoint: Specifies the endpoint to construct the network up to. dropout_rate: `float` between 0 and 1. Fraction of the input units to @@ -275,13 +275,13 @@ def __init__(self, } inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } streams = self._backbone(inputs['image']) pool = tf.math.reduce_mean(streams[self._final_endpoint], axis=[1, 2, 3]) - fc = tf.keras.layers.Dropout(dropout_rate)(pool) - logits = tf.keras.layers.Dense(**self._build_dense_layer_params())(fc) + fc = tf_keras.layers.Dropout(dropout_rate)(pool) + logits = tf_keras.layers.Dense(**self._build_dense_layer_params())(fc) super(S3DModel, self).__init__(inputs=inputs, outputs=logits, **kwargs) @@ -307,11 +307,11 @@ def _build_dense_layer_params(self): @backbone_factory.register_backbone_builder('s3d') def build_s3d( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds S3D backbone.""" backbone_type = backbone_config.type @@ -338,11 +338,11 @@ def build_s3d( @model_factory.register_model_builder('s3d') def build_s3d_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: cfg.S3DModel, num_classes: int, - l2_regularizer: tf.keras.regularizers.Regularizer = None -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds S3D model with classification layer.""" input_specs_dict = {'image': input_specs} backbone = build_s3d(input_specs, model_config.backbone, diff --git a/official/projects/s3d/modeling/s3d_test.py b/official/projects/s3d/modeling/s3d_test.py index 87f3f69e01a..a7ab8fe8d0f 100644 --- a/official/projects/s3d/modeling/s3d_test.py +++ b/official/projects/s3d/modeling/s3d_test.py @@ -15,7 +15,7 @@ """Tests for S3D model.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.s3d.modeling import s3d @@ -36,11 +36,11 @@ def test_build(self, num_frames, height, width, first_temporal_kernel_size): batch_size = 5 input_shape = [batch_size, num_frames, height, width, 3] - input_specs = tf.keras.layers.InputSpec(shape=input_shape) + input_specs = tf_keras.layers.InputSpec(shape=input_shape) network = s3d.S3D( input_specs=input_specs ) - inputs = tf.keras.Input(shape=input_shape[1:], batch_size=input_shape[0]) + inputs = tf_keras.Input(shape=input_shape[1:], batch_size=input_shape[0]) endpoints = network(inputs) temporal_1a = (num_frames - 1)//2 + 1 @@ -71,7 +71,7 @@ def test_build(self, num_frames, height, width, first_temporal_kernel_size): def test_serialize_deserialize(self): # Create a network object that sets all of its config options. kwargs = dict( - input_specs=tf.keras.layers.InputSpec(shape=(5, 64, 224, 224, 3)), + input_specs=tf_keras.layers.InputSpec(shape=(5, 64, 224, 224, 3)), final_endpoint='Mixed_5c', first_temporal_kernel_size=3, temporal_conv_start_at='Conv2d_2c_3x3', @@ -81,7 +81,7 @@ def test_serialize_deserialize(self): use_sync_bn=False, norm_momentum=0.999, norm_epsilon=0.001, - temporal_conv_initializer=tf.keras.initializers.TruncatedNormal( + temporal_conv_initializer=tf_keras.initializers.TruncatedNormal( mean=0.0, stddev=0.01), temporal_conv_type='2+1d', kernel_initializer='truncated_normal', diff --git a/official/projects/simclr/configs/multitask_config_test.py b/official/projects/simclr/configs/multitask_config_test.py index d522d8e9bd2..67251b1476d 100644 --- a/official/projects/simclr/configs/multitask_config_test.py +++ b/official/projects/simclr/configs/multitask_config_test.py @@ -14,7 +14,7 @@ """Tests for multitask_config.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.modeling.multitask import configs as multitask_configs diff --git a/official/projects/simclr/configs/simclr_test.py b/official/projects/simclr/configs/simclr_test.py index 8969b9008ab..f52fc3e1ac5 100644 --- a/official/projects/simclr/configs/simclr_test.py +++ b/official/projects/simclr/configs/simclr_test.py @@ -15,7 +15,7 @@ """Tests for SimCLR config.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/simclr/dataloaders/preprocess_ops.py b/official/projects/simclr/dataloaders/preprocess_ops.py index 8d3a8decaae..79a3fc3a5e5 100644 --- a/official/projects/simclr/dataloaders/preprocess_ops.py +++ b/official/projects/simclr/dataloaders/preprocess_ops.py @@ -14,7 +14,7 @@ """Preprocessing ops.""" import functools -import tensorflow as tf +import tensorflow as tf, tf_keras CROP_PROPORTION = 0.875 # Standard for ImageNet. diff --git a/official/projects/simclr/dataloaders/simclr_input.py b/official/projects/simclr/dataloaders/simclr_input.py index 5da2773e097..0ba70397a93 100644 --- a/official/projects/simclr/dataloaders/simclr_input.py +++ b/official/projects/simclr/dataloaders/simclr_input.py @@ -38,7 +38,7 @@ from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.dataloaders import preprocess_ops as simclr_preprocess_ops from official.projects.simclr.modeling import simclr_model diff --git a/official/projects/simclr/heads/simclr_head.py b/official/projects/simclr/heads/simclr_head.py index bb9cf0af328..17d54a48c01 100644 --- a/official/projects/simclr/heads/simclr_head.py +++ b/official/projects/simclr/heads/simclr_head.py @@ -16,15 +16,15 @@ from typing import Optional, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.modeling.layers import nn_blocks -regularizers = tf.keras.regularizers -layers = tf.keras.layers +regularizers = tf_keras.regularizers +layers = tf_keras.layers -class ProjectionHead(tf.keras.layers.Layer): +class ProjectionHead(tf_keras.layers.Layer): """Projection head.""" def __init__( @@ -48,9 +48,9 @@ def __init__( ft_proj_idx: `int` index of layer to use during fine-tuning. 0 means no projection head during fine tuning, -1 means the final layer. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. use_sync_bn: if True, use synchronized batch normalization. norm_momentum: `float` normalization omentum for the moving average. @@ -143,7 +143,7 @@ def call(self, inputs, training=None): return proj_head_output, proj_finetune_output -class ClassificationHead(tf.keras.layers.Layer): +class ClassificationHead(tf_keras.layers.Layer): """Classification Head.""" def __init__( @@ -160,9 +160,9 @@ def __init__( num_classes: `int` size of the output dimension or number of classes for classification task. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. name: `str`, name of the layer. **kwargs: keyword arguments to be passed. diff --git a/official/projects/simclr/heads/simclr_head_test.py b/official/projects/simclr/heads/simclr_head_test.py index aa3a6059faf..617d749ca18 100644 --- a/official/projects/simclr/heads/simclr_head_test.py +++ b/official/projects/simclr/heads/simclr_head_test.py @@ -15,7 +15,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.heads import simclr_head @@ -33,7 +33,7 @@ def test_head_creation(self, num_proj_layers, proj_output_dim): proj_output_dim=proj_output_dim) input_dim = 64 - x = tf.keras.Input(shape=(input_dim,)) + x = tf_keras.Input(shape=(input_dim,)) proj_head_output, proj_finetune_output = test_layer(x) proj_head_output_dim = input_dim @@ -90,7 +90,7 @@ def test_head_creation(self, num_classes): test_layer = simclr_head.ClassificationHead(num_classes=num_classes) input_dim = 64 - x = tf.keras.Input(shape=(input_dim,)) + x = tf_keras.Input(shape=(input_dim,)) out_x = test_layer(x) self.assertAllEqual(out_x.shape.as_list(), diff --git a/official/projects/simclr/losses/contrastive_losses.py b/official/projects/simclr/losses/contrastive_losses.py index 3b3399b22c9..8f59e396823 100644 --- a/official/projects/simclr/losses/contrastive_losses.py +++ b/official/projects/simclr/losses/contrastive_losses.py @@ -16,7 +16,7 @@ import functools -import tensorflow as tf +import tensorflow as tf, tf_keras LARGE_NUM = 1e9 diff --git a/official/projects/simclr/losses/contrastive_losses_test.py b/official/projects/simclr/losses/contrastive_losses_test.py index a291e972331..15ce5aca0d9 100644 --- a/official/projects/simclr/losses/contrastive_losses_test.py +++ b/official/projects/simclr/losses/contrastive_losses_test.py @@ -15,7 +15,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.losses import contrastive_losses diff --git a/official/projects/simclr/modeling/layers/nn_blocks.py b/official/projects/simclr/modeling/layers/nn_blocks.py index 0ce1053c89d..9733cad8d21 100644 --- a/official/projects/simclr/modeling/layers/nn_blocks.py +++ b/official/projects/simclr/modeling/layers/nn_blocks.py @@ -15,14 +15,14 @@ """Contains common building blocks for simclr neural networks.""" from typing import Text, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -regularizers = tf.keras.regularizers +regularizers = tf_keras.regularizers -class DenseBN(tf.keras.layers.Layer): +class DenseBN(tf_keras.layers.Layer): """Modified Dense layer to help build simclr system. The layer is a standards combination of Dense, BatchNorm and Activation. @@ -54,9 +54,9 @@ def __init__( zero. activation: `str` name of the activation function. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. Default to None. name: `str`, name of the layer. **kwargs: keyword arguments to be passed. @@ -77,10 +77,10 @@ def __init__( self._name = name if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -106,7 +106,7 @@ def get_config(self): return dict(list(base_config.items()) + list(config.items())) def build(self, input_shape): - self._dense0 = tf.keras.layers.Dense( + self._dense0 = tf_keras.layers.Dense( self._output_dim, kernel_initializer=self._kernel_initializer, kernel_regularizer=self._kernel_regularizer, diff --git a/official/projects/simclr/modeling/layers/nn_blocks_test.py b/official/projects/simclr/modeling/layers/nn_blocks_test.py index 6c9007feb27..b65c514ca29 100644 --- a/official/projects/simclr/modeling/layers/nn_blocks_test.py +++ b/official/projects/simclr/modeling/layers/nn_blocks_test.py @@ -14,7 +14,7 @@ from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.modeling.layers import nn_blocks @@ -33,7 +33,7 @@ def test_pass_through(self, output_dim, use_bias, use_normalization): use_normalization=use_normalization ) - x = tf.keras.Input(shape=(64,)) + x = tf_keras.Input(shape=(64,)) out_x = test_layer(x) self.assertAllEqual(out_x.shape.as_list(), [None, output_dim]) diff --git a/official/projects/simclr/modeling/multitask_model.py b/official/projects/simclr/modeling/multitask_model.py index 627de099929..1fef5739199 100644 --- a/official/projects/simclr/modeling/multitask_model.py +++ b/official/projects/simclr/modeling/multitask_model.py @@ -16,7 +16,7 @@ from typing import Dict, Text from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling.multitask import base_model from official.projects.simclr.configs import multitask_config as simclr_multitask_config @@ -36,7 +36,7 @@ def __init__(self, config: simclr_multitask_config.SimCLRMTModelConfig, self._config = config # Build shared backbone. - self._input_specs = tf.keras.layers.InputSpec(shape=[None] + + self._input_specs = tf_keras.layers.InputSpec(shape=[None] + config.input_size) l2_weight_decay = config.l2_weight_decay @@ -44,7 +44,7 @@ def __init__(self, config: simclr_multitask_config.SimCLRMTModelConfig, # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) self._l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None) self._backbone = backbones.factory.build_backbone( @@ -67,7 +67,7 @@ def __init__(self, config: simclr_multitask_config.SimCLRMTModelConfig, super().__init__(**kwargs) - def _instantiate_sub_tasks(self) -> Dict[Text, tf.keras.Model]: + def _instantiate_sub_tasks(self) -> Dict[Text, tf_keras.Model]: tasks = {} for model_config in self._config.heads: diff --git a/official/projects/simclr/modeling/multitask_model_test.py b/official/projects/simclr/modeling/multitask_model_test.py index 2d8352b3ac9..935acd85278 100644 --- a/official/projects/simclr/modeling/multitask_model_test.py +++ b/official/projects/simclr/modeling/multitask_model_test.py @@ -16,7 +16,7 @@ import os.path -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.configs import multitask_config from official.projects.simclr.modeling import multitask_model diff --git a/official/projects/simclr/modeling/simclr_model.py b/official/projects/simclr/modeling/simclr_model.py index 2ff968ebc1b..11b735c2307 100644 --- a/official/projects/simclr/modeling/simclr_model.py +++ b/official/projects/simclr/modeling/simclr_model.py @@ -16,9 +16,9 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers PRETRAIN = 'pretrain' FINETUNE = 'finetune' @@ -27,13 +27,13 @@ SUPERVISED_OUTPUT_KEY = 'supervised_outputs' -class SimCLRModel(tf.keras.Model): +class SimCLRModel(tf_keras.Model): """A classification model based on SimCLR framework.""" def __init__(self, - backbone: tf.keras.models.Model, - projection_head: tf.keras.layers.Layer, - supervised_head: Optional[tf.keras.layers.Layer] = None, + backbone: tf_keras.models.Model, + projection_head: tf_keras.layers.Layer, + supervised_head: Optional[tf_keras.layers.Layer] = None, input_specs=layers.InputSpec(shape=[None, None, None, 3]), mode: str = PRETRAIN, backbone_trainable: bool = True, @@ -45,7 +45,7 @@ def __init__(self, projection_head: a projection head network. supervised_head: a head network for supervised learning, e.g. classification head. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. mode: `str` indicates mode of training to be executed. backbone_trainable: `bool` whether the backbone is trainable or not. **kwargs: keyword arguments to be passed. diff --git a/official/projects/simclr/modeling/simclr_model_test.py b/official/projects/simclr/modeling/simclr_model_test.py index 41ea093a923..d431d453c91 100644 --- a/official/projects/simclr/modeling/simclr_model_test.py +++ b/official/projects/simclr/modeling/simclr_model_test.py @@ -15,7 +15,7 @@ """Test for SimCLR model.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.simclr.heads import simclr_head from official.projects.simclr.modeling import simclr_model @@ -33,10 +33,10 @@ class SimCLRModelTest(parameterized.TestCase, tf.test.TestCase): def test_model_creation(self, project_dim, num_proj_layers, ft_proj_idx): input_size = 224 inputs = np.random.rand(2, input_size, input_size, 3) - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.ResNet(model_id=50, activation='relu', input_specs=input_specs) diff --git a/official/projects/simclr/tasks/simclr.py b/official/projects/simclr/tasks/simclr.py index a55aa5794f7..ace34bbfc0e 100644 --- a/official/projects/simclr/tasks/simclr.py +++ b/official/projects/simclr/tasks/simclr.py @@ -27,7 +27,7 @@ from typing import Dict, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions @@ -82,7 +82,7 @@ def create_optimizer(self, def build_model(self): model_config = self.task_config.model - input_specs = tf.keras.layers.InputSpec(shape=[None] + + input_specs = tf_keras.layers.InputSpec(shape=[None] + model_config.input_size) l2_weight_decay = self.task_config.loss.l2_weight_decay @@ -90,7 +90,7 @@ def build_model(self): # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None) # Build backbone @@ -138,7 +138,7 @@ def build_model(self): return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -230,12 +230,12 @@ def build_losses(self, labels = tf.concat([labels, labels], 0) if self.task_config.evaluation.one_hot: - sup_loss = tf.keras.losses.CategoricalCrossentropy( - from_logits=True, reduction=tf.keras.losses.Reduction.NONE)(labels, + sup_loss = tf_keras.losses.CategoricalCrossentropy( + from_logits=True, reduction=tf_keras.losses.Reduction.NONE)(labels, outputs) else: - sup_loss = tf.keras.losses.SparseCategoricalCrossentropy( - from_logits=True, reduction=tf.keras.losses.Reduction.NONE)(labels, + sup_loss = tf_keras.losses.SparseCategoricalCrossentropy( + from_logits=True, reduction=tf_keras.losses.Reduction.NONE)(labels, outputs) sup_loss = tf.reduce_mean(sup_loss) @@ -269,19 +269,19 @@ def build_metrics(self, training=True): if self.task_config.model.supervised_head: metric_names.extend(['supervised_loss', 'accuracy']) for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) else: k = self.task_config.evaluation.top_k if self.task_config.evaluation.one_hot: metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k)) ] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k)) ] return metrics @@ -313,7 +313,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): scaled_loss = losses['total_loss'] / num_replicas # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables @@ -322,7 +322,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): logging.info(var.name) grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -395,7 +395,7 @@ def create_optimizer(self, def build_model(self): model_config = self.task_config.model - input_specs = tf.keras.layers.InputSpec(shape=[None] + + input_specs = tf_keras.layers.InputSpec(shape=[None] + model_config.input_size) l2_weight_decay = self.task_config.loss.l2_weight_decay @@ -403,7 +403,7 @@ def build_model(self): # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None) backbone = backbones.factory.build_backbone( @@ -445,7 +445,7 @@ def build_model(self): return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -514,13 +514,13 @@ def build_losses(self, labels, model_outputs, aux_losses=None): """ losses_config = self.task_config.loss if losses_config.one_hot: - total_loss = tf.keras.losses.categorical_crossentropy( + total_loss = tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=True, label_smoothing=losses_config.label_smoothing) else: - total_loss = tf.keras.losses.sparse_categorical_crossentropy( + total_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, model_outputs, from_logits=True) total_loss = tf_utils.safe_mean(total_loss) @@ -534,14 +534,14 @@ def build_metrics(self, training=True): k = self.task_config.evaluation.top_k if self.task_config.evaluation.one_hot: metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k)) ] else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k)) ] return metrics @@ -580,7 +580,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables @@ -590,7 +590,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) diff --git a/official/projects/teams/teams.py b/official/projects/teams/teams.py index ccae68c07c6..4e2a6861d8a 100644 --- a/official/projects/teams/teams.py +++ b/official/projects/teams/teams.py @@ -16,7 +16,7 @@ import dataclasses import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -76,7 +76,7 @@ def get_encoder(bert_config: TeamsEncoderConfig, hidden_size=bert_config.hidden_size, embedding_width=bert_config.embedding_size, max_seq_length=bert_config.max_position_embeddings, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), dropout_rate=bert_config.dropout_rate, ) @@ -87,7 +87,7 @@ def get_encoder(bert_config: TeamsEncoderConfig, bert_config.hidden_activation), dropout_rate=bert_config.dropout_rate, attention_dropout_rate=bert_config.attention_dropout_rate, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), ) if embedding_network is None: @@ -101,7 +101,7 @@ def get_encoder(bert_config: TeamsEncoderConfig, hidden_cfg=hidden_cfg, num_hidden_instances=bert_config.num_layers, pooled_output_dim=bert_config.hidden_size, - pooler_layer_initializer=tf.keras.initializers.TruncatedNormal( + pooler_layer_initializer=tf_keras.initializers.TruncatedNormal( stddev=bert_config.initializer_range), dict_outputs=True) diff --git a/official/projects/teams/teams_pretrainer.py b/official/projects/teams/teams_pretrainer.py index 025ea1e6e1f..a6a330f4f41 100644 --- a/official/projects/teams/teams_pretrainer.py +++ b/official/projects/teams/teams_pretrainer.py @@ -15,7 +15,7 @@ """Trainer network for TEAMS models.""" # pylint: disable=g-classes-have-attributes -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers @@ -24,7 +24,7 @@ _LOGIT_PENALTY_MULTIPLIER = 10000 -class ReplacedTokenDetectionHead(tf.keras.layers.Layer): +class ReplacedTokenDetectionHead(tf_keras.layers.Layer): """Replaced token detection discriminator head. Arguments: @@ -60,12 +60,12 @@ def __init__(self, attention_dropout_rate=self.hidden_cfg['attention_dropout_rate'], kernel_initializer=tf_utils.clone_initializer(self.initializer), name='transformer/layer_%d_rtd' % i)) - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( self.hidden_size, activation=self.activation, kernel_initializer=tf_utils.clone_initializer(self.initializer), name='transform/rtd_dense') - self.rtd_head = tf.keras.layers.Dense( + self.rtd_head = tf_keras.layers.Dense( units=1, kernel_initializer=tf_utils.clone_initializer(self.initializer), name='transform/rtd_head') @@ -95,7 +95,7 @@ def call(self, sequence_data, input_mask): return tf.squeeze(rtd_logits, axis=-1) -class MultiWordSelectionHead(tf.keras.layers.Layer): +class MultiWordSelectionHead(tf_keras.layers.Layer): """Multi-word selection discriminator head. Arguments: @@ -117,15 +117,15 @@ def __init__(self, super(MultiWordSelectionHead, self).__init__(name=name, **kwargs) self.embedding_table = embedding_table self.activation = activation - self.initializer = tf.keras.initializers.get(initializer) + self.initializer = tf_keras.initializers.get(initializer) self._vocab_size, self.embed_size = self.embedding_table.shape - self.dense = tf.keras.layers.Dense( + self.dense = tf_keras.layers.Dense( self.embed_size, activation=self.activation, kernel_initializer=self.initializer, name='transform/mws_dense') - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( axis=-1, epsilon=1e-12, name='transform/mws_layernorm') if output not in ('predictions', 'logits'): @@ -202,8 +202,8 @@ def _gather_indexes(self, sequence_tensor, positions): return output_tensor -@tf.keras.utils.register_keras_serializable(package='Text') -class TeamsPretrainer(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Text') +class TeamsPretrainer(tf_keras.Model): """TEAMS network training model. This is an implementation of the network structure described in "Training diff --git a/official/projects/teams/teams_pretrainer_test.py b/official/projects/teams/teams_pretrainer_test.py index e56b9efa7b5..2b8d5c4b550 100644 --- a/official/projects/teams/teams_pretrainer_test.py +++ b/official/projects/teams/teams_pretrainer_test.py @@ -14,7 +14,7 @@ """Tests for TEAMS pre trainer network.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations from official.nlp.modeling.networks import encoder_scaffold @@ -34,7 +34,7 @@ def _get_network(self, vocab_size): 'hidden_size': hidden_size, 'embedding_width': hidden_size, 'max_seq_length': sequence_length, - 'initializer': tf.keras.initializers.TruncatedNormal(stddev=0.02), + 'initializer': tf_keras.initializers.TruncatedNormal(stddev=0.02), 'dropout_rate': 0.1, } embedding_inst = packed_sequence_embedding.PackedSequenceEmbedding( @@ -51,7 +51,7 @@ def _get_network(self, vocab_size): 'attention_dropout_rate': 0.1, 'kernel_initializer': - tf.keras.initializers.TruncatedNormal(stddev=0.02), + tf_keras.initializers.TruncatedNormal(stddev=0.02), } return encoder_scaffold.EncoderScaffold( num_hidden_instances=2, @@ -79,12 +79,12 @@ def test_teams_pretrainer(self): # Create a set of 2-dimensional inputs (the first dimension is implicit). num_token_predictions = 2 sequence_length = 128 - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - lm_positions = tf.keras.Input( + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + lm_positions = tf_keras.Input( shape=(num_token_predictions,), dtype=tf.int32) - lm_ids = tf.keras.Input(shape=(num_token_predictions,), dtype=tf.int32) + lm_ids = tf_keras.Input(shape=(num_token_predictions,), dtype=tf.int32) inputs = { 'input_word_ids': word_ids, 'input_mask': mask, diff --git a/official/projects/teams/teams_task.py b/official/projects/teams/teams_task.py index cc367d801a9..37ef5467d4f 100644 --- a/official/projects/teams/teams_task.py +++ b/official/projects/teams/teams_task.py @@ -15,7 +15,7 @@ """TEAMS pretraining task (Joint Masked LM, Replaced Token Detection and ).""" import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -79,7 +79,7 @@ def _build_pretrainer( candidate_size=config.candidate_size, mlm_activation=tf_utils.get_activation( generator_encoder_cfg.hidden_activation), - mlm_initializer=tf.keras.initializers.TruncatedNormal( + mlm_initializer=tf_keras.initializers.TruncatedNormal( stddev=generator_encoder_cfg.initializer_range)) @@ -99,7 +99,7 @@ def build_losses(self, metrics = dict([(metric.name, metric) for metric in metrics]) # Generator MLM loss. - lm_prediction_losses = tf.keras.losses.sparse_categorical_crossentropy( + lm_prediction_losses = tf_keras.losses.sparse_categorical_crossentropy( labels['masked_lm_ids'], tf.cast(model_outputs['lm_outputs'], tf.float32), from_logits=True) @@ -127,7 +127,7 @@ def build_losses(self, # Discriminator MWS loss. mws_logits = model_outputs['disc_mws_logits'] mws_labels = model_outputs['disc_mws_label'] - mws_loss = tf.keras.losses.sparse_categorical_crossentropy( + mws_loss = tf_keras.losses.sparse_categorical_crossentropy( mws_labels, mws_logits, from_logits=True) mws_numerator_loss = tf.reduce_sum(mws_loss * lm_label_weights) mws_denominator_loss = tf.reduce_sum(lm_label_weights) @@ -169,15 +169,15 @@ def dummy_data(_): def build_metrics(self, training=None): del training metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), - tf.keras.metrics.Mean(name='masked_lm_loss'), - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='masked_lm_accuracy'), + tf_keras.metrics.Mean(name='masked_lm_loss'), + tf_keras.metrics.SparseCategoricalAccuracy( name='replaced_token_detection_accuracy'), - tf.keras.metrics.Mean(name='replaced_token_detection_loss'), - tf.keras.metrics.SparseCategoricalAccuracy( + tf_keras.metrics.Mean(name='replaced_token_detection_loss'), + tf_keras.metrics.SparseCategoricalAccuracy( name='multiword_selection_accuracy'), - tf.keras.metrics.Mean(name='multiword_selection_loss'), - tf.keras.metrics.Mean(name='total_loss'), + tf_keras.metrics.Mean(name='multiword_selection_loss'), + tf_keras.metrics.Mean(name='total_loss'), ] return metrics @@ -203,8 +203,8 @@ def process_metrics(self, metrics, labels, model_outputs): model_outputs['disc_mws_label'], model_outputs['disc_mws_logits'], labels['masked_lm_weights']) - def train_step(self, inputs, model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, metrics): + def train_step(self, inputs, model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics): """Does forward and backward. Args: @@ -233,7 +233,7 @@ def train_step(self, inputs, model: tf.keras.Model, self.process_metrics(metrics, inputs, outputs) return {self.loss: loss} - def validation_step(self, inputs, model: tf.keras.Model, metrics): + def validation_step(self, inputs, model: tf_keras.Model, metrics): """Validatation step. Args: diff --git a/official/projects/teams/teams_task_test.py b/official/projects/teams/teams_task_test.py index 48eaa4940e0..f5231927385 100644 --- a/official/projects/teams/teams_task_test.py +++ b/official/projects/teams/teams_task_test.py @@ -15,7 +15,7 @@ """Tests for teams_task.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import encoders from official.nlp.data import pretrain_dataloader @@ -48,7 +48,7 @@ def test_task(self, num_shared_hidden_layers, dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/projects/text_classification_example/classification_data_loader.py b/official/projects/text_classification_example/classification_data_loader.py index 5b564279371..6d54a8129b5 100644 --- a/official/projects/text_classification_example/classification_data_loader.py +++ b/official/projects/text_classification_example/classification_data_loader.py @@ -16,7 +16,7 @@ from typing import Dict, Mapping, Optional, Tuple import dataclasses -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/projects/text_classification_example/classification_example.py b/official/projects/text_classification_example/classification_example.py index 61e6b9d4a25..fcd7900c8e9 100644 --- a/official/projects/text_classification_example/classification_example.py +++ b/official/projects/text_classification_example/classification_example.py @@ -17,7 +17,7 @@ import dataclasses from typing import List, Mapping, Text from seqeval import metrics as seqeval_metrics -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -62,7 +62,7 @@ class ClassificationExampleConfig(cfg.TaskConfig): class ClassificationExampleTask(base_task.Task): """Task object for classification.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: if self.task_config.hub_module_url and self.task_config.init_checkpoint: raise ValueError('At most one of `hub_module_url` and ' '`init_checkpoint` can be specified.') @@ -75,12 +75,12 @@ def build_model(self) -> tf.keras.Model: return models.BertClassifier( network=encoder_network, num_classes=len(self.task_config.class_names), - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=self.task_config.model.head_initializer_range), dropout_rate=self.task_config.model.head_dropout) def build_losses(self, labels, model_outputs, aux_losses=None) -> tf.Tensor: - loss = tf.keras.losses.sparse_categorical_crossentropy( + loss = tf_keras.losses.sparse_categorical_crossentropy( labels, tf.cast(model_outputs, tf.float32), from_logits=True) return tf_utils.safe_mean(loss) @@ -92,7 +92,7 @@ def build_inputs(self, return loader.load(input_context) def inference_step(self, inputs, - model: tf.keras.Model) -> Mapping[str, tf.Tensor]: + model: tf_keras.Model) -> Mapping[str, tf.Tensor]: """Performs the forward step.""" logits = model(inputs, training=False) return { @@ -102,7 +102,7 @@ def inference_step(self, inputs, def validation_step(self, inputs, - model: tf.keras.Model, + model: tf_keras.Model, metrics=None) -> Mapping[str, tf.Tensor]: """Validatation step. diff --git a/official/projects/text_classification_example/classification_example_test.py b/official/projects/text_classification_example/classification_example_test.py index 0db6d629563..4a1d1181bb3 100644 --- a/official/projects/text_classification_example/classification_example_test.py +++ b/official/projects/text_classification_example/classification_example_test.py @@ -14,7 +14,7 @@ """Tests for nlp.projects.example.classification_example.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.nlp.configs import encoders @@ -60,7 +60,7 @@ def test_task_with_dummy_data(self): dataset = task.build_inputs(train_data_config) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.initialize(model) task.train_step(next(iterator), model, optimizer, metrics=metrics) diff --git a/official/projects/token_dropping/encoder.py b/official/projects/token_dropping/encoder.py index a19d14d8020..ce8d01d9621 100644 --- a/official/projects/token_dropping/encoder.py +++ b/official/projects/token_dropping/encoder.py @@ -17,19 +17,19 @@ from typing import Any, Callable, Optional, Union, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.modeling import layers -_Initializer = Union[str, tf.keras.initializers.Initializer] +_Initializer = Union[str, tf_keras.initializers.Initializer] _Activation = Union[str, Callable[..., Any]] -_approx_gelu = lambda x: tf.keras.activations.gelu(x, approximate=True) +_approx_gelu = lambda x: tf_keras.activations.gelu(x, approximate=True) -class TokenDropBertEncoder(tf.keras.layers.Layer): +class TokenDropBertEncoder(tf_keras.layers.Layer): """Bi-directional Transformer-based encoder network with token dropping. During pretraining, we drop unimportant tokens starting from an intermediate @@ -106,11 +106,11 @@ def __init__( token_keep_k: int = 256, token_allow_list: Tuple[int, ...] = (100, 101, 102, 103), token_deny_list: Tuple[int, ...] = (0,), - initializer: _Initializer = tf.keras.initializers.TruncatedNormal( + initializer: _Initializer = tf_keras.initializers.TruncatedNormal( stddev=0.02), output_range: Optional[int] = None, embedding_width: Optional[int] = None, - embedding_layer: Optional[tf.keras.layers.Layer] = None, + embedding_layer: Optional[tf_keras.layers.Layer] = None, norm_first: bool = False, with_dense_inputs: bool = False, **kwargs): @@ -133,8 +133,8 @@ def __init__( logging.warning('`output_range` is available as an argument for `call()`.' 'The `output_range` as __init__ argument is deprecated.') - activation = tf.keras.activations.get(inner_activation) - initializer = tf.keras.initializers.get(initializer) + activation = tf_keras.activations.get(inner_activation) + initializer = tf_keras.initializers.get(initializer) if embedding_width is None: embedding_width = hidden_size @@ -160,17 +160,17 @@ def __init__( use_one_hot=True, name='type_embeddings') - self._embedding_norm_layer = tf.keras.layers.LayerNormalization( + self._embedding_norm_layer = tf_keras.layers.LayerNormalization( name='embeddings/layer_norm', axis=-1, epsilon=1e-12, dtype=tf.float32) - self._embedding_dropout = tf.keras.layers.Dropout( + self._embedding_dropout = tf_keras.layers.Dropout( rate=output_dropout, name='embedding_dropout') # We project the 'embedding' output to 'hidden_size' if it is not already # 'hidden_size'. self._embedding_projection = None if embedding_width != hidden_size: - self._embedding_projection = tf.keras.layers.EinsumDense( + self._embedding_projection = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -212,7 +212,7 @@ def __init__( name='transformer/layer_%d' % i) self._transformer_layers.append(layer) - self._pooler_layer = tf.keras.layers.Dense( + self._pooler_layer = tf_keras.layers.Dense( units=hidden_size, activation='tanh', kernel_initializer=tf_utils.clone_initializer(initializer), @@ -226,7 +226,7 @@ def __init__( 'max_sequence_length': max_sequence_length, 'type_vocab_size': type_vocab_size, 'inner_dim': inner_dim, - 'inner_activation': tf.keras.activations.serialize(activation), + 'inner_activation': tf_keras.activations.serialize(activation), 'output_dropout': output_dropout, 'attention_dropout': attention_dropout, 'token_loss_init_value': token_loss_init_value, @@ -234,7 +234,7 @@ def __init__( 'token_keep_k': token_keep_k, 'token_allow_list': token_allow_list, 'token_deny_list': token_deny_list, - 'initializer': tf.keras.initializers.serialize(initializer), + 'initializer': tf_keras.initializers.serialize(initializer), 'output_range': output_range, 'embedding_width': embedding_width, 'embedding_layer': embedding_layer, @@ -243,19 +243,19 @@ def __init__( } if with_dense_inputs: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_inputs=tf.keras.Input( + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_inputs=tf_keras.Input( shape=(None, embedding_width), dtype=tf.float32), - dense_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - dense_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), + dense_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + dense_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), ) else: self.inputs = dict( - input_word_ids=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_mask=tf.keras.Input(shape=(None,), dtype=tf.int32), - input_type_ids=tf.keras.Input(shape=(None,), dtype=tf.int32)) + input_word_ids=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_mask=tf_keras.Input(shape=(None,), dtype=tf.int32), + input_type_ids=tf_keras.Input(shape=(None,), dtype=tf.int32)) def call(self, inputs, output_range: Optional[tf.Tensor] = None): if isinstance(inputs, dict): diff --git a/official/projects/token_dropping/encoder_config.py b/official/projects/token_dropping/encoder_config.py index 29060a33ce0..05408a0bc6e 100644 --- a/official/projects/token_dropping/encoder_config.py +++ b/official/projects/token_dropping/encoder_config.py @@ -15,7 +15,7 @@ """Token dropping encoder configuration and instantiation.""" import dataclasses from typing import Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.modeling.hyperparams import base_config @@ -53,7 +53,7 @@ def get_encoder(encoder_cfg: TokenDropBertEncoderConfig): attention_dropout_rate=encoder_cfg.attention_dropout_rate, max_sequence_length=encoder_cfg.max_position_embeddings, type_vocab_size=encoder_cfg.type_vocab_size, - initializer=tf.keras.initializers.TruncatedNormal( + initializer=tf_keras.initializers.TruncatedNormal( stddev=encoder_cfg.initializer_range), output_range=encoder_cfg.output_range, embedding_width=encoder_cfg.embedding_size, diff --git a/official/projects/token_dropping/encoder_test.py b/official/projects/token_dropping/encoder_test.py index 7e9be2a7930..c7e09284d99 100644 --- a/official/projects/token_dropping/encoder_test.py +++ b/official/projects/token_dropping/encoder_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.modeling.networks import bert_encoder from official.projects.token_dropping import encoder @@ -27,7 +27,7 @@ class TokenDropBertEncoderTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(TokenDropBertEncoderTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") def test_dict_outputs_network_creation(self): hidden_size = 32 @@ -42,9 +42,9 @@ def test_dict_outputs_network_creation(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -52,7 +52,7 @@ def test_dict_outputs_network_creation(self): self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -77,9 +77,9 @@ def test_dict_outputs_all_encoder_outputs_network_creation(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) all_encoder_outputs = dict_outputs["encoder_outputs"] @@ -99,7 +99,7 @@ def test_dict_outputs_all_encoder_outputs_network_creation(self): def test_dict_outputs_network_creation_with_float16_dtype(self): hidden_size = 32 sequence_length = 21 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = encoder.TokenDropBertEncoder( vocab_size=100, @@ -111,9 +111,9 @@ def test_dict_outputs_network_creation_with_float16_dtype(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -151,9 +151,9 @@ def test_dict_outputs_network_invocation( token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids), output_range=output_range) @@ -161,7 +161,7 @@ def test_dict_outputs_network_invocation( pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -191,7 +191,7 @@ def test_dict_outputs_network_invocation( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[1], sequence_length) @@ -212,7 +212,7 @@ def test_dict_outputs_network_invocation( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -230,9 +230,9 @@ def test_network_creation(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -240,7 +240,7 @@ def test_network_creation(self): self.assertIsInstance(test_network.transformer_layers, list) self.assertLen(test_network.transformer_layers, 3) - self.assertIsInstance(test_network.pooler_layer, tf.keras.layers.Dense) + self.assertIsInstance(test_network.pooler_layer, tf_keras.layers.Dense) expected_data_shape = [None, sequence_length, hidden_size] expected_pooled_shape = [None, hidden_size] @@ -278,9 +278,9 @@ def test_all_encoder_outputs_network_creation(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) all_encoder_outputs = dict_outputs["encoder_outputs"] @@ -300,7 +300,7 @@ def test_all_encoder_outputs_network_creation(self): def test_network_creation_with_float16_dtype(self): hidden_size = 32 sequence_length = 21 - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") # Create a small BertEncoder for testing. test_network = encoder.TokenDropBertEncoder( vocab_size=100, @@ -311,9 +311,9 @@ def test_network_creation_with_float16_dtype(self): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] @@ -349,9 +349,9 @@ def test_network_invocation(self, output_range, out_seq_len): token_allow_list=(), token_deny_list=()) # Create the inputs (note that the first dimension is implicit). - word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) - type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32) + word_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + mask = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) + type_ids = tf_keras.Input(shape=(sequence_length,), dtype=tf.int32) dict_outputs = test_network( dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids), output_range=output_range) @@ -359,7 +359,7 @@ def test_network_invocation(self, output_range, out_seq_len): pooled = dict_outputs["pooled_output"] # Create a model based off of this network: - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) # Invoke the model. We can't validate the output data here (the model is too # complex) but this will catch structural runtime errors. @@ -388,7 +388,7 @@ def test_network_invocation(self, output_range, out_seq_len): dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[1], sequence_length) @@ -408,7 +408,7 @@ def test_network_invocation(self, output_range, out_seq_len): dict(input_word_ids=word_ids, input_mask=mask, input_type_ids=type_ids)) data = dict_outputs["sequence_output"] pooled = dict_outputs["pooled_output"] - model = tf.keras.Model([word_ids, mask, type_ids], [data, pooled]) + model = tf_keras.Model([word_ids, mask, type_ids], [data, pooled]) outputs = model.predict([word_id_data, mask_data, type_id_data]) self.assertEqual(outputs[0].shape[-1], hidden_size) self.assertTrue(hasattr(test_network, "_embedding_projection")) @@ -418,7 +418,7 @@ class TokenDropCompatibilityTest(tf.test.TestCase): def tearDown(self): super().tearDown() - tf.keras.mixed_precision.set_global_policy("float32") + tf_keras.mixed_precision.set_global_policy("float32") def test_checkpoint_forward_compatible(self): batch_size = 3 @@ -494,7 +494,7 @@ def test_keras_model_checkpoint_forward_compatible(self): old_net = bert_encoder.BertEncoderV2(**kwargs) inputs = old_net.inputs outputs = old_net(inputs) - old_model = tf.keras.Model(inputs=inputs, outputs=outputs) + old_model = tf_keras.Model(inputs=inputs, outputs=outputs) old_model_outputs = old_model(data) ckpt = tf.train.Checkpoint(net=old_model) path = ckpt.save(self.get_temp_dir()) @@ -505,7 +505,7 @@ def test_keras_model_checkpoint_forward_compatible(self): **kwargs) inputs = new_net.inputs outputs = new_net(inputs) - new_model = tf.keras.Model(inputs=inputs, outputs=outputs) + new_model = tf_keras.Model(inputs=inputs, outputs=outputs) new_ckpt = tf.train.Checkpoint(net=new_model) new_ckpt.restore(path) diff --git a/official/projects/token_dropping/masked_lm.py b/official/projects/token_dropping/masked_lm.py index 62e875fdbc0..94dee420b86 100644 --- a/official/projects/token_dropping/masked_lm.py +++ b/official/projects/token_dropping/masked_lm.py @@ -16,7 +16,7 @@ import dataclasses from typing import Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.nlp.tasks import masked_lm @@ -40,7 +40,7 @@ def build_losses(self, """Return the final loss, and the masked-lm loss.""" with tf.name_scope('MaskedLMTask/losses'): metrics = dict([(metric.name, metric) for metric in metrics]) - lm_prediction_losses = tf.keras.losses.sparse_categorical_crossentropy( + lm_prediction_losses = tf_keras.losses.sparse_categorical_crossentropy( labels['masked_lm_ids'], tf.cast(model_outputs['mlm_logits'], tf.float32), from_logits=True) @@ -55,7 +55,7 @@ def build_losses(self, sentence_outputs = tf.cast( model_outputs['next_sentence'], dtype=tf.float32) sentence_loss = tf.reduce_mean( - tf.keras.losses.sparse_categorical_crossentropy( + tf_keras.losses.sparse_categorical_crossentropy( sentence_labels, sentence_outputs, from_logits=True)) metrics['next_sentence_loss'].update_state(sentence_loss) total_loss = mlm_loss + sentence_loss @@ -66,8 +66,8 @@ def build_losses(self, total_loss += tf.add_n(aux_losses) return total_loss, lm_prediction_losses - def train_step(self, inputs, model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, metrics): + def train_step(self, inputs, model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics): """Does forward and backward. Args: @@ -103,7 +103,7 @@ def train_step(self, inputs, model: tf.keras.Model, self.process_metrics(metrics, inputs, outputs) return {self.loss: loss} - def validation_step(self, inputs, model: tf.keras.Model, metrics): + def validation_step(self, inputs, model: tf_keras.Model, metrics): """Validatation step. Args: diff --git a/official/projects/token_dropping/masked_lm_test.py b/official/projects/token_dropping/masked_lm_test.py index 77174635c39..207f8f932b5 100644 --- a/official/projects/token_dropping/masked_lm_test.py +++ b/official/projects/token_dropping/masked_lm_test.py @@ -14,7 +14,7 @@ """Tests for official.nlp.tasks.masked_lm.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.nlp.configs import bert from official.nlp.configs import encoders @@ -49,7 +49,7 @@ def test_task(self): dataset = task.build_inputs(config.train_data) iterator = iter(dataset) - optimizer = tf.keras.optimizers.SGD(lr=0.1) + optimizer = tf_keras.optimizers.SGD(lr=0.1) task.train_step(next(iterator), model, optimizer, metrics=metrics) task.validation_step(next(iterator), model, metrics=metrics) diff --git a/official/projects/triviaqa/dataset.py b/official/projects/triviaqa/dataset.py index 8343a489c53..5c6bd14e056 100644 --- a/official/projects/triviaqa/dataset.py +++ b/official/projects/triviaqa/dataset.py @@ -20,7 +20,7 @@ from absl import logging import apache_beam as beam import six -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets.public_api as tfds from official.projects.triviaqa import preprocess diff --git a/official/projects/triviaqa/evaluate.py b/official/projects/triviaqa/evaluate.py index b80ea560eae..bd4d6f3fd5a 100644 --- a/official/projects/triviaqa/evaluate.py +++ b/official/projects/triviaqa/evaluate.py @@ -18,7 +18,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.triviaqa import evaluation diff --git a/official/projects/triviaqa/inputs.py b/official/projects/triviaqa/inputs.py index a518b9e104b..320d60bce9f 100644 --- a/official/projects/triviaqa/inputs.py +++ b/official/projects/triviaqa/inputs.py @@ -16,7 +16,7 @@ import os from typing import Optional, Text, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.modeling import tf_utils diff --git a/official/projects/triviaqa/modeling.py b/official/projects/triviaqa/modeling.py index cc598908bca..30b951f3ba1 100644 --- a/official/projects/triviaqa/modeling.py +++ b/official/projects/triviaqa/modeling.py @@ -13,13 +13,13 @@ # limitations under the License. """Modeling for TriviaQA.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp.configs import encoders -class TriviaQaHead(tf.keras.layers.Layer): +class TriviaQaHead(tf_keras.layers.Layer): """Computes logits given token and global embeddings.""" def __init__(self, @@ -29,17 +29,17 @@ def __init__(self, attention_dropout_rate=0.0, **kwargs): super(TriviaQaHead, self).__init__(**kwargs) - self._attention_dropout = tf.keras.layers.Dropout(attention_dropout_rate) - self._intermediate_dense = tf.keras.layers.Dense(intermediate_size) - self._intermediate_activation = tf.keras.layers.Activation( + self._attention_dropout = tf_keras.layers.Dropout(attention_dropout_rate) + self._intermediate_dense = tf_keras.layers.Dense(intermediate_size) + self._intermediate_activation = tf_keras.layers.Activation( intermediate_activation) - self._output_dropout = tf.keras.layers.Dropout(dropout_rate) - self._output_layer_norm = tf.keras.layers.LayerNormalization() - self._logits_dense = tf.keras.layers.Dense(2) + self._output_dropout = tf_keras.layers.Dropout(dropout_rate) + self._output_layer_norm = tf_keras.layers.LayerNormalization() + self._logits_dense = tf_keras.layers.Dense(2) def build(self, input_shape): output_shape = input_shape['token_embeddings'][-1] - self._output_dense = tf.keras.layers.Dense(output_shape) + self._output_dense = tf_keras.layers.Dense(output_shape) super(TriviaQaHead, self).build(input_shape) def call(self, inputs, training=None): @@ -59,14 +59,14 @@ def call(self, inputs, training=None): return logits -class TriviaQaModel(tf.keras.Model): +class TriviaQaModel(tf_keras.Model): """Model for TriviaQA.""" def __init__(self, model_config: encoders.EncoderConfig, sequence_length: int, **kwargs): inputs = dict( - token_ids=tf.keras.Input((sequence_length,), dtype=tf.int32), - question_lengths=tf.keras.Input((), dtype=tf.int32)) + token_ids=tf_keras.Input((sequence_length,), dtype=tf.int32), + question_lengths=tf_keras.Input((), dtype=tf.int32)) encoder = encoders.build_encoder(model_config) x = encoder( dict( @@ -91,7 +91,7 @@ def encoder(self): return self._encoder -class SpanOrCrossEntropyLoss(tf.keras.losses.Loss): +class SpanOrCrossEntropyLoss(tf_keras.losses.Loss): """Cross entropy loss for multiple correct answers. See https://arxiv.org/abs/1710.10723. diff --git a/official/projects/triviaqa/predict.py b/official/projects/triviaqa/predict.py index db2ed8dfc9d..c84c05763d1 100644 --- a/official/projects/triviaqa/predict.py +++ b/official/projects/triviaqa/predict.py @@ -22,7 +22,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds import sentencepiece as spm @@ -155,7 +155,7 @@ def main(argv): FLAGS.data_dir, FLAGS.split, FLAGS.batch_size, include_answers=False) # Initialize model and compile. with strategy.scope(): - model = tf.keras.models.load_model(FLAGS.saved_model_dir, compile=False) + model = tf_keras.models.load_model(FLAGS.saved_model_dir, compile=False) logging.info('Model initialized. Beginning prediction loop.') logits_fn = tf.function( functools.partial(prediction.distributed_logits_fn, model)) diff --git a/official/projects/triviaqa/prediction.py b/official/projects/triviaqa/prediction.py index 72a82ac5c39..0206428ce12 100644 --- a/official/projects/triviaqa/prediction.py +++ b/official/projects/triviaqa/prediction.py @@ -13,7 +13,7 @@ # limitations under the License. """Functions for inference.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def split_and_pad(strategy, batch_size, x): diff --git a/official/projects/triviaqa/train.py b/official/projects/triviaqa/train.py index b34038a0f20..1f8568d1d52 100644 --- a/official/projects/triviaqa/train.py +++ b/official/projects/triviaqa/train.py @@ -24,7 +24,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds import sentencepiece as spm @@ -180,7 +180,7 @@ def fit(model, logging.info(hparams) learning_rate_schedule = nlp_optimization.WarmUp( learning_rate, - tf.keras.optimizers.schedules.PolynomialDecay( + tf_keras.optimizers.schedules.PolynomialDecay( learning_rate, num_decay_steps, end_learning_rate=0., @@ -213,7 +213,7 @@ def init_fn(init_checkpoint_path): model.fit( train_dataset, callbacks=[ - tf.keras.callbacks.TensorBoard(model_dir, write_graph=False), + tf_keras.callbacks.TensorBoard(model_dir, write_graph=False), ]) ckpt_path = ckpt_manager.save() if evaluate_fn is None: @@ -233,12 +233,12 @@ def evaluate(sp_processor, features_map_fn, labels_map_fn, logits_fn, decode_logits_fn, split_and_pad_fn, distribute_strategy, validation_dataset, ground_truth): """Run evaluation.""" - loss_metric = tf.keras.metrics.Mean() + loss_metric = tf_keras.metrics.Mean() @tf.function def update_loss(y, logits): loss_fn = modeling.SpanOrCrossEntropyLoss( - reduction=tf.keras.losses.Reduction.NONE) + reduction=tf_keras.losses.Reduction.NONE) return loss_metric(loss_fn(y, logits)) predictions = collections.defaultdict(list) diff --git a/official/projects/unified_detector/data_conversion/convert.py b/official/projects/unified_detector/data_conversion/convert.py index ce7613e3e03..a442b9c3e12 100644 --- a/official/projects/unified_detector/data_conversion/convert.py +++ b/official/projects/unified_detector/data_conversion/convert.py @@ -29,7 +29,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras import tqdm import utils diff --git a/official/projects/unified_detector/data_conversion/utils.py b/official/projects/unified_detector/data_conversion/utils.py index c20b0cfdad4..dc8bad23571 100644 --- a/official/projects/unified_detector/data_conversion/utils.py +++ b/official/projects/unified_detector/data_conversion/utils.py @@ -19,7 +19,7 @@ import cv2 import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras def encode_image( diff --git a/official/projects/unified_detector/data_loaders/autoaugment.py b/official/projects/unified_detector/data_loaders/autoaugment.py index 940807ce9d9..5e448a16384 100644 --- a/official/projects/unified_detector/data_loaders/autoaugment.py +++ b/official/projects/unified_detector/data_loaders/autoaugment.py @@ -35,7 +35,7 @@ import inspect import math -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_addons.image as tfa_image # This signifies the max integer that the controller RNN could predict for the diff --git a/official/projects/unified_detector/data_loaders/input_reader.py b/official/projects/unified_detector/data_loaders/input_reader.py index 62a6ec66047..432a7a96ddb 100644 --- a/official/projects/unified_detector/data_loaders/input_reader.py +++ b/official/projects/unified_detector/data_loaders/input_reader.py @@ -24,7 +24,7 @@ import gin from six.moves import map -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from research.object_detection.utils import label_map_util diff --git a/official/projects/unified_detector/data_loaders/tf_example_decoder.py b/official/projects/unified_detector/data_loaders/tf_example_decoder.py index 3d6824b1b90..c7aee105a09 100644 --- a/official/projects/unified_detector/data_loaders/tf_example_decoder.py +++ b/official/projects/unified_detector/data_loaders/tf_example_decoder.py @@ -16,7 +16,7 @@ from typing import List, Optional, Sequence, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.unified_detector.utils.typing import TensorDict from official.vision.dataloaders import decoder diff --git a/official/projects/unified_detector/data_loaders/universal_detection_parser.py b/official/projects/unified_detector/data_loaders/universal_detection_parser.py index 6433fd6e265..ab6c36a2684 100644 --- a/official/projects/unified_detector/data_loaders/universal_detection_parser.py +++ b/official/projects/unified_detector/data_loaders/universal_detection_parser.py @@ -19,7 +19,7 @@ from typing import Any, Tuple import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.unified_detector.data_loaders import autoaugment from official.projects.unified_detector.data_loaders import tf_example_decoder diff --git a/official/projects/unified_detector/external_configurables.py b/official/projects/unified_detector/external_configurables.py index 0fb200a54a1..ce408990220 100644 --- a/official/projects/unified_detector/external_configurables.py +++ b/official/projects/unified_detector/external_configurables.py @@ -16,7 +16,7 @@ import gin import gin.tf.external_configurables -import tensorflow as tf +import tensorflow as tf, tf_keras # Tensorflow. -gin.external_configurable(tf.keras.layers.experimental.SyncBatchNormalization) +gin.external_configurable(tf_keras.layers.experimental.SyncBatchNormalization) diff --git a/official/projects/unified_detector/modeling/universal_detector.py b/official/projects/unified_detector/modeling/universal_detector.py index df17736b8aa..3b022dc1fef 100644 --- a/official/projects/unified_detector/modeling/universal_detector.py +++ b/official/projects/unified_detector/modeling/universal_detector.py @@ -17,7 +17,7 @@ from typing import Any, Dict, Optional, Sequence, Tuple, Union import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from deeplab2 import config_pb2 from deeplab2.model.decoder import max_deeplab as max_deeplab_head @@ -49,7 +49,7 @@ def universal_detection_loss_weights( @gin.configurable -class LayerNorm(tf.keras.layers.LayerNormalization): +class LayerNorm(tf_keras.layers.LayerNormalization): """A wrapper to allow passing the `training` argument. The normalization layers in the MaX-DeepLab implementation are passed with @@ -79,13 +79,13 @@ def get_max_deep_lab_backbone(num_slots: int = 128): @gin.configurable -class UniversalDetector(tf.keras.layers.Layer): +class UniversalDetector(tf_keras.layers.Layer): """Univeral Detector.""" loss_items = ("loss_pq", "loss_inst_dist", "loss_para", "loss_mask_id", "loss_segmentation_word") def __init__(self, - backbone_fn: tf.keras.layers.Layer = get_max_deep_lab_backbone, + backbone_fn: tf_keras.layers.Layer = get_max_deep_lab_backbone, mask_threshold: float = 0.4, class_threshold: float = 0.5, filter_area: float = 32, @@ -480,7 +480,7 @@ def _get_decoder_head( }), num_classes=3, aux_sem_intermediate=256, - norm_fn=tf.keras.layers.BatchNormalization, + norm_fn=tf_keras.layers.BatchNormalization, ) -> max_deeplab_head.MaXDeepLab: """Get the MaX-DeepLab prediction head. @@ -519,7 +519,7 @@ def _get_decoder_head( configs.max_deeplab, 0, norm_fn) -class PseudoLayer(tf.keras.layers.Layer): +class PseudoLayer(tf_keras.layers.Layer): """Pseudo layer for ablation study. The `call()` function has the same argument signature as a transformer @@ -536,9 +536,9 @@ def __init__(self, extra_fc: bool): super().__init__(name="extra_fc") self._extra_fc = extra_fc if extra_fc: - self._layer = tf.keras.Sequential([ - tf.keras.layers.Dense(256, activation="relu"), - tf.keras.layers.LayerNormalization(), + self._layer = tf_keras.Sequential([ + tf_keras.layers.Dense(256, activation="relu"), + tf_keras.layers.LayerNormalization(), ]) def call(self, @@ -555,18 +555,18 @@ def call(self, @gin.configurable() def _get_embed_head( dimension=256, - norm_fn=tf.keras.layers.BatchNormalization -) -> Tuple[tf.keras.Sequential, tf.keras.Sequential]: + norm_fn=tf_keras.layers.BatchNormalization +) -> Tuple[tf_keras.Sequential, tf_keras.Sequential]: """Projection layers to get instance & grouping features.""" - instance_head = tf.keras.Sequential([ - tf.keras.layers.Dense(dimension, use_bias=False), + instance_head = tf_keras.Sequential([ + tf_keras.layers.Dense(dimension, use_bias=False), norm_fn(), - tf.keras.layers.ReLU(), + tf_keras.layers.ReLU(), ]) - grouping_head = tf.keras.Sequential([ - tf.keras.layers.Dense(dimension, use_bias=False), + grouping_head = tf_keras.Sequential([ + tf_keras.layers.Dense(dimension, use_bias=False), norm_fn(), - tf.keras.layers.ReLU(), + tf_keras.layers.ReLU(), ]) return instance_head, grouping_head @@ -575,7 +575,7 @@ def _get_embed_head( def _get_para_head( dimension=128, num_layer=3, - extra_fc=False) -> Tuple[tf.keras.layers.Layer, tf.keras.layers.Layer]: + extra_fc=False) -> Tuple[tf_keras.layers.Layer, tf_keras.layers.Layer]: """Get the additional para head. Args: @@ -602,7 +602,7 @@ def _get_para_head( }) else: encoder = PseudoLayer(extra_fc) - dense = tf.keras.layers.Dense(dimension) + dense = tf_keras.layers.Dense(dimension) return encoder, dense @@ -815,11 +815,11 @@ def _paragraph_grouping_loss( # step 3: # compute loss - loss_fn = tf.keras.losses.BinaryCrossentropy( + loss_fn = tf_keras.losses.BinaryCrossentropy( from_logits=True, label_smoothing=0, axis=-1, - reduction=tf.keras.losses.Reduction.NONE, + reduction=tf_keras.losses.Reduction.NONE, name="para_dist") affinity = tf.reshape(affinity, (-1, 1)) # (b*n*n, 1) gt_affinity = tf.reshape(gt_affinity, (-1, 1)) # (b*n*n, 1) diff --git a/official/projects/unified_detector/run_inference.py b/official/projects/unified_detector/run_inference.py index bc5a52e760a..7a4fff4aeb7 100644 --- a/official/projects/unified_detector/run_inference.py +++ b/official/projects/unified_detector/run_inference.py @@ -25,7 +25,7 @@ import cv2 import gin import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tqdm from official.projects.unified_detector import external_configurables # pylint: disable=unused-import @@ -81,7 +81,7 @@ def _preprocess(raw_image: np.ndarray) -> Union[np.ndarray, float]: return tf.expand_dims(img_tensor, 0).numpy(), float(ratio) -def load_model() -> tf.keras.layers.Layer: +def load_model() -> tf_keras.layers.Layer: gin.parse_config_file(_GIN_FILE.value) model = universal_detector.UniversalDetector() ckpt = tf.train.Checkpoint(model=model) @@ -91,7 +91,7 @@ def load_model() -> tf.keras.layers.Layer: return model -def inference(img_file: str, model: tf.keras.layers.Layer) -> Dict[str, Any]: +def inference(img_file: str, model: tf_keras.layers.Layer) -> Dict[str, Any]: """Inference step.""" img = cv2.cvtColor(cv2.imread(img_file), cv2.COLOR_BGR2RGB) img_ndarray, ratio = _preprocess(img) diff --git a/official/projects/unified_detector/tasks/ocr_task.py b/official/projects/unified_detector/tasks/ocr_task.py index ea317485350..100b01a8a43 100644 --- a/official/projects/unified_detector/tasks/ocr_task.py +++ b/official/projects/unified_detector/tasks/ocr_task.py @@ -17,7 +17,7 @@ from typing import Callable, Dict, Optional, Sequence, Tuple, Union import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -28,7 +28,7 @@ from official.projects.unified_detector.utils import typing NestedTensorDict = typing.NestedTensorDict -ModelType = Union[tf.keras.layers.Layer, tf.keras.Model] +ModelType = Union[tf_keras.layers.Layer, tf_keras.Model] @task_factory.register_task_cls(ocr_config.OcrTaskConfig) @@ -62,13 +62,13 @@ def build_inputs( input_context) def build_metrics(self, - training: bool = True) -> Sequence[tf.keras.metrics.Metric]: + training: bool = True) -> Sequence[tf_keras.metrics.Metric]: """Build the metrics (currently, only for loss summaries in TensorBoard).""" del training metrics = [] # Add loss items for name in self._loss_items: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) # TODO(longshangbang): add evaluation metrics return metrics @@ -76,8 +76,8 @@ def train_step( self, inputs: Tuple[NestedTensorDict, NestedTensorDict], model: ModelType, - optimizer: tf.keras.optimizers.Optimizer, - metrics: Optional[Sequence[tf.keras.metrics.Metric]] = None + optimizer: tf_keras.optimizers.Optimizer, + metrics: Optional[Sequence[tf_keras.metrics.Metric]] = None ) -> Dict[str, tf.Tensor]: features, labels = inputs input_dict = {"features": features} @@ -85,7 +85,7 @@ def train_step( input_dict["labels"] = labels is_mixed_precision = isinstance(optimizer, - tf.keras.mixed_precision.LossScaleOptimizer) + tf_keras.mixed_precision.LossScaleOptimizer) with tf.GradientTape() as tape: outputs = model(**input_dict, training=True) diff --git a/official/projects/unified_detector/utils/typing.py b/official/projects/unified_detector/utils/typing.py index 6c4241f5862..db4b636ddfa 100644 --- a/official/projects/unified_detector/utils/typing.py +++ b/official/projects/unified_detector/utils/typing.py @@ -17,7 +17,7 @@ from typing import Dict, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras NpDict = Dict[str, np.ndarray] FeaturesAndLabelsType = Dict[str, Dict[str, tf.Tensor]] diff --git a/official/projects/unified_detector/utils/utilities.py b/official/projects/unified_detector/utils/utilities.py index d83e111c178..bf6aa43588c 100644 --- a/official/projects/unified_detector/utils/utilities.py +++ b/official/projects/unified_detector/utils/utilities.py @@ -17,7 +17,7 @@ import collections from typing import List, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras def resolve_shape( diff --git a/official/projects/video_ssl/configs/video_ssl_test.py b/official/projects/video_ssl/configs/video_ssl_test.py index b35d8edea1e..671b31585d4 100644 --- a/official/projects/video_ssl/configs/video_ssl_test.py +++ b/official/projects/video_ssl/configs/video_ssl_test.py @@ -15,7 +15,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/projects/video_ssl/dataloaders/video_ssl_input.py b/official/projects/video_ssl/dataloaders/video_ssl_input.py index 291e646f4fe..a87e798de29 100644 --- a/official/projects/video_ssl/dataloaders/video_ssl_input.py +++ b/official/projects/video_ssl/dataloaders/video_ssl_input.py @@ -17,7 +17,7 @@ from typing import Dict, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.video_ssl.configs import video_ssl as exp_cfg from official.projects.video_ssl.ops import video_ssl_preprocess_ops from official.vision.dataloaders import video_input diff --git a/official/projects/video_ssl/dataloaders/video_ssl_input_test.py b/official/projects/video_ssl/dataloaders/video_ssl_input_test.py index e785b310e56..4277f595ae3 100644 --- a/official/projects/video_ssl/dataloaders/video_ssl_input_test.py +++ b/official/projects/video_ssl/dataloaders/video_ssl_input_test.py @@ -18,7 +18,7 @@ # Import libraries import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.video_ssl.configs import video_ssl as exp_cfg from official.projects.video_ssl.dataloaders import video_ssl_input diff --git a/official/projects/video_ssl/losses/losses.py b/official/projects/video_ssl/losses/losses.py index a2adaf63fea..df2c289d622 100644 --- a/official/projects/video_ssl/losses/losses.py +++ b/official/projects/video_ssl/losses/losses.py @@ -15,7 +15,7 @@ """Define losses.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.compiler.tf2xla.python import xla diff --git a/official/projects/video_ssl/modeling/video_ssl_model.py b/official/projects/video_ssl/modeling/video_ssl_model.py index a04c14b8253..ec4c42b36df 100644 --- a/official/projects/video_ssl/modeling/video_ssl_model.py +++ b/official/projects/video_ssl/modeling/video_ssl_model.py @@ -17,17 +17,17 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.projects.video_ssl.configs import video_ssl as video_ssl_cfg from official.vision.modeling import backbones from official.vision.modeling import factory_3d as model_factory -layers = tf.keras.layers +layers = tf_keras.layers -class VideoSSLModel(tf.keras.Model): +class VideoSSLModel(tf_keras.Model): """A video ssl model class builder.""" def __init__(self, @@ -38,7 +38,7 @@ def __init__(self, hidden_norm_args, projection_dim, input_specs: Optional[Mapping[str, - tf.keras.layers.InputSpec]] = None, + tf_keras.layers.InputSpec]] = None, dropout_rate: float = 0.0, aggregate_endpoints: bool = False, kernel_initializer='random_uniform', @@ -54,14 +54,14 @@ def __init__(self, hidden_layer_num: `int` number of hidden layers in MLP. hidden_norm_args: `dict` for batchnorm arguments in MLP. projection_dim: `int` number of output dimension for MLP. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. dropout_rate: `float` rate for dropout regularization. aggregate_endpoints: `bool` aggregate all end ponits or only use the final end point. kernel_initializer: kernel initializer for the dense layer. - kernel_regularizer: tf.keras.regularizers.Regularizer object. Default to + kernel_regularizer: tf_keras.regularizers.Regularizer object. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object. Default to + bias_regularizer: tf_keras.regularizers.Regularizer object. Default to None. **kwargs: keyword arguments to be passed. """ @@ -93,19 +93,19 @@ def __init__(self, self._backbone = backbone inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } endpoints = backbone(inputs['image']) if aggregate_endpoints: pooled_feats = [] for endpoint in endpoints.values(): - x_pool = tf.keras.layers.GlobalAveragePooling3D()(endpoint) + x_pool = tf_keras.layers.GlobalAveragePooling3D()(endpoint) pooled_feats.append(x_pool) x = tf.concat(pooled_feats, axis=1) else: x = endpoints[max(endpoints.keys())] - x = tf.keras.layers.GlobalAveragePooling3D()(x) + x = tf_keras.layers.GlobalAveragePooling3D()(x) # L2 Normalize feature after backbone if normalize_feature: @@ -113,19 +113,19 @@ def __init__(self, # MLP hidden layers for _ in range(hidden_layer_num): - x = tf.keras.layers.Dense(hidden_dim)(x) + x = tf_keras.layers.Dense(hidden_dim)(x) if self._config_dict['use_sync_bn']: - x = tf.keras.layers.experimental.SyncBatchNormalization( + x = tf_keras.layers.experimental.SyncBatchNormalization( momentum=self._config_dict['norm_momentum'], epsilon=self._config_dict['norm_epsilon'])(x) else: - x = tf.keras.layers.BatchNormalization( + x = tf_keras.layers.BatchNormalization( momentum=self._config_dict['norm_momentum'], epsilon=self._config_dict['norm_epsilon'])(x) x = tf_utils.get_activation(self._config_dict['activation'])(x) # Projection head - x = tf.keras.layers.Dense(projection_dim)(x) + x = tf_keras.layers.Dense(projection_dim)(x) super().__init__(inputs=inputs, outputs=x, **kwargs) @@ -148,10 +148,10 @@ def from_config(cls, config, custom_objects=None): @model_factory.register_model_builder('video_ssl_model') def build_video_ssl_pretrain_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: video_ssl_cfg.VideoSSLModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds the video classification model.""" del num_classes input_specs_dict = {'image': input_specs} diff --git a/official/projects/video_ssl/ops/video_ssl_preprocess_ops.py b/official/projects/video_ssl/ops/video_ssl_preprocess_ops.py index f3008bffb54..ef3ae2b1d61 100644 --- a/official/projects/video_ssl/ops/video_ssl_preprocess_ops.py +++ b/official/projects/video_ssl/ops/video_ssl_preprocess_ops.py @@ -16,7 +16,7 @@ import functools from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras def random_apply(func, p, x): diff --git a/official/projects/video_ssl/ops/video_ssl_preprocess_ops_test.py b/official/projects/video_ssl/ops/video_ssl_preprocess_ops_test.py index 73c5b3e67f6..29d14d27255 100644 --- a/official/projects/video_ssl/ops/video_ssl_preprocess_ops_test.py +++ b/official/projects/video_ssl/ops/video_ssl_preprocess_ops_test.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.video_ssl.ops import video_ssl_preprocess_ops from official.vision.ops import preprocess_ops_3d diff --git a/official/projects/video_ssl/tasks/linear_eval.py b/official/projects/video_ssl/tasks/linear_eval.py index f4ce0cf23d1..3fa7fa38e04 100644 --- a/official/projects/video_ssl/tasks/linear_eval.py +++ b/official/projects/video_ssl/tasks/linear_eval.py @@ -15,7 +15,7 @@ """Video ssl linear evaluation task definition.""" from typing import Any, Optional, List, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.core import task_factory @@ -28,7 +28,7 @@ class VideoSSLEvalTask(video_classification.VideoClassificationTask): """A task for video ssl linear evaluation.""" - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -49,8 +49,8 @@ def initialize(self, model: tf.keras.Model): def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. diff --git a/official/projects/video_ssl/tasks/pretrain.py b/official/projects/video_ssl/tasks/pretrain.py index 1dbfc9d3b31..935df1ff7fa 100644 --- a/official/projects/video_ssl/tasks/pretrain.py +++ b/official/projects/video_ssl/tasks/pretrain.py @@ -14,7 +14,7 @@ """Video ssl pretrain task definition.""" from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.core import input_reader @@ -39,7 +39,7 @@ def build_model(self): for d1, d2 in zip(self.task_config.train_data.feature_shape, self.task_config.validation_data.feature_shape) ] - input_specs = tf.keras.layers.InputSpec(shape=[None] + common_input_shape) + input_specs = tf_keras.layers.InputSpec(shape=[None] + common_input_shape) logging.info('Build model input %r', common_input_shape) model = factory_3d.build_model( @@ -104,9 +104,9 @@ def build_losses(self, model_outputs, num_replicas, model): def build_metrics(self, training=True): """Gets streaming metrics for training/validation.""" metrics = [ - tf.keras.metrics.Mean(name='contrast_acc'), - tf.keras.metrics.Mean(name='contrast_entropy'), - tf.keras.metrics.Mean(name='reg_loss') + tf_keras.metrics.Mean(name='contrast_acc'), + tf_keras.metrics.Mean(name='contrast_entropy'), + tf_keras.metrics.Mean(name='reg_loss') ] return metrics @@ -151,14 +151,14 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) diff --git a/official/projects/video_ssl/tasks/pretrain_test.py b/official/projects/video_ssl/tasks/pretrain_test.py index c4ad2ebeb1d..44f285a0e07 100644 --- a/official/projects/video_ssl/tasks/pretrain_test.py +++ b/official/projects/video_ssl/tasks/pretrain_test.py @@ -18,7 +18,7 @@ import random import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official import vision diff --git a/official/projects/videoglue/datasets/action_localization.py b/official/projects/videoglue/datasets/action_localization.py index 1e63c32e059..2514c10ce22 100644 --- a/official/projects/videoglue/datasets/action_localization.py +++ b/official/projects/videoglue/datasets/action_localization.py @@ -18,7 +18,7 @@ from typing import Any, Dict, List, Mapping, Optional, Union from dmvr import video_dataset -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.datasets.common import utils diff --git a/official/projects/videoglue/datasets/common/processors.py b/official/projects/videoglue/datasets/common/processors.py index 38cd4c3e240..bd1ab1332e4 100644 --- a/official/projects/videoglue/datasets/common/processors.py +++ b/official/projects/videoglue/datasets/common/processors.py @@ -18,7 +18,7 @@ from dmvr import processors import simclr.data_util as simclr_data -import tensorflow as tf +import tensorflow as tf, tf_keras sample_sequence = processors.sample_sequence sample_linsapce_sequence = processors.sample_linspace_sequence diff --git a/official/projects/videoglue/datasets/common/utils.py b/official/projects/videoglue/datasets/common/utils.py index 40eb5f51f28..357bb3f75a4 100644 --- a/official/projects/videoglue/datasets/common/utils.py +++ b/official/projects/videoglue/datasets/common/utils.py @@ -18,7 +18,7 @@ from dmvr import builders from dmvr import modalities -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.datasets.common import processors from official.vision.ops import augment diff --git a/official/projects/videoglue/datasets/dataset_factory.py b/official/projects/videoglue/datasets/dataset_factory.py index 99bbf2c7c83..68b3598bc37 100644 --- a/official/projects/videoglue/datasets/dataset_factory.py +++ b/official/projects/videoglue/datasets/dataset_factory.py @@ -17,7 +17,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.projects.videoglue.datasets import action_localization diff --git a/official/projects/videoglue/datasets/video_classification.py b/official/projects/videoglue/datasets/video_classification.py index bb29a1e3774..6a7d3e2bac7 100644 --- a/official/projects/videoglue/datasets/video_classification.py +++ b/official/projects/videoglue/datasets/video_classification.py @@ -17,7 +17,7 @@ from typing import Any, Mapping, Optional from dmvr import video_dataset -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.datasets.common import utils from official.vision.ops import augment diff --git a/official/projects/videoglue/evaluation/spatiotemporal_action_localization_evaluator.py b/official/projects/videoglue/evaluation/spatiotemporal_action_localization_evaluator.py index 2fadb9a8999..4063b2ed6b6 100644 --- a/official/projects/videoglue/evaluation/spatiotemporal_action_localization_evaluator.py +++ b/official/projects/videoglue/evaluation/spatiotemporal_action_localization_evaluator.py @@ -17,7 +17,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from object_detection.utils import object_detection_evaluation diff --git a/official/projects/videoglue/modeling/backbones/vit_3d.py b/official/projects/videoglue/modeling/backbones/vit_3d.py index f534eaaa654..78ddc5eceb9 100644 --- a/official/projects/videoglue/modeling/backbones/vit_3d.py +++ b/official/projects/videoglue/modeling/backbones/vit_3d.py @@ -17,7 +17,7 @@ from typing import Any, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.configs import backbones_3d as cfg from official.vision.modeling.backbones import factory @@ -25,14 +25,14 @@ Encoder = vit.Encoder TokenLayer = vit.TokenLayer -layers = tf.keras.layers +layers = tf_keras.layers -class AddSeparablePositionEmbs(tf.keras.layers.Layer): +class AddSeparablePositionEmbs(tf_keras.layers.Layer): """Adds (optionally learned) positional embeddings to the inputs.""" def __init__(self, - posemb_init: Optional[tf.keras.initializers.Initializer] = None, + posemb_init: Optional[tf_keras.initializers.Initializer] = None, posemb_origin_shape: Optional[Tuple[int, int]] = None, posemb_target_shape: Optional[Tuple[int, int]] = None, **kwargs): @@ -69,12 +69,12 @@ def build(self, inputs_shape): 'pos_embedding_time', (1, nt, nc), dtype=tf.float32, - initializer=tf.keras.initializers.TruncatedNormal(0.02)) + initializer=tf_keras.initializers.TruncatedNormal(0.02)) self._pos_embedding_space = self.add_weight( 'pos_embedding_space', (1, nl, nc), dtype=tf.float32, - initializer=tf.keras.initializers.TruncatedNormal(0.02)) + initializer=tf_keras.initializers.TruncatedNormal(0.02)) def _interpolate(self, pos_embedding: tf.Tensor, from_shape: Tuple[int, int], @@ -111,7 +111,7 @@ def call(self, inputs: tf.Tensor, inputs_positions: Any = None) -> tf.Tensor: return inputs + pos_embedding_time + pos_embedding_space -class VisionTransformer3D(tf.keras.Model): +class VisionTransformer3D(tf_keras.Model): """Class to build VisionTransformer-3D family model. The Vision Transformer architecture with the modification on the first @@ -135,7 +135,7 @@ def __init__( hidden_size: int = 768, representation_size: int = 0, pooler: str = 'token', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, original_init: bool = True, pos_embed_shape: Optional[ Union[Tuple[int, int], Tuple[int, int, int]]] = None): @@ -184,7 +184,7 @@ def __init__( nh = self._input_specs.shape[2] // self._spatial_patch_size nw = self._input_specs.shape[3] // self._spatial_patch_size - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) add_pos_embed = True if self._variant == 'native': x = self._tokenize(inputs) @@ -225,7 +225,7 @@ def __init__( raise ValueError(f'unrecognized pooler type: {pooler}') if representation_size: - x = tf.keras.layers.Dense( + x = tf_keras.layers.Dense( representation_size, kernel_regularizer=kernel_regularizer, name='pre_logits', @@ -247,7 +247,7 @@ def __init__( def _tokenize(self, inputs: tf.Tensor): """The first layer to tokenize and project the input tensor.""" - x = tf.keras.layers.Conv3D( + x = tf_keras.layers.Conv3D( filters=self._hidden_size, kernel_size=self._patch_size, strides=self._patch_size, @@ -255,14 +255,14 @@ def _tokenize(self, inputs: tf.Tensor): kernel_regularizer=self._kernel_regularizer, kernel_initializer=('lecun_normal' if self._original_init else 'he_uniform'))(inputs) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': time_axis, rows_axis, cols_axis = (1, 2, 3) else: time_axis, rows_axis, cols_axis = (2, 3, 4) # The reshape below assumes the data_format is 'channels_last,' so # transpose to that. Once the data is flattened by the reshape, the # data_format is irrelevant, so no need to update - # tf.keras.backend.image_data_format. + # tf_keras.backend.image_data_format. x = tf.transpose(x, perm=[0, 2, 3, 4, 1]) nt = self._input_specs.shape[time_axis] // self._temporal_patch_size @@ -281,7 +281,7 @@ def _mae_tokenize(self, inputs: tf.Tensor): mean = tf.constant((0.45, 0.45, 0.45), dtype=inputs.dtype) std = tf.constant((0.225, 0.225, 0.225), dtype=inputs.dtype) inputs = (inputs - mean) / std - x = tf.keras.layers.Conv3D( + x = tf_keras.layers.Conv3D( filters=self._hidden_size, kernel_size=self._patch_size, strides=self._patch_size, @@ -289,14 +289,14 @@ def _mae_tokenize(self, inputs: tf.Tensor): kernel_regularizer=self._kernel_regularizer, kernel_initializer=('lecun_normal' if self._original_init else 'he_uniform'))(inputs) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': time_axis, rows_axis, cols_axis = (1, 2, 3) else: time_axis, rows_axis, cols_axis = (2, 3, 4) # The reshape below assumes the data_format is 'channels_last,' so # transpose to that. Once the data is flattened by the reshape, the # data_format is irrelevant, so no need to update - # tf.keras.backend.image_data_format. + # tf_keras.backend.image_data_format. x = tf.transpose(x, perm=[0, 2, 3, 4, 1]) nc = x.shape[-1] @@ -316,10 +316,10 @@ def _mae_tokenize(self, inputs: tf.Tensor): @factory.register_backbone_builder('vit_3d') def build_vit_3d( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: cfg.Backbone3D, norm_activation_config: Any, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None): + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None): """Builds ViT-3D model. Args: diff --git a/official/projects/videoglue/modeling/heads/action_transformer.py b/official/projects/videoglue/modeling/heads/action_transformer.py index 6ceae6ab7ca..5e85a26d7c8 100644 --- a/official/projects/videoglue/modeling/heads/action_transformer.py +++ b/official/projects/videoglue/modeling/heads/action_transformer.py @@ -15,7 +15,7 @@ """The implementation of action transformer head.""" from typing import Mapping, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.modeling.heads import simple from official.projects.videoglue.modeling.heads import transformer_decoder @@ -29,7 +29,7 @@ def _get_shape(x: tf.Tensor): return [dynamic[i] if s is None else s for i, s in enumerate(static)] -class ActionTransformerHead(tf.keras.layers.Layer): +class ActionTransformerHead(tf_keras.layers.Layer): """A Video Action Transformer Head. Reference: Girdhar, Rohit et. al. "Video action transformer network." In CVPR @@ -58,8 +58,8 @@ def __init__( attention_dropout_rate: float = 0.0, layer_norm_epsilon: float = 1e-6, use_positional_embedding: bool = True, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, name: str = 'action_transformer_classifier', **kwargs, ): @@ -83,8 +83,8 @@ def __init__( attention_dropout_rate: The attention dropout rate. layer_norm_epsilon: The layer norm epsilon. use_positional_embedding: Whether to use positional embedding. - kernel_regularizer: tf.keras.regularizers.Regularizer object. - bias_regularizer: tf.keras.regularizers.Regularizer object. + kernel_regularizer: tf_keras.regularizers.Regularizer object. + bias_regularizer: tf_keras.regularizers.Regularizer object. name: The head name. **kwargs: Keyword arguments to be passed. """ @@ -101,14 +101,14 @@ def __init__( if self._use_positional_embedding: self._spatial_mlp = [ - tf.keras.layers.Dense( + tf_keras.layers.Dense( 4, use_bias=True, activation='relu', name='spatial_mlp_l1', kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer), - tf.keras.layers.Dense( + tf_keras.layers.Dense( 8, use_bias=True, name='spatial_mlp_l2', @@ -116,14 +116,14 @@ def __init__( bias_regularizer=bias_regularizer), ] self._temporal_mlp = [ - tf.keras.layers.Dense( + tf_keras.layers.Dense( 4, use_bias=True, activation='relu', name='temporal_mlp_l1', kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer), - tf.keras.layers.Dense( + tf_keras.layers.Dense( 8, use_bias=True, name='temporal_mlp_l2', @@ -134,7 +134,7 @@ def __init__( self._roi_aligner = roi_aligner.MultilevelROIAligner( crop_size=crop_size, sample_offset=sample_offset) - self._max_pooler = tf.keras.layers.MaxPool2D( + self._max_pooler = tf_keras.layers.MaxPool2D( pool_size=(crop_size, crop_size), strides=1, padding='valid') @@ -153,7 +153,7 @@ def __init__( else: self._attention_decoder = None - self._dropout_layer = tf.keras.layers.Dropout(dropout_rate) + self._dropout_layer = tf_keras.layers.Dropout(dropout_rate) self._classifier = simple.MLP( num_hidden_layers=self._num_hidden_layers, num_hidden_channels=self._num_hidden_channels, diff --git a/official/projects/videoglue/modeling/heads/simple.py b/official/projects/videoglue/modeling/heads/simple.py index 6364aa35a3d..4efcad71395 100644 --- a/official/projects/videoglue/modeling/heads/simple.py +++ b/official/projects/videoglue/modeling/heads/simple.py @@ -16,16 +16,16 @@ from typing import Any, Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.modeling.backbones import vit -class AddTemporalPositionEmbs(tf.keras.layers.Layer): +class AddTemporalPositionEmbs(tf_keras.layers.Layer): """Adds learned temporal positional embeddings to the video features.""" def __init__(self, - posemb_init: Optional[tf.keras.initializers.Initializer] = None, + posemb_init: Optional[tf_keras.initializers.Initializer] = None, **kwargs): """Constructs Postional Embedding module. @@ -51,7 +51,7 @@ def call(self, inputs: tf.Tensor) -> tf.Tensor: return inputs -class MLP(tf.keras.layers.Layer): +class MLP(tf_keras.layers.Layer): """Constructs the Multi-Layer Perceptron head.""" def __init__( @@ -64,8 +64,8 @@ def __init__( norm_epsilon: float = 1e-5, activation: Optional[str] = None, normalize_inputs: bool = False, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Multi-Layer Perceptron initialization. @@ -78,8 +78,8 @@ def __init__( norm_epsilon: the batch norm epsilon. activation: the activation function. normalize_inputs: whether to normalize inputs. - kernel_regularizer: tf.keras.regularizers.Regularizer object. - bias_regularizer: tf.keras.regularizers.Regularizer object. + kernel_regularizer: tf_keras.regularizers.Regularizer object. + bias_regularizer: tf_keras.regularizers.Regularizer object. **kwargs: keyword arguments to be passed. """ super().__init__(**kwargs) @@ -99,26 +99,26 @@ def __init__( # MLP hidden layers for _ in range(num_hidden_layers): self._layers.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( num_hidden_channels, use_bias=False, kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)) if use_sync_bn: self._layers.append( - tf.keras.layers.experimental.SyncBatchNormalization( + tf_keras.layers.experimental.SyncBatchNormalization( momentum=norm_momentum, epsilon=norm_epsilon)) else: self._layers.append( - tf.keras.layers.BatchNormalization( + tf_keras.layers.BatchNormalization( momentum=norm_momentum, epsilon=norm_epsilon)) if activation is not None: self._layers.append(tf_utils.get_activation(activation)) # Projection head - self._layers.append(tf.keras.layers.Dense(num_output_channels)) + self._layers.append(tf_keras.layers.Dense(num_output_channels)) def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: """Forward calls with N-D inputs tensor.""" @@ -126,7 +126,7 @@ def call(self, inputs: tf.Tensor, training: bool) -> tf.Tensor: inputs = tf.nn.l2_normalize(inputs, axis=-1) for layer in self._layers: - if isinstance(layer, tf.keras.layers.Layer): + if isinstance(layer, tf_keras.layers.Layer): inputs = layer(inputs, training=training) else: # activation inputs = layer(inputs) @@ -154,7 +154,7 @@ def from_config(cls, config: Mapping[str, Any]): return cls(**config) -class AttentionPoolerClassificationHead(tf.keras.layers.Layer): +class AttentionPoolerClassificationHead(tf_keras.layers.Layer): """Head layer for attention pooling classification network. Applies pooling attention, dropout, and classifier projection. Expects input @@ -170,8 +170,8 @@ def __init__( dropout_rate: float = 0., kernel_initializer: str = 'HeNormal', kernel_regularizer: Optional[ - tf.keras.regularizers.Regularizer] = tf.keras.regularizers.L2(1.5e-5), - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + tf_keras.regularizers.Regularizer] = tf_keras.regularizers.L2(1.5e-5), + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, add_temporal_pos_embed: bool = False, **kwargs): """Implementation for video model classifier head. @@ -201,17 +201,17 @@ def __init__( self._add_temporal_pos_embed = add_temporal_pos_embed if self._add_temporal_pos_embed: self._pos_embed = AddTemporalPositionEmbs( - posemb_init=tf.keras.initializers.RandomNormal(stddev=0.02), + posemb_init=tf_keras.initializers.RandomNormal(stddev=0.02), name='posembed_final_learnt', ) - self._pooler_attention_layer_norm = tf.keras.layers.LayerNormalization( + self._pooler_attention_layer_norm = tf_keras.layers.LayerNormalization( name='pooler_attention_layer_norm', axis=-1, epsilon=1e-6, dtype=tf.float32) - self._pooler_attention_layer = tf.keras.layers.MultiHeadAttention( + self._pooler_attention_layer = tf_keras.layers.MultiHeadAttention( num_heads=num_heads, key_dim=(hidden_size // num_heads), value_dim=None, @@ -220,8 +220,8 @@ def __init__( kernel_initializer='glorot_uniform', name='pooler_attention') - self._dropout = tf.keras.layers.Dropout(dropout_rate) - self._classifier = tf.keras.layers.Dense( + self._dropout = tf_keras.layers.Dropout(dropout_rate) + self._classifier = tf_keras.layers.Dense( num_classes, kernel_initializer=kernel_initializer, kernel_regularizer=self._kernel_regularizer, diff --git a/official/projects/videoglue/modeling/heads/transformer_decoder.py b/official/projects/videoglue/modeling/heads/transformer_decoder.py index d14a267b05d..f093d35e48c 100644 --- a/official/projects/videoglue/modeling/heads/transformer_decoder.py +++ b/official/projects/videoglue/modeling/heads/transformer_decoder.py @@ -17,7 +17,7 @@ from typing import Mapping, Optional, Union, List, Sequence from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras def _get_shape(x: tf.Tensor): @@ -27,7 +27,7 @@ def _get_shape(x: tf.Tensor): return [dynamic[i] if s is None else s for i, s in enumerate(static)] -class DecoderUnit(tf.keras.layers.Layer): +class DecoderUnit(tf_keras.layers.Layer): """Constructs the decoder MHA module used in Transformer layers.""" def __init__( @@ -37,8 +37,8 @@ def __init__( dropout_rate: float, activation: str, layer_norm_epsilon: float, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): super().__init__(**kwargs) @@ -57,21 +57,21 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): input_shape: the input shape for the keras tensor. """ # Query, key, and value mapping. - self.layer_q = tf.keras.layers.Dense( + self.layer_q = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer, name='query') - self.layer_k = tf.keras.layers.Dense( + self.layer_k = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer, name='key') - self.layer_v = tf.keras.layers.Dense( + self.layer_v = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, @@ -79,24 +79,24 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): bias_regularizer=self._bias_regularizer, name='value') - self.dropout = tf.keras.layers.Dropout(self._dropout_rate) + self.dropout = tf_keras.layers.Dropout(self._dropout_rate) # Note here is a different behavior for contrib_layers.layer_norm and - # tf.keras.layers.LayerNormalization, where by default, the former + # tf_keras.layers.LayerNormalization, where by default, the former # calculates mean/variance across all axes except the first one # (batch axis), while the latter one computes statistics only on the last # axis. - self.layer_norm = tf.keras.layers.LayerNormalization( + self.layer_norm = tf_keras.layers.LayerNormalization( epsilon=self._layer_norm_epsilon, name='layer_norm') - self.ffn1 = tf.keras.layers.Dense( + self.ffn1 = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=self._activation, kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer, name='ffn1') - self.ffn2 = tf.keras.layers.Dense( + self.ffn2 = tf_keras.layers.Dense( self._num_channels, use_bias=self._use_bias, activation=None, @@ -155,7 +155,7 @@ def call(self, return outputs -class TransformerDecoderLayer(tf.keras.layers.Layer): +class TransformerDecoderLayer(tf_keras.layers.Layer): """Constructs the main Transformer decoder module which includes MHA + FFN.""" def __init__( @@ -166,8 +166,8 @@ def __init__( activation: str, dropout_rate: float, layer_norm_epsilon: float, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, name: str = 'decoder_layer', **kwargs): super().__init__(name=name) @@ -233,7 +233,7 @@ def call( return outputs -class TransformerDecoder(tf.keras.layers.Layer): +class TransformerDecoder(tf_keras.layers.Layer): """Constructs the final Transformer decoder stack.""" def __init__( @@ -245,8 +245,8 @@ def __init__( activation: str, dropout_rate: float, layer_norm_epsilon: float, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, name: str = 'transformer_decoder', **kwargs): super().__init__(name=name) diff --git a/official/projects/videoglue/modeling/video_action_transformer_model.py b/official/projects/videoglue/modeling/video_action_transformer_model.py index 552fc632ec3..8d12527882a 100644 --- a/official/projects/videoglue/modeling/video_action_transformer_model.py +++ b/official/projects/videoglue/modeling/video_action_transformer_model.py @@ -15,7 +15,7 @@ """Builds the Video Action Transformer Network.""" from typing import Mapping, Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.configs import spatiotemporal_action_localization as cfg from official.projects.videoglue.modeling.backbones import vit_3d # pylint: disable=unused-import @@ -24,8 +24,8 @@ from official.vision.modeling import factory_3d as model_factory -@tf.keras.utils.register_keras_serializable(package='Vision') -class VideoActionTransformerModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class VideoActionTransformerModel(tf_keras.Model): """A Video Action Transformer Network. Reference: Girdhar, Rohit et. al. "Video action transformer network." In CVPR @@ -34,7 +34,7 @@ class VideoActionTransformerModel(tf.keras.Model): def __init__( self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: int, endpoint_name: str, # parameters for classifier @@ -55,9 +55,9 @@ def __init__( attention_dropout_rate: float = 0.0, layer_norm_epsilon: float = 1e-6, use_positional_embedding: bool = True, - input_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + input_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initialization function. @@ -81,16 +81,16 @@ def __init__( layer_norm_epsilon: The layer norm epsilon. use_positional_embedding: Whether to use positional embedding. input_specs: Specs of the input tensor. - kernel_regularizer: tf.keras.regularizers.Regularizer object. - bias_regularizer: tf.keras.regularizers.Regularizer object. + kernel_regularizer: tf_keras.regularizers.Regularizer object. + bias_regularizer: tf_keras.regularizers.Regularizer object. **kwargs: Keyword arguments to be passed. """ if not input_specs: input_specs = { 'image': - tf.keras.layers.InputSpec(shape=[None, None, None, None, 3]), + tf_keras.layers.InputSpec(shape=[None, None, None, None, 3]), 'instances_position': - tf.keras.layers.InputSpec(shape=[None, None, 4]), + tf_keras.layers.InputSpec(shape=[None, None, 4]), } self._num_classes = num_classes @@ -120,8 +120,8 @@ def __init__( self._backbone = backbone def _build_model( - self, backbone: tf.keras.Model, - input_specs: Mapping[str, tf.keras.layers.InputSpec] + self, backbone: tf_keras.Model, + input_specs: Mapping[str, tf_keras.layers.InputSpec] ) -> Tuple[Mapping[str, tf.Tensor], tf.Tensor]: """Builds the model network. @@ -135,7 +135,7 @@ def _build_model( """ inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } endpoints = backbone(inputs['image']) features = endpoints[self._endpoint_name] @@ -168,17 +168,17 @@ def _build_model( return inputs, outputs @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: """Returns the backbone of the model.""" return self._backbone @model_factory.register_model_builder('video_action_transformer_model') def build_video_action_transformer_model( - input_specs_dict: Mapping[str, tf.keras.layers.InputSpec], + input_specs_dict: Mapping[str, tf_keras.layers.InputSpec], model_config: cfg.VideoActionTransformerModel, num_classes: int, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None ) -> VideoActionTransformerModel: """Builds the video action localziation model.""" backbone = backbones.factory.build_backbone( diff --git a/official/projects/videoglue/modeling/video_classification_model.py b/official/projects/videoglue/modeling/video_classification_model.py index f2dcafb1bb1..7c8c489aca9 100644 --- a/official/projects/videoglue/modeling/video_classification_model.py +++ b/official/projects/videoglue/modeling/video_classification_model.py @@ -15,7 +15,7 @@ """Builds video classification models.""" from typing import Any, Mapping, Optional, Union, List, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.videoglue.configs import video_classification as cfg from official.projects.videoglue.modeling.backbones import vit_3d # pylint: disable=unused-import @@ -23,17 +23,17 @@ from official.vision.modeling import backbones from official.vision.modeling import factory_3d as model_factory -layers = tf.keras.layers +layers = tf_keras.layers -class MultiHeadVideoClassificationModel(tf.keras.Model): +class MultiHeadVideoClassificationModel(tf_keras.Model): """A multi-head video classification class builder.""" def __init__( self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: Union[List[int], int], - input_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + input_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, dropout_rate: float = 0.0, attention_num_heads: int = 6, attention_hidden_size: int = 768, @@ -41,8 +41,8 @@ def __init__( add_temporal_pos_emb_pooler: bool = False, aggregate_endpoints: bool = False, kernel_initializer: str = 'random_uniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, require_endpoints: Optional[List[Text]] = None, classifier_type: str = 'linear', **kwargs): @@ -51,7 +51,7 @@ def __init__( Args: backbone: a 3d backbone network. num_classes: `int` number of classes in classification task. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. dropout_rate: `float` rate for dropout regularization. attention_num_heads: attention pooler layer number of heads. attention_hidden_size: attention pooler layer hidden size. @@ -61,9 +61,9 @@ def __init__( aggregate_endpoints: `bool` aggregate all end ponits or only use the final end point. kernel_initializer: kernel initializer for the dense layer. - kernel_regularizer: tf.keras.regularizers.Regularizer object. Default to + kernel_regularizer: tf_keras.regularizers.Regularizer object. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object. Default to + bias_regularizer: tf_keras.regularizers.Regularizer object. Default to None. require_endpoints: the required endpoints for prediction. If None or empty, then only uses the final endpoint. @@ -93,12 +93,12 @@ def __init__( self._backbone = backbone inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } endpoints = backbone(inputs['image']) if classifier_type == 'linear': - pool_or_flatten_op = tf.keras.layers.GlobalAveragePooling3D() + pool_or_flatten_op = tf_keras.layers.GlobalAveragePooling3D() elif classifier_type == 'pooler': pool_or_flatten_op = lambda x: tf.reshape( # pylint:disable=g-long-lambda x, @@ -137,8 +137,8 @@ def __init__( outputs = [] if classifier_type == 'linear': for nc in num_classes: - x = tf.keras.layers.Dropout(dropout_rate)(input_embeddings) - x = tf.keras.layers.Dense( + x = tf_keras.layers.Dropout(dropout_rate)(input_embeddings) + x = tf_keras.layers.Dense( nc, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)(x) @@ -164,12 +164,12 @@ def __init__( @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" return dict(backbone=self.backbone) @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone def get_config(self) -> Mapping[str, Any]: @@ -182,10 +182,10 @@ def from_config(cls, config, custom_objects=None): @model_factory.register_model_builder('mh_video_classification') def build_mh_video_classification_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: cfg.MultiHeadVideoClassificationModel, num_classes: Union[List[int], int], - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None ) -> MultiHeadVideoClassificationModel: """Builds the video classification model.""" input_specs_dict = {'image': input_specs} diff --git a/official/projects/videoglue/tasks/multihead_video_classification.py b/official/projects/videoglue/tasks/multihead_video_classification.py index 042a65fa4f8..b5e79afdf4e 100644 --- a/official/projects/videoglue/tasks/multihead_video_classification.py +++ b/official/projects/videoglue/tasks/multihead_video_classification.py @@ -15,7 +15,7 @@ """HS Video Classification task.""" from typing import Any, List, Optional, Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.videoglue.configs import video_classification as exp_cfg @@ -82,7 +82,7 @@ def build_inputs(self, params: exp_cfg.DataConfig, input_context=None): params=params, dataset_config=dataset_config) return data_loader(input_context=input_context) - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -98,30 +98,30 @@ def build_metrics(self, training: bool = True): for label_name in self._get_label_names(): if self._is_multilabel(): metrics += [ - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( curve='ROC', multi_label=self._is_multilabel(), name=f'{label_name}/ROC-AUC'), - tf.keras.metrics.RecallAtPrecision( + tf_keras.metrics.RecallAtPrecision( precision=0.95, name=f'{label_name}/RecallAtPrecision95'), - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( curve='PR', multi_label=self._is_multilabel(), name=f'{label_name}/PR-AUC'), ] else: metrics += [ - tf.keras.metrics.CategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy( name=f'{label_name}/accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.TopKCategoricalAccuracy( k=1, name=f'{label_name}/top_1_accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.TopKCategoricalAccuracy( k=5, name=f'{label_name}/top_5_accuracy') ] if self._is_multihead(): metrics.append( - tf.keras.metrics.Mean(name='label_joint/accuracy')) + tf_keras.metrics.Mean(name='label_joint/accuracy')) return metrics def process_metrics(self, metrics: List[Any], @@ -176,8 +176,8 @@ def build_losses(self, def train_step(self, inputs: Mapping[str, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward pass. @@ -196,7 +196,7 @@ def train_step(self, num_replicas = tf.distribute.get_strategy().num_replicas_in_sync with tf.GradientTape() as tape: outputs = model(features, training=True) - # tf.keras.Model eliminates the list if the outputs list len is 1. + # tf_keras.Model eliminates the list if the outputs list len is 1. # Recover it here to be compatible with multihead settings. outputs = [outputs] if isinstance(outputs, tf.Tensor) else outputs # Casting output layer as float32 is necessary when mixed_precision is @@ -219,14 +219,14 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scale back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -238,7 +238,7 @@ def train_step(self, def validation_step(self, inputs: Mapping[str, tf.Tensor], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. @@ -260,7 +260,7 @@ def validation_step(self, features['image'], input_partition_dims) outputs = self.inference_step(features, model) - # tf.keras.Model eliminates the list if the outputs list len is 1. + # tf_keras.Model eliminates the list if the outputs list len is 1. # Recover it here to be compatible with multihead settings. outputs = [outputs] if isinstance(outputs, tf.Tensor) else outputs # Casting output layer as float32 is necessary when mixed_precision is diff --git a/official/projects/videoglue/tasks/spatiotemporal_action_localization.py b/official/projects/videoglue/tasks/spatiotemporal_action_localization.py index 0d8418ed301..df8353f1d08 100644 --- a/official/projects/videoglue/tasks/spatiotemporal_action_localization.py +++ b/official/projects/videoglue/tasks/spatiotemporal_action_localization.py @@ -16,7 +16,7 @@ from typing import Any, List, Optional, Mapping from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import task_factory from official.projects.videoglue.configs import spatiotemporal_action_localization as exp_cfg @@ -36,7 +36,7 @@ def _is_multilabel(self): """Whether the dataset/task has multi-labels.""" return True - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds video model.""" common_input_shape = [ d1 if d1 == d2 else None @@ -47,16 +47,16 @@ def build_model(self) -> tf.keras.Model: num_instances = self.task_config.train_data.num_instances input_specs_dict = { 'image': - tf.keras.layers.InputSpec(shape=[None] + common_input_shape), + tf_keras.layers.InputSpec(shape=[None] + common_input_shape), 'instances_position': - tf.keras.layers.InputSpec(shape=[None, num_instances, 4]), + tf_keras.layers.InputSpec(shape=[None, num_instances, 4]), } l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory_3d.build_model( @@ -97,7 +97,7 @@ def build_inputs( params=params, dataset_config=dataset_config) return data_loader(input_context=input_context) - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -125,8 +125,8 @@ def build_losses(self, losses_config = self.task_config.losses # in shape [B, N] - xent_loss_fn = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.NONE, + xent_loss_fn = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.NONE, from_logits=False, label_smoothing=losses_config.label_smoothing) class_targets = labels['class_target'] @@ -162,8 +162,8 @@ def build_losses(self, def build_metrics(self, training: bool = True): """Gets streaming metrics for training/validation.""" metrics = [ - tf.keras.metrics.AUC(curve='PR', multi_label=True, name='AUPR'), - tf.keras.metrics.AUC(curve='ROC', multi_label=True, name='AUROC'), + tf_keras.metrics.AUC(curve='PR', multi_label=True, name='AUPR'), + tf_keras.metrics.AUC(curve='ROC', multi_label=True, name='AUROC'), ] self.evaluator = eval_util.SpatiotemporalActionLocalizationEvaluator() return metrics @@ -195,8 +195,8 @@ def process_metrics(self, metrics: List[Any], def train_step(self, inputs: Mapping[str, tf.Tensor], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does one forward and backward pass. @@ -225,7 +225,7 @@ def train_step(self, def validation_step(self, inputs: Mapping[str, tf.Tensor], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. diff --git a/official/projects/videoglue/tools/checkpoint_loader.py b/official/projects/videoglue/tools/checkpoint_loader.py index 33f1d4862fb..d6370aca765 100644 --- a/official/projects/videoglue/tools/checkpoint_loader.py +++ b/official/projects/videoglue/tools/checkpoint_loader.py @@ -18,7 +18,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint:disable=line-too-long @@ -79,7 +79,7 @@ class CheckpointLoaderBase(object): """Checkpoint loader object.""" - def __init__(self, model: tf.keras.Model, + def __init__(self, model: tf_keras.Model, init_checkpoint: str, init_checkpoint_type: str): self._init_checkpoint = init_checkpoint @@ -93,7 +93,7 @@ def __init__(self, model: tf.keras.Model, logging.info('Finished loading pretrained checkpoint from %s', ckpt_dir_or_file) - def _load_checkpoint(self, model: tf.keras.Model, ckpt_dir_or_file: str): + def _load_checkpoint(self, model: tf_keras.Model, ckpt_dir_or_file: str): """Loads checkpoint.""" if self._init_checkpoint_type == 'all': ckpt = tf.train.Checkpoint(model=model) @@ -133,7 +133,7 @@ def _maybe_transpose_pytorch_weight(self, ckpt_weight): return ckpt_weight def _customized_vmae_initialize(self, - model: tf.keras.Model, + model: tf_keras.Model, ckpt_dir_or_file: str): """Loads pretrained Video MAE checkpoint.""" with tf.io.gfile.GFile(ckpt_dir_or_file, 'rb') as ckpt: @@ -194,14 +194,14 @@ def _customized_vmae_initialize(self, logging.info('Finished loading pretrained checkpoint from %s', ckpt_dir_or_file) - def _load_checkpoint(self, model: tf.keras.Model, ckpt_dir_or_file: str): + def _load_checkpoint(self, model: tf_keras.Model, ckpt_dir_or_file: str): """Loads checkpoint.""" self._customized_vmae_initialize( model=model, ckpt_dir_or_file=ckpt_dir_or_file) def get_checkpoint_loader( - model: tf.keras.Model, init_checkpoint: str, init_checkpoint_type: str): + model: tf_keras.Model, init_checkpoint: str, init_checkpoint_type: str): """Gets the corresponding checkpoint loader.""" if init_checkpoint_type == 'customized_vmae': diff --git a/official/projects/volumetric_models/configs/semantic_segmentation_3d_test.py b/official/projects/volumetric_models/configs/semantic_segmentation_3d_test.py index 05de447fbfe..fb381baae14 100644 --- a/official/projects/volumetric_models/configs/semantic_segmentation_3d_test.py +++ b/official/projects/volumetric_models/configs/semantic_segmentation_3d_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/volumetric_models/dataloaders/segmentation_input_3d.py b/official/projects/volumetric_models/dataloaders/segmentation_input_3d.py index 5cacdb55b84..27551ca3966 100644 --- a/official/projects/volumetric_models/dataloaders/segmentation_input_3d.py +++ b/official/projects/volumetric_models/dataloaders/segmentation_input_3d.py @@ -15,7 +15,7 @@ """Data parser and processing for 3D segmentation datasets.""" from typing import Any, Dict, Sequence, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder from official.vision.dataloaders import parser diff --git a/official/projects/volumetric_models/dataloaders/segmentation_input_3d_test.py b/official/projects/volumetric_models/dataloaders/segmentation_input_3d_test.py index de4e8d54619..d452ee7ec91 100644 --- a/official/projects/volumetric_models/dataloaders/segmentation_input_3d_test.py +++ b/official/projects/volumetric_models/dataloaders/segmentation_input_3d_test.py @@ -17,7 +17,7 @@ import os from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.dataloaders import segmentation_input_3d from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/volumetric_models/evaluation/segmentation_metrics.py b/official/projects/volumetric_models/evaluation/segmentation_metrics.py index 13533d48c59..89228d47fe4 100644 --- a/official/projects/volumetric_models/evaluation/segmentation_metrics.py +++ b/official/projects/volumetric_models/evaluation/segmentation_metrics.py @@ -15,16 +15,16 @@ """Metrics for segmentation.""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.losses import segmentation_losses class DiceScore: """Dice score metric for semantic segmentation. - This class follows the same function interface as tf.keras.metrics.Metric but - does not derive from tf.keras.metrics.Metric or utilize its functions. The - reason is a tf.keras.metrics.Metric object does not run well on CPU while + This class follows the same function interface as tf_keras.metrics.Metric but + does not derive from tf_keras.metrics.Metric or utilize its functions. The + reason is a tf_keras.metrics.Metric object does not run well on CPU while created on GPU, when running with MirroredStrategy. The same interface allows for minimal change to the upstream tasks. diff --git a/official/projects/volumetric_models/evaluation/segmentation_metrics_test.py b/official/projects/volumetric_models/evaluation/segmentation_metrics_test.py index 619519840ee..5d5874b1177 100644 --- a/official/projects/volumetric_models/evaluation/segmentation_metrics_test.py +++ b/official/projects/volumetric_models/evaluation/segmentation_metrics_test.py @@ -15,7 +15,7 @@ """Tests for segmentation_losses.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.evaluation import segmentation_metrics diff --git a/official/projects/volumetric_models/losses/segmentation_losses.py b/official/projects/volumetric_models/losses/segmentation_losses.py index 0932447991f..38becb81a7b 100644 --- a/official/projects/volumetric_models/losses/segmentation_losses.py +++ b/official/projects/volumetric_models/losses/segmentation_losses.py @@ -15,7 +15,7 @@ """Losses used for segmentation models.""" from typing import Optional, Sequence -import tensorflow as tf +import tensorflow as tf, tf_keras class SegmentationLossDiceScore(object): @@ -65,7 +65,7 @@ def __call__(self, logits: tf.Tensor, labels: tf.Tensor) -> tf.Tensor: if labels.get_shape().ndims < 2 or logits.get_shape().ndims < 2: raise ValueError('The labels and logits must be at least rank 2.') - epsilon = tf.keras.backend.epsilon() + epsilon = tf_keras.backend.epsilon() keep_label_axis = list(range(len(logits.shape) - 1)) keep_batch_axis = list(range(1, len(logits.shape))) diff --git a/official/projects/volumetric_models/losses/segmentation_losses_test.py b/official/projects/volumetric_models/losses/segmentation_losses_test.py index 70667634074..8c1fac25a5e 100644 --- a/official/projects/volumetric_models/losses/segmentation_losses_test.py +++ b/official/projects/volumetric_models/losses/segmentation_losses_test.py @@ -15,7 +15,7 @@ """Tests for segmentation_losses.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.losses import segmentation_losses diff --git a/official/projects/volumetric_models/modeling/backbones/unet_3d.py b/official/projects/volumetric_models/modeling/backbones/unet_3d.py index 73ab9643fa8..6d594bb781e 100644 --- a/official/projects/volumetric_models/modeling/backbones/unet_3d.py +++ b/official/projects/volumetric_models/modeling/backbones/unet_3d.py @@ -22,16 +22,16 @@ from typing import Any, Mapping, Sequence # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.volumetric_models.modeling import nn_blocks_3d from official.vision.modeling.backbones import factory -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class UNet3D(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class UNet3D(tf_keras.Model): """Class to build 3D UNet backbone.""" def __init__( @@ -41,7 +41,7 @@ def __init__( pool_size: Sequence[int] = (2, 2, 2), kernel_size: Sequence[int] = (3, 3, 3), base_filters: int = 32, - kernel_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', norm_momentum: float = 0.99, norm_epsilon: float = 0.001, @@ -64,7 +64,7 @@ def __init__( convolution network will have. Following layers will contain a multiple of this number. Lowering this number will likely reduce the amount of memory required to train the model. - kernel_regularizer: A tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: A tf_keras.regularizers.Regularizer object for Conv2D. Default to None. activation: The name of the activation function. norm_momentum: The normalization momentum for the moving average. @@ -92,7 +92,7 @@ def __init__( self._use_batch_normalization = use_batch_normalization # Build 3D UNet. - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=input_specs.shape[1:], dtype=input_specs.dtype) x = inputs endpoints = {} @@ -117,7 +117,7 @@ def __init__( pool_size=pool_size, strides=(2, 2, 2), padding='valid', - data_format=tf.keras.backend.image_data_format())( + data_format=tf_keras.backend.image_data_format())( x2) else: x = x2 @@ -153,10 +153,10 @@ def output_specs(self) -> Mapping[str, tf.TensorShape]: @factory.register_backbone_builder('unet_3d') def build_unet3d( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds 3D UNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/projects/volumetric_models/modeling/backbones/unet_3d_test.py b/official/projects/volumetric_models/modeling/backbones/unet_3d_test.py index 7dac6a4cdfd..2789ec8ae84 100644 --- a/official/projects/volumetric_models/modeling/backbones/unet_3d_test.py +++ b/official/projects/volumetric_models/modeling/backbones/unet_3d_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.modeling.backbones import unet_3d @@ -29,9 +29,9 @@ class UNet3DTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, input_size, model_id): """Test creation of UNet3D family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = unet_3d.UNet3D(model_id=model_id) - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size[0], input_size[0], input_size[1], 3), batch_size=1) endpoints = network(inputs) diff --git a/official/projects/volumetric_models/modeling/decoders/factory.py b/official/projects/volumetric_models/modeling/decoders/factory.py index 9c77ea674d1..466419070df 100644 --- a/official/projects/volumetric_models/modeling/decoders/factory.py +++ b/official/projects/volumetric_models/modeling/decoders/factory.py @@ -43,7 +43,7 @@ def build_my_decoder(): # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import registry from official.modeling import hyperparams @@ -58,7 +58,7 @@ def register_decoder_builder(key: str): This decorator supports registration of decoder builder as follows: ``` - class MyDecoder(tf.keras.Model): + class MyDecoder(tf_keras.Model): pass @register_decoder_builder('mydecoder') @@ -83,7 +83,7 @@ def builder(input_specs, config, l2_reg): def build_identity( input_specs: Optional[Mapping[str, tf.TensorShape]] = None, model_config: Optional[hyperparams.Config] = None, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None) -> None: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None) -> None: del input_specs, model_config, l2_regularizer # Unused by identity decoder. return None @@ -91,15 +91,15 @@ def build_identity( def build_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, - **kwargs) -> Union[None, tf.keras.Model, tf.keras.layers.Layer]: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, + **kwargs) -> Union[None, tf_keras.Model, tf_keras.layers.Layer]: # pytype: disable=annotation-type-mismatch # typed-keras """Builds decoder from a config. Args: input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A `OneOfConfig` of model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` object. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` object. Default to None. **kwargs: Additional keyword args to be passed to decoder builder. diff --git a/official/projects/volumetric_models/modeling/decoders/factory_test.py b/official/projects/volumetric_models/modeling/decoders/factory_test.py index e2fb4608b6d..4d3758f96be 100644 --- a/official/projects/volumetric_models/modeling/decoders/factory_test.py +++ b/official/projects/volumetric_models/modeling/decoders/factory_test.py @@ -15,7 +15,7 @@ """Tests for factory functions.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.projects.volumetric_models.configs import decoders as decoders_cfg diff --git a/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder.py b/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder.py index 2a5571540a8..180a10f1e60 100644 --- a/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder.py +++ b/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder.py @@ -21,17 +21,17 @@ from typing import Any, Dict, Mapping, Optional, Sequence -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.volumetric_models.modeling import nn_blocks_3d from official.projects.volumetric_models.modeling.decoders import factory -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class UNet3DDecoder(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class UNet3DDecoder(tf_keras.Model): """Class to build 3D UNet decoder.""" def __init__(self, @@ -39,7 +39,7 @@ def __init__(self, input_specs: Mapping[str, tf.TensorShape], pool_size: Sequence[int] = (2, 2, 2), kernel_size: Sequence[int] = (3, 3, 3), - kernel_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', norm_momentum: float = 0.99, norm_epsilon: float = 0.001, @@ -57,7 +57,7 @@ def __init__(self, {level: TensorShape} from a backbone. pool_size: The pooling size for the max pooling operations. kernel_size: The kernel size for 3D convolution. - kernel_regularizer: A tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: A tf_keras.regularizers.Regularizer object for Conv2D. Default to None. activation: The name of the activation function. norm_momentum: The normalization momentum for the moving average. @@ -89,7 +89,7 @@ def __init__(self, self._norm = layers.BatchNormalization self._use_batch_normalization = use_batch_normalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': channel_dim = -1 else: channel_dim = 1 @@ -141,7 +141,7 @@ def _build_input_pyramid(self, input_specs: Dict[str, tf.TensorShape], inputs = {} for level, spec in input_specs.items(): - inputs[level] = tf.keras.Input(shape=spec[1:]) + inputs[level] = tf_keras.Input(shape=spec[1:]) return inputs def get_config(self) -> Mapping[str, Any]: @@ -161,19 +161,19 @@ def output_specs(self) -> Mapping[str, tf.TensorShape]: def build_unet_3d_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds UNet3D decoder from a config. Args: input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A OneOfConfig. Model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` instance. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` instance. Default to None. Returns: - A `tf.keras.Model` instance of the UNet3D decoder. + A `tf_keras.Model` instance of the UNet3D decoder. """ decoder_type = model_config.decoder.type decoder_cfg = model_config.decoder.get() diff --git a/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder_test.py b/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder_test.py index ae4d89ab768..2ce9e29eebc 100644 --- a/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder_test.py +++ b/official/projects/volumetric_models/modeling/decoders/unet_3d_decoder_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.modeling.backbones import unet_3d from official.projects.volumetric_models.modeling.decoders import unet_3d_decoder @@ -30,10 +30,10 @@ class UNet3DDecoderTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, input_size, model_id): """Test creation of UNet3D family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') # `input_size` consists of [spatial size, volume size]. - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size[0], input_size[0], input_size[1], 3), batch_size=1) backbone = unet_3d.UNet3D(model_id=model_id) network = unet_3d_decoder.UNet3DDecoder( diff --git a/official/projects/volumetric_models/modeling/factory.py b/official/projects/volumetric_models/modeling/factory.py index 70927aa7444..12b9f41eb38 100644 --- a/official/projects/volumetric_models/modeling/factory.py +++ b/official/projects/volumetric_models/modeling/factory.py @@ -16,7 +16,7 @@ from typing import Sequence, Union # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.volumetric_models.modeling.decoders import factory as decoder_factory @@ -26,11 +26,11 @@ def build_segmentation_model_3d( - input_specs: Union[tf.keras.layers.InputSpec, - Sequence[tf.keras.layers.InputSpec]], + input_specs: Union[tf_keras.layers.InputSpec, + Sequence[tf_keras.layers.InputSpec]], model_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds Segmentation model.""" norm_activation_config = model_config.norm_activation backbone = backbone_factory.build_backbone( diff --git a/official/projects/volumetric_models/modeling/factory_test.py b/official/projects/volumetric_models/modeling/factory_test.py index 2571658a55c..7f3ee9aea4d 100644 --- a/official/projects/volumetric_models/modeling/factory_test.py +++ b/official/projects/volumetric_models/modeling/factory_test.py @@ -15,7 +15,7 @@ """Tests for factory.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.projects.volumetric_models.configs import semantic_segmentation_3d as exp_cfg @@ -30,19 +30,19 @@ class SegmentationModelBuilderTest(parameterized.TestCase, tf.test.TestCase): ((64, 64, 64), None, False)) def test_unet3d_builder(self, input_size, weight_decay, use_bn): num_classes = 3 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], input_size[2], 3]) model_config = exp_cfg.SemanticSegmentationModel3D(num_classes=num_classes) model_config.head.use_batch_normalization = use_bn l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) model = factory.build_segmentation_model_3d( input_specs=input_specs, model_config=model_config, l2_regularizer=l2_regularizer) self.assertIsInstance( - model, tf.keras.Model, - 'Output should be a tf.keras.Model instance but got %s' % type(model)) + model, tf_keras.Model, + 'Output should be a tf_keras.Model instance but got %s' % type(model)) if __name__ == '__main__': diff --git a/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d.py b/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d.py index 967ef332055..bc37372fd66 100644 --- a/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d.py +++ b/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d.py @@ -15,13 +15,13 @@ """Segmentation heads.""" from typing import Any, Union, Sequence, Mapping, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class SegmentationHead3D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SegmentationHead3D(tf_keras.layers.Layer): """Segmentation head for 3D input.""" def __init__(self, @@ -35,8 +35,8 @@ def __init__(self, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, use_batch_normalization: bool = False, - kernel_regularizer: tf.keras.regularizers.Regularizer = None, - bias_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, + bias_regularizer: tf_keras.regularizers.Regularizer = None, output_logits: bool = True, # pytype: disable=annotation-type-mismatch # typed-keras **kwargs): """Initialize params to build segmentation head. @@ -60,9 +60,9 @@ def __init__(self, norm_epsilon: `float`, the epsilon parameter of the normalization layers. use_batch_normalization: A bool of whether to use batch normalization or not. - kernel_regularizer: `tf.keras.regularizers.Regularizer` object for layer + kernel_regularizer: `tf_keras.regularizers.Regularizer` object for layer kernel. - bias_regularizer: `tf.keras.regularizers.Regularizer` object for bias. + bias_regularizer: `tf_keras.regularizers.Regularizer` object for bias. output_logits: A `bool` of whether to output logits or not. Default is True. If set to False, output softmax. **kwargs: other keyword arguments passed to Layer. @@ -84,7 +84,7 @@ def __init__(self, 'bias_regularizer': bias_regularizer, 'output_logits': output_logits } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -92,20 +92,20 @@ def __init__(self, def build(self, input_shape: Union[tf.TensorShape, Sequence[tf.TensorShape]]): """Creates the variables of the segmentation head.""" - conv_op = tf.keras.layers.Conv3D + conv_op = tf_keras.layers.Conv3D conv_kwargs = { 'kernel_size': (3, 3, 3), 'padding': 'same', 'use_bias': False, - 'kernel_initializer': tf.keras.initializers.RandomNormal(stddev=0.01), + 'kernel_initializer': tf_keras.initializers.RandomNormal(stddev=0.01), 'kernel_regularizer': self._config_dict['kernel_regularizer'], } final_kernel_size = (1, 1, 1) bn_op = ( - tf.keras.layers.experimental.SyncBatchNormalization + tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] else - tf.keras.layers.BatchNormalization) + tf_keras.layers.BatchNormalization) bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -133,7 +133,7 @@ def build(self, input_shape: Union[tf.TensorShape, Sequence[tf.TensorShape]]): padding='valid', activation=None, bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer']) @@ -170,10 +170,10 @@ def call(self, inputs: Tuple[Union[tf.Tensor, Mapping[str, tf.Tensor]], x = self._norms[i](x) x = self._activation(x) - x = tf.keras.layers.UpSampling3D(size=self._config_dict['upsample_factor'])( + x = tf_keras.layers.UpSampling3D(size=self._config_dict['upsample_factor'])( x) x = self._classifier(x) - return x if self._config_dict['output_logits'] else tf.keras.layers.Softmax( + return x if self._config_dict['output_logits'] else tf_keras.layers.Softmax( dtype='float32')( x) diff --git a/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d_test.py b/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d_test.py index 5b2852f5eaf..e64c1c87206 100644 --- a/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d_test.py +++ b/official/projects/volumetric_models/modeling/heads/segmentation_heads_3d_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.modeling.heads import segmentation_heads_3d diff --git a/official/projects/volumetric_models/modeling/nn_blocks_3d.py b/official/projects/volumetric_models/modeling/nn_blocks_3d.py index 206cd2f6e6a..f281c2e1f9e 100644 --- a/official/projects/volumetric_models/modeling/nn_blocks_3d.py +++ b/official/projects/volumetric_models/modeling/nn_blocks_3d.py @@ -17,14 +17,14 @@ from typing import Sequence, Union # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.modeling.layers import nn_layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class BasicBlock3DVolume(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BasicBlock3DVolume(tf_keras.layers.Layer): """A basic 3d convolution block.""" def __init__(self, @@ -32,8 +32,8 @@ def __init__(self, strides: Union[int, Sequence[int]], kernel_size: Union[int, Sequence[int]], kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: tf.keras.regularizers.Regularizer = None, - bias_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, + bias_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -53,9 +53,9 @@ def __init__(self, height and width of the 3D convolution window. Can be a single integer to specify the same value for all spatial dimensions. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + 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. @@ -84,10 +84,10 @@ def __init__(self, self._use_batch_normalization = use_batch_normalization if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -99,12 +99,12 @@ def build(self, input_shape: tf.TensorShape): self._norms = [] for filters in self._filters: self._convs.append( - tf.keras.layers.Conv3D( + tf_keras.layers.Conv3D( filters=filters, kernel_size=self._kernel_size, strides=self._strides, padding='same', - data_format=tf.keras.backend.image_data_format(), + data_format=tf_keras.backend.image_data_format(), activation=None)) self._norms.append( self._norm( @@ -143,8 +143,8 @@ def call(self, inputs: tf.Tensor, training: bool = None) -> tf.Tensor: return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResidualBlock3DVolume(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResidualBlock3DVolume(tf_keras.layers.Layer): """A residual 3d block.""" def __init__(self, @@ -176,9 +176,9 @@ def __init__(self, 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. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + 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. @@ -203,10 +203,10 @@ def __init__(self, self._bias_regularizer = bias_regularizer if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -214,7 +214,7 @@ def __init__(self, def build(self, input_shape): if self._use_projection: - self._shortcut = tf.keras.layers.Conv3D( + self._shortcut = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=1, strides=self._strides, @@ -227,7 +227,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv1 = tf.keras.layers.Conv3D( + self._conv1 = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -241,7 +241,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv2 = tf.keras.layers.Conv3D( + self._conv2 = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=3, strides=1, @@ -315,8 +315,8 @@ def call(self, inputs, training=None): return self._activation_fn(x + shortcut) -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckBlock3DVolume(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckBlock3DVolume(tf_keras.layers.Layer): """A standard bottleneck block.""" def __init__(self, @@ -350,9 +350,9 @@ def __init__(self, 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. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + 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. @@ -377,10 +377,10 @@ def __init__(self, self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer if use_sync_bn: - self._norm = tf.keras.layers.experimental.SyncBatchNormalization + self._norm = tf_keras.layers.experimental.SyncBatchNormalization else: - self._norm = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + self._norm = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -388,7 +388,7 @@ def __init__(self, def build(self, input_shape): if self._use_projection: - self._shortcut = tf.keras.layers.Conv3D( + self._shortcut = tf_keras.layers.Conv3D( filters=self._filters * 4, kernel_size=1, strides=self._strides, @@ -401,7 +401,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv1 = tf.keras.layers.Conv3D( + self._conv1 = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=1, strides=1, @@ -414,7 +414,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv2 = tf.keras.layers.Conv3D( + self._conv2 = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -429,7 +429,7 @@ def build(self, input_shape): momentum=self._norm_momentum, epsilon=self._norm_epsilon) - self._conv3 = tf.keras.layers.Conv3D( + self._conv3 = tf_keras.layers.Conv3D( filters=self._filters * 4, kernel_size=1, strides=1, diff --git a/official/projects/volumetric_models/modeling/nn_blocks_3d_test.py b/official/projects/volumetric_models/modeling/nn_blocks_3d_test.py index bf769e9ce22..7a38632a561 100644 --- a/official/projects/volumetric_models/modeling/nn_blocks_3d_test.py +++ b/official/projects/volumetric_models/modeling/nn_blocks_3d_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.modeling import nn_blocks_3d @@ -26,7 +26,7 @@ class NNBlocks3DTest(parameterized.TestCase, tf.test.TestCase): @parameterized.parameters((128, 128, 32, 1), (256, 256, 16, 2)) def test_bottleneck_block_3d_volume_creation(self, spatial_size, volume_size, filters, strides): - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(spatial_size, spatial_size, volume_size, filters * 4), batch_size=1) block = nn_blocks_3d.BottleneckBlock3DVolume( @@ -46,7 +46,7 @@ def test_bottleneck_block_3d_volume_creation(self, spatial_size, volume_size, @parameterized.parameters((128, 128, 32, 1), (256, 256, 64, 2)) def test_residual_block_3d_volume_creation(self, spatial_size, volume_size, filters, strides): - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(spatial_size, spatial_size, volume_size, filters), batch_size=1) block = nn_blocks_3d.ResidualBlock3DVolume( filters=filters, @@ -65,7 +65,7 @@ def test_residual_block_3d_volume_creation(self, spatial_size, volume_size, @parameterized.parameters((128, 128, 64, 1, 3), (256, 256, 128, 2, 1)) def test_basic_block_3d_volume_creation(self, spatial_size, volume_size, filters, strides, kernel_size): - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(spatial_size, spatial_size, volume_size, filters), batch_size=1) block = nn_blocks_3d.BasicBlock3DVolume( filters=filters, strides=strides, kernel_size=kernel_size) diff --git a/official/projects/volumetric_models/modeling/segmentation_model_test.py b/official/projects/volumetric_models/modeling/segmentation_model_test.py index b0c080dbbf7..992283caff5 100644 --- a/official/projects/volumetric_models/modeling/segmentation_model_test.py +++ b/official/projects/volumetric_models/modeling/segmentation_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models.modeling import backbones from official.projects.volumetric_models.modeling import decoders from official.projects.volumetric_models.modeling.heads import segmentation_heads_3d @@ -35,7 +35,7 @@ def test_segmentation_network_unet3d_creation(self, input_size, depth): """Test for creation of a segmentation network.""" num_classes = 2 inputs = np.random.rand(2, input_size[0], input_size[0], input_size[1], 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.UNet3D(model_id=depth) decoder = decoders.UNet3DDecoder( diff --git a/official/projects/volumetric_models/serving/semantic_segmentation_3d.py b/official/projects/volumetric_models/serving/semantic_segmentation_3d.py index 04f46dde437..c34ceffee45 100644 --- a/official/projects/volumetric_models/serving/semantic_segmentation_3d.py +++ b/official/projects/volumetric_models/serving/semantic_segmentation_3d.py @@ -16,7 +16,7 @@ from typing import Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.projects.volumetric_models.modeling import backbones @@ -28,10 +28,10 @@ class SegmentationModule(export_base.ExportModule): """Segmentation Module.""" - def _build_model(self) -> tf.keras.Model: + def _build_model(self) -> tf_keras.Model: """Builds and returns a segmentation model.""" num_channels = self.params.task.model.num_channels - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[self._batch_size] + self._input_image_size + [num_channels]) return factory.build_segmentation_model_3d( diff --git a/official/projects/volumetric_models/serving/semantic_segmentation_3d_test.py b/official/projects/volumetric_models/serving/semantic_segmentation_3d_test.py index a520e3063b2..7d0fe9c8e2c 100644 --- a/official/projects/volumetric_models/serving/semantic_segmentation_3d_test.py +++ b/official/projects/volumetric_models/serving/semantic_segmentation_3d_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/projects/volumetric_models/tasks/semantic_segmentation_3d.py b/official/projects/volumetric_models/tasks/semantic_segmentation_3d.py index 429fd2f4d61..e3417f11a3b 100644 --- a/official/projects/volumetric_models/tasks/semantic_segmentation_3d.py +++ b/official/projects/volumetric_models/tasks/semantic_segmentation_3d.py @@ -16,7 +16,7 @@ from typing import Any, Dict, Mapping, Optional, Sequence, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -33,9 +33,9 @@ class SemanticSegmentation3DTask(base_task.Task): """A task for semantic segmentation.""" - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds segmentation model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size + [self.task_config.model.num_channels], dtype=self.task_config.train_data.dtype) @@ -45,7 +45,7 @@ def build_model(self) -> tf.keras.Model: # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_segmentation_model_3d( @@ -66,7 +66,7 @@ def build_model(self) -> tf.keras.Model: return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -143,13 +143,13 @@ def build_losses(self, return total_loss def build_metrics(self, - training: bool = True) -> Sequence[tf.keras.metrics.Metric]: + training: bool = True) -> Sequence[tf_keras.metrics.Metric]: """Gets streaming metrics for training/validation.""" metrics = [] num_classes = self.task_config.model.num_classes if training: metrics.extend([ - tf.keras.metrics.CategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy( name='train_categorical_accuracy', dtype=tf.float32) ]) else: @@ -168,9 +168,9 @@ def build_metrics(self, def train_step( self, inputs, - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, - metrics: Optional[Sequence[tf.keras.metrics.Metric]] = None + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, + metrics: Optional[Sequence[tf_keras.metrics.Metric]] = None ) -> Dict[Any, Any]: """Does forward and backward. @@ -211,14 +211,14 @@ def train_step( # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -236,8 +236,8 @@ def train_step( def validation_step( self, inputs, - model: tf.keras.Model, - metrics: Optional[Sequence[tf.keras.metrics.Metric]] = None + model: tf_keras.Model, + metrics: Optional[Sequence[tf_keras.metrics.Metric]] = None ) -> Dict[Any, Any]: """Validatation step. @@ -275,25 +275,25 @@ def validation_step( return logs - def inference_step(self, inputs, model: tf.keras.Model) -> tf.Tensor: + def inference_step(self, inputs, model: tf_keras.Model) -> tf.Tensor: """Performs the forward step.""" return model(inputs, training=False) def aggregate_logs( self, state: Optional[Sequence[Union[segmentation_metrics.DiceScore, - tf.keras.metrics.Metric]]] = None, + tf_keras.metrics.Metric]]] = None, step_outputs: Optional[Mapping[str, Any]] = None - ) -> Sequence[tf.keras.metrics.Metric]: + ) -> Sequence[tf_keras.metrics.Metric]: """Aggregates statistics to compute metrics over training. Args: - state: A sequence of tf.keras.metrics.Metric objects. Each element records + state: A sequence of tf_keras.metrics.Metric objects. Each element records a metric. step_outputs: A dictionary of [metric_name, (labels, output)] from a step. Returns: - An updated sequence of tf.keras.metrics.Metric objects. + An updated sequence of tf_keras.metrics.Metric objects. """ if state is None: for metric in self.metrics: diff --git a/official/projects/volumetric_models/tasks/semantic_segmentation_3d_test.py b/official/projects/volumetric_models/tasks/semantic_segmentation_3d_test.py index e340dfd9ef0..0aec2583538 100644 --- a/official/projects/volumetric_models/tasks/semantic_segmentation_3d_test.py +++ b/official/projects/volumetric_models/tasks/semantic_segmentation_3d_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import registry_imports # pylint: disable=unused-import from official.core import exp_factory diff --git a/official/projects/volumetric_models/train_test.py b/official/projects/volumetric_models/train_test.py index c076b91c411..599f503c12b 100644 --- a/official/projects/volumetric_models/train_test.py +++ b/official/projects/volumetric_models/train_test.py @@ -19,7 +19,7 @@ from absl import flags from absl import logging from absl.testing import flagsaver -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.volumetric_models import train as train_lib from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/waste_identification_ml/model_inference/postprocessing.py b/official/projects/waste_identification_ml/model_inference/postprocessing.py index 6408cf61b70..a76bc214b73 100644 --- a/official/projects/waste_identification_ml/model_inference/postprocessing.py +++ b/official/projects/waste_identification_ml/model_inference/postprocessing.py @@ -30,7 +30,7 @@ import copy from typing import Any, Optional, TypedDict import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras class DetectionResult(TypedDict): diff --git a/official/projects/waste_identification_ml/model_inference/preprocessing.py b/official/projects/waste_identification_ml/model_inference/preprocessing.py index a69fe48ae6a..bfada4f5036 100644 --- a/official/projects/waste_identification_ml/model_inference/preprocessing.py +++ b/official/projects/waste_identification_ml/model_inference/preprocessing.py @@ -15,7 +15,7 @@ """This module provides utilities to normalize image tensors. """ from typing import Sequence -import tensorflow as tf +import tensorflow as tf, tf_keras MEAN_NORM = (0.485, 0.456, 0.406) STDDEV_NORM = (0.229, 0.224, 0.225) diff --git a/official/projects/yolo/dataloaders/classification_input.py b/official/projects/yolo/dataloaders/classification_input.py index 719e64631e1..39d9f784eb7 100644 --- a/official/projects/yolo/dataloaders/classification_input.py +++ b/official/projects/yolo/dataloaders/classification_input.py @@ -13,7 +13,7 @@ # limitations under the License. """Classification decoder and parser.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import classification_input from official.vision.ops import preprocess_ops diff --git a/official/projects/yolo/dataloaders/tf_example_decoder.py b/official/projects/yolo/dataloaders/tf_example_decoder.py index cab074de8e2..d11c51da149 100644 --- a/official/projects/yolo/dataloaders/tf_example_decoder.py +++ b/official/projects/yolo/dataloaders/tf_example_decoder.py @@ -17,7 +17,7 @@ A decoder to decode string tensors containing serialized tensorflow.Example protos for object detection. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tf_example_decoder diff --git a/official/projects/yolo/dataloaders/yolo_input.py b/official/projects/yolo/dataloaders/yolo_input.py index 74ad1326d62..16fc9a629a7 100644 --- a/official/projects/yolo/dataloaders/yolo_input.py +++ b/official/projects/yolo/dataloaders/yolo_input.py @@ -13,7 +13,7 @@ # limitations under the License. """Detection Data parser and processing for YOLO.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import anchor from official.projects.yolo.ops import preprocessing_ops diff --git a/official/projects/yolo/losses/yolo_loss.py b/official/projects/yolo/losses/yolo_loss.py index 162a10fe677..609fa036855 100644 --- a/official/projects/yolo/losses/yolo_loss.py +++ b/official/projects/yolo/losses/yolo_loss.py @@ -17,7 +17,7 @@ import collections import functools -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops from official.projects.yolo.ops import loss_utils @@ -411,7 +411,7 @@ def _compute_loss(self, true_counts, inds, y_true, boxes, classes, y_pred): # make training more unstable but may also return higher APs. pred_class = loss_utils.apply_mask( ind_mask, tf.gather_nd(pred_class, inds, batch_dims=1)) - class_loss = tf.keras.losses.binary_crossentropy( + class_loss = tf_keras.losses.binary_crossentropy( tf.expand_dims(true_class, axis=-1), tf.expand_dims(pred_class, axis=-1), label_smoothing=self._label_smoothing, @@ -556,7 +556,7 @@ def _compute_loss(self, true_counts, inds, y_true, boxes, classes, y_pred): true_conf = tf.squeeze(true_conf, axis=-1) # Compute the cross entropy loss for the confidence map. - bce = tf.keras.losses.binary_crossentropy( + bce = tf_keras.losses.binary_crossentropy( tf.expand_dims(true_conf, axis=-1), pred_conf, from_logits=True) if self._ignore_thresh != 0.0: bce = loss_utils.apply_mask(obj_mask, bce) @@ -565,7 +565,7 @@ def _compute_loss(self, true_counts, inds, y_true, boxes, classes, y_pred): conf_loss = tf.reduce_mean(bce) # Compute the cross entropy loss for the class maps. - class_loss = tf.keras.losses.binary_crossentropy( + class_loss = tf_keras.losses.binary_crossentropy( true_class, pred_class, label_smoothing=self._label_smoothing, diff --git a/official/projects/yolo/losses/yolo_loss_test.py b/official/projects/yolo/losses/yolo_loss_test.py index fdf6ce5d6d8..10b263243b5 100644 --- a/official/projects/yolo/losses/yolo_loss_test.py +++ b/official/projects/yolo/losses/yolo_loss_test.py @@ -15,7 +15,7 @@ """Tests for yolo heads.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.losses import yolo_loss @@ -35,7 +35,7 @@ def inpdict(input_shape, dtype=tf.float32): inputs[key] = tf.ones(input_shape[key], dtype=dtype) return inputs - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 255], '4': [1, 26, 26, 255], diff --git a/official/projects/yolo/losses/yolov7_loss.py b/official/projects/yolo/losses/yolov7_loss.py index d74996694b1..191d5fdd88c 100644 --- a/official/projects/yolo/losses/yolov7_loss.py +++ b/official/projects/yolo/losses/yolov7_loss.py @@ -14,7 +14,7 @@ """YOLOv7 loss function.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops from official.vision.losses import focal_loss @@ -46,7 +46,7 @@ def merge_labels(labels): return tf.concat([classes[..., None], boxes], axis=-1) -class YoloV7Loss(tf.keras.losses.Loss): +class YoloV7Loss(tf_keras.losses.Loss): """YOLOv7 loss function.""" def __init__( @@ -64,7 +64,7 @@ def __init__( iou_mix_ratio=1.0, num_classes=80, auto_balance=False, - reduction=tf.keras.losses.Reduction.NONE, + reduction=tf_keras.losses.Reduction.NONE, name=None, ): """Constructor for YOLOv7 loss. @@ -404,7 +404,7 @@ def get_config(self): return dict(list(base_config.items()) + list(config.items())) -class YoloV7LossOTA(tf.keras.losses.Loss): +class YoloV7LossOTA(tf_keras.losses.Loss): """YOLOv7 loss function with OTA. OTA (Optimal Transport Assignment) uses Sinkhorn-Knopp algorithm to copmute @@ -429,7 +429,7 @@ def __init__( iou_mix_ratio=1.0, num_classes=80, auto_balance=False, - reduction=tf.keras.losses.Reduction.NONE, + reduction=tf_keras.losses.Reduction.NONE, name=None, ): """Constructor for YOLOv7 loss OTA. diff --git a/official/projects/yolo/losses/yolov7_loss_test.py b/official/projects/yolo/losses/yolov7_loss_test.py index f0397fd41ad..1316fc109bd 100644 --- a/official/projects/yolo/losses/yolov7_loss_test.py +++ b/official/projects/yolo/losses/yolov7_loss_test.py @@ -17,7 +17,7 @@ from absl import logging from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.losses import yolov7_loss from official.projects.yolo.ops import box_ops diff --git a/official/projects/yolo/modeling/backbones/darknet.py b/official/projects/yolo/modeling/backbones/darknet.py index 3ab15afadb3..e69b35c91f8 100644 --- a/official/projects/yolo/modeling/backbones/darknet.py +++ b/official/projects/yolo/modeling/backbones/darknet.py @@ -37,7 +37,7 @@ import collections -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.yolo.modeling.layers import nn_blocks @@ -104,7 +104,7 @@ class LayerBuilder: def __init__(self): self._layer_dict = { 'ConvBN': (nn_blocks.ConvBN, self.conv_bn_config_todict), - 'MaxPool': (tf.keras.layers.MaxPool2D, self.maxpool_config_todict) + 'MaxPool': (tf_keras.layers.MaxPool2D, self.maxpool_config_todict) } def conv_bn_config_todict(self, config, kwargs): @@ -372,13 +372,13 @@ def __call__(self, config, kwargs): } -class Darknet(tf.keras.Model): +class Darknet(tf_keras.Model): """The Darknet backbone architecture.""" def __init__( self, model_id='darknet53', - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), min_level=None, max_level=5, width_scale=1.0, @@ -435,7 +435,7 @@ def __init__( 'name': None } - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) output = self._build_struct(layer_specs, inputs) super().__init__( inputs=inputs, outputs=output, name=self._model_name, **kwargs @@ -571,7 +571,7 @@ def _csp_tiny_stack(self, inputs, config, name): return x, x_route def _tiny_stack(self, inputs, config, name): - x = tf.keras.layers.MaxPool2D( + x = tf_keras.layers.MaxPool2D( pool_size=2, strides=config.strides, padding='same', @@ -676,11 +676,11 @@ def get_config(self): @factory.register_backbone_builder('darknet') def build_darknet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds darknet.""" backbone_config = backbone_config.get() diff --git a/official/projects/yolo/modeling/backbones/darknet_test.py b/official/projects/yolo/modeling/backbones/darknet_test.py index e775f78a76f..75ca04eff79 100644 --- a/official/projects/yolo/modeling/backbones/darknet_test.py +++ b/official/projects/yolo/modeling/backbones/darknet_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -34,13 +34,13 @@ class DarknetTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, model_id, endpoint_filter_scale, scale_final, dilate): """Test creation of ResNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = darknet.Darknet( model_id=model_id, min_level=3, max_level=5, dilate=dilate) self.assertEqual(network.model_id, model_id) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) if dilate: @@ -78,7 +78,7 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(1, 224, 224, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): network = darknet.Darknet( @@ -92,13 +92,13 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): @parameterized.parameters(1, 3, 4) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = darknet.Darknet( model_id='darknet53', min_level=3, max_level=5, input_specs=input_specs) - inputs = tf.keras.Input(shape=(224, 224, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(224, 224, input_dim), batch_size=1) _ = network(inputs) def test_serialize_deserialize(self): diff --git a/official/projects/yolo/modeling/backbones/yolov7.py b/official/projects/yolo/modeling/backbones/yolov7.py index 2f2ff507308..04fe9776896 100644 --- a/official/projects/yolo/modeling/backbones/yolov7.py +++ b/official/projects/yolo/modeling/backbones/yolov7.py @@ -28,7 +28,7 @@ arXiv:2207.02696 """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.yolo.modeling.layers import nn_blocks @@ -38,8 +38,8 @@ # Required block functions for YOLOv7 backbone familes. _BLOCK_FNS = { 'convbn': nn_blocks.ConvBN, - 'maxpool2d': tf.keras.layers.MaxPooling2D, - 'concat': tf.keras.layers.Concatenate, + 'maxpool2d': tf_keras.layers.MaxPooling2D, + 'concat': tf_keras.layers.Concatenate, } # Names for key arguments needed by each block function. @@ -247,13 +247,13 @@ } -class YoloV7(tf.keras.Model): +class YoloV7(tf_keras.Model): """YOLOv7 backbone architecture.""" def __init__( self, model_id='yolov7', - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), use_sync_bn=False, norm_momentum=0.99, norm_epsilon=0.001, @@ -267,17 +267,17 @@ def __init__( Args: model_id: a `str` represents the model variants. - input_specs: a `tf.keras.layers.InputSpec` of the input tensor. + input_specs: a `tf_keras.layers.InputSpec` of the input tensor. use_sync_bn: if set to `True`, use synchronized batch normalization. norm_momentum: a `float` of normalization momentum for the moving average. norm_epsilon: a small `float` added to variance to avoid dividing by zero. activation: a `str` name of the activation function. kernel_initializer: a `str` for kernel initializer of convolutional layers. - kernel_regularizer: a `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: a `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. bias_initializer: a `str` for bias initializer of convolutional layers. - bias_regularizer: a `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: a `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -296,7 +296,7 @@ def __init__( self._bias_initializer = bias_initializer self._bias_regularizer = bias_regularizer - inputs = tf.keras.layers.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.layers.Input(shape=input_specs.shape[1:]) block_specs = BACKBONES[model_id.lower()] outputs = [] @@ -363,11 +363,11 @@ def output_specs(self): @factory.register_backbone_builder('yolov7') def build_yolov7( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds YOLOv7.""" assert backbone_config.type == 'yolov7', ( diff --git a/official/projects/yolo/modeling/backbones/yolov7_test.py b/official/projects/yolo/modeling/backbones/yolov7_test.py index 05a5886af1f..5e69ccc7215 100644 --- a/official/projects/yolo/modeling/backbones/yolov7_test.py +++ b/official/projects/yolo/modeling/backbones/yolov7_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -32,12 +32,12 @@ class YoloV7BackboneTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, model_id): """Tests declaration of YOLOv7 backbone variants.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = yolov7.YoloV7(model_id) self.assertEqual(network.get_config()['model_id'], model_id) - inputs = tf.keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) + inputs = tf_keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) outputs = network(inputs) for level, level_output in outputs.items(): @@ -57,7 +57,7 @@ def test_sync_bn_multiple_devices(self, strategy): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(1, *_INPUT_SIZE, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): network = yolov7.YoloV7(model_id='yolov7') diff --git a/official/projects/yolo/modeling/decoders/yolo_decoder.py b/official/projects/yolo/modeling/decoders/yolo_decoder.py index 5c5ff992822..1c7f51c224b 100644 --- a/official/projects/yolo/modeling/decoders/yolo_decoder.py +++ b/official/projects/yolo/modeling/decoders/yolo_decoder.py @@ -15,7 +15,7 @@ """Feature Pyramid Network and Path Aggregation variants used in YOLO.""" from typing import Mapping, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.yolo.modeling.layers import nn_blocks @@ -84,13 +84,13 @@ } -class _IdentityRoute(tf.keras.layers.Layer): +class _IdentityRoute(tf_keras.layers.Layer): def call(self, inputs): # pylint: disable=arguments-differ return None, inputs -class YoloFPN(tf.keras.layers.Layer): +class YoloFPN(tf_keras.layers.Layer): """YOLO Feature pyramid network.""" def __init__(self, @@ -128,8 +128,8 @@ def __init__(self, norm_epsilon: `float`, small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. **kwargs: keyword arguments to be passed. """ @@ -246,7 +246,7 @@ def call(self, inputs): return outputs -class YoloPAN(tf.keras.layers.Layer): +class YoloPAN(tf_keras.layers.Layer): """YOLO Path Aggregation Network.""" def __init__(self, @@ -282,8 +282,8 @@ def __init__(self, norm_epsilon: `float`, small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. fpn_input: `bool`, for whether the input into this fucntion is an FPN or a backbone. fpn_filter_scale: `int`, scaling factor for the FPN filters. @@ -438,7 +438,7 @@ def call(self, inputs): return outputs -class YoloDecoder(tf.keras.Model): +class YoloDecoder(tf_keras.Model): """Darknet Backbone Decoder.""" def __init__(self, @@ -489,8 +489,8 @@ def __init__(self, norm_epsilon: `float`, small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. **kwargs: keyword arguments to be passed. """ @@ -533,7 +533,7 @@ def __init__(self, **self._base_config) inputs = { - key: tf.keras.layers.Input(shape=value[1:]) + key: tf_keras.layers.Input(shape=value[1:]) for key, value in input_specs.items() } if self._use_fpn: @@ -575,20 +575,20 @@ def from_config(cls, config, custom_objects=None): def build_yolo_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - **kwargs) -> Union[None, tf.keras.Model, tf.keras.layers.Layer]: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + **kwargs) -> Union[None, tf_keras.Model, tf_keras.layers.Layer]: """Builds Yolo FPN/PAN decoder from a config. Args: input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A OneOfConfig. Model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` instance. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` instance. Default to None. **kwargs: Additional kwargs arguments. Returns: - A `tf.keras.Model` instance of the Yolo FPN/PAN decoder. + A `tf_keras.Model` instance of the Yolo FPN/PAN decoder. """ decoder_cfg = model_config.decoder.get() norm_activation_config = model_config.norm_activation diff --git a/official/projects/yolo/modeling/decoders/yolo_decoder_test.py b/official/projects/yolo/modeling/decoders/yolo_decoder_test.py index 3b9b3172601..e58d1207784 100644 --- a/official/projects/yolo/modeling/decoders/yolo_decoder_test.py +++ b/official/projects/yolo/modeling/decoders/yolo_decoder_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -66,7 +66,7 @@ def _build_yolo_decoder(self, input_specs, name='1'): @parameterized.parameters('1', '6spp', '6sppfpn', '6') def test_network_creation(self, version): """Test creation of ResNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 256], '4': [1, 26, 26, 512], @@ -94,7 +94,7 @@ def test_network_creation(self, version): def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): """Test for sync bn on TPU and GPU devices.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): input_shape = { @@ -113,7 +113,7 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): @parameterized.parameters(1, 3, 4) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 256], @@ -129,7 +129,7 @@ def test_input_specs(self, input_dim): def test_serialize_deserialize(self): """Create a network object that sets all of its config options.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 256], diff --git a/official/projects/yolo/modeling/decoders/yolov7.py b/official/projects/yolo/modeling/decoders/yolov7.py index e4ed716b28a..1f4fd11e1a9 100644 --- a/official/projects/yolo/modeling/decoders/yolov7.py +++ b/official/projects/yolo/modeling/decoders/yolov7.py @@ -28,7 +28,7 @@ arXiv:2207.02696 """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.projects.yolo.modeling.layers import nn_blocks @@ -38,9 +38,9 @@ # Required block functions for YOLOv7 decoder familes. _BLOCK_FNS = { 'convbn': nn_blocks.ConvBN, - 'upsample2d': tf.keras.layers.UpSampling2D, - 'maxpool2d': tf.keras.layers.MaxPooling2D, - 'concat': tf.keras.layers.Concatenate, + 'upsample2d': tf_keras.layers.UpSampling2D, + 'maxpool2d': tf_keras.layers.MaxPooling2D, + 'concat': tf_keras.layers.Concatenate, 'sppcspc': nn_blocks.SPPCSPC, 'repconv': nn_blocks.RepConv, } @@ -304,7 +304,7 @@ } -class YoloV7(tf.keras.Model): +class YoloV7(tf_keras.Model): """YOLOv7 decoder architecture.""" def __init__( @@ -334,10 +334,10 @@ def __init__( use_separable_conv: `bool` wether to use separable convs. kernel_initializer: a `str` for kernel initializer of convolutional layers. - kernel_regularizer: a `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: a `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. bias_initializer: a `str` for bias initializer of convolutional layers. - bias_regularizer: a `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: a `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -396,7 +396,7 @@ def __init__( def _generate_inputs(self, input_specs): inputs = {} for level, input_shape in input_specs.items(): - inputs[level] = tf.keras.layers.Input(shape=input_shape[1:]) + inputs[level] = tf_keras.layers.Input(shape=input_shape[1:]) return inputs def _group_layer_inputs(self, from_index, inputs, outputs): @@ -437,10 +437,10 @@ def output_specs(self): @factory.register_decoder_builder('yolov7') def build_yolov7( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, -) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, +) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds YOLOv7 decoder.""" decoder_config = model_config.decoder norm_activation_config = model_config.norm_activation diff --git a/official/projects/yolo/modeling/decoders/yolov7_test.py b/official/projects/yolo/modeling/decoders/yolov7_test.py index fc4c728a2be..eeda8f33748 100644 --- a/official/projects/yolo/modeling/decoders/yolov7_test.py +++ b/official/projects/yolo/modeling/decoders/yolov7_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -33,13 +33,13 @@ class YoloV7DecoderTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, model_id): """Tests declaration of YOLOv7 decoder variants.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone_network = backbone.YoloV7(model_id) decoder_network = decoder.YoloV7(backbone_network.output_specs, model_id) self.assertEqual(decoder_network.get_config()['model_id'], model_id) - inputs = tf.keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) + inputs = tf_keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) outputs = decoder_network(backbone_network(inputs)) for level, level_output in outputs.items(): @@ -59,7 +59,7 @@ def test_sync_bn_multiple_devices(self, strategy): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(1, *_INPUT_SIZE, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): backbone_network = backbone.YoloV7(model_id='yolov7', use_sync_bn=True) diff --git a/official/projects/yolo/modeling/factory_test.py b/official/projects/yolo/modeling/factory_test.py index eb1a941c1c8..9bd449c2810 100644 --- a/official/projects/yolo/modeling/factory_test.py +++ b/official/projects/yolo/modeling/factory_test.py @@ -15,7 +15,7 @@ """Tests for factory.py.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=unused-import from official.projects.yolo.configs import backbones @@ -37,7 +37,7 @@ class FactoryTest(tf.test.TestCase): def test_yolo_builder(self): num_classes = 3 input_size = 640 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]) model_config = yolo.Yolo( num_classes=num_classes, @@ -55,7 +55,7 @@ def test_yolo_builder(self): yolo.Box(box=[192, 243]), yolo.Box(box=[459, 401]) ])) - l2_regularizer = tf.keras.regularizers.l2(5e-5) + l2_regularizer = tf_keras.regularizers.l2(5e-5) yolo_model, _ = factory.build_yolo( input_specs=input_specs, @@ -69,7 +69,7 @@ def test_yolo_builder(self): def test_yolov7_builder(self): num_classes = 3 input_size = 640 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3] ) model_config = yolov7.YoloV7( @@ -90,7 +90,7 @@ def test_yolov7_builder(self): ], ), ) - l2_regularizer = tf.keras.regularizers.l2(5e-5) + l2_regularizer = tf_keras.regularizers.l2(5e-5) yolo_model = factory.build_yolov7( input_specs=input_specs, diff --git a/official/projects/yolo/modeling/heads/yolo_head.py b/official/projects/yolo/modeling/heads/yolo_head.py index 5c975d04a59..7391c8b2197 100644 --- a/official/projects/yolo/modeling/heads/yolo_head.py +++ b/official/projects/yolo/modeling/heads/yolo_head.py @@ -14,11 +14,11 @@ """Yolo heads.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.layers import nn_blocks -class YoloHead(tf.keras.layers.Layer): +class YoloHead(tf_keras.layers.Layer): """YOLO Prediction Head.""" def __init__(self, @@ -50,8 +50,8 @@ def __init__(self, norm_epsilon: `float`, small float added to variance to avoid dividing by zero. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. activation: `str`, the activation function to use typically leaky or mish. smart_bias: `bool`, whether to use smart bias. use_separable_conv: `bool` wether to use separable convs. @@ -94,7 +94,7 @@ def __init__(self, def bias_init(self, scale, inshape, isize=640, no_per_conf=8): def bias(shape, dtype): - init = tf.keras.initializers.Zeros() + init = tf_keras.initializers.Zeros() base = init(shape, dtype=dtype) if self._smart_bias: base = tf.reshape(base, [self._boxes_per_level, -1]) diff --git a/official/projects/yolo/modeling/heads/yolo_head_test.py b/official/projects/yolo/modeling/heads/yolo_head_test.py index d121ea0665d..b95351835b6 100644 --- a/official/projects/yolo/modeling/heads/yolo_head_test.py +++ b/official/projects/yolo/modeling/heads/yolo_head_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.heads import yolo_head as heads @@ -25,7 +25,7 @@ class YoloDecoderTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self): """Test creation of YOLO family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 256], '4': [1, 26, 26, 512], @@ -49,7 +49,7 @@ def test_network_creation(self): def test_serialize_deserialize(self): # Create a network object that sets all of its config options. - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 256], '4': [1, 26, 26, 512], diff --git a/official/projects/yolo/modeling/heads/yolov7_head.py b/official/projects/yolo/modeling/heads/yolov7_head.py index 897922e5d31..26e2a3e09d7 100644 --- a/official/projects/yolo/modeling/heads/yolov7_head.py +++ b/official/projects/yolo/modeling/heads/yolov7_head.py @@ -14,11 +14,11 @@ """YOLOv7 heads.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import initializer_ops -class YoloV7DetectionHead(tf.keras.layers.Layer): +class YoloV7DetectionHead(tf_keras.layers.Layer): """YOLOv7 Detection Head.""" def __init__( @@ -42,9 +42,9 @@ def __init__( max_level: maximum feature level. num_anchors: integer for number of anchors at each location. kernel_initializer: kernel_initializer for convolutional layers. - kernel_regularizer: tf.keras.regularizers.Regularizer object for Conv2D. + kernel_regularizer: tf_keras.regularizers.Regularizer object for Conv2D. bias_initializer: bias initializer for convolutional layers. - bias_regularizer: tf.keras.regularizers.Regularizer object for Conv2d. + bias_regularizer: tf_keras.regularizers.Regularizer object for Conv2d. use_separable_conv: `bool` wether to use separable convs. **kwargs: other keyword arguments. """ @@ -65,7 +65,7 @@ def __init__( def _bias_init(self, scale, in_channels, isize=640, no_per_conf=8): def bias(shape, dtype): - init = tf.keras.initializers.VarianceScaling( + init = tf_keras.initializers.VarianceScaling( scale=1 / 3, mode='fan_in', distribution='uniform') base = init([in_channels, *shape], dtype=dtype)[0] @@ -84,9 +84,9 @@ def build(self, input_shape): self._implicit_adds = [] self._implicit_muls = [] conv_op = ( - tf.keras.layers.SeparableConv2D + tf_keras.layers.SeparableConv2D if self._use_separable_conv - else tf.keras.layers.Conv2D + else tf_keras.layers.Conv2D ) for level in range(self._min_level, self._max_level + 1): # Note that we assume height == width. @@ -108,7 +108,7 @@ def build(self, input_shape): self.add_weight( name=f'implicit_adds_l{level}', shape=[1, 1, 1, in_channels], - initializer=tf.keras.initializers.random_normal( + initializer=tf_keras.initializers.random_normal( mean=0.0, stddev=0.02 ), trainable=True, @@ -118,7 +118,7 @@ def build(self, input_shape): self.add_weight( name=f'implicit_muls_l{level}', shape=[1, 1, 1, (self._num_classes + 5) * self._num_anchors], - initializer=tf.keras.initializers.random_normal( + initializer=tf_keras.initializers.random_normal( mean=1.0, stddev=0.02 ), trainable=True, diff --git a/official/projects/yolo/modeling/heads/yolov7_head_test.py b/official/projects/yolo/modeling/heads/yolov7_head_test.py index 3c11aa301cd..6ae7881a109 100644 --- a/official/projects/yolo/modeling/heads/yolov7_head_test.py +++ b/official/projects/yolo/modeling/heads/yolov7_head_test.py @@ -15,7 +15,7 @@ """Tests for yolov7 heads.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.backbones import yolov7 as backbone from official.projects.yolo.modeling.decoders import yolov7 as decoder @@ -31,13 +31,13 @@ class YoloV7DetectionHeadTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, model_id): """Tests declaration of YOLOv7 detection head.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone_network = backbone.YoloV7(model_id) decoder_network = decoder.YoloV7(backbone_network.output_specs, model_id) head_network = head.YoloV7DetectionHead() - inputs = tf.keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) + inputs = tf_keras.Input(shape=(*_INPUT_SIZE, 3), batch_size=1) outputs = head_network(decoder_network(backbone_network(inputs))) for level, level_output in outputs.items(): diff --git a/official/projects/yolo/modeling/layers/detection_generator.py b/official/projects/yolo/modeling/layers/detection_generator.py index 0734d64fc43..9bbf2862308 100644 --- a/official/projects/yolo/modeling/layers/detection_generator.py +++ b/official/projects/yolo/modeling/layers/detection_generator.py @@ -14,7 +14,7 @@ """Contains common building blocks for yolo layer (detection layer).""" from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.losses import yolo_loss from official.projects.yolo.ops import box_ops @@ -22,7 +22,7 @@ from official.vision.modeling.layers import detection_generator -class YoloLayer(tf.keras.layers.Layer): +class YoloLayer(tf_keras.layers.Layer): """Yolo layer (detection generator).""" def __init__( diff --git a/official/projects/yolo/modeling/layers/detection_generator_test.py b/official/projects/yolo/modeling/layers/detection_generator_test.py index d43165ad10f..938bbacfec8 100644 --- a/official/projects/yolo/modeling/layers/detection_generator_test.py +++ b/official/projects/yolo/modeling/layers/detection_generator_test.py @@ -14,7 +14,7 @@ """Tests for yolo detection generator.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.layers import detection_generator @@ -29,7 +29,7 @@ class YoloDecoderTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, nms_version, use_class_agnostic_nms): """Test creation of ResNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_shape = { '3': [1, 52, 52, 255], '4': [1, 26, 26, 255], diff --git a/official/projects/yolo/modeling/layers/nn_blocks.py b/official/projects/yolo/modeling/layers/nn_blocks.py index 649f3c43d99..ca2ff5b5878 100644 --- a/official/projects/yolo/modeling/layers/nn_blocks.py +++ b/official/projects/yolo/modeling/layers/nn_blocks.py @@ -16,19 +16,19 @@ import functools from typing import Callable, List, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.ops import spatial_transform_ops -class Identity(tf.keras.layers.Layer): +class Identity(tf_keras.layers.Layer): def call(self, inputs): return inputs -class ConvBN(tf.keras.layers.Layer): +class ConvBN(tf_keras.layers.Layer): """ConvBN block. Modified Convolution layer to match that of the Darknet Library. @@ -102,7 +102,7 @@ def __init__(self, if kernel_initializer == 'VarianceScaling': # to match pytorch initialization method - self._kernel_initializer = tf.keras.initializers.VarianceScaling( + self._kernel_initializer = tf_keras.initializers.VarianceScaling( scale=1 / 3, mode='fan_in', distribution='uniform') else: self._kernel_initializer = kernel_initializer @@ -123,13 +123,13 @@ def __init__(self, if not isinstance(ksize, List) and not isinstance(ksize, Tuple): ksize = [ksize] if use_separable_conv and not all([a == 1 for a in ksize]): - self._conv_base = tf.keras.layers.SeparableConv2D + self._conv_base = tf_keras.layers.SeparableConv2D else: - self._conv_base = tf.keras.layers.Conv2D + self._conv_base = tf_keras.layers.Conv2D - self._bn_base = tf.keras.layers.BatchNormalization + self._bn_base = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': # format: (batch_size, height, width, channels) self._bn_axis = -1 else: @@ -168,7 +168,7 @@ def build(self, input_shape): self.bn = None if self._activation == 'leaky': - self._activation_fn = tf.keras.layers.LeakyReLU(alpha=self._leaky_alpha) + 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: @@ -238,7 +238,7 @@ def get_config(self): return layer_config -class DarkResidual(tf.keras.layers.Layer): +class DarkResidual(tf_keras.layers.Layer): """Darknet block with Residual connection for Yolo v3 Backbone.""" def __init__(self, @@ -364,9 +364,9 @@ def build(self, input_shape): padding='same', **dark_conv_args) - self._shortcut = tf.keras.layers.Add() + self._shortcut = tf_keras.layers.Add() if self._sc_activation == 'leaky': - self._activation_fn = tf.keras.layers.LeakyReLU(alpha=self._leaky_alpha) + self._activation_fn = tf_keras.layers.LeakyReLU(alpha=self._leaky_alpha) elif self._sc_activation == 'mish': self._activation_fn = lambda x: x * tf.math.tanh(tf.math.softplus(x)) else: @@ -402,13 +402,13 @@ def get_config(self): return layer_config -class CSPTiny(tf.keras.layers.Layer): +class CSPTiny(tf_keras.layers.Layer): """CSP Tiny layer. A Small size convolution block proposed in the CSPNet. The layer uses shortcuts, routing(concatnation), and feature grouping in order to improve gradient variablity and allow for high efficency, low power residual learning - for small networtf.keras. + for small networtf_keras. 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 @@ -533,7 +533,7 @@ def build(self, input_shape): **dark_conv_args) if self._downsample: - self._maxpool = tf.keras.layers.MaxPool2D( + self._maxpool = tf_keras.layers.MaxPool2D( pool_size=2, strides=2, padding='same', data_format=None) super().build(input_shape) @@ -551,7 +551,7 @@ def call(self, inputs, training=None): return x, x5 -class CSPRoute(tf.keras.layers.Layer): +class CSPRoute(tf_keras.layers.Layer): """CSPRoute block. Down sampling layer to take the place of down sampleing done in Residual @@ -690,7 +690,7 @@ def call(self, inputs, training=None): return (x, y) -class CSPConnect(tf.keras.layers.Layer): +class CSPConnect(tf_keras.layers.Layer): """CSPConnect block. Sister Layer to the CSPRoute layer. Merges the partial feature stacks @@ -793,7 +793,7 @@ def build(self, input_shape): kernel_size=self._kernel_size, strides=(1, 1), **dark_conv_args) - self._concat = tf.keras.layers.Concatenate(axis=-1) + self._concat = tf_keras.layers.Concatenate(axis=-1) if not self._drop_final: self._conv2 = ConvBN( @@ -814,7 +814,7 @@ def call(self, inputs, training=None): return x -class CSPStack(tf.keras.layers.Layer): +class CSPStack(tf_keras.layers.Layer): """CSP Stack layer. CSP full stack, combines the route and the connect in case you dont want to @@ -934,7 +934,7 @@ def call(self, inputs, training=None): return x -class PathAggregationBlock(tf.keras.layers.Layer): +class PathAggregationBlock(tf_keras.layers.Layer): """Path Aggregation block.""" def __init__(self, @@ -1088,7 +1088,7 @@ def build(self, input_shape): else: self._build_regular(input_shape, dark_conv_args) - self._concat = tf.keras.layers.Concatenate() + self._concat = tf_keras.layers.Concatenate() super().build(input_shape) def _call_regular(self, inputs, training=None): @@ -1124,7 +1124,7 @@ def call(self, inputs, training=None): return self._call_regular(inputs, training=training) -class SPP(tf.keras.layers.Layer): +class SPP(tf_keras.layers.Layer): """Spatial Pyramid Pooling. A non-agregated SPP layer that uses Pooling. @@ -1140,7 +1140,7 @@ def build(self, input_shape): maxpools = [] for size in self._sizes: maxpools.append( - tf.keras.layers.MaxPool2D( + tf_keras.layers.MaxPool2D( pool_size=(size, size), strides=(1, 1), padding='same', @@ -1153,7 +1153,7 @@ def call(self, inputs, training=None): for maxpool in self._maxpools: outputs.append(maxpool(inputs)) outputs.append(inputs) - concat_output = tf.keras.layers.concatenate(outputs) + concat_output = tf_keras.layers.concatenate(outputs) return concat_output def get_config(self): @@ -1162,7 +1162,7 @@ def get_config(self): return layer_config -class SAM(tf.keras.layers.Layer): +class SAM(tf_keras.layers.Layer): """Spatial Attention Model. [1] Sanghyun Woo, Jongchan Park, Joon-Young Lee, In So Kweon @@ -1224,7 +1224,7 @@ def build(self, input_shape): self._filters = input_shape[-1] self._conv = ConvBN(filters=self._filters, **self.dark_conv_args) if self._output_activation == 'leaky': - self._activation_fn = tf.keras.layers.LeakyReLU(alpha=self._leaky_alpha) + self._activation_fn = tf_keras.layers.LeakyReLU(alpha=self._leaky_alpha) elif self._output_activation == 'mish': self._activation_fn = lambda x: x * tf.math.tanh(tf.math.softplus(x)) else: @@ -1242,7 +1242,7 @@ def call(self, inputs, training=None): return self._activation_fn(inputs * attention_mask) -class CAM(tf.keras.layers.Layer): +class CAM(tf_keras.layers.Layer): """Channel Attention Model. [1] Sanghyun Woo, Jongchan Park, Joon-Young Lee, In So Kweon @@ -1274,7 +1274,7 @@ def __init__(self, self._bn_args = {} else: self._bn = functools.partial( - tf.keras.layers.BatchNormalization, synchronized=use_sync_bn) + tf_keras.layers.BatchNormalization, synchronized=use_sync_bn) self._bn_args = { 'momentum': norm_momentum, 'epsilon': norm_epsilon, @@ -1297,18 +1297,18 @@ def __init__(self, def build(self, input_shape): self._filters = input_shape[-1] - self._mlp = tf.keras.Sequential([ - tf.keras.layers.Dense(self._filters, **self._mlp_args), + self._mlp = tf_keras.Sequential([ + tf_keras.layers.Dense(self._filters, **self._mlp_args), self._bn(**self._bn_args), - tf.keras.layers.Dense( + tf_keras.layers.Dense( int(self._filters * self._reduction_ratio), **self._mlp_args), self._bn(**self._bn_args), - tf.keras.layers.Dense(self._filters, **self._mlp_args), + tf_keras.layers.Dense(self._filters, **self._mlp_args), self._bn(**self._bn_args), ]) if self._activation == 'leaky': - self._activation_fn = tf.keras.layers.LeakyReLU(alpha=self._leaky_alpha) + 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: @@ -1325,7 +1325,7 @@ def call(self, inputs, training=None): return inputs * attention_mask -class CBAM(tf.keras.layers.Layer): +class CBAM(tf_keras.layers.Layer): """Convolutional Block Attention Module. [1] Sanghyun Woo, Jongchan Park, Joon-Young Lee, In So Kweon @@ -1398,7 +1398,7 @@ def call(self, inputs, training=None): return self._sam(self._cam(inputs)) -class DarkRouteProcess(tf.keras.layers.Layer): +class DarkRouteProcess(tf_keras.layers.Layer): """Dark Route Process block. Process darknet outputs and connect back bone to head more generalizably @@ -1696,7 +1696,7 @@ def call(self, inputs, training=None): return self._call_regular(inputs) -class Reorg(tf.keras.layers.Layer): +class Reorg(tf_keras.layers.Layer): """Splits a high resolution image into 4 lower resolution images. Used in YOLOR to process very high resolution inputs efficiently. @@ -1713,7 +1713,7 @@ def call(self, x, training=None): axis=-1) -class SPPCSPC(tf.keras.layers.Layer): +class SPPCSPC(tf_keras.layers.Layer): """Cross-stage partial network with spatial pyramid pooling. This module is used in YOLOv7 to process backbone feature at the highest @@ -1797,7 +1797,7 @@ def build(self, input_shape): self._conv1_2 = conv_op(filters, kernel_size=3, strides=1) self._conv1_3 = conv_op(filters, kernel_size=1, strides=1) self._poolings = [ - tf.keras.layers.MaxPooling2D(pool_size, strides=1, padding='same') + tf_keras.layers.MaxPooling2D(pool_size, strides=1, padding='same') for pool_size in self._pool_sizes ] self._conv1_4 = conv_op(filters, kernel_size=1, strides=1) @@ -1839,7 +1839,7 @@ def get_config(self): return layer_config -class RepConv(tf.keras.layers.Layer): +class RepConv(tf_keras.layers.Layer): """Represented convolution. https://arxiv.org/abs/2101.03697 @@ -1909,9 +1909,9 @@ def __init__( def build(self, input_shape): conv_op = functools.partial( - tf.keras.layers.SeparableConv2D + tf_keras.layers.SeparableConv2D if self._use_separable_conv - else tf.keras.layers.Conv2D, + else tf_keras.layers.Conv2D, filters=self._filters, strides=self._strides, padding=self._padding, @@ -1921,7 +1921,7 @@ def build(self, input_shape): bias_regularizer=self._bias_regularizer, ) bn_op = functools.partial( - tf.keras.layers.BatchNormalization, + tf_keras.layers.BatchNormalization, synchronized=self._use_sync_bn, momentum=self._norm_momentum, epsilon=self._norm_epsilon, diff --git a/official/projects/yolo/modeling/layers/nn_blocks_test.py b/official/projects/yolo/modeling/layers/nn_blocks_test.py index 2e5de5f7426..8bc5806ecca 100644 --- a/official/projects/yolo/modeling/layers/nn_blocks_test.py +++ b/official/projects/yolo/modeling/layers/nn_blocks_test.py @@ -14,7 +14,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.layers import nn_blocks @@ -24,7 +24,7 @@ class CSPConnectTest(tf.test.TestCase, parameterized.TestCase): @parameterized.named_parameters(('same', 224, 224, 64, 1), ('downsample', 224, 224, 64, 2)) def test_pass_through(self, width, height, filters, mod): - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.CSPRoute(filters=filters, filter_scale=mod) test_layer2 = nn_blocks.CSPConnect(filters=filters, filter_scale=mod) outx, px = test_layer(x) @@ -39,8 +39,8 @@ def test_pass_through(self, width, height, filters, mod): @parameterized.named_parameters(('same', 224, 224, 64, 1), ('downsample', 224, 224, 128, 2)) def test_gradient_pass_though(self, filters, width, height, mod): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.CSPRoute(filters, filter_scale=mod) path_layer = nn_blocks.CSPConnect(filters, filter_scale=mod) @@ -68,7 +68,7 @@ class CSPRouteTest(tf.test.TestCase, parameterized.TestCase): @parameterized.named_parameters(('same', 224, 224, 64, 1), ('downsample', 224, 224, 64, 2)) def test_pass_through(self, width, height, filters, mod): - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.CSPRoute(filters=filters, filter_scale=mod) outx, _ = test_layer(x) print(outx) @@ -81,8 +81,8 @@ def test_pass_through(self, width, height, filters, mod): @parameterized.named_parameters(('same', 224, 224, 64, 1), ('downsample', 224, 224, 128, 2)) def test_gradient_pass_though(self, filters, width, height, mod): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.CSPRoute(filters, filter_scale=mod) path_layer = nn_blocks.CSPConnect(filters, filter_scale=mod) @@ -115,7 +115,7 @@ def test_pass_through(self, kernel_size, padding, strides): pad_const = 1 else: pad_const = 0 - x = tf.keras.Input(shape=(224, 224, 3)) + x = tf_keras.Input(shape=(224, 224, 3)) test_layer = nn_blocks.ConvBN( filters=64, kernel_size=kernel_size, @@ -134,8 +134,8 @@ def test_pass_through(self, kernel_size, padding, strides): @parameterized.named_parameters(('filters', 3)) def test_gradient_pass_though(self, filters): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() with tf.device('/CPU:0'): test_layer = nn_blocks.ConvBN(filters, kernel_size=(3, 3), padding='same') @@ -162,7 +162,7 @@ def test_pass_through(self, width, height, filters, downsample): mod = 1 if downsample: mod = 2 - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.DarkResidual(filters=filters, downsample=downsample) outx = test_layer(x) print(outx) @@ -176,8 +176,8 @@ def test_pass_through(self, width, height, filters, downsample): ('downsample', 32, 223, 223, True), ('oddball', 32, 223, 223, False)) def test_gradient_pass_though(self, filters, width, height, downsample): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.DarkResidual(filters, downsample=downsample) if downsample: @@ -209,7 +209,7 @@ class DarkSppTest(tf.test.TestCase, parameterized.TestCase): ('test1', 300, 300, 10, [2, 3, 4, 5]), ('test2', 256, 256, 5, [10])) def test_pass_through(self, width, height, channels, sizes): - x = tf.keras.Input(shape=(width, height, channels)) + x = tf_keras.Input(shape=(width, height, channels)) test_layer = nn_blocks.SPP(sizes=sizes) outx = test_layer(x) self.assertAllEqual(outx.shape.as_list(), @@ -220,8 +220,8 @@ def test_pass_through(self, width, height, channels, sizes): ('test1', 300, 300, 10, [2, 3, 4, 5]), ('test2', 256, 256, 5, [10])) def test_gradient_pass_though(self, width, height, channels, sizes): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.SPP(sizes=sizes) init = tf.random_normal_initializer() @@ -249,7 +249,7 @@ class DarkRouteProcessTest(tf.test.TestCase, parameterized.TestCase): ('test1', 224, 224, 64, 7, False), ('test2', 223, 223, 32, 3, False), ('tiny', 223, 223, 16, 1, False), ('spp', 224, 224, 64, 7, False)) def test_pass_through(self, width, height, filters, repetitions, spp): - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.DarkRouteProcess( filters=filters, repetitions=repetitions, insert_spp=spp) outx = test_layer(x) @@ -270,8 +270,8 @@ def test_pass_through(self, width, height, filters, repetitions, spp): ('test1', 224, 224, 64, 7, False), ('test2', 223, 223, 32, 3, False), ('tiny', 223, 223, 16, 1, False), ('spp', 224, 224, 64, 7, False)) def test_gradient_pass_though(self, width, height, filters, repetitions, spp): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.DarkRouteProcess( filters=filters, repetitions=repetitions, insert_spp=spp) @@ -307,7 +307,7 @@ class SPPCSPCTest(tf.test.TestCase, parameterized.TestCase): ('test1', 300, 300, 32, [2, 3, 4, 5], 1.0), ('test2', 256, 256, 16, [10], 2.0)) def test_pass_through(self, width, height, filters, pool_sizes, scale): - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.SPPCSPC(filters, pool_sizes, scale) out = test_layer(x) self.assertAllEqual(out.shape.as_list(), [None, width, height, filters]) @@ -317,8 +317,8 @@ def test_pass_through(self, width, height, filters, pool_sizes, scale): ('test2', 256, 256, 16, [10], 2.0)) def test_gradient_pass_though( self, width, height, filters, pool_sizes, scale): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.SPPCSPC(filters, pool_sizes, scale) init = tf.random_normal_initializer() @@ -343,7 +343,7 @@ class RepConvTest(tf.test.TestCase, parameterized.TestCase): ('test1', 300, 300, 32, 2), ('test2', 256, 256, 16, 4)) def test_pass_through(self, width, height, filters, strides): - x = tf.keras.Input(shape=(width, height, filters)) + x = tf_keras.Input(shape=(width, height, filters)) test_layer = nn_blocks.RepConv(filters, strides=strides) out = test_layer(x) self.assertAllEqual(out.shape.as_list(), @@ -353,8 +353,8 @@ def test_pass_through(self, width, height, filters, strides): ('test1', 300, 300, 32, 2), ('test2', 256, 256, 16, 4)) def test_gradient_pass_though(self, width, height, filters, strides): - loss = tf.keras.losses.MeanSquaredError() - optimizer = tf.keras.optimizers.SGD() + loss = tf_keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.SGD() test_layer = nn_blocks.RepConv(filters, strides=strides) init = tf.random_normal_initializer() diff --git a/official/projects/yolo/modeling/yolo_model.py b/official/projects/yolo/modeling/yolo_model.py index 4c8a6be292a..02640b4af54 100644 --- a/official/projects/yolo/modeling/yolo_model.py +++ b/official/projects/yolo/modeling/yolo_model.py @@ -15,11 +15,11 @@ """Yolo models.""" from typing import Mapping, Union, Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.layers import nn_blocks -class Yolo(tf.keras.Model): +class Yolo(tf_keras.Model): """The YOLO model class.""" def __init__(self, @@ -31,8 +31,8 @@ def __init__(self, """Detection initialization function. Args: - backbone: `tf.keras.Model` a backbone network. - decoder: `tf.keras.Model` a decoder network. + backbone: `tf_keras.Model` a backbone network. + decoder: `tf_keras.Model` a decoder network. head: `RetinaNetHead`, the RetinaNet head. detection_generator: the detection generator. **kwargs: keyword arguments to be passed. @@ -93,7 +93,7 @@ def from_config(cls, config): @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.decoder is not None: diff --git a/official/projects/yolo/modeling/yolov7_model.py b/official/projects/yolo/modeling/yolov7_model.py index 4b2b2c220be..47c7d9b3e23 100644 --- a/official/projects/yolo/modeling/yolov7_model.py +++ b/official/projects/yolo/modeling/yolov7_model.py @@ -16,19 +16,19 @@ from typing import Mapping, Union, Any, Dict from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.modeling.layers import nn_blocks -class YoloV7(tf.keras.Model): +class YoloV7(tf_keras.Model): """The YOLOv7 model class.""" def __init__(self, backbone, decoder, head, detection_generator, **kwargs): """Detection initialization function. Args: - backbone: `tf.keras.Model` a backbone network. - decoder: `tf.keras.Model` a decoder network. + backbone: `tf_keras.Model` a backbone network. + decoder: `tf_keras.Model` a decoder network. head: `RetinaNetHead`, the RetinaNet head. detection_generator: the detection generator. **kwargs: keyword arguments to be passed. @@ -90,7 +90,7 @@ def from_config(cls, config): @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.decoder is not None: diff --git a/official/projects/yolo/ops/anchor.py b/official/projects/yolo/ops/anchor.py index 359be048436..0bd5ecd2738 100644 --- a/official/projects/yolo/ops/anchor.py +++ b/official/projects/yolo/ops/anchor.py @@ -14,7 +14,7 @@ """Yolo Anchor labler.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops from official.projects.yolo.ops import loss_utils diff --git a/official/projects/yolo/ops/box_ops.py b/official/projects/yolo/ops/box_ops.py index 09af953ef10..4faf849e9cd 100644 --- a/official/projects/yolo/ops/box_ops.py +++ b/official/projects/yolo/ops/box_ops.py @@ -14,7 +14,7 @@ """Yolo box ops.""" import math -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import math_ops diff --git a/official/projects/yolo/ops/box_ops_test.py b/official/projects/yolo/ops/box_ops_test.py index 375db321111..620b29357f4 100644 --- a/official/projects/yolo/ops/box_ops_test.py +++ b/official/projects/yolo/ops/box_ops_test.py @@ -15,7 +15,7 @@ """box_ops tests.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops diff --git a/official/projects/yolo/ops/initializer_ops.py b/official/projects/yolo/ops/initializer_ops.py index 90ff1f40a62..50561132f1a 100644 --- a/official/projects/yolo/ops/initializer_ops.py +++ b/official/projects/yolo/ops/initializer_ops.py @@ -14,13 +14,13 @@ """Yolo initializer ops.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def pytorch_kernel_initializer(kernel_initializer): """Prepare kernel weights initializer to match PyTorch implementation.""" if kernel_initializer == 'VarianceScaling': - return tf.keras.initializers.VarianceScaling( + return tf_keras.initializers.VarianceScaling( scale=1 / 3, mode='fan_in', distribution='uniform' ) return kernel_initializer diff --git a/official/projects/yolo/ops/kmeans_anchors.py b/official/projects/yolo/ops/kmeans_anchors.py index 92db32e06c7..e167ec4bb80 100644 --- a/official/projects/yolo/ops/kmeans_anchors.py +++ b/official/projects/yolo/ops/kmeans_anchors.py @@ -16,7 +16,7 @@ import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import input_reader from official.projects.yolo.ops import box_ops diff --git a/official/projects/yolo/ops/kmeans_anchors_test.py b/official/projects/yolo/ops/kmeans_anchors_test.py index c119de966ce..4cff07dac94 100644 --- a/official/projects/yolo/ops/kmeans_anchors_test.py +++ b/official/projects/yolo/ops/kmeans_anchors_test.py @@ -15,7 +15,7 @@ """kmeans_test tests.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import kmeans_anchors diff --git a/official/projects/yolo/ops/loss_utils.py b/official/projects/yolo/ops/loss_utils.py index ad868d43d69..3ec398e5d59 100644 --- a/official/projects/yolo/ops/loss_utils.py +++ b/official/projects/yolo/ops/loss_utils.py @@ -15,7 +15,7 @@ """Yolo loss utility functions.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import box_ops from official.projects.yolo.ops import math_ops @@ -43,7 +43,7 @@ def sigmoid_bce(y, x_prime, label_smoothing): This simplification is used by the darknet library in order to improve training stability. The gradient is almost the same - as tf.keras.losses.binary_crossentropy but varies slightly and + as tf_keras.losses.binary_crossentropy but varies slightly and yields different performance. Args: @@ -171,7 +171,7 @@ def __init__(self, anchors, scale_anchors=None): scale_anchors: An `int` for how much to scale this level to get the original input shape. """ - self.dtype = tf.keras.backend.floatx() + self.dtype = tf_keras.backend.floatx() self._scale_anchors = scale_anchors self._anchors = tf.convert_to_tensor(anchors) return @@ -206,7 +206,7 @@ def _extend_batch(self, grid, batch_size): def __call__(self, height, width, batch_size, dtype=None): if dtype is None: - self.dtype = tf.keras.backend.floatx() + self.dtype = tf_keras.backend.floatx() else: self.dtype = dtype grid_points = self._build_grid_points(height, width, self._anchors, diff --git a/official/projects/yolo/ops/math_ops.py b/official/projects/yolo/ops/math_ops.py index 657d3096533..309c1e2b51c 100644 --- a/official/projects/yolo/ops/math_ops.py +++ b/official/projects/yolo/ops/math_ops.py @@ -13,7 +13,7 @@ # limitations under the License. """A set of private math operations used to safely implement the YOLO loss.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def rm_nan_inf(x, val=0.0): diff --git a/official/projects/yolo/ops/mosaic.py b/official/projects/yolo/ops/mosaic.py index 65ef000e730..f1cef99e136 100644 --- a/official/projects/yolo/ops/mosaic.py +++ b/official/projects/yolo/ops/mosaic.py @@ -15,7 +15,7 @@ """Mosaic op.""" import random -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import preprocessing_ops from official.vision.ops import augment diff --git a/official/projects/yolo/ops/preprocessing_ops.py b/official/projects/yolo/ops/preprocessing_ops.py index d7d1aecfeea..163e5faee02 100644 --- a/official/projects/yolo/ops/preprocessing_ops.py +++ b/official/projects/yolo/ops/preprocessing_ops.py @@ -16,7 +16,7 @@ import random import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import augment from official.vision.ops import box_ops as bbox_ops diff --git a/official/projects/yolo/ops/preprocessing_ops_test.py b/official/projects/yolo/ops/preprocessing_ops_test.py index 3d6c6314a7f..7ac77bca019 100644 --- a/official/projects/yolo/ops/preprocessing_ops_test.py +++ b/official/projects/yolo/ops/preprocessing_ops_test.py @@ -15,7 +15,7 @@ """Tests for preprocessing_ops.py.""" from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import preprocessing_ops from official.vision.ops import box_ops as bbox_ops diff --git a/official/projects/yolo/optimization/configs/optimizer_config.py b/official/projects/yolo/optimization/configs/optimizer_config.py index ed946b944f8..1b47fbbbbdd 100644 --- a/official/projects/yolo/optimization/configs/optimizer_config.py +++ b/official/projects/yolo/optimization/configs/optimizer_config.py @@ -41,7 +41,7 @@ class BaseOptimizerConfig(base_config.Config): class SGDTorchConfig(optimizer_config.BaseOptimizerConfig): """Configuration for SGD optimizer. - The attributes for this class matches the arguments of tf.keras.optimizer.SGD. + The attributes for this class matches the arguments of tf_keras.optimizer.SGD. Attributes: name: name of the optimizer. diff --git a/official/projects/yolo/optimization/optimizer_factory.py b/official/projects/yolo/optimization/optimizer_factory.py index a86d4d014a1..55edbc47a81 100644 --- a/official/projects/yolo/optimization/optimizer_factory.py +++ b/official/projects/yolo/optimization/optimizer_factory.py @@ -73,7 +73,7 @@ def get_bias_lr_schedule(self, bias_lr): bias_lr: learning rate config. Returns: - tf.keras.optimizers.schedules.LearningRateSchedule instance. If + tf_keras.optimizers.schedules.LearningRateSchedule instance. If learning rate type is consant, lr_config.learning_rate is returned. """ if self._lr_type == 'constant': diff --git a/official/projects/yolo/optimization/sgd_torch.py b/official/projects/yolo/optimization/sgd_torch.py index d8edb1b5aa3..633c73d532f 100644 --- a/official/projects/yolo/optimization/sgd_torch.py +++ b/official/projects/yolo/optimization/sgd_torch.py @@ -16,9 +16,9 @@ import re from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras -LearningRateSchedule = tf.keras.optimizers.schedules.LearningRateSchedule +LearningRateSchedule = tf_keras.optimizers.schedules.LearningRateSchedule def _var_key(var): @@ -43,7 +43,7 @@ def _var_key(var): return var._unique_id -class SGDTorch(tf.keras.optimizers.legacy.Optimizer): +class SGDTorch(tf_keras.optimizers.legacy.Optimizer): """Optimizer that simulates the SGD module used in pytorch. diff --git a/official/projects/yolo/serving/export_module_factory.py b/official/projects/yolo/serving/export_module_factory.py index a365937cbea..dc97b13fac8 100644 --- a/official/projects/yolo/serving/export_module_factory.py +++ b/official/projects/yolo/serving/export_module_factory.py @@ -16,7 +16,7 @@ from typing import Any, Callable, Dict, List, Optional, Text, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import export_base @@ -37,7 +37,7 @@ class ExportModule(export_base.ExportModule): def __init__(self, params: cfg.ExperimentConfig, - model: tf.keras.Model, + model: tf_keras.Model, input_signature: Union[tf.TensorSpec, Dict[str, tf.TensorSpec]], preprocessor: Optional[Callable[..., Any]] = None, inference_step: Optional[Callable[..., Any]] = None, @@ -47,7 +47,7 @@ def __init__(self, Args: params: A dataclass for parameters to the module. - model: A tf.keras.Model instance to be exported. + model: A tf_keras.Model instance to be exported. input_signature: tf.TensorSpec, e.g. tf.TensorSpec(shape=[None, 224, 224, 3], dtype=tf.uint8) preprocessor: An optional callable to preprocess the inputs. @@ -112,7 +112,7 @@ def create_classification_export_module( """Creates classification export module.""" input_signature = export_utils.get_image_input_signatures( input_type, batch_size, input_image_size, num_channels, input_name) - input_specs = tf.keras.layers.InputSpec(shape=[batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[batch_size] + input_image_size + [num_channels]) model = factory.build_classification_model( @@ -162,7 +162,7 @@ def create_yolo_export_module( """Creates YOLO export module.""" input_signature = export_utils.get_image_input_signatures( input_type, batch_size, input_image_size, num_channels, input_name) - input_specs = tf.keras.layers.InputSpec(shape=[batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[batch_size] + input_image_size + [num_channels]) if isinstance(params.task, yolo.YoloTask): model, _ = yolo_factory.build_yolo( diff --git a/official/projects/yolo/serving/model_fn.py b/official/projects/yolo/serving/model_fn.py index c9ec9a5f142..0ac699a544b 100644 --- a/official/projects/yolo/serving/model_fn.py +++ b/official/projects/yolo/serving/model_fn.py @@ -16,7 +16,7 @@ from typing import List, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yolo.ops import preprocessing_ops from official.vision.ops import box_ops diff --git a/official/projects/yolo/tasks/task_utils.py b/official/projects/yolo/tasks/task_utils.py index 78452f98e08..d9b7a6b5908 100644 --- a/official/projects/yolo/tasks/task_utils.py +++ b/official/projects/yolo/tasks/task_utils.py @@ -13,7 +13,7 @@ # limitations under the License. """Utils for yolo task.""" -import tensorflow as tf +import tensorflow as tf, tf_keras class ListMetrics: @@ -29,7 +29,7 @@ def build_metric(self): metric_names = self._metric_names metrics = [] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) return metrics def update_state(self, loss_metrics): diff --git a/official/projects/yolo/tasks/yolo.py b/official/projects/yolo/tasks/yolo.py index fe711d500c6..a43937f024b 100644 --- a/official/projects/yolo/tasks/yolo.py +++ b/official/projects/yolo/tasks/yolo.py @@ -18,7 +18,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -113,9 +113,9 @@ def build_model(self): l2_weight_decay = self.task_config.weight_decay / 2.0 input_size = model_base_cfg.input_size.copy() - input_specs = tf.keras.layers.InputSpec(shape=[None] + input_size) + input_specs = tf_keras.layers.InputSpec(shape=[None] + input_size) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None) + tf_keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None) model, losses = factory.build_yolo( input_specs, model_base_cfg, l2_regularizer) model.build(input_specs.shape) @@ -279,7 +279,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): loss_metrics) = self.build_losses(y_pred['raw_output'], label) # Scale the loss for numerical stability - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) # Compute the gradient @@ -287,7 +287,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): gradients = tape.gradient(scaled_loss, train_vars) # Get unscaled loss if we are using the loss scale optimizer on fp16 - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): gradients = optimizer.get_unscaled_gradients(gradients) # Apply gradients to the model @@ -380,7 +380,7 @@ def reduce_aggregated_logs(self, aggregated_logs, global_step=None): res = self.coco_metric.result() return res - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: diff --git a/official/projects/yolo/tasks/yolov7.py b/official/projects/yolo/tasks/yolov7.py index c1bcf45b0f6..e169900532e 100644 --- a/official/projects/yolo/tasks/yolov7.py +++ b/official/projects/yolo/tasks/yolov7.py @@ -17,7 +17,7 @@ from typing import Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -140,9 +140,9 @@ def build_model(self): l2_weight_decay = self.task_config.weight_decay / 2.0 input_size = model_base_cfg.input_size.copy() - input_specs = tf.keras.layers.InputSpec(shape=[None] + input_size) + input_specs = tf_keras.layers.InputSpec(shape=[None] + input_size) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None) + tf_keras.regularizers.l2(l2_weight_decay) if l2_weight_decay else None) model = factory.build_yolov7(input_specs, model_base_cfg, l2_regularizer) model.build(input_specs.shape) model.summary(print_fn=logging.info) @@ -301,7 +301,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): scaled_loss = loss # Scale the loss for numerical stability - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) # Compute the gradient @@ -309,7 +309,7 @@ def train_step(self, inputs, model, optimizer, metrics=None): gradients = tape.gradient(scaled_loss, train_vars) # Get unscaled loss if we are using the loss scale optimizer on fp16 - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): gradients = optimizer.get_unscaled_gradients(gradients) # Apply gradients to the model @@ -406,7 +406,7 @@ def reduce_aggregated_logs(self, aggregated_logs, global_step=None): res = self.coco_metric.result() return res - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: diff --git a/official/projects/yt8m/configs/yt8m_test.py b/official/projects/yt8m/configs/yt8m_test.py index f5766c2a0b1..8e08d0acf33 100644 --- a/official/projects/yt8m/configs/yt8m_test.py +++ b/official/projects/yt8m/configs/yt8m_test.py @@ -13,7 +13,7 @@ # limitations under the License. from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import exp_factory diff --git a/official/projects/yt8m/dataloaders/utils.py b/official/projects/yt8m/dataloaders/utils.py index 0bb4a75a2b1..d0168581f3c 100644 --- a/official/projects/yt8m/dataloaders/utils.py +++ b/official/projects/yt8m/dataloaders/utils.py @@ -16,7 +16,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tfexample_utils diff --git a/official/projects/yt8m/dataloaders/yt8m_input.py b/official/projects/yt8m/dataloaders/yt8m_input.py index 21c6aa48081..7d94ccf734f 100644 --- a/official/projects/yt8m/dataloaders/yt8m_input.py +++ b/official/projects/yt8m/dataloaders/yt8m_input.py @@ -24,7 +24,7 @@ """ from typing import Any, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.dataloaders import utils from official.vision.configs import video_classification as exp_cfg from official.vision.dataloaders import decoder diff --git a/official/projects/yt8m/dataloaders/yt8m_input_test.py b/official/projects/yt8m/dataloaders/yt8m_input_test.py index 44b2217dbb8..60189de021a 100644 --- a/official/projects/yt8m/dataloaders/yt8m_input_test.py +++ b/official/projects/yt8m/dataloaders/yt8m_input_test.py @@ -17,7 +17,7 @@ from absl import logging from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import input_reader from official.projects.yt8m.configs import yt8m as yt8m_configs diff --git a/official/projects/yt8m/eval_utils/eval_util.py b/official/projects/yt8m/eval_utils/eval_util.py index 2881b1b7977..c6441690b6b 100644 --- a/official/projects/yt8m/eval_utils/eval_util.py +++ b/official/projects/yt8m/eval_utils/eval_util.py @@ -15,7 +15,7 @@ """Provides functions to help with evaluating models.""" import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.eval_utils import average_precision_calculator as ap_calculator from official.projects.yt8m.eval_utils import mean_average_precision_calculator as map_calculator diff --git a/official/projects/yt8m/eval_utils/eval_util_test.py b/official/projects/yt8m/eval_utils/eval_util_test.py index 94f721b919e..f1edd2cfe04 100644 --- a/official/projects/yt8m/eval_utils/eval_util_test.py +++ b/official/projects/yt8m/eval_utils/eval_util_test.py @@ -15,7 +15,7 @@ from absl import logging from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.eval_utils.average_precision_calculator import AveragePrecisionCalculator diff --git a/official/projects/yt8m/modeling/backbones/dbof.py b/official/projects/yt8m/modeling/backbones/dbof.py index 833c4c05c93..f0127b6ddab 100644 --- a/official/projects/yt8m/modeling/backbones/dbof.py +++ b/official/projects/yt8m/modeling/backbones/dbof.py @@ -17,7 +17,7 @@ import functools from typing import Any, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -28,7 +28,7 @@ from official.vision.modeling.backbones import factory -layers = tf.keras.layers +layers = tf_keras.layers class Dbof(layers.Layer): @@ -49,13 +49,13 @@ def __init__( ), params: yt8m_cfg.DbofModel = yt8m_cfg.DbofModel(), norm_activation: common.NormActivation = common.NormActivation(), - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs, ): """YT8M initialization function. Args: - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. [batch_size x num_frames x num_features]. params: model configuration parameters. norm_activation: Model normalization and activation configs. @@ -162,12 +162,12 @@ def call( @factory.register_backbone_builder("dbof") def build_dbof( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs, -) -> tf.keras.Model: +) -> tf_keras.Model: """Builds a dbof backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() @@ -182,5 +182,5 @@ def build_dbof( ) # Warmup calls to build model variables. - dbof(tf.keras.Input(input_specs.shape[1:])) + dbof(tf_keras.Input(input_specs.shape[1:])) return dbof diff --git a/official/projects/yt8m/modeling/backbones/dbof_test.py b/official/projects/yt8m/modeling/backbones/dbof_test.py index 01cee231a4c..1b75d7882f5 100644 --- a/official/projects/yt8m/modeling/backbones/dbof_test.py +++ b/official/projects/yt8m/modeling/backbones/dbof_test.py @@ -15,7 +15,7 @@ """Tests for dbof.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.configs import yt8m as yt8m_cfg from official.projects.yt8m.modeling.backbones import dbof @@ -45,7 +45,7 @@ def test_dbof_backbone( context_gate_cluster_bottleneck_size=context_gate_cluster_bottleneck_size, ) backbone = dbof.Dbof( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, 32]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, 32]), params=model_cfg, ) diff --git a/official/projects/yt8m/modeling/heads/logistic.py b/official/projects/yt8m/modeling/heads/logistic.py index 49baef5b864..48f5febaeb4 100644 --- a/official/projects/yt8m/modeling/heads/logistic.py +++ b/official/projects/yt8m/modeling/heads/logistic.py @@ -16,10 +16,10 @@ from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers class LogisticModel(layers.Layer): @@ -29,7 +29,7 @@ def __init__( self, vocab_size: int = 3862, return_logits: bool = False, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs, ): """Creates a logistic model. diff --git a/official/projects/yt8m/modeling/heads/moe.py b/official/projects/yt8m/modeling/heads/moe.py index 78cc1e533f1..baa71986112 100644 --- a/official/projects/yt8m/modeling/heads/moe.py +++ b/official/projects/yt8m/modeling/heads/moe.py @@ -17,12 +17,12 @@ from typing import Any, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.modeling import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers class MoeModel(layers.Layer): @@ -36,7 +36,7 @@ def __init__( use_output_context_gate: bool = False, normalizer_params: Optional[dict[str, Any]] = None, vocab_as_last_dim: bool = False, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs, ): """Creates a Mixture of (Logistic) Experts model. diff --git a/official/projects/yt8m/modeling/nn_layers.py b/official/projects/yt8m/modeling/nn_layers.py index 88db73b86cf..3e16998045e 100644 --- a/official/projects/yt8m/modeling/nn_layers.py +++ b/official/projects/yt8m/modeling/nn_layers.py @@ -16,12 +16,12 @@ from typing import Any, Dict, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.modeling import yt8m_model_utils -class ContextGate(tf.keras.layers.Layer): +class ContextGate(tf_keras.layers.Layer): """Context Gating. More details: https://arxiv.org/pdf/1706.06905.pdf.""" def __init__( @@ -29,10 +29,10 @@ def __init__( normalizer_fn=None, normalizer_params: Optional[Dict[str, Any]] = None, kernel_initializer: Union[ - str, tf.keras.regularizers.Regularizer + str, tf_keras.regularizers.Regularizer ] = "glorot_uniform", - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_initializer: Union[str, tf.keras.regularizers.Regularizer] = "zeros", + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_initializer: Union[str, tf_keras.regularizers.Regularizer] = "zeros", hidden_layer_size: int = 0, pooling_method: Optional[str] = None, additive_residual: bool = False, @@ -83,7 +83,7 @@ def __init__( self._additive_residual = additive_residual if hidden_layer_size >= 2: - self._gates_bottleneck = tf.keras.layers.Dense( + self._gates_bottleneck = tf_keras.layers.Dense( hidden_layer_size, activation="relu6", kernel_initializer=kernel_initializer, @@ -101,7 +101,7 @@ def build(self, input_shape): super().build(input_shape) feature_size = input_shape[-1] activation_fn = tf.nn.relu6 if self._additive_residual else tf.nn.sigmoid - self._gates = tf.keras.layers.Dense( + self._gates = tf_keras.layers.Dense( feature_size, activation=activation_fn, kernel_initializer=self._kernel_initializer, diff --git a/official/projects/yt8m/modeling/nn_layers_test.py b/official/projects/yt8m/modeling/nn_layers_test.py index 27bc3b458e5..6155218edb3 100644 --- a/official/projects/yt8m/modeling/nn_layers_test.py +++ b/official/projects/yt8m/modeling/nn_layers_test.py @@ -15,7 +15,7 @@ """Tests for nn_layers.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.modeling import nn_layers @@ -34,7 +34,7 @@ def test_context_gate( """Test for creation of a context gate layer.""" context_gate = nn_layers.ContextGate( - normalizer_fn=tf.keras.layers.BatchNormalization, + normalizer_fn=tf_keras.layers.BatchNormalization, hidden_layer_size=hidden_layer_size, additive_residual=additive_residual, pooling_method=pooling_method, diff --git a/official/projects/yt8m/modeling/yt8m_model.py b/official/projects/yt8m/modeling/yt8m_model.py index 9037b40f799..1c18d412a3e 100644 --- a/official/projects/yt8m/modeling/yt8m_model.py +++ b/official/projects/yt8m/modeling/yt8m_model.py @@ -18,7 +18,7 @@ from typing import Any, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.configs import yt8m as yt8m_cfg from official.projects.yt8m.modeling import backbones # pylint: disable=unused-import @@ -26,10 +26,10 @@ from official.vision.modeling.backbones import factory -layers = tf.keras.layers +layers = tf_keras.layers -class VideoClassificationModel(tf.keras.Model): +class VideoClassificationModel(tf_keras.Model): """A video classification model class builder. The model consists of a backbone (dbof) and a classification head. @@ -43,7 +43,7 @@ class VideoClassificationModel(tf.keras.Model): def __init__( self, params: yt8m_cfg.VideoClassificationModel, - backbone: Optional[tf.keras.Model] = None, + backbone: Optional[tf_keras.Model] = None, num_classes: int = 3862, input_specs: layers.InputSpec = layers.InputSpec( shape=[None, None, 1152] @@ -57,7 +57,7 @@ def __init__( params: Model configuration parameters. backbone: Optional backbone model. Will build a backbone if None. num_classes: `int` number of classes in dataset. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. [batch_size x num_frames x num_features] l2_weight_decay: An optional `float` of kernel regularizer weight decay. **kwargs: keyword arguments to be passed. @@ -79,7 +79,7 @@ def __init__( # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / 2.0) + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None ) @@ -113,7 +113,7 @@ def build_head(self): return l2_regularizer = ( - tf.keras.regularizers.l2(self._l2_weight_decay / 2.0) + tf_keras.regularizers.l2(self._l2_weight_decay / 2.0) if self._l2_weight_decay else None ) diff --git a/official/projects/yt8m/modeling/yt8m_model_test.py b/official/projects/yt8m/modeling/yt8m_model_test.py index 5c8360575f5..7a46ee32102 100644 --- a/official/projects/yt8m/modeling/yt8m_model_test.py +++ b/official/projects/yt8m/modeling/yt8m_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.configs import yt8m as yt8m_cfg from official.projects.yt8m.modeling import yt8m_model @@ -42,7 +42,7 @@ def test_yt8m_network_creation( num_frames = 24 feature_dims = 52 num_classes = 45 - input_specs = tf.keras.layers.InputSpec(shape=[None, None, feature_dims]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, feature_dims]) params = yt8m_cfg.YT8MTask().model params.backbone.dbof.pooling_method = pooling_method diff --git a/official/projects/yt8m/modeling/yt8m_model_utils.py b/official/projects/yt8m/modeling/yt8m_model_utils.py index fea2deeb4d9..ab62b9830e8 100644 --- a/official/projects/yt8m/modeling/yt8m_model_utils.py +++ b/official/projects/yt8m/modeling/yt8m_model_utils.py @@ -16,7 +16,7 @@ from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras def _large_compatible_negative(tensor_type): diff --git a/official/projects/yt8m/modeling/yt8m_model_utils_test.py b/official/projects/yt8m/modeling/yt8m_model_utils_test.py index 7d33c9135b8..5e669f3a975 100644 --- a/official/projects/yt8m/modeling/yt8m_model_utils_test.py +++ b/official/projects/yt8m/modeling/yt8m_model_utils_test.py @@ -14,7 +14,7 @@ """Tests for YT8M modeling utilities.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m.modeling import yt8m_model_utils diff --git a/official/projects/yt8m/tasks/yt8m_task.py b/official/projects/yt8m/tasks/yt8m_task.py index 0bee5a39aa2..d4a74ef3966 100644 --- a/official/projects/yt8m/tasks/yt8m_task.py +++ b/official/projects/yt8m/tasks/yt8m_task.py @@ -16,7 +16,7 @@ from typing import Dict, List, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import task_factory @@ -38,7 +38,7 @@ def build_model(self): common_input_shape = [None, sum(train_cfg.feature_sizes)] # [batch_size x num_frames x num_features] - input_specs = tf.keras.layers.InputSpec(shape=[None] + common_input_shape) + input_specs = tf_keras.layers.InputSpec(shape=[None] + common_input_shape) logging.info('Build model input %r', common_input_shape) l2_weight_decay = self.task_config.losses.l2_weight_decay @@ -53,8 +53,8 @@ def build_model(self): # Warmup calls to build model variables. _ = model( - inputs=tf.keras.Input(common_input_shape, dtype=tf.float32), - num_frames=tf.keras.Input([], dtype=tf.float32), + inputs=tf_keras.Input(common_input_shape, dtype=tf.float32), + num_frames=tf_keras.Input([], dtype=tf.float32), ) non_trainable_batch_norm_variables = [] @@ -144,7 +144,7 @@ def build_losses( A dict of tensors contains total loss, model loss tensors. """ losses_config = self.task_config.losses - model_loss = tf.keras.losses.binary_crossentropy( + model_loss = tf_keras.losses.binary_crossentropy( tf.expand_dims(labels, axis=-1), tf.expand_dims(model_outputs, axis=-1), from_logits=losses_config.from_logits, @@ -185,7 +185,7 @@ def build_metrics(self, training=True): metrics = [] metric_names = ['total_loss', 'model_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if ( self.task_config.evaluation.average_precision is not None @@ -203,7 +203,7 @@ def build_metrics(self, training=True): def process_metrics( self, - metrics: List[tf.keras.metrics.Metric], + metrics: List[tf_keras.metrics.Metric], labels: tf.Tensor, outputs: tf.Tensor, model_losses: Optional[Dict[str, tf.Tensor]] = None, @@ -331,14 +331,14 @@ def train_step(self, inputs, model, optimizer, metrics=None): # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) # Apply gradient clipping. diff --git a/official/projects/yt8m/train_test.py b/official/projects/yt8m/train_test.py index 4d3054b7561..a09e21c6504 100644 --- a/official/projects/yt8m/train_test.py +++ b/official/projects/yt8m/train_test.py @@ -18,7 +18,7 @@ from absl import flags from absl.testing import flagsaver from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.projects.yt8m import train as train_lib from official.projects.yt8m.dataloaders import utils diff --git a/official/recommendation/create_ncf_data.py b/official/recommendation/create_ncf_data.py index 871428d80db..f46d78eb3e8 100644 --- a/official/recommendation/create_ncf_data.py +++ b/official/recommendation/create_ncf_data.py @@ -20,7 +20,7 @@ # Import libraries from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: enable=g-bad-import-order from official.recommendation import movielens diff --git a/official/recommendation/data_pipeline.py b/official/recommendation/data_pipeline.py index e7a3c0569af..3d4fee24b7e 100644 --- a/official/recommendation/data_pipeline.py +++ b/official/recommendation/data_pipeline.py @@ -32,7 +32,7 @@ from absl import logging import numpy as np from six.moves import queue -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.tpu.datasets import StreamingFilesDataset from official.recommendation import constants as rconst diff --git a/official/recommendation/data_preprocessing.py b/official/recommendation/data_preprocessing.py index f967988dac7..9a2dd0222c7 100644 --- a/official/recommendation/data_preprocessing.py +++ b/official/recommendation/data_preprocessing.py @@ -28,7 +28,7 @@ from absl import logging import numpy as np import pandas as pd -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation import constants as rconst from official.recommendation import data_pipeline diff --git a/official/recommendation/data_test.py b/official/recommendation/data_test.py index 2fce42dcae1..dc041bd0fd3 100644 --- a/official/recommendation/data_test.py +++ b/official/recommendation/data_test.py @@ -26,7 +26,7 @@ import numpy as np import scipy.stats -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation import constants as rconst from official.recommendation import data_preprocessing diff --git a/official/recommendation/movielens.py b/official/recommendation/movielens.py index d4ab77d7405..020b780e6e8 100644 --- a/official/recommendation/movielens.py +++ b/official/recommendation/movielens.py @@ -35,7 +35,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: enable=g-bad-import-order from official.utils.flags import core as flags_core diff --git a/official/recommendation/ncf_common.py b/official/recommendation/ncf_common.py index 2442a6b81f4..5738fb6238b 100644 --- a/official/recommendation/ncf_common.py +++ b/official/recommendation/ncf_common.py @@ -24,7 +24,7 @@ from absl import flags from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.recommendation import constants as rconst diff --git a/official/recommendation/ncf_input_pipeline.py b/official/recommendation/ncf_input_pipeline.py index 8687db89687..a0072664155 100644 --- a/official/recommendation/ncf_input_pipeline.py +++ b/official/recommendation/ncf_input_pipeline.py @@ -17,7 +17,7 @@ import functools # pylint: disable=g-bad-import-order -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: enable=g-bad-import-order from official.recommendation import constants as rconst diff --git a/official/recommendation/ncf_keras_main.py b/official/recommendation/ncf_keras_main.py index f6a66ae0ef5..cf4571e2944 100644 --- a/official/recommendation/ncf_keras_main.py +++ b/official/recommendation/ncf_keras_main.py @@ -26,7 +26,7 @@ from absl import app from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: enable=g-bad-import-order from official.common import distribute_utils @@ -51,7 +51,7 @@ def metric_fn(logits, dup_mask, match_mlperf): return in_top_k, metric_weights -class MetricLayer(tf.keras.layers.Layer): +class MetricLayer(tf_keras.layers.Layer): """Custom layer of metrics for NCF model.""" def __init__(self, match_mlperf): @@ -81,14 +81,14 @@ def call(self, inputs, training=False): return logits -class LossLayer(tf.keras.layers.Layer): +class LossLayer(tf_keras.layers.Layer): """Pass-through loss layer for NCF model.""" def __init__(self, loss_normalization_factor): # The loss may overflow in float16, so we use float32 instead. super(LossLayer, self).__init__(dtype="float32") self.loss_normalization_factor = loss_normalization_factor - self.loss = tf.keras.losses.SparseCategoricalCrossentropy( + self.loss = tf_keras.losses.SparseCategoricalCrossentropy( from_logits=True, reduction="sum") def get_config(self): @@ -107,7 +107,7 @@ def call(self, inputs): return logits -class IncrementEpochCallback(tf.keras.callbacks.Callback): +class IncrementEpochCallback(tf_keras.callbacks.Callback): """A callback to increase the requested epoch for the data producer. The reason why we need this is because we can only buffer a limited amount of @@ -122,7 +122,7 @@ def on_epoch_begin(self, epoch, logs=None): self._producer.increment_request_epoch() -class CustomEarlyStopping(tf.keras.callbacks.Callback): +class CustomEarlyStopping(tf_keras.callbacks.Callback): """Stop training has reached a desired hit rate.""" def __init__(self, monitor, desired_value): @@ -157,28 +157,28 @@ def _get_keras_model(params): """Constructs and returns the model.""" batch_size = params["batch_size"] - user_input = tf.keras.layers.Input( + user_input = tf_keras.layers.Input( shape=(1,), name=movielens.USER_COLUMN, dtype=tf.int32) - item_input = tf.keras.layers.Input( + item_input = tf_keras.layers.Input( shape=(1,), name=movielens.ITEM_COLUMN, dtype=tf.int32) - valid_pt_mask_input = tf.keras.layers.Input( + valid_pt_mask_input = tf_keras.layers.Input( shape=(1,), name=rconst.VALID_POINT_MASK, dtype=tf.bool) - dup_mask_input = tf.keras.layers.Input( + dup_mask_input = tf_keras.layers.Input( shape=(1,), name=rconst.DUPLICATE_MASK, dtype=tf.int32) - label_input = tf.keras.layers.Input( + label_input = tf_keras.layers.Input( shape=(1,), name=rconst.TRAIN_LABEL_KEY, dtype=tf.bool) base_model = neumf_model.construct_model(user_input, item_input, params) logits = base_model.output - zeros = tf.keras.layers.Lambda(lambda x: x * 0)(logits) + zeros = tf_keras.layers.Lambda(lambda x: x * 0)(logits) - softmax_logits = tf.keras.layers.concatenate([zeros, logits], axis=-1) + softmax_logits = tf_keras.layers.concatenate([zeros, logits], axis=-1) # Custom training loop calculates loss and metric as a part of # training/evaluation step function. @@ -190,7 +190,7 @@ def _get_keras_model(params): softmax_logits = LossLayer(batch_size)( [softmax_logits, label_input, valid_pt_mask_input]) - keras_model = tf.keras.Model( + keras_model = tf_keras.Model( inputs={ movielens.USER_COLUMN: user_input, movielens.ITEM_COLUMN: item_input, @@ -216,7 +216,7 @@ def run_ncf(_): model_helpers.apply_clean(FLAGS) if FLAGS.dtype == "fp16" and FLAGS.fp16_implementation == "keras": - tf.keras.mixed_precision.set_global_policy("mixed_float16") + tf_keras.mixed_precision.set_global_policy("mixed_float16") strategy = distribute_utils.get_distribution_strategy( distribution_strategy=FLAGS.distribution_strategy, @@ -265,7 +265,7 @@ def run_ncf(_): with distribute_utils.get_strategy_scope(strategy): keras_model = _get_keras_model(params) - optimizer = tf.keras.optimizers.Adam( + optimizer = tf_keras.optimizers.Adam( learning_rate=params["learning_rate"], beta_1=params["beta1"], beta_2=params["beta2"], @@ -283,9 +283,9 @@ def run_ncf(_): # here for the case where a custom training loop or fixed loss scale is # used. if loss_scale == "dynamic": - optimizer = tf.keras.mixed_precision.LossScaleOptimizer(optimizer) + optimizer = tf_keras.mixed_precision.LossScaleOptimizer(optimizer) else: - optimizer = tf.keras.mixed_precision.LossScaleOptimizer( + optimizer = tf_keras.mixed_precision.LossScaleOptimizer( optimizer, dynamic=False, initial_scale=loss_scale) if params["keras_use_ctl"]: @@ -306,10 +306,10 @@ def run_ncf(_): if not FLAGS.ml_perf: # Create Tensorboard summary and checkpoint callbacks. summary_dir = os.path.join(FLAGS.model_dir, "summaries") - summary_callback = tf.keras.callbacks.TensorBoard( + summary_callback = tf_keras.callbacks.TensorBoard( summary_dir, profile_batch=0) checkpoint_path = os.path.join(FLAGS.model_dir, "checkpoint") - checkpoint_callback = tf.keras.callbacks.ModelCheckpoint( + checkpoint_callback = tf_keras.callbacks.ModelCheckpoint( checkpoint_path, save_weights_only=True) callbacks += [summary_callback, checkpoint_callback] @@ -375,7 +375,7 @@ def run_ncf_custom_training(params, Returns: A tuple of train loss and a list of training and evaluation results. """ - loss_object = tf.keras.losses.SparseCategoricalCrossentropy( + loss_object = tf_keras.losses.SparseCategoricalCrossentropy( reduction="sum", from_logits=True) train_input_iterator = iter( strategy.experimental_distribute_dataset(train_input_dataset)) diff --git a/official/recommendation/ncf_test.py b/official/recommendation/ncf_test.py index dc9a5a066d7..6ddc66a0a71 100644 --- a/official/recommendation/ncf_test.py +++ b/official/recommendation/ncf_test.py @@ -20,7 +20,7 @@ import unittest -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.eager import context # pylint: disable=ungrouped-imports from official.recommendation import constants as rconst from official.recommendation import ncf_common diff --git a/official/recommendation/neumf_model.py b/official/recommendation/neumf_model.py index 1c9756c879c..70cb6f87a3a 100644 --- a/official/recommendation/neumf_model.py +++ b/official/recommendation/neumf_model.py @@ -36,7 +36,7 @@ import sys from six.moves import xrange # pylint: disable=redefined-builtin -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow import estimator as tf_estimator from typing import Any, Dict, Text @@ -79,8 +79,8 @@ def neumf_model_fn(features, labels, mode, params): users = features[movielens.USER_COLUMN] items = features[movielens.ITEM_COLUMN] - user_input = tf.keras.layers.Input(tensor=users) - item_input = tf.keras.layers.Input(tensor=items) + user_input = tf_keras.layers.Input(tensor=users) + item_input = tf_keras.layers.Input(tensor=items) logits = construct_model(user_input, item_input, params).output # Softmax with the first column of zeros is equivalent to sigmoid. @@ -136,7 +136,7 @@ def _strip_first_and_last_dimension(x, batch_size): def construct_model(user_input: tf.Tensor, item_input: tf.Tensor, - params: Dict[Text, Any]) -> tf.keras.Model: + params: Dict[Text, Any]) -> tf_keras.Model: """Initialize NeuMF model. Args: @@ -175,59 +175,59 @@ def mlp_slice_fn(x): # It turns out to be significantly more effecient to store the MF and MLP # embedding portions in the same table, and then slice as needed. - embedding_user = tf.keras.layers.Embedding( + embedding_user = tf_keras.layers.Embedding( num_users, mf_dim + model_layers[0] // 2, embeddings_initializer=embedding_initializer, - embeddings_regularizer=tf.keras.regularizers.l2(mf_regularization), + embeddings_regularizer=tf_keras.regularizers.l2(mf_regularization), input_length=1, name="embedding_user")( user_input) - embedding_item = tf.keras.layers.Embedding( + embedding_item = tf_keras.layers.Embedding( num_items, mf_dim + model_layers[0] // 2, embeddings_initializer=embedding_initializer, - embeddings_regularizer=tf.keras.regularizers.l2(mf_regularization), + embeddings_regularizer=tf_keras.regularizers.l2(mf_regularization), input_length=1, name="embedding_item")( item_input) # GMF part - mf_user_latent = tf.keras.layers.Lambda( + mf_user_latent = tf_keras.layers.Lambda( mf_slice_fn, name="embedding_user_mf")( embedding_user) - mf_item_latent = tf.keras.layers.Lambda( + mf_item_latent = tf_keras.layers.Lambda( mf_slice_fn, name="embedding_item_mf")( embedding_item) # MLP part - mlp_user_latent = tf.keras.layers.Lambda( + mlp_user_latent = tf_keras.layers.Lambda( mlp_slice_fn, name="embedding_user_mlp")( embedding_user) - mlp_item_latent = tf.keras.layers.Lambda( + mlp_item_latent = tf_keras.layers.Lambda( mlp_slice_fn, name="embedding_item_mlp")( embedding_item) # Element-wise multiply - mf_vector = tf.keras.layers.multiply([mf_user_latent, mf_item_latent]) + mf_vector = tf_keras.layers.multiply([mf_user_latent, mf_item_latent]) # Concatenation of two latent features - mlp_vector = tf.keras.layers.concatenate([mlp_user_latent, mlp_item_latent]) + mlp_vector = tf_keras.layers.concatenate([mlp_user_latent, mlp_item_latent]) num_layer = len(model_layers) # Number of layers in the MLP for layer in xrange(1, num_layer): - model_layer = tf.keras.layers.Dense( + model_layer = tf_keras.layers.Dense( model_layers[layer], - kernel_regularizer=tf.keras.regularizers.l2(mlp_reg_layers[layer]), + kernel_regularizer=tf_keras.regularizers.l2(mlp_reg_layers[layer]), activation="relu") mlp_vector = model_layer(mlp_vector) # Concatenate GMF and MLP parts - predict_vector = tf.keras.layers.concatenate([mf_vector, mlp_vector]) + predict_vector = tf_keras.layers.concatenate([mf_vector, mlp_vector]) # Final prediction layer - logits = tf.keras.layers.Dense( + logits = tf_keras.layers.Dense( 1, activation=None, kernel_initializer="lecun_uniform", @@ -235,7 +235,7 @@ def mlp_slice_fn(x): predict_vector) # Print model topology. - model = tf.keras.models.Model([user_input, item_input], logits) + model = tf_keras.models.Model([user_input, item_input], logits) model.summary() sys.stdout.flush() diff --git a/official/recommendation/ranking/common.py b/official/recommendation/ranking/common.py index cc3728c1c30..2d932508e7c 100644 --- a/official/recommendation/ranking/common.py +++ b/official/recommendation/ranking/common.py @@ -15,7 +15,7 @@ """Flags and common definitions for Ranking Models.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import flags as tfm_flags @@ -44,8 +44,8 @@ def define_flags() -> None: 'overhead, and the output file can be gigantic if profiling many steps.') -@tf.keras.utils.register_keras_serializable(package='RANKING') -class WarmUpAndPolyDecay(tf.keras.optimizers.schedules.LearningRateSchedule): +@tf_keras.utils.register_keras_serializable(package='RANKING') +class WarmUpAndPolyDecay(tf_keras.optimizers.schedules.LearningRateSchedule): """Learning rate callable for the embeddings. Linear warmup on [0, warmup_steps] then diff --git a/official/recommendation/ranking/configs/config_test.py b/official/recommendation/ranking/configs/config_test.py index 2bd184f932f..6c9b989eb73 100644 --- a/official/recommendation/ranking/configs/config_test.py +++ b/official/recommendation/ranking/configs/config_test.py @@ -15,7 +15,7 @@ """Unit tests for DLRM config.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation.ranking.configs import config diff --git a/official/recommendation/ranking/data/data_pipeline.py b/official/recommendation/ranking/data/data_pipeline.py index b77fd52d444..099780ced34 100644 --- a/official/recommendation/ranking/data/data_pipeline.py +++ b/official/recommendation/ranking/data/data_pipeline.py @@ -18,7 +18,7 @@ """ from typing import List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation.ranking.configs import config diff --git a/official/recommendation/ranking/data/data_pipeline_test.py b/official/recommendation/ranking/data/data_pipeline_test.py index 96762ecd3ea..fbc4c558a40 100644 --- a/official/recommendation/ranking/data/data_pipeline_test.py +++ b/official/recommendation/ranking/data/data_pipeline_test.py @@ -15,7 +15,7 @@ """Unit tests for data_pipeline.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation.ranking.configs import config from official.recommendation.ranking.data import data_pipeline diff --git a/official/recommendation/ranking/preprocessing/criteo_preprocess.py b/official/recommendation/ranking/preprocessing/criteo_preprocess.py index b500a2e6ccd..69dc5edfc29 100644 --- a/official/recommendation/ranking/preprocessing/criteo_preprocess.py +++ b/official/recommendation/ranking/preprocessing/criteo_preprocess.py @@ -36,7 +36,7 @@ import apache_beam as beam import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_transform as tft import tensorflow_transform.beam as tft_beam from tensorflow_transform.tf_metadata import dataset_metadata diff --git a/official/recommendation/ranking/preprocessing/shard_rebalancer.py b/official/recommendation/ranking/preprocessing/shard_rebalancer.py index 508edbf26c5..f7e4d12d9d5 100644 --- a/official/recommendation/ranking/preprocessing/shard_rebalancer.py +++ b/official/recommendation/ranking/preprocessing/shard_rebalancer.py @@ -20,7 +20,7 @@ import os import apache_beam as beam -import tensorflow as tf +import tensorflow as tf, tf_keras parser = argparse.ArgumentParser() diff --git a/official/recommendation/ranking/task.py b/official/recommendation/ranking/task.py index cb776727a0a..5d7d4047fef 100644 --- a/official/recommendation/ranking/task.py +++ b/official/recommendation/ranking/task.py @@ -17,7 +17,7 @@ import math from typing import Dict, List, Optional, Union -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_recommenders as tfrs from official.core import base_task @@ -121,7 +121,7 @@ def create_optimizer(cls, optimizer_config: config.OptimizationConfig, """See base class. Return None, optimizer is set in `build_model`.""" return None - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Creates Ranking model architecture and Optimizers. The RankingModel uses different optimizers/learning rates for embedding @@ -138,11 +138,11 @@ def build_model(self) -> tf.keras.Model: warmup_steps=lr_config.warmup_steps, decay_steps=lr_config.decay_steps, decay_start_steps=lr_config.decay_start_steps) - embedding_optimizer = tf.keras.optimizers.get( + embedding_optimizer = tf_keras.optimizers.get( self.optimizer_config.embedding_optimizer, use_legacy_optimizer=True) embedding_optimizer.learning_rate = lr_callable - dense_optimizer = tf.keras.optimizers.get( + dense_optimizer = tf_keras.optimizers.get( self.optimizer_config.dense_optimizer, use_legacy_optimizer=True) if self.optimizer_config.dense_optimizer == 'SGD': dense_lr_config = self.optimizer_config.dense_sgd_config @@ -173,8 +173,8 @@ def build_model(self) -> tf.keras.Model: feature_interaction = tfrs.layers.feature_interaction.DotInteraction( skip_gather=True) elif self.task_config.model.interaction == 'cross': - feature_interaction = tf.keras.Sequential([ - tf.keras.layers.Concatenate(), + feature_interaction = tf_keras.Sequential([ + tf_keras.layers.Concatenate(), tfrs.layers.feature_interaction.Cross() ]) else: @@ -201,9 +201,9 @@ def build_model(self) -> tf.keras.Model: def train_step( self, inputs: Dict[str, tf.Tensor], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, - metrics: Optional[List[tf.keras.metrics.Metric]] = None) -> tf.Tensor: + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, + metrics: Optional[List[tf_keras.metrics.Metric]] = None) -> tf.Tensor: """See base class.""" # All metrics need to be passed through the RankingModel. assert metrics == model.metrics @@ -212,8 +212,8 @@ def train_step( def validation_step( self, inputs: Dict[str, tf.Tensor], - model: tf.keras.Model, - metrics: Optional[List[tf.keras.metrics.Metric]] = None) -> tf.Tensor: + model: tf_keras.Model, + metrics: Optional[List[tf_keras.metrics.Metric]] = None) -> tf.Tensor: """See base class.""" # All metrics need to be passed through the RankingModel. assert metrics == model.metrics diff --git a/official/recommendation/ranking/task_test.py b/official/recommendation/ranking/task_test.py index 3489ade62e6..3a8eb8653ff 100644 --- a/official/recommendation/ranking/task_test.py +++ b/official/recommendation/ranking/task_test.py @@ -15,7 +15,7 @@ """Unit tests for task.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.recommendation.ranking import task diff --git a/official/recommendation/ranking/train.py b/official/recommendation/ranking/train.py index abcd07bf175..9bb44c72abf 100644 --- a/official/recommendation/ranking/train.py +++ b/official/recommendation/ranking/train.py @@ -20,7 +20,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.core import base_trainer @@ -150,7 +150,7 @@ def get_dataset_fn(params): callbacks = [checkpoint_callback, time_callback] if enable_tensorboard: - tensorboard_callback = tf.keras.callbacks.TensorBoard( + tensorboard_callback = tf_keras.callbacks.TensorBoard( log_dir=model_dir, update_freq=min(1000, params.trainer.validation_interval), profile_batch=FLAGS.profile_steps) diff --git a/official/recommendation/ranking/train_test.py b/official/recommendation/ranking/train_test.py index 69e1adb2a0d..d2cab6a1d12 100644 --- a/official/recommendation/ranking/train_test.py +++ b/official/recommendation/ranking/train_test.py @@ -18,7 +18,7 @@ import os from absl import flags from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.recommendation.ranking import common from official.recommendation.ranking import train diff --git a/official/requirements.txt b/official/requirements.txt index cfddbc27a2d..5f5838812fb 100644 --- a/official/requirements.txt +++ b/official/requirements.txt @@ -10,6 +10,7 @@ scipy>=0.19.1 tensorflow-hub>=0.6.0 tensorflow-model-optimization>=0.4.1 tensorflow-datasets +tf-keras gin-config tf_slim>=1.1.0 Cython diff --git a/official/utils/docs/build_orbit_api_docs.py b/official/utils/docs/build_orbit_api_docs.py index 7d80c7ac201..ac4a7faf175 100644 --- a/official/utils/docs/build_orbit_api_docs.py +++ b/official/utils/docs/build_orbit_api_docs.py @@ -25,7 +25,7 @@ import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow_docs.api_generator import doc_controls from tensorflow_docs.api_generator import generate_lib from tensorflow_docs.api_generator import public_api @@ -57,8 +57,8 @@ def hide_module_model_and_layer_methods(): complex layers. """ module_contents = list(tf.Module.__dict__.items()) - model_contents = list(tf.keras.Model.__dict__.items()) - layer_contents = list(tf.keras.layers.Layer.__dict__.items()) + model_contents = list(tf_keras.Model.__dict__.items()) + layer_contents = list(tf_keras.layers.Layer.__dict__.items()) for name, obj in module_contents + layer_contents + model_contents: if name == '__init__': diff --git a/official/utils/docs/build_tfm_api_docs.py b/official/utils/docs/build_tfm_api_docs.py index 7f83c5af404..32e3d219195 100644 --- a/official/utils/docs/build_tfm_api_docs.py +++ b/official/utils/docs/build_tfm_api_docs.py @@ -26,7 +26,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow_docs.api_generator import doc_controls from tensorflow_docs.api_generator import generate_lib from tensorflow_docs.api_generator import parser @@ -102,8 +102,8 @@ def hide_module_model_and_layer_methods(): complex layers. """ module_contents = list(tf.Module.__dict__.items()) - model_contents = list(tf.keras.Model.__dict__.items()) - layer_contents = list(tf.keras.layers.Layer.__dict__.items()) + model_contents = list(tf_keras.Model.__dict__.items()) + layer_contents = list(tf_keras.layers.Layer.__dict__.items()) for name, obj in module_contents + layer_contents + model_contents: if name == '__init__': diff --git a/official/utils/flags/_base.py b/official/utils/flags/_base.py index 76f7633d7e4..3185e261501 100644 --- a/official/utils/flags/_base.py +++ b/official/utils/flags/_base.py @@ -15,7 +15,7 @@ """Flags which will be nearly universal across models.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/_distribution.py b/official/utils/flags/_distribution.py index 5a25af35bd5..24e48961624 100644 --- a/official/utils/flags/_distribution.py +++ b/official/utils/flags/_distribution.py @@ -15,7 +15,7 @@ """Flags related to distributed execution.""" from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.utils.flags._conventions import help_wrap diff --git a/official/utils/flags/_performance.py b/official/utils/flags/_performance.py index 4b75379c34a..adf040b942e 100644 --- a/official/utils/flags/_performance.py +++ b/official/utils/flags/_performance.py @@ -17,7 +17,7 @@ import multiprocessing from absl import flags # pylint: disable=g-bad-import-order -import tensorflow as tf # pylint: disable=g-bad-import-order +import tensorflow as tf, tf_keras # pylint: disable=g-bad-import-order from official.utils.flags._conventions import help_wrap @@ -202,7 +202,7 @@ def _check_loss_scale(loss_scale): help=help_wrap( "When --dtype=fp16, how fp16 should be implemented. This has no " "impact on correctness. 'keras' uses the " - "tf.keras.mixed_precision API. 'graph_rewrite' uses the " + "tf_keras.mixed_precision API. 'graph_rewrite' uses the " "tf.compat.v1.mixed_precision." "enable_mixed_precision_graph_rewrite API.")) diff --git a/official/utils/flags/flags_test.py b/official/utils/flags/flags_test.py index f5b89ccd37b..d86681b939e 100644 --- a/official/utils/flags/flags_test.py +++ b/official/utils/flags/flags_test.py @@ -15,7 +15,7 @@ import unittest from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras from official.utils.flags import core as flags_core # pylint: disable=g-bad-import-order diff --git a/official/utils/misc/keras_utils.py b/official/utils/misc/keras_utils.py index 2a80bd57a5d..a2b33c118a3 100644 --- a/official/utils/misc/keras_utils.py +++ b/official/utils/misc/keras_utils.py @@ -19,7 +19,7 @@ import time from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.eager import monitoring @@ -47,7 +47,7 @@ def __repr__(self): self.batch_index, self.timestamp) -class TimeHistory(tf.keras.callbacks.Callback): +class TimeHistory(tf_keras.callbacks.Callback): """Callback for Keras models.""" def __init__(self, batch_size, log_steps, initial_step=0, logdir=None): @@ -165,7 +165,7 @@ def on_epoch_end(self, epoch, logs=None): self.steps_in_epoch = 0 -class SimpleCheckpoint(tf.keras.callbacks.Callback): +class SimpleCheckpoint(tf_keras.callbacks.Callback): """Keras callback to save tf.train.Checkpoints.""" def __init__(self, checkpoint_manager): diff --git a/official/utils/misc/model_helpers.py b/official/utils/misc/model_helpers.py index ee27aab8556..4c6a28cd965 100644 --- a/official/utils/misc/model_helpers.py +++ b/official/utils/misc/model_helpers.py @@ -17,7 +17,7 @@ import numbers from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras 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 3f1e2c90149..fc327d091e4 100644 --- a/official/utils/misc/model_helpers_test.py +++ b/official/utils/misc/model_helpers_test.py @@ -14,7 +14,7 @@ """Tests for Model Helper functions.""" -import tensorflow as tf # pylint: disable=g-bad-import-order +import tensorflow as tf, tf_keras # pylint: disable=g-bad-import-order from official.utils.misc import model_helpers diff --git a/official/utils/testing/mock_task.py b/official/utils/testing/mock_task.py index dbc619aa9ff..375801371ee 100644 --- a/official/utils/testing/mock_task.py +++ b/official/utils/testing/mock_task.py @@ -17,7 +17,7 @@ import dataclasses import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -25,7 +25,7 @@ from official.modeling.hyperparams import base_config -class MockModel(tf.keras.Model): +class MockModel(tf_keras.Model): def __init__(self, network): super().__init__() @@ -50,18 +50,18 @@ def __init__(self, params=None, logging_dir=None, name=None): super().__init__(params=params, logging_dir=logging_dir, name=name) def build_model(self, *arg, **kwargs): - inputs = tf.keras.layers.Input(shape=(2,), name="random", dtype=tf.float32) - outputs = tf.keras.layers.Dense( - 1, bias_initializer=tf.keras.initializers.Ones(), name="dense_0")( + inputs = tf_keras.layers.Input(shape=(2,), name="random", dtype=tf.float32) + outputs = tf_keras.layers.Dense( + 1, bias_initializer=tf_keras.initializers.Ones(), name="dense_0")( inputs) - network = tf.keras.Model(inputs=inputs, outputs=outputs) + network = tf_keras.Model(inputs=inputs, outputs=outputs) return MockModel(network) def build_metrics(self, training: bool = True): del training - return [tf.keras.metrics.Accuracy(name="acc")] + return [tf_keras.metrics.Accuracy(name="acc")] - def validation_step(self, inputs, model: tf.keras.Model, metrics=None): + def validation_step(self, inputs, model: tf_keras.Model, metrics=None): logs = super().validation_step(inputs, model, metrics) logs["counter"] = tf.constant(1, dtype=tf.float32) return logs diff --git a/official/vision/configs/image_classification_test.py b/official/vision/configs/image_classification_test.py index f9f1c4667bc..03c30fa8b32 100644 --- a/official/vision/configs/image_classification_test.py +++ b/official/vision/configs/image_classification_test.py @@ -15,7 +15,7 @@ """Tests for image_classification.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/vision/configs/maskrcnn_test.py b/official/vision/configs/maskrcnn_test.py index 9ee93abeff5..31e0ce35691 100644 --- a/official/vision/configs/maskrcnn_test.py +++ b/official/vision/configs/maskrcnn_test.py @@ -15,7 +15,7 @@ """Tests for maskrcnn.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/vision/configs/retinanet_test.py b/official/vision/configs/retinanet_test.py index ba367c6e61b..f5ac9f79394 100644 --- a/official/vision/configs/retinanet_test.py +++ b/official/vision/configs/retinanet_test.py @@ -15,7 +15,7 @@ """Tests for retinanet.""" # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/vision/configs/semantic_segmentation_test.py b/official/vision/configs/semantic_segmentation_test.py index 1db377e94f1..6c40fba8488 100644 --- a/official/vision/configs/semantic_segmentation_test.py +++ b/official/vision/configs/semantic_segmentation_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/vision/configs/video_classification_test.py b/official/vision/configs/video_classification_test.py index fc750fb1a3b..96d487e3dd1 100644 --- a/official/vision/configs/video_classification_test.py +++ b/official/vision/configs/video_classification_test.py @@ -16,7 +16,7 @@ # pylint: disable=unused-import from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official import vision from official.core import config_definitions as cfg diff --git a/official/vision/data/create_coco_tf_record.py b/official/vision/data/create_coco_tf_record.py index cfcd679ad59..4480abf127e 100644 --- a/official/vision/data/create_coco_tf_record.py +++ b/official/vision/data/create_coco_tf_record.py @@ -37,7 +37,7 @@ import numpy as np from pycocotools import mask -import tensorflow as tf +import tensorflow as tf, tf_keras import multiprocessing as mp from official.vision.data import tfrecord_lib diff --git a/official/vision/data/image_utils_test.py b/official/vision/data/image_utils_test.py index 629be04ae52..0e390fa971b 100644 --- a/official/vision/data/image_utils_test.py +++ b/official/vision/data/image_utils_test.py @@ -16,7 +16,7 @@ import imghdr from unittest import mock from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.data import fake_feature_generator from official.vision.data import image_utils diff --git a/official/vision/data/process_coco_few_shot_json_files.py b/official/vision/data/process_coco_few_shot_json_files.py index e81e31f218a..57c2b8bda49 100644 --- a/official/vision/data/process_coco_few_shot_json_files.py +++ b/official/vision/data/process_coco_few_shot_json_files.py @@ -29,7 +29,7 @@ from absl import app from absl import flags -import tensorflow as tf +import tensorflow as tf, tf_keras logger = tf.get_logger() logger.setLevel(logging.INFO) diff --git a/official/vision/data/tf_example_builder_test.py b/official/vision/data/tf_example_builder_test.py index 962f3f90d8f..90f471e9d21 100644 --- a/official/vision/data/tf_example_builder_test.py +++ b/official/vision/data/tf_example_builder_test.py @@ -15,7 +15,7 @@ """Tests for tf_example_builder.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.data import fake_feature_generator from official.vision.data import image_utils from official.vision.data import tf_example_builder diff --git a/official/vision/data/tfrecord_lib.py b/official/vision/data/tfrecord_lib.py index 4eeef2d85ce..79978376f53 100644 --- a/official/vision/data/tfrecord_lib.py +++ b/official/vision/data/tfrecord_lib.py @@ -21,7 +21,7 @@ from absl import logging import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras import multiprocessing as mp diff --git a/official/vision/data/tfrecord_lib_test.py b/official/vision/data/tfrecord_lib_test.py index 4d98b580c5c..09de3312e9a 100644 --- a/official/vision/data/tfrecord_lib_test.py +++ b/official/vision/data/tfrecord_lib_test.py @@ -18,7 +18,7 @@ from absl import flags from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.data import create_coco_tf_record as create_coco_tf_record_lib from official.vision.data import tfrecord_lib @@ -135,7 +135,7 @@ def test_obj_annotation_tf_example(self): os.mkdir(image_dir) for image in images: image_path = os.path.join(image_dir, image['file_name']) - tf.keras.utils.save_img( + tf_keras.utils.save_img( image_path, tf.ones(shape=(image['height'], image['width'], 3)).numpy(), ) diff --git a/official/vision/dataloaders/classification_input.py b/official/vision/dataloaders/classification_input.py index 3852690f15b..5ec136e32b3 100644 --- a/official/vision/dataloaders/classification_input.py +++ b/official/vision/dataloaders/classification_input.py @@ -15,7 +15,7 @@ """Classification decoder and parser.""" from typing import Any, Dict, List, Optional, Tuple # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import common from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/input_reader.py b/official/vision/dataloaders/input_reader.py index 37f633cdb5a..48442d06842 100644 --- a/official/vision/dataloaders/input_reader.py +++ b/official/vision/dataloaders/input_reader.py @@ -17,7 +17,7 @@ from typing import Any, Callable, Mapping, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import input_reader diff --git a/official/vision/dataloaders/maskrcnn_input.py b/official/vision/dataloaders/maskrcnn_input.py index d834f44bea9..c8043c62d63 100644 --- a/official/vision/dataloaders/maskrcnn_input.py +++ b/official/vision/dataloaders/maskrcnn_input.py @@ -17,7 +17,7 @@ from typing import Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import common from official.vision.dataloaders import parser diff --git a/official/vision/dataloaders/retinanet_input.py b/official/vision/dataloaders/retinanet_input.py index 42e81416744..f4dac3060d8 100644 --- a/official/vision/dataloaders/retinanet_input.py +++ b/official/vision/dataloaders/retinanet_input.py @@ -23,7 +23,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import parser from official.vision.dataloaders import utils diff --git a/official/vision/dataloaders/segmentation_input.py b/official/vision/dataloaders/segmentation_input.py index de56835bcda..afd780c8bc0 100644 --- a/official/vision/dataloaders/segmentation_input.py +++ b/official/vision/dataloaders/segmentation_input.py @@ -14,7 +14,7 @@ """Data parser and processing for segmentation datasets.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import semantic_segmentation as config_lib from official.vision.dataloaders import decoder from official.vision.dataloaders import parser diff --git a/official/vision/dataloaders/tf_example_decoder.py b/official/vision/dataloaders/tf_example_decoder.py index d73ad5ef937..ad59cdac845 100644 --- a/official/vision/dataloaders/tf_example_decoder.py +++ b/official/vision/dataloaders/tf_example_decoder.py @@ -17,7 +17,7 @@ A decoder to decode string tensors containing serialized tensorflow.Example protos for object detection. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/tf_example_decoder_test.py b/official/vision/dataloaders/tf_example_decoder_test.py index c9614bffb22..2977d8118b2 100644 --- a/official/vision/dataloaders/tf_example_decoder_test.py +++ b/official/vision/dataloaders/tf_example_decoder_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tf_example_decoder from official.vision.dataloaders import tfexample_utils diff --git a/official/vision/dataloaders/tf_example_label_map_decoder.py b/official/vision/dataloaders/tf_example_label_map_decoder.py index 731e5b90761..31ab2256371 100644 --- a/official/vision/dataloaders/tf_example_label_map_decoder.py +++ b/official/vision/dataloaders/tf_example_label_map_decoder.py @@ -19,7 +19,7 @@ """ import csv # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tf_example_decoder diff --git a/official/vision/dataloaders/tf_example_label_map_decoder_test.py b/official/vision/dataloaders/tf_example_label_map_decoder_test.py index 09a921cc0db..9c0ce729ee8 100644 --- a/official/vision/dataloaders/tf_example_label_map_decoder_test.py +++ b/official/vision/dataloaders/tf_example_label_map_decoder_test.py @@ -18,7 +18,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tf_example_label_map_decoder from official.vision.dataloaders import tfexample_utils diff --git a/official/vision/dataloaders/tfds_classification_decoders.py b/official/vision/dataloaders/tfds_classification_decoders.py index 4547ddee096..38718824466 100644 --- a/official/vision/dataloaders/tfds_classification_decoders.py +++ b/official/vision/dataloaders/tfds_classification_decoders.py @@ -14,7 +14,7 @@ """TFDS Classification decoders.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/tfds_detection_decoders.py b/official/vision/dataloaders/tfds_detection_decoders.py index 400c58b4278..a6542f2a7df 100644 --- a/official/vision/dataloaders/tfds_detection_decoders.py +++ b/official/vision/dataloaders/tfds_detection_decoders.py @@ -14,7 +14,7 @@ """TFDS detection decoders.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/tfds_factory_test.py b/official/vision/dataloaders/tfds_factory_test.py index 543cc96f66b..fe2348d416f 100644 --- a/official/vision/dataloaders/tfds_factory_test.py +++ b/official/vision/dataloaders/tfds_factory_test.py @@ -15,7 +15,7 @@ """Tests for tfds factory functions.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder as base_decoder from official.vision.dataloaders import tfds_factory diff --git a/official/vision/dataloaders/tfds_segmentation_decoders.py b/official/vision/dataloaders/tfds_segmentation_decoders.py index cc66b4883f4..1bdd7d46932 100644 --- a/official/vision/dataloaders/tfds_segmentation_decoders.py +++ b/official/vision/dataloaders/tfds_segmentation_decoders.py @@ -14,7 +14,7 @@ """TFDS Semantic Segmentation decoders.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/tfexample_utils.py b/official/vision/dataloaders/tfexample_utils.py index 2fc587494d1..94d53327f3c 100644 --- a/official/vision/dataloaders/tfexample_utils.py +++ b/official/vision/dataloaders/tfexample_utils.py @@ -45,7 +45,7 @@ def test_foo(self): from typing import Mapping, Optional, Sequence, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import file_writers from official.vision.data import fake_feature_generator diff --git a/official/vision/dataloaders/utils.py b/official/vision/dataloaders/utils.py index 591f0b7a142..8479a13fb9f 100644 --- a/official/vision/dataloaders/utils.py +++ b/official/vision/dataloaders/utils.py @@ -16,7 +16,7 @@ from typing import Dict # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import preprocess_ops diff --git a/official/vision/dataloaders/utils_test.py b/official/vision/dataloaders/utils_test.py index 1b48070091a..848b2e74ea4 100644 --- a/official/vision/dataloaders/utils_test.py +++ b/official/vision/dataloaders/utils_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import utils diff --git a/official/vision/dataloaders/video_input.py b/official/vision/dataloaders/video_input.py index a4d933ecb77..453db2f69a8 100644 --- a/official/vision/dataloaders/video_input.py +++ b/official/vision/dataloaders/video_input.py @@ -17,7 +17,7 @@ from typing import Dict, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import video_classification as exp_cfg from official.vision.dataloaders import decoder diff --git a/official/vision/dataloaders/video_input_test.py b/official/vision/dataloaders/video_input_test.py index e91303cbb38..8809a0d1b60 100644 --- a/official/vision/dataloaders/video_input_test.py +++ b/official/vision/dataloaders/video_input_test.py @@ -18,7 +18,7 @@ # Import libraries import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds from official.vision.configs import common diff --git a/official/vision/evaluation/coco_evaluator.py b/official/vision/evaluation/coco_evaluator.py index 1d0bcb59331..e1c53b56d53 100644 --- a/official/vision/evaluation/coco_evaluator.py +++ b/official/vision/evaluation/coco_evaluator.py @@ -33,7 +33,7 @@ import numpy as np from pycocotools import cocoeval import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import coco_utils diff --git a/official/vision/evaluation/coco_utils.py b/official/vision/evaluation/coco_utils.py index 6aca74703ee..5a1cd85317c 100644 --- a/official/vision/evaluation/coco_utils.py +++ b/official/vision/evaluation/coco_utils.py @@ -25,7 +25,7 @@ from pycocotools import coco from pycocotools import mask as mask_api import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.vision.dataloaders import tf_example_decoder diff --git a/official/vision/evaluation/coco_utils_test.py b/official/vision/evaluation/coco_utils_test.py index 60ea5cfaf27..d151054773e 100644 --- a/official/vision/evaluation/coco_utils_test.py +++ b/official/vision/evaluation/coco_utils_test.py @@ -17,7 +17,7 @@ import os import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import tfexample_utils from official.vision.evaluation import coco_utils diff --git a/official/vision/evaluation/instance_metrics.py b/official/vision/evaluation/instance_metrics.py index cb2766f1bb2..a049249bef9 100644 --- a/official/vision/evaluation/instance_metrics.py +++ b/official/vision/evaluation/instance_metrics.py @@ -17,13 +17,13 @@ from typing import Any, Dict, Optional, Tuple, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops from official.vision.ops import mask_ops -class AveragePrecision(tf.keras.layers.Layer): +class AveragePrecision(tf_keras.layers.Layer): """The algorithm which computes average precision from P-R curve.""" def __init__(self, *args, **kwargs): @@ -179,7 +179,7 @@ def call(self, precisions: tf.Tensor, recalls: tf.Tensor) -> tf.Tensor: return tf.reduce_sum(p * delta_r[..., :-1], axis=-1) -class MatchingAlgorithm(tf.keras.layers.Layer): +class MatchingAlgorithm(tf_keras.layers.Layer): """The algorithm which matches detections to ground truths.""" def __init__(self, *args, **kwargs): @@ -465,7 +465,7 @@ def _count_detection_type( return count -class InstanceMetrics(tf.keras.metrics.Metric): +class InstanceMetrics(tf_keras.metrics.Metric): """Reports the metrics of instance detection & segmentation.""" def __init__( diff --git a/official/vision/evaluation/instance_metrics_test.py b/official/vision/evaluation/instance_metrics_test.py index 01d13008953..ef20eec6d20 100644 --- a/official/vision/evaluation/instance_metrics_test.py +++ b/official/vision/evaluation/instance_metrics_test.py @@ -15,7 +15,7 @@ """Tests for metrics.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import instance_metrics diff --git a/official/vision/evaluation/iou.py b/official/vision/evaluation/iou.py index b772c17e26a..7a4a7432f39 100644 --- a/official/vision/evaluation/iou.py +++ b/official/vision/evaluation/iou.py @@ -17,10 +17,10 @@ from typing import Any, Dict, Optional, Sequence, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras -class PerClassIoU(tf.keras.metrics.MeanIoU): +class PerClassIoU(tf_keras.metrics.MeanIoU): """Computes the per-class Intersection-Over-Union metric. This metric computes the IOU for each semantic class. @@ -39,7 +39,7 @@ class PerClassIoU(tf.keras.metrics.MeanIoU): >>> # sum_row = [2, 2], sum_col = [2, 2], true_positives = [1, 1] >>> # iou = true_positives / (sum_row + sum_col - true_positives)) >>> # result = [(1 / (2 + 2 - 1), 1 / (2 + 2 - 1)] = 0.33 - >>> m = tf.keras.metrics.MeanIoU(num_classes=2) + >>> m = tf_keras.metrics.MeanIoU(num_classes=2) >>> m.update_state([0, 0, 1, 1], [0, 1, 0, 1]) >>> m.result().numpy() [0.33333334, 0.33333334] @@ -61,7 +61,7 @@ def result(self): return tf.math.divide_no_nan(true_positives, denominator) -class PerClassIoUV2(tf.keras.metrics.Metric): +class PerClassIoUV2(tf_keras.metrics.Metric): """Computes the per-class Intersection-Over-Union metric. This implementation converts predictions and ground-truth to binary masks, diff --git a/official/vision/evaluation/iou_test.py b/official/vision/evaluation/iou_test.py index 1d6b80348b5..74e9c57808c 100644 --- a/official/vision/evaluation/iou_test.py +++ b/official/vision/evaluation/iou_test.py @@ -14,7 +14,7 @@ """Tests for iou metric.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import iou diff --git a/official/vision/evaluation/panoptic_quality.py b/official/vision/evaluation/panoptic_quality.py index b988880405c..03e49da4ec6 100644 --- a/official/vision/evaluation/panoptic_quality.py +++ b/official/vision/evaluation/panoptic_quality.py @@ -29,7 +29,7 @@ from typing import Any, Dict, Optional, Tuple, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops @@ -323,7 +323,7 @@ def _get_instance_class_ids( return tf.where(result == 0, -1, result) -class PanopticQualityV2(tf.keras.metrics.Metric): +class PanopticQualityV2(tf_keras.metrics.Metric): """Panoptic quality metrics with vectorized implementation. This implementation is supported on TPU. diff --git a/official/vision/evaluation/panoptic_quality_evaluator.py b/official/vision/evaluation/panoptic_quality_evaluator.py index 88afefdaccc..6be16279956 100644 --- a/official/vision/evaluation/panoptic_quality_evaluator.py +++ b/official/vision/evaluation/panoptic_quality_evaluator.py @@ -27,7 +27,7 @@ """ import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import panoptic_quality diff --git a/official/vision/evaluation/panoptic_quality_evaluator_test.py b/official/vision/evaluation/panoptic_quality_evaluator_test.py index c0798cc4ca5..b9e6df0af6d 100644 --- a/official/vision/evaluation/panoptic_quality_evaluator_test.py +++ b/official/vision/evaluation/panoptic_quality_evaluator_test.py @@ -15,7 +15,7 @@ """Tests for panoptic_quality_evaluator.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import panoptic_quality_evaluator diff --git a/official/vision/evaluation/panoptic_quality_test.py b/official/vision/evaluation/panoptic_quality_test.py index 517fd19f8a3..8694180c6c5 100644 --- a/official/vision/evaluation/panoptic_quality_test.py +++ b/official/vision/evaluation/panoptic_quality_test.py @@ -21,7 +21,7 @@ from absl.testing import absltest import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import panoptic_quality diff --git a/official/vision/evaluation/segmentation_metrics.py b/official/vision/evaluation/segmentation_metrics.py index a9fc5e20a9f..8deadcac5bf 100644 --- a/official/vision/evaluation/segmentation_metrics.py +++ b/official/vision/evaluation/segmentation_metrics.py @@ -16,17 +16,17 @@ from typing import Optional, Sequence, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import iou from official.vision.ops import box_ops from official.vision.ops import spatial_transform_ops -class MeanIoU(tf.keras.metrics.MeanIoU): +class MeanIoU(tf_keras.metrics.MeanIoU): """Mean IoU metric for semantic segmentation. - This class utilizes tf.keras.metrics.MeanIoU to perform batched mean iou when + This class utilizes tf_keras.metrics.MeanIoU to perform batched mean iou when both input images and ground-truth masks are resized to the same size (rescale_predictions=False). It also computes mean IoU on ground-truth original sizes, in which case, each prediction is rescaled back to the diff --git a/official/vision/evaluation/segmentation_metrics_test.py b/official/vision/evaluation/segmentation_metrics_test.py index 2e21c5131ae..597c6011f65 100644 --- a/official/vision/evaluation/segmentation_metrics_test.py +++ b/official/vision/evaluation/segmentation_metrics_test.py @@ -15,7 +15,7 @@ """Tests for segmentation_metrics.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.evaluation import segmentation_metrics diff --git a/official/vision/evaluation/wod_detection_evaluator.py b/official/vision/evaluation/wod_detection_evaluator.py index 7395950be70..d63b52825f6 100644 --- a/official/vision/evaluation/wod_detection_evaluator.py +++ b/official/vision/evaluation/wod_detection_evaluator.py @@ -16,7 +16,7 @@ import pprint from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops from waymo_open_dataset import label_pb2 from waymo_open_dataset.metrics.python import wod_detection_evaluator diff --git a/official/vision/examples/starter/example_input.py b/official/vision/examples/starter/example_input.py index 3120c06de1f..20423c3bd96 100644 --- a/official/vision/examples/starter/example_input.py +++ b/official/vision/examples/starter/example_input.py @@ -20,7 +20,7 @@ """ from typing import Mapping, List, Tuple # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import decoder from official.vision.dataloaders import parser diff --git a/official/vision/examples/starter/example_model.py b/official/vision/examples/starter/example_model.py index 800ad66a235..3ffc857684a 100644 --- a/official/vision/examples/starter/example_model.py +++ b/official/vision/examples/starter/example_model.py @@ -21,21 +21,21 @@ from typing import Any, Mapping # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.examples.starter import example_config as example_cfg -class ExampleModel(tf.keras.Model): +class ExampleModel(tf_keras.Model): """A example model class. - A model is a subclass of tf.keras.Model where layers are built in the + A model is a subclass of tf_keras.Model where layers are built in the constructor. """ def __init__( self, num_classes: int, - input_specs: tf.keras.layers.InputSpec = tf.keras.layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = tf_keras.layers.InputSpec( shape=[None, None, None, 3]), **kwargs): """Initializes the example model. @@ -45,22 +45,22 @@ def __init__( Args: num_classes: The number of classes in classification task. - input_specs: A `tf.keras.layers.InputSpec` spec of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` spec of the input tensor. **kwargs: Additional keyword arguments to be passed. """ - inputs = tf.keras.Input(shape=input_specs.shape[1:], name=input_specs.name) - outputs = tf.keras.layers.Conv2D( + inputs = tf_keras.Input(shape=input_specs.shape[1:], name=input_specs.name) + outputs = tf_keras.layers.Conv2D( filters=16, kernel_size=3, strides=2, padding='same', use_bias=False)( inputs) - outputs = tf.keras.layers.Conv2D( + outputs = tf_keras.layers.Conv2D( filters=32, kernel_size=3, strides=2, padding='same', use_bias=False)( outputs) - outputs = tf.keras.layers.Conv2D( + outputs = tf_keras.layers.Conv2D( filters=64, kernel_size=3, strides=2, padding='same', use_bias=False)( outputs) - outputs = tf.keras.layers.GlobalAveragePooling2D()(outputs) - outputs = tf.keras.layers.Dense(1024, activation='relu')(outputs) - outputs = tf.keras.layers.Dense(num_classes)(outputs) + outputs = tf_keras.layers.GlobalAveragePooling2D()(outputs) + outputs = tf_keras.layers.Dense(1024, activation='relu')(outputs) + outputs = tf_keras.layers.Dense(num_classes)(outputs) super().__init__(inputs=inputs, outputs=outputs, **kwargs) self._input_specs = input_specs @@ -76,9 +76,9 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -def build_example_model(input_specs: tf.keras.layers.InputSpec, +def build_example_model(input_specs: tf_keras.layers.InputSpec, model_config: example_cfg.ExampleModel, - **kwargs) -> tf.keras.Model: + **kwargs) -> tf_keras.Model: """Builds and returns the example model. This function is the main entry point to build a model. Commonly, it builds a @@ -95,7 +95,7 @@ def build_example_model(input_specs: tf.keras.layers.InputSpec, **kwargs: Additional keyword arguments to be passed. Returns: - A tf.keras.Model object. + A tf_keras.Model object. """ return ExampleModel( num_classes=model_config.num_classes, input_specs=input_specs, **kwargs) diff --git a/official/vision/examples/starter/example_task.py b/official/vision/examples/starter/example_task.py index 04813ca7cfa..22374a05eaf 100644 --- a/official/vision/examples/starter/example_task.py +++ b/official/vision/examples/starter/example_task.py @@ -15,7 +15,7 @@ """An example task definition for image classification.""" from typing import Any, List, Optional, Tuple, Sequence, Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -35,9 +35,9 @@ class ExampleTask(base_task.Task): and one training and evaluation step, etc. """ - def build_model(self) -> tf.keras.Model: + def build_model(self) -> tf_keras.Model: """Builds a model.""" - input_specs = tf.keras.layers.InputSpec(shape=[None] + + input_specs = tf_keras.layers.InputSpec(shape=[None] + self.task_config.model.input_size) model = example_model.build_example_model( @@ -88,12 +88,12 @@ def build_losses(self, Args: labels: Input groundt-ruth labels. model_outputs: Output of the model. - aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf.keras.Model. + aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf_keras.Model. Returns: The total loss tensor. """ - total_loss = tf.keras.losses.sparse_categorical_crossentropy( + total_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, model_outputs, from_logits=True) total_loss = tf_utils.safe_mean(total_loss) @@ -103,31 +103,31 @@ def build_losses(self, return total_loss def build_metrics(self, - training: bool = True) -> Sequence[tf.keras.metrics.Metric]: + training: bool = True) -> Sequence[tf_keras.metrics.Metric]: """Gets streaming metrics for training/validation. This function builds and returns a list of metrics to compute during training and validation. The list contains objects of subclasses of - tf.keras.metrics.Metric. Training and validation can have different metrics. + tf_keras.metrics.Metric. Training and validation can have different metrics. Args: training: Whether the metric is for training or not. Returns: - A list of tf.keras.metrics.Metric objects. + A list of tf_keras.metrics.Metric objects. """ k = self.task_config.evaluation.top_k metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k)) ] return metrics def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None) -> Mapping[str, Any]: """Does forward and backward. @@ -139,7 +139,7 @@ def train_step(self, Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. optimizer: The optimizer for this training step. metrics: A nested structure of metrics objects. @@ -163,14 +163,14 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -181,13 +181,13 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None) -> Mapping[str, Any]: """Runs validation step. Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. metrics: A nested structure of metrics objects. Returns: @@ -204,6 +204,6 @@ def validation_step(self, self.process_metrics(metrics, labels, outputs) return logs - def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model) -> Any: + def inference_step(self, inputs: tf.Tensor, model: tf_keras.Model) -> Any: """Performs the forward step. It is used in 'validation_step'.""" return model(inputs, training=False) diff --git a/official/vision/losses/focal_loss.py b/official/vision/losses/focal_loss.py index 7fd3d84e071..67a525b02f8 100644 --- a/official/vision/losses/focal_loss.py +++ b/official/vision/losses/focal_loss.py @@ -14,10 +14,10 @@ """Losses used for detection models.""" -import tensorflow as tf +import tensorflow as tf, tf_keras -class FocalLoss(tf.keras.losses.Loss): +class FocalLoss(tf_keras.losses.Loss): """Implements a Focal loss for classification problems. Reference: @@ -27,14 +27,14 @@ class FocalLoss(tf.keras.losses.Loss): def __init__(self, alpha, gamma, - reduction=tf.keras.losses.Reduction.AUTO, + reduction=tf_keras.losses.Reduction.AUTO, name=None): """Initializes `FocalLoss`. Args: alpha: The `alpha` weight factor for binary class imbalance. gamma: The `gamma` focusing parameter to re-weight loss. - reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to + reduction: (Optional) Type of `tf_keras.losses.Reduction` to apply to loss. Default value is `AUTO`. `AUTO` indicates that the reduction option will be determined by the usage context. For almost all cases this defaults to `SUM_OVER_BATCH_SIZE`. When used with diff --git a/official/vision/losses/loss_utils.py b/official/vision/losses/loss_utils.py index be6ac577c9a..b77621cca76 100644 --- a/official/vision/losses/loss_utils.py +++ b/official/vision/losses/loss_utils.py @@ -14,7 +14,7 @@ """Losses utilities for detection models.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def multi_level_flatten(multi_level_inputs, last_dim=None): diff --git a/official/vision/losses/maskrcnn_losses.py b/official/vision/losses/maskrcnn_losses.py index dec15971a75..b5f71a40c59 100644 --- a/official/vision/losses/maskrcnn_losses.py +++ b/official/vision/losses/maskrcnn_losses.py @@ -15,7 +15,7 @@ """Losses for maskrcnn model.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras class RpnScoreLoss(object): @@ -23,8 +23,8 @@ class RpnScoreLoss(object): def __init__(self, rpn_batch_size_per_im): self._rpn_batch_size_per_im = rpn_batch_size_per_im - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, score_outputs, labels): """Computes total RPN detection loss. @@ -86,8 +86,8 @@ def __init__(self, huber_loss_delta: float): # The delta is typically around the mean value of regression target. # for instances, the regression targets of 512x512 input with 6 anchors on # P2-P6 pyramid is about [0.1, 0.1, 0.2, 0.2]. - self._huber_loss = tf.keras.losses.Huber( - delta=huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + self._huber_loss = tf_keras.losses.Huber( + delta=huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) def __call__(self, box_outputs, labels): """Computes total RPN detection loss. @@ -261,8 +261,8 @@ def __init__(self, class_agnostic_bbox_pred: if True, class agnostic bounding box prediction is performed. """ - self._huber_loss = tf.keras.losses.Huber( - delta=huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + self._huber_loss = tf_keras.losses.Huber( + delta=huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) self._class_agnostic_bbox_pred = class_agnostic_bbox_pred def __call__(self, box_outputs, class_targets, box_targets): @@ -335,8 +335,8 @@ class MaskrcnnLoss(object): """Mask R-CNN instance segmentation mask loss function.""" def __init__(self): - self._binary_crossentropy = tf.keras.losses.BinaryCrossentropy( - reduction=tf.keras.losses.Reduction.SUM, from_logits=True) + self._binary_crossentropy = tf_keras.losses.BinaryCrossentropy( + reduction=tf_keras.losses.Reduction.SUM, from_logits=True) def __call__(self, mask_outputs, mask_targets, select_class_targets): """Computes the mask loss of Mask-RCNN. diff --git a/official/vision/losses/maskrcnn_losses_test.py b/official/vision/losses/maskrcnn_losses_test.py index 1e65cc5e88e..f6453166ebe 100644 --- a/official/vision/losses/maskrcnn_losses_test.py +++ b/official/vision/losses/maskrcnn_losses_test.py @@ -15,7 +15,7 @@ """Tests for maskrcnn_losses.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.losses import maskrcnn_losses diff --git a/official/vision/losses/retinanet_losses.py b/official/vision/losses/retinanet_losses.py index 202e9ad5067..4cd5f39ba00 100644 --- a/official/vision/losses/retinanet_losses.py +++ b/official/vision/losses/retinanet_losses.py @@ -15,7 +15,7 @@ """Losses used for detection models.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras def focal_loss(logits, targets, alpha, gamma): @@ -53,7 +53,7 @@ def focal_loss(logits, targets, alpha, gamma): return weighted_loss -class FocalLoss(tf.keras.losses.Loss): +class FocalLoss(tf_keras.losses.Loss): """Implements a Focal loss for classification problems. Reference: @@ -64,7 +64,7 @@ def __init__(self, alpha, gamma, num_classes, - reduction=tf.keras.losses.Reduction.AUTO, + reduction=tf_keras.losses.Reduction.AUTO, name=None): """Initializes `FocalLoss`. @@ -72,7 +72,7 @@ def __init__(self, alpha: The `alpha` weight factor for binary class imbalance. gamma: The `gamma` focusing parameter to re-weight loss. num_classes: Number of foreground classes. - reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to + reduction: (Optional) Type of `tf_keras.losses.Reduction` to apply to loss. Default value is `AUTO`. `AUTO` indicates that the reduction option will be determined by the usage context. For almost all cases this defaults to `SUM_OVER_BATCH_SIZE`. When used with @@ -134,19 +134,19 @@ def get_config(self): return dict(list(base_config.items()) + list(config.items())) -class RetinanetBoxLoss(tf.keras.losses.Loss): +class RetinanetBoxLoss(tf_keras.losses.Loss): """RetinaNet box Huber loss.""" def __init__(self, delta, - reduction=tf.keras.losses.Reduction.AUTO, + reduction=tf_keras.losses.Reduction.AUTO, name=None): """Initializes `RetinanetBoxLoss`. Args: delta: A float, the point where the Huber loss function changes from a quadratic to linear. - reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to + reduction: (Optional) Type of `tf_keras.losses.Reduction` to apply to loss. Default value is `AUTO`. `AUTO` indicates that the reduction option will be determined by the usage context. For almost all cases this defaults to `SUM_OVER_BATCH_SIZE`. When used with @@ -157,8 +157,8 @@ def __init__(self, more details. name: Optional name for the op. Defaults to 'retinanet_class_loss'. """ - self._huber_loss = tf.keras.losses.Huber( - delta=delta, reduction=tf.keras.losses.Reduction.NONE) + self._huber_loss = tf_keras.losses.Huber( + delta=delta, reduction=tf_keras.losses.Reduction.NONE) self._delta = delta super(RetinanetBoxLoss, self).__init__(reduction=reduction, name=name) diff --git a/official/vision/losses/segmentation_losses.py b/official/vision/losses/segmentation_losses.py index e9de225f576..2bf071e37eb 100644 --- a/official/vision/losses/segmentation_losses.py +++ b/official/vision/losses/segmentation_losses.py @@ -14,7 +14,7 @@ """Losses used for segmentation models.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.dataloaders import utils @@ -266,8 +266,8 @@ class MaskScoringLoss: def __init__(self, ignore_label): self._ignore_label = ignore_label - self._mse_loss = tf.keras.losses.MeanSquaredError( - reduction=tf.keras.losses.Reduction.NONE) + self._mse_loss = tf_keras.losses.MeanSquaredError( + reduction=tf_keras.losses.Reduction.NONE) def __call__(self, predicted_scores, logits, labels): actual_scores = get_actual_mask_scores(logits, labels, self._ignore_label) diff --git a/official/vision/losses/segmentation_losses_test.py b/official/vision/losses/segmentation_losses_test.py index add5e9a8920..8f9344e3340 100644 --- a/official/vision/losses/segmentation_losses_test.py +++ b/official/vision/losses/segmentation_losses_test.py @@ -15,7 +15,7 @@ """Tests for segmentation_losses.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.losses import segmentation_losses diff --git a/official/vision/modeling/backbones/efficientnet.py b/official/vision/modeling/backbones/efficientnet.py index 2dc7ba34c7b..9f4d4876d1a 100644 --- a/official/vision/modeling/backbones/efficientnet.py +++ b/official/vision/modeling/backbones/efficientnet.py @@ -19,7 +19,7 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -27,7 +27,7 @@ from official.vision.modeling.layers import nn_blocks from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers # The fixed EfficientNet-B0 architecture discovered by NAS. # Each element represents a specification of a building block: @@ -92,8 +92,8 @@ def block_spec_decoder(specs: List[Tuple[Any, ...]], width_scale: float, return decoded_specs -@tf.keras.utils.register_keras_serializable(package='Vision') -class EfficientNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class EfficientNet(tf_keras.Model): """Creates an EfficientNet family model. This implements the EfficientNet model from: @@ -104,13 +104,13 @@ class EfficientNet(tf.keras.Model): def __init__(self, model_id: str, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), se_ratio: float = 0.0, stochastic_depth_drop_rate: float = 0.0, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: tf.keras.regularizers.Regularizer = None, - bias_regularizer: tf.keras.regularizers.Regularizer = None, + kernel_regularizer: tf_keras.regularizers.Regularizer = None, + bias_regularizer: tf_keras.regularizers.Regularizer = None, activation: str = 'relu', se_inner_activation: str = 'relu', use_sync_bn: bool = False, @@ -121,15 +121,15 @@ def __init__(self, Args: model_id: A `str` of model ID of EfficientNet. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. se_ratio: A `float` of squeeze and excitation ratio for inverted bottleneck blocks. stochastic_depth_drop_rate: A `float` of drop rate for drop connect layer. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. activation: A `str` of name of the activation function. se_inner_activation: A `str` of name of the activation function used in @@ -153,13 +153,13 @@ def __init__(self, self._bias_regularizer = bias_regularizer self._norm = layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = -1 else: bn_axis = 1 # Build EfficientNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) width_scale = SCALING_MAP[model_id]['width_scale'] depth_scale = SCALING_MAP[model_id]['depth_scale'] @@ -305,11 +305,11 @@ def output_specs(self): @factory.register_backbone_builder('efficientnet') def build_efficientnet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, - se_inner_activation: str = 'relu') -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, + se_inner_activation: str = 'relu') -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds EfficientNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/efficientnet_test.py b/official/vision/modeling/backbones/efficientnet_test.py index 5b0e19e2f0a..273526ca1e8 100644 --- a/official/vision/modeling/backbones/efficientnet_test.py +++ b/official/vision/modeling/backbones/efficientnet_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import efficientnet @@ -26,11 +26,11 @@ class EfficientNetTest(parameterized.TestCase, tf.test.TestCase): @parameterized.parameters(32, 224) def test_network_creation(self, input_size): """Test creation of EfficientNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = efficientnet.EfficientNet(model_id='b0') - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) self.assertAllEqual([1, input_size / 2**2, input_size / 2**2, 24], @@ -50,24 +50,24 @@ def test_network_scaling(self, model_id): 'b3': 10783528, 'b6': 40960136, } - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_size = 32 network = efficientnet.EfficientNet(model_id=model_id, se_ratio=0.25) self.assertEqual(network.count_params(), efficientnet_params[model_id]) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) _ = network(inputs) @parameterized.parameters(1, 3) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = efficientnet.EfficientNet(model_id='b0', input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) def test_serialize_deserialize(self): diff --git a/official/vision/modeling/backbones/factory.py b/official/vision/modeling/backbones/factory.py index 85cb7188c62..7f0670ccbae 100644 --- a/official/vision/modeling/backbones/factory.py +++ b/official/vision/modeling/backbones/factory.py @@ -45,7 +45,7 @@ def build_my_backbone(): # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import registry from official.modeling import hyperparams @@ -61,7 +61,7 @@ def register_backbone_builder(key: str): This decorator supports registration of backbone builder as follows: ``` - class MyBackbone(tf.keras.Model): + class MyBackbone(tf_keras.Model): pass @register_backbone_builder('mybackbone') @@ -82,24 +82,24 @@ def builder(input_specs, config, l2_reg): return registry.register(_REGISTERED_BACKBONE_CLS, key) -def build_backbone(input_specs: Union[tf.keras.layers.InputSpec, - Sequence[tf.keras.layers.InputSpec]], +def build_backbone(input_specs: Union[tf_keras.layers.InputSpec, + Sequence[tf_keras.layers.InputSpec]], backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, - **kwargs) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, + **kwargs) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds backbone from a config. Args: - input_specs: A (sequence of) `tf.keras.layers.InputSpec` of input. + input_specs: A (sequence of) `tf_keras.layers.InputSpec` of input. backbone_config: A `OneOfConfig` of backbone config. norm_activation_config: A config for normalization/activation layer. - l2_regularizer: A `tf.keras.regularizers.Regularizer` object. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` object. Default to None. **kwargs: Additional keyword args to be passed to backbone builder. Returns: - A `tf.keras.Model` instance of the backbone. + A `tf_keras.Model` instance of the backbone. """ backbone_builder = registry.lookup(_REGISTERED_BACKBONE_CLS, backbone_config.type) diff --git a/official/vision/modeling/backbones/factory_test.py b/official/vision/modeling/backbones/factory_test.py index 4aaf8ae8917..d49764ea709 100644 --- a/official/vision/modeling/backbones/factory_test.py +++ b/official/vision/modeling/backbones/factory_test.py @@ -15,7 +15,7 @@ """Tests for factory functions.""" # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.vision.configs import backbones as backbones_cfg @@ -42,7 +42,7 @@ def test_resnet_creation(self, model_id): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) @@ -73,7 +73,7 @@ def test_efficientnet_creation(self, model_id, se_ratio): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) @@ -106,7 +106,7 @@ def test_mobilenet_creation(self, model_id, filter_size_scale): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) @@ -122,7 +122,7 @@ def test_spinenet_creation(self, model_id): min_level = 3 max_level = 7 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]) network = backbones.SpineNet( input_specs=input_specs, @@ -138,7 +138,7 @@ def test_spinenet_creation(self, model_id): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec( + input_specs=tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) @@ -162,7 +162,7 @@ def test_revnet_creation(self, model_id): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) @@ -214,7 +214,7 @@ def test_mobiledet_creation(self, model_id, filter_size_scale): norm_momentum=0.99, norm_epsilon=1e-5, use_sync_bn=False) factory_network = factory.build_backbone( - input_specs=tf.keras.layers.InputSpec(shape=[None, None, None, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, None, None, 3]), backbone_config=backbone_config, norm_activation_config=norm_activation_config) diff --git a/official/vision/modeling/backbones/mobiledet.py b/official/vision/modeling/backbones/mobiledet.py index 832d481cccb..8e42d287c80 100644 --- a/official/vision/modeling/backbones/mobiledet.py +++ b/official/vision/modeling/backbones/mobiledet.py @@ -17,7 +17,7 @@ import dataclasses from typing import Any, Dict, Optional, Tuple, List -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.vision.modeling.backbones import factory @@ -26,7 +26,7 @@ from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers # pylint: disable=pointless-string-statement @@ -344,22 +344,22 @@ def block_spec_decoder( return decoded_specs -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobileDet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobileDet(tf_keras.Model): """Creates a MobileDet family model.""" def __init__( self, model_id: str = 'MobileDetCPU', filter_size_scale: float = 1.0, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), # The followings are for hyper-parameter tuning. norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, # The followings should be kept the same most of the times. min_depth: int = 8, divisible_by: int = 8, @@ -375,14 +375,14 @@ def __init__( channels) for all convolution ops. The value must be greater than zero. Typical usage will be to set this value in (0, 1) to reduce the number of parameters or computation cost of the model. - input_specs: A `tf.keras.layers.InputSpec` of specs of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of specs of the input tensor. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. min_depth: An `int` of minimum depth (number of channels) for all convolution ops. Enforced when filter_size_scale < 1, and not an active @@ -413,7 +413,7 @@ def __init__( self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) block_specs = SUPPORTED_SPECS_MAP.get(model_id) self._decoded_specs = block_spec_decoder( @@ -522,7 +522,7 @@ def _mobiledet_base(self, raise ValueError('Unknown block type {} for layer {}'.format( block_def.block_fn, i)) - net = tf.keras.layers.Activation('linear', name=block_name)(net) + net = tf_keras.layers.Activation('linear', name=block_name)(net) if block_def.is_output: endpoints[str(endpoint_level)] = net @@ -558,11 +558,11 @@ def output_specs(self): @factory.register_backbone_builder('mobiledet') def build_mobiledet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds MobileDet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/mobiledet_test.py b/official/vision/modeling/backbones/mobiledet_test.py index 9700649760b..fd7a456ab64 100644 --- a/official/vision/modeling/backbones/mobiledet_test.py +++ b/official/vision/modeling/backbones/mobiledet_test.py @@ -17,7 +17,7 @@ import itertools from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import mobiledet @@ -71,12 +71,12 @@ def test_serialize_deserialize(self, model_id): )) def test_input_specs(self, input_dim, model_id): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = mobiledet.MobileDet(model_id=model_id, input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) @parameterized.parameters( @@ -91,7 +91,7 @@ def test_input_specs(self, input_dim, model_id): )) def test_mobiledet_creation(self, model_id, input_size): """Test creation of MobileDet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') mobiledet_layers = { # The number of filters of layers having outputs been collected @@ -105,7 +105,7 @@ def test_mobiledet_creation(self, model_id, input_size): network = mobiledet.MobileDet(model_id=model_id, filter_size_scale=1.0) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) for idx, num_filter in enumerate(mobiledet_layers[model_id]): diff --git a/official/vision/modeling/backbones/mobilenet.py b/official/vision/modeling/backbones/mobilenet.py index 279eb917966..93ec26a0b1b 100644 --- a/official/vision/modeling/backbones/mobilenet.py +++ b/official/vision/modeling/backbones/mobilenet.py @@ -18,21 +18,21 @@ from typing import Optional, Dict, Any, Tuple # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils from official.vision.modeling.backbones import factory from official.vision.modeling.layers import nn_blocks from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers # pylint: disable=pointless-string-statement -@tf.keras.utils.register_keras_serializable(package='Vision') -class Conv2DBNBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Conv2DBNBlock(tf_keras.layers.Layer): """A convolution block with batch normalization.""" def __init__( @@ -44,8 +44,8 @@ def __init__( use_explicit_padding: bool = False, activation: str = 'relu6', kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, use_normalization: bool = True, use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -67,9 +67,9 @@ def __init__( activation: A `str` name of the activation function. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. use_normalization: If True, use batch normalization. use_sync_bn: If True, use synchronized batch normalization. @@ -91,13 +91,13 @@ def __init__( self._use_sync_bn = use_sync_bn self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization if use_explicit_padding and kernel_size > 1: self._padding = 'valid' else: self._padding = 'same' - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -124,8 +124,8 @@ def get_config(self): def build(self, input_shape): if self._use_explicit_padding and self._kernel_size > 1: padding_size = nn_layers.get_padding_for_kernel_size(self._kernel_size) - self._pad = tf.keras.layers.ZeroPadding2D(padding_size) - self._conv0 = tf.keras.layers.Conv2D( + self._pad = tf_keras.layers.ZeroPadding2D(padding_size) + self._conv0 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=self._kernel_size, strides=self._strides, @@ -614,22 +614,22 @@ def block_spec_decoder( return decoded_specs -@tf.keras.utils.register_keras_serializable(package='Vision') -class MobileNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MobileNet(tf_keras.Model): """Creates a MobileNet family model.""" def __init__( self, model_id: str = 'MobileNetV2', filter_size_scale: float = 1.0, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), # The followings are for hyper-parameter tuning. norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, # The followings should be kept the same most of the times. output_stride: Optional[int] = None, min_depth: int = 8, @@ -652,14 +652,14 @@ def __init__( channels) for all convolution ops. The value must be greater than zero. Typical usage will be to set this value in (0, 1) to reduce the number of parameters or computation cost of the model. - input_specs: A `tf.keras.layers.InputSpec` of specs of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of specs of the input tensor. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A `str` for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. output_stride: An `int` that specifies the requested ratio of input to output spatial resolution. If not None, then we invoke atrous @@ -714,7 +714,7 @@ def __init__( self._finegrain_classification_mode = finegrain_classification_mode self._output_intermediate_endpoints = output_intermediate_endpoints - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) block_specs = SUPPORTED_SPECS_MAP.get(model_id) self._decoded_specs = block_spec_decoder( @@ -865,7 +865,7 @@ def _mobilenet_base(self, raise ValueError('Unknown block type {} for layer {}'.format( block_def.block_fn, i)) - net = tf.keras.layers.Activation('linear', name=block_name)(net) + net = tf_keras.layers.Activation('linear', name=block_name)(net) if block_def.is_output: endpoints[str(endpoint_level)] = net @@ -909,11 +909,11 @@ def output_specs(self): @factory.register_backbone_builder('mobilenet') def build_mobilenet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds MobileNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/mobilenet_test.py b/official/vision/modeling/backbones/mobilenet_test.py index f503ab98cfd..97214d58fcd 100644 --- a/official/vision/modeling/backbones/mobilenet_test.py +++ b/official/vision/modeling/backbones/mobilenet_test.py @@ -20,7 +20,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import mobilenet @@ -89,12 +89,12 @@ def test_serialize_deserialize(self, model_id): )) def test_input_specs(self, input_dim, model_id): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = mobilenet.MobileNet(model_id=model_id, input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) @parameterized.parameters( @@ -115,7 +115,7 @@ def test_input_specs(self, input_dim, model_id): def test_mobilenet_creation(self, model_id, input_size): """Test creation of MobileNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') mobilenet_layers = { # The number of filters of layers having outputs been collected @@ -135,7 +135,7 @@ def test_mobilenet_creation(self, model_id, network = mobilenet.MobileNet(model_id=model_id, filter_size_scale=1.0) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) for idx, num_filter in enumerate(mobilenet_layers[model_id]): @@ -160,7 +160,7 @@ def test_mobilenet_creation(self, model_id, [32, 224], )) def test_mobilenet_intermediate_layers(self, model_id, input_size): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') # Tests the mobilenet intermediate depthwise layers. mobilenet_depthwise_layers = { # The number of filters of depthwise layers having outputs been @@ -182,7 +182,7 @@ def test_mobilenet_intermediate_layers(self, model_id, input_size): filter_size_scale=1.0, output_intermediate_endpoints=True) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) for idx, num_filter in enumerate(mobilenet_depthwise_layers[model_id]): @@ -243,7 +243,7 @@ def test_mobilenet_scaling(self, model_id, self.assertEqual(network.count_params(), mobilenet_params[(model_id, filter_size_scale)]) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) _ = network(inputs) @parameterized.parameters( @@ -264,7 +264,7 @@ def test_mobilenet_scaling(self, model_id, )) def test_mobilenet_output_stride(self, model_id, output_stride): """Test for creation of a MobileNet with different output strides.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') mobilenet_layers = { # The number of filters of the layers outputs been collected @@ -286,7 +286,7 @@ def test_mobilenet_output_stride(self, model_id, output_stride): level = int(math.log2(output_stride)) input_size = 224 - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) num_filter = mobilenet_layers[model_id] self.assertAllEqual( diff --git a/official/vision/modeling/backbones/resnet.py b/official/vision/modeling/backbones/resnet.py index 197471be2c4..53e356a509a 100644 --- a/official/vision/modeling/backbones/resnet.py +++ b/official/vision/modeling/backbones/resnet.py @@ -17,7 +17,7 @@ from typing import Callable, Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -25,7 +25,7 @@ from official.vision.modeling.layers import nn_blocks from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers # Specifications for different ResNet variants. # Each entry specifies block configurations of the particular ResNet variant. @@ -101,8 +101,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResNet(tf_keras.Model): """Creates ResNet and ResNet-RS family models. This implements the Deep Residual Network from: @@ -118,7 +118,7 @@ class ResNet(tf.keras.Model): def __init__( self, model_id: int, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), depth_multiplier: float = 1.0, stem_type: str = 'v0', @@ -132,15 +132,15 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, bn_trainable: bool = True, **kwargs): """Initializes a ResNet model. Args: model_id: An `int` of the depth of ResNet backbone model. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. depth_multiplier: A `float` of the depth multiplier to uniformaly scale up all layers in channel size. This argument is also referred to as `width_multiplier` in (https://arxiv.org/abs/2103.07579). @@ -158,9 +158,9 @@ def __init__( norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A small `float` added to variance to avoid dividing by zero. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. bn_trainable: A `bool` that indicates whether batch norm layers should be trainable. Default to True. @@ -185,13 +185,13 @@ def __init__( self._bias_regularizer = bias_regularizer self._bn_trainable = bn_trainable - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build ResNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) x = self._stem(inputs) endpoints = {} @@ -324,7 +324,7 @@ def _block_group(self, inputs: tf.Tensor, filters: int, strides: int, - block_fn: Callable[..., tf.keras.layers.Layer], + block_fn: Callable[..., tf_keras.layers.Layer], block_repeats: int = 1, stochastic_depth_drop_rate: float = 0.0, name: str = 'block_group'): @@ -381,7 +381,7 @@ def _block_group(self, bn_trainable=self._bn_trainable)( x) - return tf.keras.layers.Activation('linear', name=name)(x) + return tf_keras.layers.Activation('linear', name=name)(x) def get_config(self): config_dict = { @@ -416,10 +416,10 @@ def output_specs(self): @factory.register_backbone_builder('resnet') def build_resnet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds ResNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/resnet_3d.py b/official/vision/modeling/backbones/resnet_3d.py index 0d51f3ca20e..f1f45b304fd 100644 --- a/official/vision/modeling/backbones/resnet_3d.py +++ b/official/vision/modeling/backbones/resnet_3d.py @@ -16,7 +16,7 @@ from typing import Callable, List, Tuple, Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -24,7 +24,7 @@ from official.vision.modeling.layers import nn_blocks_3d from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers RESNET_SPECS = { 50: [ @@ -72,8 +72,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResNet3D(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResNet3D(tf_keras.Model): """Creates a 3D ResNet family model.""" def __init__( @@ -82,7 +82,7 @@ def __init__( temporal_strides: List[int], temporal_kernel_sizes: List[Tuple[int]], use_self_gating: Optional[List[int]] = None, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, None, 3]), stem_type: str = 'v0', stem_conv_temporal_kernel_size: int = 5, @@ -95,8 +95,8 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a 3D ResNet model. @@ -108,7 +108,7 @@ def __init__( sizes for all 3d blocks in different block groups. use_self_gating: A list of booleans to specify applying self-gating module or not in each block group. If None, self-gating is not applied. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. stem_type: A `str` of stem type of ResNet. Default to `v0`. If set to `v1`, use ResNet-D type stem (https://arxiv.org/abs/1812.01187). stem_conv_temporal_kernel_size: An `int` of temporal kernel size for the @@ -124,9 +124,9 @@ def __init__( norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -149,13 +149,13 @@ def __init__( self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build ResNet3D backbone. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) endpoints = self._build_model(inputs) self._output_specs = {l: endpoints[l].get_shape() for l in endpoints} @@ -294,7 +294,7 @@ def _block_group(self, spatial_strides: int, block_fn: Callable[ ..., - tf.keras.layers.Layer] = nn_blocks_3d.BottleneckBlock3D, + tf_keras.layers.Layer] = nn_blocks_3d.BottleneckBlock3D, block_repeats: int = 1, stochastic_depth_drop_rate: float = 0.0, use_self_gating: bool = False, @@ -401,11 +401,11 @@ def output_specs(self): @factory.register_backbone_builder('resnet_3d') def build_resnet3d( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds ResNet 3d backbone from a config.""" backbone_cfg = backbone_config.get() @@ -440,11 +440,11 @@ def build_resnet3d( @factory.register_backbone_builder('resnet_3d_rs') def build_resnet3d_rs( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds ResNet-3D-RS backbone from a config.""" backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/resnet_3d_test.py b/official/vision/modeling/backbones/resnet_3d_test.py index 9cb9585427a..1cdc1086af4 100644 --- a/official/vision/modeling/backbones/resnet_3d_test.py +++ b/official/vision/modeling/backbones/resnet_3d_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import resnet_3d @@ -31,7 +31,7 @@ class ResNet3DTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, model_id, endpoint_filter_scale, stem_type, se_ratio, init_stochastic_depth_rate): """Test creation of ResNet3D family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') temporal_strides = [1, 1, 1, 1] temporal_kernel_sizes = [(3, 3, 3), (3, 1, 3, 1), (3, 1, 3, 1, 3, 1), (1, 3, 1)] @@ -45,7 +45,7 @@ def test_network_creation(self, input_size, model_id, endpoint_filter_scale, stem_type=stem_type, se_ratio=se_ratio, init_stochastic_depth_rate=init_stochastic_depth_rate) - inputs = tf.keras.Input(shape=(8, input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(8, input_size, input_size, 3), batch_size=1) endpoints = network(inputs) self.assertAllEqual([ diff --git a/official/vision/modeling/backbones/resnet_deeplab.py b/official/vision/modeling/backbones/resnet_deeplab.py index cbcf861030e..627f8f2d300 100644 --- a/official/vision/modeling/backbones/resnet_deeplab.py +++ b/official/vision/modeling/backbones/resnet_deeplab.py @@ -17,14 +17,14 @@ from typing import Callable, Optional, Tuple, List import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils from official.vision.modeling.backbones import factory from official.vision.modeling.layers import nn_blocks from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers # Specifications for different ResNet variants. # Each entry specifies block configurations of the particular ResNet variant. @@ -58,8 +58,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class DilatedResNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DilatedResNet(tf_keras.Model): """Creates a ResNet model with Deeplabv3 modifications. This backbone is suitable for semantic segmentation. This implements @@ -72,7 +72,7 @@ def __init__( self, model_id: int, output_stride: int, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), stem_type: str = 'v0', resnetd_shortcut: bool = False, @@ -86,8 +86,8 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a ResNet model with DeepLab modification. @@ -95,7 +95,7 @@ def __init__( model_id: An `int` specifies depth of ResNet backbone model. output_stride: An `int` of output stride, ratio of input to output resolution. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. stem_type: A `str` of stem type. Can be `v0` or `v1`. `v1` replaces 7x7 conv by 3 3x3 convs. resnetd_shortcut: A `bool` of whether to use ResNet-D shortcut in @@ -113,9 +113,9 @@ def __init__( norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -136,13 +136,13 @@ def __init__( self._se_ratio = se_ratio self._init_stochastic_depth_rate = init_stochastic_depth_rate - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = -1 else: bn_axis = 1 # Build ResNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) if stem_type == 'v0': x = layers.Conv2D( @@ -291,7 +291,7 @@ def _block_group(self, filters: int, strides: int, dilation_rate: int, - block_fn: Callable[..., tf.keras.layers.Layer], + block_fn: Callable[..., tf_keras.layers.Layer], block_repeats: int = 1, stochastic_depth_drop_rate: float = 0.0, multigrid: Optional[List[int]] = None, @@ -392,10 +392,10 @@ def output_specs(self): @factory.register_backbone_builder('dilated_resnet') def build_dilated_resnet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds ResNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/resnet_deeplab_test.py b/official/vision/modeling/backbones/resnet_deeplab_test.py index df987afffb3..7b859203ed2 100644 --- a/official/vision/modeling/backbones/resnet_deeplab_test.py +++ b/official/vision/modeling/backbones/resnet_deeplab_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -39,11 +39,11 @@ class ResNetTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, model_id, endpoint_filter_scale, output_stride): """Test creation of ResNet models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = resnet_deeplab.DilatedResNet(model_id=model_id, output_stride=output_stride) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) print(endpoints) self.assertAllEqual([ @@ -69,7 +69,7 @@ def test_network_features(self, stem_type, se_ratio, endpoint_filter_scale = 4 output_stride = 8 - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = resnet_deeplab.DilatedResNet( model_id=model_id, @@ -79,7 +79,7 @@ def test_network_features(self, stem_type, se_ratio, replace_stem_max_pool=replace_stem_max_pool, se_ratio=se_ratio, init_stochastic_depth_rate=init_stochastic_depth_rate) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) print(endpoints) self.assertAllEqual([ @@ -99,7 +99,7 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(64, 128, 128, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): network = resnet_deeplab.DilatedResNet( @@ -109,13 +109,13 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): @parameterized.parameters(1, 3, 4) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = resnet_deeplab.DilatedResNet( model_id=50, output_stride=8, input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) def test_serialize_deserialize(self): diff --git a/official/vision/modeling/backbones/resnet_test.py b/official/vision/modeling/backbones/resnet_test.py index d0b6fca23a4..ab98a45e88a 100644 --- a/official/vision/modeling/backbones/resnet_test.py +++ b/official/vision/modeling/backbones/resnet_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -47,12 +47,12 @@ def test_network_creation(self, input_size, model_id, 101: 42605504, 152: 58295232, } - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = resnet.ResNet(model_id=model_id) self.assertEqual(network.count_params(), resnet_params[model_id]) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) self.assertAllEqual( @@ -80,7 +80,7 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(64, 128, 128, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): network = resnet.ResNet(model_id=50, use_sync_bn=use_sync_bn) @@ -96,7 +96,7 @@ def test_resnet_rs(self, input_size, model_id, endpoint_filter_scale, stem_type, se_ratio, init_stochastic_depth_rate, depth_multiplier, resnetd_shortcut, replace_stem_max_pool): """Test creation of ResNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = resnet.ResNet( model_id=model_id, depth_multiplier=depth_multiplier, @@ -105,18 +105,18 @@ def test_resnet_rs(self, input_size, model_id, endpoint_filter_scale, replace_stem_max_pool=replace_stem_max_pool, se_ratio=se_ratio, init_stochastic_depth_rate=init_stochastic_depth_rate) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) _ = network(inputs) @parameterized.parameters(1, 3, 4) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = resnet.ResNet(model_id=50, input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) def test_serialize_deserialize(self): diff --git a/official/vision/modeling/backbones/revnet.py b/official/vision/modeling/backbones/revnet.py index 1f0a864611c..64e229c5b96 100644 --- a/official/vision/modeling/backbones/revnet.py +++ b/official/vision/modeling/backbones/revnet.py @@ -16,7 +16,7 @@ from typing import Any, Callable, Dict, Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils from official.vision.modeling.backbones import factory @@ -48,8 +48,8 @@ } -@tf.keras.utils.register_keras_serializable(package='Vision') -class RevNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RevNet(tf_keras.Model): """Creates a Reversible ResNet (RevNet) family model. This implements: @@ -62,26 +62,26 @@ class RevNet(tf.keras.Model): def __init__( self, model_id: int, - input_specs: tf.keras.layers.InputSpec = tf.keras.layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = tf_keras.layers.InputSpec( shape=[None, None, None, 3]), activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a RevNet model. Args: model_id: An `int` of depth/id of ResNet backbone model. - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. activation: A `str` name of the activation function. use_sync_bn: If True, use synchronized batch normalization. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. **kwargs: Additional keyword arguments to be passed. """ @@ -93,14 +93,14 @@ def __init__( self._norm_epsilon = norm_epsilon self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - axis = -1 if tf.keras.backend.image_data_format() == 'channels_last' else 1 + axis = -1 if tf_keras.backend.image_data_format() == 'channels_last' else 1 # Build RevNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) - x = tf.keras.layers.Conv2D( + x = tf_keras.layers.Conv2D( filters=REVNET_SPECS[model_id][0][1], kernel_size=7, strides=2, use_bias=False, padding='same', kernel_initializer=self._kernel_initializer, @@ -111,7 +111,7 @@ def __init__( epsilon=norm_epsilon, synchronized=use_sync_bn)(x) x = tf_utils.get_activation(activation)(x) - x = tf.keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x) + x = tf_keras.layers.MaxPool2D(pool_size=3, strides=2, padding='same')(x) endpoints = {} for i, spec in enumerate(REVNET_SPECS[model_id]): @@ -144,7 +144,7 @@ def _block_group(self, inputs: tf.Tensor, filters: int, strides: int, - inner_block_fn: Callable[..., tf.keras.layers.Layer], + inner_block_fn: Callable[..., tf_keras.layers.Layer], block_repeats: int, batch_norm_first: bool, name: str = 'revblock_group') -> tf.Tensor: @@ -201,7 +201,7 @@ def get_config(self) -> Dict[str, Any]: @classmethod def from_config(cls, config: Dict[str, Any], - custom_objects: Optional[Any] = None) -> tf.keras.Model: + custom_objects: Optional[Any] = None) -> tf_keras.Model: return cls(**config) @property @@ -212,10 +212,10 @@ def output_specs(self) -> Dict[int, tf.TensorShape]: @factory.register_backbone_builder('revnet') def build_revnet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: # pytype: disable=annotation-type-mismatch # typed-keras """Builds RevNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/revnet_test.py b/official/vision/modeling/backbones/revnet_test.py index 6b7a1c7a971..375db32812c 100644 --- a/official/vision/modeling/backbones/revnet_test.py +++ b/official/vision/modeling/backbones/revnet_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import revnet @@ -30,10 +30,10 @@ class RevNetTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, model_id, endpoint_filter_scale): """Test creation of RevNet family models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') network = revnet.RevNet(model_id=model_id) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = network(inputs) network.summary() @@ -53,12 +53,12 @@ def test_network_creation(self, input_size, model_id, @parameterized.parameters(1, 3, 4) def test_input_specs(self, input_dim): """Test different input feature dimensions.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, input_dim]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, input_dim]) network = revnet.RevNet(model_id=56, input_specs=input_specs) - inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1) + inputs = tf_keras.Input(shape=(128, 128, input_dim), batch_size=1) _ = network(inputs) def test_serialize_deserialize(self): diff --git a/official/vision/modeling/backbones/spinenet.py b/official/vision/modeling/backbones/spinenet.py index cec3a3719e3..a871e716037 100644 --- a/official/vision/modeling/backbones/spinenet.py +++ b/official/vision/modeling/backbones/spinenet.py @@ -20,7 +20,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -29,7 +29,7 @@ from official.vision.modeling.layers import nn_layers from official.vision.ops import spatial_transform_ops -layers = tf.keras.layers +layers = tf_keras.layers FILTER_SIZE_MAP = { 1: 32, @@ -124,8 +124,8 @@ def build_block_specs( return [BlockSpec(*b) for b in block_specs] -@tf.keras.utils.register_keras_serializable(package='Vision') -class SpineNet(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SpineNet(tf_keras.Model): """Creates a SpineNet family model. This implements: @@ -137,7 +137,7 @@ class SpineNet(tf.keras.Model): def __init__( self, - input_specs: tf.keras.layers.InputSpec = tf.keras.layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = tf_keras.layers.InputSpec( shape=[None, None, None, 3]), min_level: int = 3, max_level: int = 7, @@ -148,8 +148,8 @@ def __init__( filter_size_scale: float = 1.0, init_stochastic_depth_rate: float = 0.0, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -158,7 +158,7 @@ def __init__( """Initializes a SpineNet model. Args: - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. min_level: An `int` of min level for output mutiscale features. max_level: An `int` of max level for output mutiscale features. block_specs: A list of block specifications for the SpineNet model @@ -173,9 +173,9 @@ def __init__( of parameters or computation cost of the model. init_stochastic_depth_rate: A `float` of initial stochastic depth rate. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. activation: A `str` name of the activation function. use_sync_bn: If True, use synchronized batch normalization. @@ -207,13 +207,13 @@ def __init__( self._set_activation_fn(activation) self._norm = layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build SpineNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) net = self._build_stem(inputs=inputs) input_width = input_specs.shape[2] @@ -547,10 +547,10 @@ def output_specs(self): @factory.register_backbone_builder('spinenet') def build_spinenet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: """Builds SpineNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/spinenet_mobile.py b/official/vision/modeling/backbones/spinenet_mobile.py index 5009b3e2a08..56d5b6f3164 100644 --- a/official/vision/modeling/backbones/spinenet_mobile.py +++ b/official/vision/modeling/backbones/spinenet_mobile.py @@ -33,7 +33,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -42,7 +42,7 @@ from official.vision.modeling.layers import nn_layers from official.vision.ops import spatial_transform_ops -layers = tf.keras.layers +layers = tf_keras.layers FILTER_SIZE_MAP = { 0: 8, @@ -116,8 +116,8 @@ def build_block_specs( return [BlockSpec(*b) for b in block_specs] -@tf.keras.utils.register_keras_serializable(package='Vision') -class SpineNetMobile(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SpineNetMobile(tf_keras.Model): """Creates a Mobile SpineNet family model. This implements: @@ -133,7 +133,7 @@ class SpineNetMobile(tf.keras.Model): def __init__( self, - input_specs: tf.keras.layers.InputSpec = tf.keras.layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = tf_keras.layers.InputSpec( shape=[None, None, None, 3]), min_level: int = 3, max_level: int = 7, @@ -145,8 +145,8 @@ def __init__( expand_ratio: int = 6, init_stochastic_depth_rate=0.0, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, activation: str = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -156,7 +156,7 @@ def __init__( """Initializes a Mobile SpineNet model. Args: - input_specs: A `tf.keras.layers.InputSpec` of the input tensor. + input_specs: A `tf_keras.layers.InputSpec` of the input tensor. min_level: An `int` of min level for output mutiscale features. max_level: An `int` of max level for output mutiscale features. block_specs: The block specifications for the SpineNet model discovered by @@ -173,9 +173,9 @@ def __init__( blocks. init_stochastic_depth_rate: A `float` of initial stochastic depth rate. kernel_initializer: A str for kernel initializer of convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. activation: A `str` name of the activation function. use_sync_bn: If True, use synchronized batch normalization. @@ -207,13 +207,13 @@ def __init__( self._num_init_blocks = 2 self._norm = layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 # Build SpineNet. - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) net = self._build_stem(inputs=inputs) input_width = input_specs.shape[2] @@ -269,7 +269,7 @@ def _block_group(self, norm_momentum=self._norm_momentum, norm_epsilon=self._norm_epsilon)( inputs) - return tf.keras.layers.Activation('linear', name=name)(x) + return tf_keras.layers.Activation('linear', name=name)(x) def _build_stem(self, inputs): """Builds SpineNet stem.""" @@ -513,10 +513,10 @@ def output_specs(self): @factory.register_backbone_builder('spinenet_mobile') def build_spinenet_mobile( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, backbone_config: hyperparams.Config, norm_activation_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: """Builds Mobile SpineNet backbone from a config.""" backbone_type = backbone_config.type backbone_cfg = backbone_config.get() diff --git a/official/vision/modeling/backbones/spinenet_mobile_test.py b/official/vision/modeling/backbones/spinenet_mobile_test.py index c08dd38ce17..8e5caa6aa08 100644 --- a/official/vision/modeling/backbones/spinenet_mobile_test.py +++ b/official/vision/modeling/backbones/spinenet_mobile_test.py @@ -29,7 +29,7 @@ """Tests for SpineNet.""" # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import spinenet_mobile @@ -47,9 +47,9 @@ def test_network_creation(self, input_size, filter_size_scale, block_repeats, min_level = 3 max_level = 7 - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]) model = spinenet_mobile.SpineNetMobile( input_specs=input_specs, @@ -62,7 +62,7 @@ def test_network_creation(self, input_size, filter_size_scale, block_repeats, init_stochastic_depth_rate=0.2, ) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = model(inputs) for l in range(min_level, max_level + 1): diff --git a/official/vision/modeling/backbones/spinenet_test.py b/official/vision/modeling/backbones/spinenet_test.py index f9106233122..5a9bcd7b25b 100644 --- a/official/vision/modeling/backbones/spinenet_test.py +++ b/official/vision/modeling/backbones/spinenet_test.py @@ -15,7 +15,7 @@ """Tests for SpineNet.""" # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import spinenet @@ -34,9 +34,9 @@ def test_network_creation(self, input_size, filter_size_scale, block_repeats, max_level): """Test creation of SpineNet models.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size, input_size, 3]) model = spinenet.SpineNet( input_specs=input_specs, @@ -49,7 +49,7 @@ def test_network_creation(self, input_size, filter_size_scale, block_repeats, init_stochastic_depth_rate=0.2, ) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) endpoints = model(inputs) for l in range(min_level, max_level + 1): @@ -67,8 +67,8 @@ def test_load_from_different_input_specs(self, input_size_1, input_size_2): """Test loading checkpoints with different input size.""" def build_spinenet(input_size): - tf.keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec( + tf_keras.backend.set_image_data_format('channels_last') + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model = spinenet.SpineNet( input_specs=input_specs, diff --git a/official/vision/modeling/backbones/vit.py b/official/vision/modeling/backbones/vit.py index 5f7eff22b34..85daa5d1299 100644 --- a/official/vision/modeling/backbones/vit.py +++ b/official/vision/modeling/backbones/vit.py @@ -18,7 +18,7 @@ from typing import Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import activations from official.vision.modeling.backbones import factory @@ -27,14 +27,14 @@ from official.vision.modeling.layers import nn_layers -layers = tf.keras.layers +layers = tf_keras.layers class AddPositionEmbs(layers.Layer): """Adds (optionally learned) positional embeddings to the inputs.""" def __init__(self, - posemb_init: Optional[tf.keras.initializers.Initializer] = None, + posemb_init: Optional[tf_keras.initializers.Initializer] = None, posemb_origin_shape: Optional[Tuple[int, int]] = None, posemb_target_shape: Optional[Tuple[int, int]] = None, **kwargs): @@ -143,7 +143,7 @@ def __init__(self, def build(self, input_shape): if self._add_pos_embed: self._pos_embed = AddPositionEmbs( - posemb_init=tf.keras.initializers.RandomNormal(stddev=0.02), + posemb_init=tf_keras.initializers.RandomNormal(stddev=0.02), posemb_origin_shape=self._pos_embed_origin_shape, posemb_target_shape=self._pos_embed_target_shape, name='posembed_input') @@ -204,7 +204,7 @@ def get_config(self): return config -class VisionTransformer(tf.keras.Model): +class VisionTransformer(tf_keras.Model): """Class to build VisionTransformer family model.""" def __init__( @@ -235,7 +235,7 @@ def __init__( self._hidden_size = hidden_size self._patch_size = patch_size - inputs = tf.keras.Input(shape=input_specs.shape[1:]) + inputs = tf_keras.Input(shape=input_specs.shape[1:]) x = layers.Conv2D( filters=hidden_size, @@ -245,14 +245,14 @@ def __init__( kernel_regularizer=kernel_regularizer, kernel_initializer='lecun_normal' if original_init else 'he_uniform')( inputs) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': rows_axis, cols_axis = (1, 2) else: rows_axis, cols_axis = (2, 3) # The reshape below assumes the data_format is 'channels_last,' so # transpose to that. Once the data is flattened by the reshape, the # data_format is irrelevant, so no need to update - # tf.keras.backend.image_data_format. + # tf_keras.backend.image_data_format. x = tf.transpose(x, perm=[0, 2, 3, 1]) pos_embed_target_shape = (x.shape[rows_axis], x.shape[cols_axis]) diff --git a/official/vision/modeling/backbones/vit_test.py b/official/vision/modeling/backbones/vit_test.py index 098359a9041..46703290ee9 100644 --- a/official/vision/modeling/backbones/vit_test.py +++ b/official/vision/modeling/backbones/vit_test.py @@ -17,7 +17,7 @@ import math from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import vit @@ -30,12 +30,12 @@ class VisionTransformerTest(parameterized.TestCase, tf.test.TestCase): ) def test_network_creation(self, input_size, params_count): """Test creation of VisionTransformer family models.""" - tf.keras.backend.set_image_data_format('channels_last') - input_specs = tf.keras.layers.InputSpec( + tf_keras.backend.set_image_data_format('channels_last') + input_specs = tf_keras.layers.InputSpec( shape=[2, input_size, input_size, 3]) network = vit.VisionTransformer(input_specs=input_specs) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) _ = network(inputs) self.assertEqual(network.count_params(), params_count) @@ -46,11 +46,11 @@ def test_network_creation(self, input_size, params_count): ) def test_network_with_diferent_configs( self, patch_size, output_2d_feature_maps, pooler): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_size = 24 expected_feat_level = str(round(math.log2(patch_size))) num_patch_rows = input_size // patch_size - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[2, input_size, input_size, 3]) network = vit.VisionTransformer( input_specs=input_specs, @@ -63,7 +63,7 @@ def test_network_with_diferent_configs( representation_size=16, output_2d_feature_maps=output_2d_feature_maps) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) output = network(inputs) if pooler == 'none': self.assertEqual( @@ -81,9 +81,9 @@ def test_network_with_diferent_configs( self.assertNotIn(expected_feat_level, output) def test_posembedding_interpolation(self): - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') input_size = 256 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[2, input_size, input_size, 3]) network = vit.VisionTransformer( input_specs=input_specs, @@ -91,7 +91,7 @@ def test_posembedding_interpolation(self): pooler='gap', pos_embed_shape=(14, 14)) # (224 // 16) - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) output = network(inputs)['pre_logits'] self.assertEqual(output.shape, [1, 1, 1, 768]) diff --git a/official/vision/modeling/classification_model.py b/official/vision/modeling/classification_model.py index c1bcdecf246..44e4314117a 100644 --- a/official/vision/modeling/classification_model.py +++ b/official/vision/modeling/classification_model.py @@ -16,25 +16,25 @@ from typing import Any, Mapping, Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class ClassificationModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ClassificationModel(tf_keras.Model): """A classification class builder.""" def __init__( self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: int, - input_specs: tf.keras.layers.InputSpec = layers.InputSpec( + input_specs: tf_keras.layers.InputSpec = layers.InputSpec( shape=[None, None, None, 3]), dropout_rate: float = 0.0, kernel_initializer: str = 'random_uniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, add_head_batch_norm: bool = False, use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -46,12 +46,12 @@ def __init__( Args: backbone: a backbone network. num_classes: `int` number of classes in classification task. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. dropout_rate: `float` rate for dropout regularization. kernel_initializer: kernel initializer for the dense layer. - kernel_regularizer: tf.keras.regularizers.Regularizer object. Default to + kernel_regularizer: tf_keras.regularizers.Regularizer object. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object. Default to + bias_regularizer: tf_keras.regularizers.Regularizer object. Default to None. add_head_batch_norm: `bool` whether to add a batch normalization layer before pool. @@ -62,10 +62,10 @@ def __init__( skip_logits_layer: `bool`, whether to skip the prediction layer. **kwargs: keyword arguments to be passed. """ - norm = tf.keras.layers.BatchNormalization - axis = -1 if tf.keras.backend.image_data_format() == 'channels_last' else 1 + norm = tf_keras.layers.BatchNormalization + axis = -1 if tf_keras.backend.image_data_format() == 'channels_last' else 1 - inputs = tf.keras.Input(shape=input_specs.shape[1:], name=input_specs.name) + inputs = tf_keras.Input(shape=input_specs.shape[1:], name=input_specs.name) endpoints = backbone(inputs) x = endpoints[max(endpoints.keys())] @@ -81,13 +81,13 @@ def __init__( # [batch_size, height, weight, channel_size] or # [batch_size, token_size, hidden_size]. if len(x.shape) == 4: - x = tf.keras.layers.GlobalAveragePooling2D()(x) + x = tf_keras.layers.GlobalAveragePooling2D()(x) elif len(x.shape) == 3: - x = tf.keras.layers.GlobalAveragePooling1D()(x) + x = tf_keras.layers.GlobalAveragePooling1D()(x) if not skip_logits_layer: - x = tf.keras.layers.Dropout(dropout_rate)(x) - x = tf.keras.layers.Dense( + x = tf_keras.layers.Dropout(dropout_rate)(x) + x = tf_keras.layers.Dense( num_classes, kernel_initializer=kernel_initializer, kernel_regularizer=kernel_regularizer, @@ -116,12 +116,12 @@ def __init__( self._norm = norm @property - def checkpoint_items(self) -> Mapping[str, tf.keras.Model]: + def checkpoint_items(self) -> Mapping[str, tf_keras.Model]: """Returns a dictionary of items to be additionally checkpointed.""" return dict(backbone=self.backbone) @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone def get_config(self) -> Mapping[str, Any]: diff --git a/official/vision/modeling/classification_model_test.py b/official/vision/modeling/classification_model_test.py index 565c61f1ec3..f437b8e2aa2 100644 --- a/official/vision/modeling/classification_model_test.py +++ b/official/vision/modeling/classification_model_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -36,14 +36,14 @@ def test_vision_transformer_creation(self, mlp_dim, num_heads, num_layers, """Test for creation of a Vision Transformer classifier.""" inputs = np.random.rand(2, 224, 224, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.VisionTransformer( mlp_dim=mlp_dim, num_heads=num_heads, num_layers=num_layers, hidden_size=hidden_size, - input_specs=tf.keras.layers.InputSpec(shape=[None, 224, 224, 3]), + input_specs=tf_keras.layers.InputSpec(shape=[None, 224, 224, 3]), ) self.assertEqual(backbone.count_params(), num_params) @@ -67,7 +67,7 @@ def test_resnet_network_creation(self, input_size, resnet_model_id, """Test for creation of a ResNet-50 classifier.""" inputs = np.random.rand(2, input_size, input_size, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.ResNet(model_id=resnet_model_id, activation=activation) self.assertEqual(backbone.count_params(), 23561152) @@ -88,7 +88,7 @@ def test_revnet_network_creation(self): revnet_model_id = 56 inputs = np.random.rand(2, 224, 224, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.RevNet(model_id=revnet_model_id) self.assertEqual(backbone.count_params(), 19473792) @@ -123,7 +123,7 @@ def test_mobilenet_network_creation(self, mobilenet_model_id, """Test for creation of a MobileNet classifier.""" inputs = np.random.rand(2, 224, 224, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.MobileNet( model_id=mobilenet_model_id, filter_size_scale=filter_size_scale) @@ -150,7 +150,7 @@ def test_sync_bn_multiple_devices(self, strategy, use_sync_bn): """Test for sync bn on TPU and GPU devices.""" inputs = np.random.rand(64, 128, 128, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') with strategy.scope(): backbone = backbones.ResNet(model_id=50, use_sync_bn=use_sync_bn) @@ -175,9 +175,9 @@ def test_data_format_gpu(self, strategy, data_format, input_dim): inputs = np.random.rand(2, 128, 128, input_dim) else: inputs = np.random.rand(2, input_dim, 128, 128) - input_specs = tf.keras.layers.InputSpec(shape=inputs.shape) + input_specs = tf_keras.layers.InputSpec(shape=inputs.shape) - tf.keras.backend.set_image_data_format(data_format) + tf_keras.backend.set_image_data_format(data_format) with strategy.scope(): backbone = backbones.ResNet(model_id=50, input_specs=input_specs) @@ -192,7 +192,7 @@ def test_data_format_gpu(self, strategy, data_format, input_dim): def test_serialize_deserialize(self): """Validate the classification net can be serialized and deserialized.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.ResNet(model_id=50) model = classification_model.ClassificationModel( diff --git a/official/vision/modeling/decoders/aspp.py b/official/vision/modeling/decoders/aspp.py index 0cebdc927ac..d53152d5186 100644 --- a/official/vision/modeling/decoders/aspp.py +++ b/official/vision/modeling/decoders/aspp.py @@ -17,7 +17,7 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.vision.modeling.decoders import factory @@ -27,8 +27,8 @@ TensorMapUnion = Union[tf.Tensor, Mapping[str, tf.Tensor]] -@tf.keras.utils.register_keras_serializable(package='Vision') -class ASPP(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ASPP(tf_keras.layers.Layer): """Creates an Atrous Spatial Pyramid Pooling (ASPP) layer.""" def __init__( @@ -43,7 +43,7 @@ def __init__( activation: str = 'relu', dropout_rate: float = 0.0, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', use_depthwise_convolution: bool = False, spp_layer_version: str = 'v1', @@ -65,7 +65,7 @@ def __init__( dropout_rate: A `float` rate for dropout regularization. kernel_initializer: A `str` name of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. interpolation: A `str` of interpolation method. It should be one of `bilinear`, `nearest`, `bicubic`, `area`, `lanczos3`, `lanczos5`, @@ -161,8 +161,8 @@ def from_config(cls, config, custom_objects=None): def build_aspp_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds ASPP decoder from a config. Args: @@ -170,11 +170,11 @@ def build_aspp_decoder( {level: TensorShape} from a backbone. Note this is for consistent interface, and is not used by ASPP decoder. model_config: A OneOfConfig. Model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` instance. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` instance. Default to None. Returns: - A `tf.keras.Model` instance of the ASPP decoder. + A `tf_keras.Model` instance of the ASPP decoder. Raises: ValueError: If the model_config.decoder.type is not `aspp`. diff --git a/official/vision/modeling/decoders/aspp_test.py b/official/vision/modeling/decoders/aspp_test.py index 897c0962e9b..4164fa34e67 100644 --- a/official/vision/modeling/decoders/aspp_test.py +++ b/official/vision/modeling/decoders/aspp_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import resnet from official.vision.modeling.decoders import aspp @@ -37,9 +37,9 @@ def test_network_creation(self, level, dilation_rates, num_filters, """Test creation of ASPP.""" input_size = 256 - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) backbone = resnet.ResNet(model_id=50) network = aspp.ASPP( diff --git a/official/vision/modeling/decoders/factory.py b/official/vision/modeling/decoders/factory.py index bb2b0d5669c..6fe7bc80a40 100644 --- a/official/vision/modeling/decoders/factory.py +++ b/official/vision/modeling/decoders/factory.py @@ -43,7 +43,7 @@ def build_my_decoder(): # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import registry from official.modeling import hyperparams @@ -58,7 +58,7 @@ def register_decoder_builder(key: str) -> Callable[..., Any]: This decorator supports registration of decoder builder as follows: ``` - class MyDecoder(tf.keras.Model): + class MyDecoder(tf_keras.Model): pass @register_decoder_builder('mydecoder') @@ -83,7 +83,7 @@ def builder(input_specs, config, l2_reg): def build_identity( input_specs: Optional[Mapping[str, tf.TensorShape]] = None, model_config: Optional[hyperparams.Config] = None, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None) -> None: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None) -> None: """Builds identity decoder from a config. All the input arguments are not used by identity decoder but kept here to @@ -93,7 +93,7 @@ def build_identity( input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A `OneOfConfig` of model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` object. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` object. Default to None. Returns: @@ -105,8 +105,8 @@ def build_identity( def build_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: tf.keras.regularizers.Regularizer = None, - **kwargs) -> Union[None, tf.keras.Model, tf.keras.layers.Layer]: # pytype: disable=annotation-type-mismatch # typed-keras + l2_regularizer: tf_keras.regularizers.Regularizer = None, + **kwargs) -> Union[None, tf_keras.Model, tf_keras.layers.Layer]: # pytype: disable=annotation-type-mismatch # typed-keras """Builds decoder from a config. A decoder can be a keras.Model, a keras.layers.Layer, or None. If it is not @@ -118,7 +118,7 @@ def build_decoder( input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A `OneOfConfig` of model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` object. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` object. Default to None. **kwargs: Additional keyword args to be passed to decoder builder. diff --git a/official/vision/modeling/decoders/factory_test.py b/official/vision/modeling/decoders/factory_test.py index 4ea86b42d42..47b3a4ecf18 100644 --- a/official/vision/modeling/decoders/factory_test.py +++ b/official/vision/modeling/decoders/factory_test.py @@ -15,7 +15,7 @@ """Tests for decoder factory functions.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.vision import configs diff --git a/official/vision/modeling/decoders/fpn.py b/official/vision/modeling/decoders/fpn.py index cbd5e91d900..27fbec5394d 100644 --- a/official/vision/modeling/decoders/fpn.py +++ b/official/vision/modeling/decoders/fpn.py @@ -17,7 +17,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -25,8 +25,8 @@ from official.vision.ops import spatial_transform_ops -@tf.keras.utils.register_keras_serializable(package='Vision') -class FPN(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class FPN(tf_keras.Model): """Creates a Feature Pyramid Network (FPN). This implements the paper: @@ -50,8 +50,8 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a Feature Pyramid Network (FPN). @@ -72,9 +72,9 @@ def __init__( norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A `str` name of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ self._config_dict = { @@ -94,16 +94,16 @@ def __init__( 'bias_regularizer': bias_regularizer, } conv2d = ( - tf.keras.layers.SeparableConv2D + tf_keras.layers.SeparableConv2D if use_separable_conv - else tf.keras.layers.Conv2D + else tf_keras.layers.Conv2D ) - norm = tf.keras.layers.BatchNormalization + norm = tf_keras.layers.BatchNormalization activation_fn = tf_utils.get_activation(activation, use_keras_layer=True) # Build input feature pyramid. bn_axis = ( - -1 if tf.keras.backend.image_data_format() == 'channels_last' else 1 + -1 if tf_keras.backend.image_data_format() == 'channels_last' else 1 ) # Get input feature pyramid from backbone. @@ -133,12 +133,12 @@ def __init__( if fusion_type == 'sum': if use_keras_layer: - feats[str(level)] = tf.keras.layers.Add()([feat_a, feat_b]) + feats[str(level)] = tf_keras.layers.Add()([feat_a, feat_b]) else: feats[str(level)] = feat_a + feat_b elif fusion_type == 'concat': if use_keras_layer: - feats[str(level)] = tf.keras.layers.Concatenate(axis=-1)( + feats[str(level)] = tf_keras.layers.Concatenate(axis=-1)( [feat_a, feat_b]) else: feats[str(level)] = tf.concat([feat_a, feat_b], axis=-1) @@ -202,7 +202,7 @@ def _build_input_pyramid(self, input_specs: Mapping[str, tf.TensorShape], inputs = {} for level, spec in input_specs.items(): - inputs[level] = tf.keras.Input(shape=spec[1:]) + inputs[level] = tf_keras.Input(shape=spec[1:]) return inputs def get_config(self) -> Mapping[str, Any]: @@ -222,19 +222,19 @@ def output_specs(self) -> Mapping[str, tf.TensorShape]: def build_fpn_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds FPN decoder from a config. Args: input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A OneOfConfig. Model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` instance. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` instance. Default to None. Returns: - A `tf.keras.Model` instance of the FPN decoder. + A `tf_keras.Model` instance of the FPN decoder. Raises: ValueError: If the model_config.decoder.type is not `fpn`. diff --git a/official/vision/modeling/decoders/fpn_test.py b/official/vision/modeling/decoders/fpn_test.py index b7362185040..56076090841 100644 --- a/official/vision/modeling/decoders/fpn_test.py +++ b/official/vision/modeling/decoders/fpn_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import mobilenet from official.vision.modeling.backbones import resnet @@ -34,9 +34,9 @@ class FPNTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, min_level, max_level, use_separable_conv, use_keras_layer, fusion_type): """Test creation of FPN.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) backbone = resnet.ResNet(model_id=50) network = fpn.FPN( @@ -66,9 +66,9 @@ def test_network_creation_with_mobilenet(self, input_size, min_level, max_level, use_separable_conv, use_keras_layer): """Test creation of FPN with mobilenet backbone.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) backbone = mobilenet.MobileNet(model_id='MobileNetV2') network = fpn.FPN( diff --git a/official/vision/modeling/decoders/nasfpn.py b/official/vision/modeling/decoders/nasfpn.py index c3359ed10ae..7504665e54e 100644 --- a/official/vision/modeling/decoders/nasfpn.py +++ b/official/vision/modeling/decoders/nasfpn.py @@ -19,7 +19,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import hyperparams from official.modeling import tf_utils @@ -61,8 +61,8 @@ def build_block_specs( return [BlockSpec(*b) for b in block_specs] -@tf.keras.utils.register_keras_serializable(package='Vision') -class NASFPN(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class NASFPN(tf_keras.Model): """Creates a NAS-FPN model. This implements the paper: @@ -85,8 +85,8 @@ def __init__( norm_momentum: float = 0.99, norm_epsilon: float = 0.001, kernel_initializer: str = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a NAS-FPN model. @@ -108,9 +108,9 @@ def __init__( norm_epsilon: A `float` added to variance to avoid dividing by zero. kernel_initializer: A `str` name of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ self._config_dict = { @@ -134,11 +134,11 @@ def __init__( build_block_specs() if block_specs is None else block_specs ) self._num_repeats = num_repeats - self._conv_op = (tf.keras.layers.SeparableConv2D + self._conv_op = (tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D) - self._norm_op = tf.keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + else tf_keras.layers.Conv2D) + self._norm_op = tf_keras.layers.BatchNormalization + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -186,7 +186,7 @@ def _build_input_pyramid(self, input_specs: Mapping[str, tf.TensorShape], inputs = {} for level, spec in input_specs.items(): - inputs[level] = tf.keras.Input(shape=spec[1:]) + inputs[level] = tf_keras.Input(shape=spec[1:]) return inputs def _resample_feature_map(self, @@ -206,7 +206,7 @@ def _resample_feature_map(self, if input_level < target_level: stride = int(2 ** (target_level - input_level)) - return tf.keras.layers.MaxPool2D( + return tf_keras.layers.MaxPool2D( pool_size=stride, strides=stride, padding='same')(x) if input_level > target_level: scale = int(2 ** (input_level - target_level)) @@ -216,7 +216,7 @@ def _resample_feature_map(self, # dtype mismatch when one input (by default float32 dtype) does not meet all # the above conditions and is output unchanged, while other inputs are # processed to have different dtype, e.g., using bfloat16 on TPU. - compute_dtype = tf.keras.layers.Layer().dtype_policy.compute_dtype + compute_dtype = tf_keras.layers.Layer().dtype_policy.compute_dtype if (compute_dtype is not None) and (x.dtype != compute_dtype): return tf.cast(x, dtype=compute_dtype) else: @@ -226,9 +226,9 @@ def _resample_feature_map(self, def _conv_kwargs(self): if self._config_dict['use_separable_conv']: return { - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -237,7 +237,7 @@ def _conv_kwargs(self): } else: return { - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], @@ -334,19 +334,19 @@ def output_specs(self) -> Mapping[str, tf.TensorShape]: def build_nasfpn_decoder( input_specs: Mapping[str, tf.TensorShape], model_config: hyperparams.Config, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None +) -> tf_keras.Model: """Builds NASFPN decoder from a config. Args: input_specs: A `dict` of input specifications. A dictionary consists of {level: TensorShape} from a backbone. model_config: A OneOfConfig. Model config. - l2_regularizer: A `tf.keras.regularizers.Regularizer` instance. Default to + l2_regularizer: A `tf_keras.regularizers.Regularizer` instance. Default to None. Returns: - A `tf.keras.Model` instance of the NASFPN decoder. + A `tf_keras.Model` instance of the NASFPN decoder. Raises: ValueError: If the model_config.decoder.type is not `nasfpn`. diff --git a/official/vision/modeling/decoders/nasfpn_test.py b/official/vision/modeling/decoders/nasfpn_test.py index cf0b5b65d57..098dcae68ce 100644 --- a/official/vision/modeling/decoders/nasfpn_test.py +++ b/official/vision/modeling/decoders/nasfpn_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.backbones import resnet from official.vision.modeling.decoders import nasfpn @@ -31,9 +31,9 @@ class NASFPNTest(parameterized.TestCase, tf.test.TestCase): def test_network_creation(self, input_size, min_level, max_level, use_separable_conv): """Test creation of NAS-FPN.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') - inputs = tf.keras.Input(shape=(input_size, input_size, 3), batch_size=1) + inputs = tf_keras.Input(shape=(input_size, input_size, 3), batch_size=1) num_filters = 256 backbone = resnet.ResNet(model_id=50) diff --git a/official/vision/modeling/factory.py b/official/vision/modeling/factory.py index 2e41af15abf..3042f0dad8a 100644 --- a/official/vision/modeling/factory.py +++ b/official/vision/modeling/factory.py @@ -16,7 +16,7 @@ from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import image_classification as classification_cfg from official.vision.configs import maskrcnn as maskrcnn_cfg @@ -39,11 +39,11 @@ def build_classification_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: classification_cfg.ImageClassificationModel, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, skip_logits_layer: bool = False, - backbone: Optional[tf.keras.Model] = None) -> tf.keras.Model: + backbone: Optional[tf_keras.Model] = None) -> tf_keras.Model: """Builds the classification model.""" norm_activation_config = model_config.norm_activation if not backbone: @@ -68,12 +68,12 @@ def build_classification_model( return model -def build_maskrcnn(input_specs: tf.keras.layers.InputSpec, +def build_maskrcnn(input_specs: tf_keras.layers.InputSpec, model_config: maskrcnn_cfg.MaskRCNN, l2_regularizer: Optional[ - tf.keras.regularizers.Regularizer] = None, - backbone: Optional[tf.keras.Model] = None, - decoder: Optional[tf.keras.Model] = None) -> tf.keras.Model: + tf_keras.regularizers.Regularizer] = None, + backbone: Optional[tf_keras.Model] = None, + decoder: Optional[tf_keras.Model] = None) -> tf_keras.Model: """Builds Mask R-CNN model.""" norm_activation_config = model_config.norm_activation if not backbone: @@ -82,7 +82,7 @@ def build_maskrcnn(input_specs: tf.keras.layers.InputSpec, backbone_config=model_config.backbone, norm_activation_config=norm_activation_config, l2_regularizer=l2_regularizer) - backbone_features = backbone(tf.keras.Input(input_specs.shape[1:])) + backbone_features = backbone(tf_keras.Input(input_specs.shape[1:])) if not decoder: decoder = decoders.factory.build_decoder( @@ -258,12 +258,12 @@ def build_maskrcnn(input_specs: tf.keras.layers.InputSpec, def build_retinanet( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: retinanet_cfg.RetinaNet, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - backbone: Optional[tf.keras.Model] = None, - decoder: Optional[tf.keras.Model] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + backbone: Optional[tf_keras.Model] = None, + decoder: Optional[tf_keras.Model] = None +) -> tf_keras.Model: """Builds RetinaNet model.""" norm_activation_config = model_config.norm_activation if not backbone: @@ -272,7 +272,7 @@ def build_retinanet( backbone_config=model_config.backbone, norm_activation_config=norm_activation_config, l2_regularizer=l2_regularizer) - backbone_features = backbone(tf.keras.Input(input_specs.shape[1:])) + backbone_features = backbone(tf_keras.Input(input_specs.shape[1:])) if not decoder: decoder = decoders.factory.build_decoder( @@ -347,12 +347,12 @@ def build_retinanet( def build_segmentation_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: segmentation_cfg.SemanticSegmentationModel, - l2_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - backbone: Optional[tf.keras.Model] = None, - decoder: Optional[tf.keras.Model] = None -) -> tf.keras.Model: + l2_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + backbone: Optional[tf_keras.Model] = None, + decoder: Optional[tf_keras.Model] = None +) -> tf_keras.Model: """Builds Segmentation model.""" norm_activation_config = model_config.norm_activation if not backbone: diff --git a/official/vision/modeling/factory_3d.py b/official/vision/modeling/factory_3d.py index 91b1316bae7..b8e557d0e51 100644 --- a/official/vision/modeling/factory_3d.py +++ b/official/vision/modeling/factory_3d.py @@ -15,7 +15,7 @@ """Factory methods to build models.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import registry from official.vision.configs import video_classification as video_classification_cfg @@ -32,7 +32,7 @@ def register_model_builder(key: str): This decorator supports registration of backbone builder as follows: ``` - class MyModel(tf.keras.Model): + class MyModel(tf_keras.Model): pass @register_backbone_builder('mybackbone') @@ -55,22 +55,22 @@ def builder(input_specs, config, l2_reg): def build_model( model_type: str, - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: video_classification_cfg.hyperparams.Config, num_classes: int, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: """Builds backbone from a config. Args: model_type: string name of model type. It should be consistent with ModelConfig.model_type. - input_specs: tf.keras.layers.InputSpec. + input_specs: tf_keras.layers.InputSpec. model_config: a OneOfConfig. Model config. num_classes: number of classes. - l2_regularizer: tf.keras.regularizers.Regularizer instance. Default to None. + l2_regularizer: tf_keras.regularizers.Regularizer instance. Default to None. Returns: - tf.keras.Model instance of the backbone. + tf_keras.Model instance of the backbone. """ model_builder = registry.lookup(_REGISTERED_MODEL_CLS, model_type) @@ -79,10 +79,10 @@ def build_model( @register_model_builder('video_classification') def build_video_classification_model( - input_specs: tf.keras.layers.InputSpec, + input_specs: tf_keras.layers.InputSpec, model_config: video_classification_cfg.VideoClassificationModel, num_classes: int, - l2_regularizer: tf.keras.regularizers.Regularizer = None) -> tf.keras.Model: + l2_regularizer: tf_keras.regularizers.Regularizer = None) -> tf_keras.Model: """Builds the video classification model.""" input_specs_dict = {'image': input_specs} norm_activation_config = model_config.norm_activation diff --git a/official/vision/modeling/factory_test.py b/official/vision/modeling/factory_test.py index 20c807f982f..def262fb776 100644 --- a/official/vision/modeling/factory_test.py +++ b/official/vision/modeling/factory_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.configs import backbones from official.vision.configs import backbones_3d @@ -38,13 +38,13 @@ class ClassificationModelBuilderTest(parameterized.TestCase, tf.test.TestCase): ) def test_builder(self, backbone_type, input_size, weight_decay): num_classes = 2 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model_config = classification_cfg.ImageClassificationModel( num_classes=num_classes, backbone=backbones.Backbone(type=backbone_type)) l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) _ = factory.build_classification_model( input_specs=input_specs, model_config=model_config, @@ -59,12 +59,12 @@ class MaskRCNNBuilderTest(parameterized.TestCase, tf.test.TestCase): ) def test_builder(self, backbone_type, input_size): num_classes = 2 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) model_config = maskrcnn_cfg.MaskRCNN( num_classes=num_classes, backbone=backbones.Backbone(type=backbone_type)) - l2_regularizer = tf.keras.regularizers.l2(5e-5) + l2_regularizer = tf_keras.regularizers.l2(5e-5) _ = factory.build_maskrcnn( input_specs=input_specs, model_config=model_config, @@ -79,7 +79,7 @@ class RetinaNetBuilderTest(parameterized.TestCase, tf.test.TestCase): ) def test_builder(self, backbone_type, input_size, has_att_heads): num_classes = 2 - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], 3]) if has_att_heads: attribute_heads_config = [ @@ -94,7 +94,7 @@ def test_builder(self, backbone_type, input_size, has_att_heads): backbone=backbones.Backbone(type=backbone_type), head=retinanet_cfg.RetinaNetHead( attribute_heads=attribute_heads_config)) - l2_regularizer = tf.keras.regularizers.l2(5e-5) + l2_regularizer = tf_keras.regularizers.l2(5e-5) _ = factory.build_retinanet( input_specs=input_specs, model_config=model_config, @@ -132,12 +132,12 @@ class VideoClassificationModelBuilderTest(parameterized.TestCase, ('resnet_3d', (None, None, None), 5e-5), ) def test_builder(self, backbone_type, input_size, weight_decay): - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, input_size[0], input_size[1], input_size[2], 3]) model_config = video_classification_cfg.VideoClassificationModel( backbone=backbones_3d.Backbone3D(type=backbone_type)) l2_regularizer = ( - tf.keras.regularizers.l2(weight_decay) if weight_decay else None) + tf_keras.regularizers.l2(weight_decay) if weight_decay else None) _ = factory_3d.build_video_classification_model( input_specs=input_specs, model_config=model_config, diff --git a/official/vision/modeling/heads/dense_prediction_heads.py b/official/vision/modeling/heads/dense_prediction_heads.py index b070b894111..f3f1d03f3ac 100644 --- a/official/vision/modeling/heads/dense_prediction_heads.py +++ b/official/vision/modeling/heads/dense_prediction_heads.py @@ -19,13 +19,13 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class RetinaNetHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RetinaNetHead(tf_keras.layers.Layer): """Creates a RetinaNet head.""" def __init__( @@ -43,8 +43,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, num_params_per_anchor: int = 4, share_level_convs: bool = True, **kwargs, @@ -75,9 +75,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. num_params_per_anchor: Number of parameters required to specify an anchor box. For example, `num_params_per_anchor` would be 4 for axis-aligned anchor boxes specified by their y-centers, x-centers, heights, and @@ -108,7 +108,7 @@ def __init__( 'share_level_convs': share_level_convs, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -123,7 +123,7 @@ def __init__( } if not self._config_dict['use_separable_conv']: self._conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal(stddev=0.01), + 'kernel_initializer': tf_keras.initializers.RandomNormal(stddev=0.01), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) @@ -145,7 +145,7 @@ def __init__( } if not self._config_dict['use_separable_conv']: self._classifier_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal(stddev=1e-5), + 'kernel_initializer': tf_keras.initializers.RandomNormal(stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) @@ -161,7 +161,7 @@ def __init__( } if not self._config_dict['use_separable_conv']: self._box_regressor_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal(stddev=1e-5), + 'kernel_initializer': tf_keras.initializers.RandomNormal(stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) @@ -225,7 +225,7 @@ def _init_attribute_kwargs(self): if not self._config_dict['use_separable_conv']: att_predictor_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=1e-5 ), 'kernel_regularizer': self._config_dict['kernel_regularizer'], @@ -377,14 +377,14 @@ def _build_attribute_net(self, conv_op, bn_op): def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the head.""" conv_op = ( - tf.keras.layers.SeparableConv2D + tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D + else tf_keras.layers.Conv2D ) bn_op = ( - tf.keras.layers.experimental.SyncBatchNormalization + tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization + else tf_keras.layers.BatchNormalization ) # Class net. @@ -493,8 +493,8 @@ def from_config(cls, config): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') -class RPNHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RPNHead(tf_keras.layers.Layer): """Creates a Region Proposal Network (RPN) head.""" def __init__( @@ -509,8 +509,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a Region Proposal Network head. @@ -531,9 +531,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(RPNHead, self).__init__(**kwargs) @@ -552,7 +552,7 @@ def __init__( 'bias_regularizer': bias_regularizer, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -560,9 +560,9 @@ def __init__( def build(self, input_shape): """Creates the variables of the head.""" - conv_op = (tf.keras.layers.SeparableConv2D + conv_op = (tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D) + else tf_keras.layers.Conv2D) conv_kwargs = { 'filters': self._config_dict['num_filters'], 'kernel_size': 3, @@ -572,13 +572,13 @@ def build(self, input_shape): } if not self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=0.01), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) - bn_op = (tf.keras.layers.experimental.SyncBatchNormalization + bn_op = (tf_keras.layers.experimental.SyncBatchNormalization if self._config_dict['use_sync_bn'] - else tf.keras.layers.BatchNormalization) + else tf_keras.layers.BatchNormalization) bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -610,7 +610,7 @@ def build(self, input_shape): } if not self._config_dict['use_separable_conv']: classifier_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) @@ -625,7 +625,7 @@ def build(self, input_shape): } if not self._config_dict['use_separable_conv']: box_regressor_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.RandomNormal( + 'kernel_initializer': tf_keras.initializers.RandomNormal( stddev=1e-5), 'kernel_regularizer': self._config_dict['kernel_regularizer'], }) diff --git a/official/vision/modeling/heads/dense_prediction_heads_test.py b/official/vision/modeling/heads/dense_prediction_heads_test.py index b5338c190f9..19f6064c01d 100644 --- a/official/vision/modeling/heads/dense_prediction_heads_test.py +++ b/official/vision/modeling/heads/dense_prediction_heads_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from official.vision.modeling.heads import dense_prediction_heads diff --git a/official/vision/modeling/heads/instance_heads.py b/official/vision/modeling/heads/instance_heads.py index 9062bcbf69b..ba6e1a071ed 100644 --- a/official/vision/modeling/heads/instance_heads.py +++ b/official/vision/modeling/heads/instance_heads.py @@ -16,13 +16,13 @@ from typing import List, Union, Optional # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -@tf.keras.utils.register_keras_serializable(package='Vision') -class DetectionHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DetectionHead(tf_keras.layers.Layer): """Creates a detection head.""" def __init__( @@ -38,8 +38,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a detection head. @@ -63,9 +63,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(DetectionHead, self).__init__(**kwargs) @@ -85,7 +85,7 @@ def __init__( 'bias_regularizer': bias_regularizer, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -93,9 +93,9 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the head.""" - conv_op = (tf.keras.layers.SeparableConv2D + conv_op = (tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D) + else tf_keras.layers.Conv2D) conv_kwargs = { 'filters': self._config_dict['num_filters'], 'kernel_size': 3, @@ -103,9 +103,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -114,13 +114,13 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): }) else: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], 'bias_regularizer': self._config_dict['bias_regularizer'], }) - bn_op = tf.keras.layers.BatchNormalization + bn_op = tf_keras.layers.BatchNormalization bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -144,9 +144,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): for i in range(self._config_dict['num_fcs']): fc_name = 'detection-fc_{}'.format(i) self._fcs.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self._config_dict['fc_dims'], - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=1 / 3.0, mode='fan_out', distribution='uniform'), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], @@ -154,9 +154,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): bn_name = 'detection-fc-bn_{}'.format(i) self._fc_norms.append(bn_op(name=bn_name, **bn_kwargs)) - self._classifier = tf.keras.layers.Dense( + self._classifier = tf_keras.layers.Dense( units=self._config_dict['num_classes'], - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], @@ -164,9 +164,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): num_box_outputs = (4 if self._config_dict['class_agnostic_bbox_pred'] else self._config_dict['num_classes'] * 4) - self._box_regressor = tf.keras.layers.Dense( + self._box_regressor = tf_keras.layers.Dense( units=num_box_outputs, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.001), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.001), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], @@ -218,8 +218,8 @@ def from_config(cls, config): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') -class MaskHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MaskHead(tf_keras.layers.Layer): """Creates a mask head.""" def __init__( @@ -233,8 +233,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, class_agnostic: bool = False, **kwargs): """Initializes a mask head. @@ -255,9 +255,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. class_agnostic: A `bool`. If set, we use a single channel mask head that is shared between all classes. **kwargs: Additional keyword arguments to be passed. @@ -278,7 +278,7 @@ def __init__( 'class_agnostic': class_agnostic } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -286,9 +286,9 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the head.""" - conv_op = (tf.keras.layers.SeparableConv2D + conv_op = (tf_keras.layers.SeparableConv2D if self._config_dict['use_separable_conv'] - else tf.keras.layers.Conv2D) + else tf_keras.layers.Conv2D) conv_kwargs = { 'filters': self._config_dict['num_filters'], 'kernel_size': 3, @@ -296,9 +296,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -307,13 +307,13 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): }) else: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], 'bias_regularizer': self._config_dict['bias_regularizer'], }) - bn_op = tf.keras.layers.BatchNormalization + bn_op = tf_keras.layers.BatchNormalization bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -334,12 +334,12 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): bn_name = 'mask-conv-bn_{}'.format(i) self._conv_norms.append(bn_op(name=bn_name, **bn_kwargs)) - self._deconv = tf.keras.layers.Conv2DTranspose( + self._deconv = tf_keras.layers.Conv2DTranspose( filters=self._config_dict['num_filters'], kernel_size=self._config_dict['upsample_factor'], strides=self._config_dict['upsample_factor'], padding='valid', - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], @@ -359,9 +359,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): } if self._config_dict['use_separable_conv']: conv_kwargs.update({ - 'depthwise_initializer': tf.keras.initializers.VarianceScaling( + 'depthwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), - 'pointwise_initializer': tf.keras.initializers.VarianceScaling( + 'pointwise_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'depthwise_regularizer': self._config_dict['kernel_regularizer'], @@ -370,7 +370,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): }) else: conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], diff --git a/official/vision/modeling/heads/instance_heads_test.py b/official/vision/modeling/heads/instance_heads_test.py index 84bc78e6828..ab4443ed788 100644 --- a/official/vision/modeling/heads/instance_heads_test.py +++ b/official/vision/modeling/heads/instance_heads_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.heads import instance_heads diff --git a/official/vision/modeling/heads/segmentation_heads.py b/official/vision/modeling/heads/segmentation_heads.py index 3904f6c69ca..261601fc5ef 100644 --- a/official/vision/modeling/heads/segmentation_heads.py +++ b/official/vision/modeling/heads/segmentation_heads.py @@ -14,14 +14,14 @@ """Contains definitions of segmentation heads.""" from typing import List, Union, Optional, Mapping, Tuple, Any -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.modeling.layers import nn_layers from official.vision.ops import spatial_transform_ops -class MaskScoring(tf.keras.Model): +class MaskScoring(tf_keras.Model): """Creates a mask scoring layer. This implements mask scoring layer from the paper: @@ -44,8 +44,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes mask scoring layer. @@ -64,9 +64,9 @@ def __init__( norm_momentum: A float for the momentum in BatchNorm. Defaults to 0.99. norm_epsilon: A float for the epsilon value in BatchNorm. Defaults to 0.001. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(MaskScoring, self).__init__(**kwargs) @@ -87,7 +87,7 @@ def __init__( 'bias_regularizer': bias_regularizer, } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -95,20 +95,20 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the mask scoring head.""" - conv_op = tf.keras.layers.Conv2D + conv_op = tf_keras.layers.Conv2D conv_kwargs = { 'filters': self._config_dict['num_filters'], 'kernel_size': 3, 'padding': 'same', } conv_kwargs.update({ - 'kernel_initializer': tf.keras.initializers.VarianceScaling( + 'kernel_initializer': tf_keras.initializers.VarianceScaling( scale=2, mode='fan_out', distribution='untruncated_normal'), 'bias_initializer': tf.zeros_initializer(), 'kernel_regularizer': self._config_dict['kernel_regularizer'], 'bias_regularizer': self._config_dict['bias_regularizer'], }) - bn_op = tf.keras.layers.BatchNormalization + bn_op = tf_keras.layers.BatchNormalization bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -121,12 +121,12 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): for i in range(self._config_dict['num_convs']): if self._config_dict['use_depthwise_convolution']: self._convs.append( - tf.keras.layers.DepthwiseConv2D( + tf_keras.layers.DepthwiseConv2D( name='mask-scoring-depthwise-conv-{}'.format(i), kernel_size=3, padding='same', use_bias=False, - depthwise_initializer=tf.keras.initializers.RandomNormal( + depthwise_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), depthwise_regularizer=self._config_dict['kernel_regularizer'], depth_multiplier=1)) @@ -147,9 +147,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): for i in range(self._config_dict['num_fcs']): fc_name = 'mask-scoring-fc-{}'.format(i) self._fcs.append( - tf.keras.layers.Dense( + tf_keras.layers.Dense( units=self._config_dict['fc_dims'], - kernel_initializer=tf.keras.initializers.VarianceScaling( + kernel_initializer=tf_keras.initializers.VarianceScaling( scale=1 / 3.0, mode='fan_out', distribution='uniform'), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], @@ -157,9 +157,9 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): bn_name = 'mask-scoring-fc-bn-{}'.format(i) self._fc_norms.append(bn_op(name=bn_name, **bn_kwargs)) - self._classifier = tf.keras.layers.Dense( + self._classifier = tf_keras.layers.Dense( units=self._config_dict['num_classes'], - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), bias_initializer=tf.zeros_initializer(), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer'], @@ -211,8 +211,8 @@ def from_config(cls, config, custom_objects=None): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') -class SegmentationHead(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SegmentationHead(tf_keras.layers.Layer): """Creates a segmentation head.""" def __init__( @@ -235,8 +235,8 @@ def __init__( use_sync_bn: bool = False, norm_momentum: float = 0.99, norm_epsilon: float = 0.001, - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a segmentation head. @@ -284,9 +284,9 @@ def __init__( normalization across different replicas. norm_momentum: A `float` of normalization momentum for the moving average. norm_epsilon: A `float` added to variance to avoid dividing by zero. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. """ super(SegmentationHead, self).__init__(**kwargs) @@ -313,7 +313,7 @@ def __init__( 'kernel_regularizer': kernel_regularizer, 'bias_regularizer': bias_regularizer } - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -322,8 +322,8 @@ def __init__( def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): """Creates the variables of the segmentation head.""" use_depthwise_convolution = self._config_dict['use_depthwise_convolution'] - conv_op = tf.keras.layers.Conv2D - bn_op = tf.keras.layers.BatchNormalization + conv_op = tf_keras.layers.Conv2D + bn_op = tf_keras.layers.BatchNormalization bn_kwargs = { 'axis': self._bn_axis, 'momentum': self._config_dict['norm_momentum'], @@ -338,7 +338,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): kernel_size=1, padding='same', use_bias=False, - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], name='segmentation_head_deeplabv3p_fusion_conv', filters=self._config_dict['low_level_num_filters']) @@ -363,12 +363,12 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): for i in range(self._config_dict['num_convs']): if use_depthwise_convolution: self._convs.append( - tf.keras.layers.DepthwiseConv2D( + tf_keras.layers.DepthwiseConv2D( name='segmentation_head_depthwise_conv_{}'.format(i), kernel_size=3, padding='same', use_bias=False, - depthwise_initializer=tf.keras.initializers.RandomNormal( + depthwise_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), depthwise_regularizer=self._config_dict['kernel_regularizer'], depth_multiplier=1)) @@ -382,7 +382,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): kernel_size=3 if not use_depthwise_convolution else 1, padding='same', use_bias=False, - kernel_initializer=tf.keras.initializers.RandomNormal( + kernel_initializer=tf_keras.initializers.RandomNormal( stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'])) norm_name = 'segmentation_head_norm_{}'.format(i) @@ -395,7 +395,7 @@ def build(self, input_shape: Union[tf.TensorShape, List[tf.TensorShape]]): padding='same', activation=self._config_dict['logit_activation'], bias_initializer=tf.zeros_initializer(), - kernel_initializer=tf.keras.initializers.RandomNormal(stddev=0.01), + kernel_initializer=tf_keras.initializers.RandomNormal(stddev=0.01), kernel_regularizer=self._config_dict['kernel_regularizer'], bias_regularizer=self._config_dict['bias_regularizer']) @@ -441,7 +441,7 @@ def call(self, inputs: Tuple[Union[tf.Tensor, Mapping[str, tf.Tensor]], if self._config_dict['feature_fusion'] == 'deeplabv3plus': x = tf.concat([x, y], axis=self._bn_axis) else: - x = tf.keras.layers.Add()([x, y]) + x = tf_keras.layers.Add()([x, y]) elif self._config_dict['feature_fusion'] == 'pyramid_fusion': if not isinstance(decoder_output, dict): raise ValueError('Only support dictionary decoder_output.') diff --git a/official/vision/modeling/heads/segmentation_heads_test.py b/official/vision/modeling/heads/segmentation_heads_test.py index 3f76b4df15c..0b19adde5e7 100644 --- a/official/vision/modeling/heads/segmentation_heads_test.py +++ b/official/vision/modeling/heads/segmentation_heads_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.heads import segmentation_heads diff --git a/official/vision/modeling/layers/box_sampler.py b/official/vision/modeling/layers/box_sampler.py index 5ced7cf2512..2b40e415424 100644 --- a/official/vision/modeling/layers/box_sampler.py +++ b/official/vision/modeling/layers/box_sampler.py @@ -15,13 +15,13 @@ """Contains definitions of box sampler.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import sampling_ops -@tf.keras.utils.register_keras_serializable(package='Vision') -class BoxSampler(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BoxSampler(tf_keras.layers.Layer): """Creates a BoxSampler to sample positive and negative boxes.""" def __init__(self, diff --git a/official/vision/modeling/layers/deeplab.py b/official/vision/modeling/layers/deeplab.py index 23a77553a21..1767085ec10 100644 --- a/official/vision/modeling/layers/deeplab.py +++ b/official/vision/modeling/layers/deeplab.py @@ -14,12 +14,12 @@ """Layers for DeepLabV3.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils -class SpatialPyramidPooling(tf.keras.layers.Layer): +class SpatialPyramidPooling(tf_keras.layers.Layer): """Implements the Atrous Spatial Pyramid Pooling. References: @@ -79,10 +79,10 @@ def __init__( self.batchnorm_epsilon = batchnorm_epsilon self.activation = activation self.dropout = dropout - self.kernel_initializer = tf.keras.initializers.get(kernel_initializer) - self.kernel_regularizer = tf.keras.regularizers.get(kernel_regularizer) + self.kernel_initializer = tf_keras.initializers.get(kernel_initializer) + self.kernel_regularizer = tf_keras.regularizers.get(kernel_regularizer) self.interpolation = interpolation - self.input_spec = tf.keras.layers.InputSpec(ndim=4) + self.input_spec = tf_keras.layers.InputSpec(ndim=4) self.pool_kernel_size = pool_kernel_size self.use_depthwise_convolution = use_depthwise_convolution @@ -90,15 +90,15 @@ def build(self, input_shape): channels = input_shape[3] self.aspp_layers = [] - bn_op = tf.keras.layers.BatchNormalization + bn_op = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': bn_axis = -1 else: bn_axis = 1 - conv_sequential = tf.keras.Sequential([ - tf.keras.layers.Conv2D( + conv_sequential = tf_keras.Sequential([ + tf_keras.layers.Conv2D( filters=self.output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer( @@ -110,7 +110,7 @@ def build(self, input_shape): momentum=self.batchnorm_momentum, epsilon=self.batchnorm_epsilon, synchronized=self.use_sync_bn), - tf.keras.layers.Activation(self.activation) + tf_keras.layers.Activation(self.activation) ]) self.aspp_layers.append(conv_sequential) @@ -119,7 +119,7 @@ def build(self, input_shape): kernel_size = (3, 3) if self.use_depthwise_convolution: leading_layers += [ - tf.keras.layers.DepthwiseConv2D( + tf_keras.layers.DepthwiseConv2D( depth_multiplier=1, kernel_size=kernel_size, padding='same', @@ -127,8 +127,8 @@ def build(self, input_shape): use_bias=False) ] kernel_size = (1, 1) - conv_sequential = tf.keras.Sequential(leading_layers + [ - tf.keras.layers.Conv2D( + conv_sequential = tf_keras.Sequential(leading_layers + [ + tf_keras.layers.Conv2D( filters=self.output_channels, kernel_size=kernel_size, padding='same', @@ -142,21 +142,21 @@ def build(self, input_shape): momentum=self.batchnorm_momentum, epsilon=self.batchnorm_epsilon, synchronized=self.use_sync_bn), - tf.keras.layers.Activation(self.activation) + tf_keras.layers.Activation(self.activation) ]) self.aspp_layers.append(conv_sequential) if self.pool_kernel_size is None: - pool_sequential = tf.keras.Sequential([ - tf.keras.layers.GlobalAveragePooling2D(), - tf.keras.layers.Reshape((1, 1, channels))]) + pool_sequential = tf_keras.Sequential([ + tf_keras.layers.GlobalAveragePooling2D(), + tf_keras.layers.Reshape((1, 1, channels))]) else: - pool_sequential = tf.keras.Sequential([ - tf.keras.layers.AveragePooling2D(self.pool_kernel_size)]) + pool_sequential = tf_keras.Sequential([ + tf_keras.layers.AveragePooling2D(self.pool_kernel_size)]) pool_sequential.add( - tf.keras.Sequential([ - tf.keras.layers.Conv2D( + tf_keras.Sequential([ + tf_keras.layers.Conv2D( filters=self.output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer( @@ -168,13 +168,13 @@ def build(self, input_shape): momentum=self.batchnorm_momentum, epsilon=self.batchnorm_epsilon, synchronized=self.use_sync_bn), - tf.keras.layers.Activation(self.activation) + tf_keras.layers.Activation(self.activation) ])) self.aspp_layers.append(pool_sequential) - self.projection = tf.keras.Sequential([ - tf.keras.layers.Conv2D( + self.projection = tf_keras.Sequential([ + tf_keras.layers.Conv2D( filters=self.output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer( @@ -186,13 +186,13 @@ def build(self, input_shape): momentum=self.batchnorm_momentum, epsilon=self.batchnorm_epsilon, synchronized=self.use_sync_bn), - tf.keras.layers.Activation(self.activation), - tf.keras.layers.Dropout(rate=self.dropout) + tf_keras.layers.Activation(self.activation), + tf_keras.layers.Dropout(rate=self.dropout) ]) def call(self, inputs, training=None): if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() result = [] for i, layer in enumerate(self.aspp_layers): x = layer(inputs, training=training) @@ -214,9 +214,9 @@ def get_config(self): 'batchnorm_epsilon': self.batchnorm_epsilon, 'activation': self.activation, 'dropout': self.dropout, - 'kernel_initializer': tf.keras.initializers.serialize( + 'kernel_initializer': tf_keras.initializers.serialize( self.kernel_initializer), - 'kernel_regularizer': tf.keras.regularizers.serialize( + 'kernel_regularizer': tf_keras.regularizers.serialize( self.kernel_regularizer), 'interpolation': self.interpolation, } diff --git a/official/vision/modeling/layers/deeplab_test.py b/official/vision/modeling/layers/deeplab_test.py index a8fc5b91321..4cfb45cc370 100644 --- a/official/vision/modeling/layers/deeplab_test.py +++ b/official/vision/modeling/layers/deeplab_test.py @@ -15,7 +15,7 @@ """Tests for ASPP.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import deeplab @@ -28,7 +28,7 @@ class DeeplabTest(tf.test.TestCase, parameterized.TestCase): ) def test_aspp(self, pool_kernel_size): del pool_kernel_size - inputs = tf.keras.Input(shape=(64, 64, 128), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64, 128), dtype=tf.float32) layer = deeplab.SpatialPyramidPooling(output_channels=256, dilation_rates=[6, 12, 18], pool_kernel_size=None) @@ -36,7 +36,7 @@ def test_aspp(self, pool_kernel_size): self.assertAllEqual([None, 64, 64, 256], output.shape) def test_aspp_invalid_shape(self): - inputs = tf.keras.Input(shape=(64, 64), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64), dtype=tf.float32) layer = deeplab.SpatialPyramidPooling(output_channels=256, dilation_rates=[6, 12, 18]) with self.assertRaises(ValueError): diff --git a/official/vision/modeling/layers/detection_generator.py b/official/vision/modeling/layers/detection_generator.py index 3e0886432cc..746eb646fac 100644 --- a/official/vision/modeling/layers/detection_generator.py +++ b/official/vision/modeling/layers/detection_generator.py @@ -19,7 +19,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import edgetpu from official.vision.ops import box_ops @@ -897,8 +897,8 @@ def dummy_post_processing(input_boxes, input_scores, input_anchors): return dummy_post_processing(boxes, scores, anchors)[::-1] -@tf.keras.utils.register_keras_serializable(package='Vision') -class DetectionGenerator(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DetectionGenerator(tf_keras.layers.Layer): """Generates the final detected boxes with scores and classes.""" def __init__( @@ -1109,8 +1109,8 @@ def from_config(cls, config): return cls(**config) -@tf.keras.utils.register_keras_serializable(package='Vision') -class MultilevelDetectionGenerator(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MultilevelDetectionGenerator(tf_keras.layers.Layer): """Generates detected boxes with scores and classes for one-stage detector.""" def __init__( diff --git a/official/vision/modeling/layers/detection_generator_test.py b/official/vision/modeling/layers/detection_generator_test.py index 758c04aa763..8da3ca7fb88 100644 --- a/official/vision/modeling/layers/detection_generator_test.py +++ b/official/vision/modeling/layers/detection_generator_test.py @@ -17,7 +17,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import detection_generator from official.vision.ops import anchor diff --git a/official/vision/modeling/layers/edgetpu.py b/official/vision/modeling/layers/edgetpu.py index b9ebd32bbe9..7e72986433e 100644 --- a/official/vision/modeling/layers/edgetpu.py +++ b/official/vision/modeling/layers/edgetpu.py @@ -16,7 +16,7 @@ from typing import List, Optional, Union, Iterable, Sequence import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras _or = tf.maximum _and = tf.minimum diff --git a/official/vision/modeling/layers/edgetpu_test.py b/official/vision/modeling/layers/edgetpu_test.py index 086c48b26d1..bf831bd81e5 100644 --- a/official/vision/modeling/layers/edgetpu_test.py +++ b/official/vision/modeling/layers/edgetpu_test.py @@ -18,7 +18,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import edgetpu @@ -169,10 +169,10 @@ def test_sharded_match(self, shape: list[int], top: int): ([20, 20, 200], 10, _stright_nms, False)) def test_sharded_size(self, shape: list[int], top: int, algorithm, fits_as_is: bool): - scores = tf.keras.Input(shape=shape, batch_size=1) - boxes = tf.keras.Input(shape=shape + [4], batch_size=1) + scores = tf_keras.Input(shape=shape, batch_size=1) + boxes = tf_keras.Input(shape=shape + [4], batch_size=1) optimized = algorithm(boxes, scores, top) - model = tf.keras.Model(inputs=[boxes, scores], outputs=optimized) + model = tf_keras.Model(inputs=[boxes, scores], outputs=optimized) max_size = _maximum_activation_size(model) if fits_as_is: # Sharding done or not needed. diff --git a/official/vision/modeling/layers/mask_sampler.py b/official/vision/modeling/layers/mask_sampler.py index 8755a1fcf7a..551fc15e845 100644 --- a/official/vision/modeling/layers/mask_sampler.py +++ b/official/vision/modeling/layers/mask_sampler.py @@ -15,7 +15,7 @@ """Contains definitions of mask sampler.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import spatial_transform_ops @@ -100,8 +100,8 @@ def _sample_and_crop_foreground_masks(candidate_rois: tf.Tensor, return foreground_rois, foreground_classes, cropped_foreground_masks -@tf.keras.utils.register_keras_serializable(package='Vision') -class MaskSampler(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MaskSampler(tf_keras.layers.Layer): """Samples and creates mask training targets.""" def __init__(self, mask_target_size: int, num_sampled_masks: int, **kwargs): diff --git a/official/vision/modeling/layers/nn_blocks.py b/official/vision/modeling/layers/nn_blocks.py index 549faf458d3..2808b351384 100644 --- a/official/vision/modeling/layers/nn_blocks.py +++ b/official/vision/modeling/layers/nn_blocks.py @@ -18,7 +18,7 @@ # Import libraries from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.nlp import modeling as nlp_modeling @@ -53,8 +53,8 @@ def _maybe_downsample(x: tf.Tensor, out_filter: int, strides: int, return x + 0. -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResidualBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResidualBlock(tf_keras.layers.Layer): """A residual block.""" def __init__(self, @@ -92,9 +92,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_explicit_padding: Use 'VALID' padding for convolutions, but prepad @@ -123,9 +123,9 @@ def __init__(self, self._norm_epsilon = norm_epsilon self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -134,7 +134,7 @@ def __init__(self, def build(self, input_shape): if self._use_projection: - self._shortcut = tf.keras.layers.Conv2D( + self._shortcut = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=1, strides=self._strides, @@ -154,10 +154,10 @@ def build(self, input_shape): conv1_padding = 'same' # explicit padding here is added for centernet if self._use_explicit_padding: - self._pad = tf.keras.layers.ZeroPadding2D(padding=(1, 1)) + self._pad = tf_keras.layers.ZeroPadding2D(padding=(1, 1)) conv1_padding = 'valid' - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -174,7 +174,7 @@ def build(self, input_shape): synchronized=self._use_sync_bn, ) - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=1, @@ -256,8 +256,8 @@ def call(self, inputs, training=None): return self._activation_fn(x + shortcut) -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckBlock(tf_keras.layers.Layer): """A standard bottleneck block.""" def __init__(self, @@ -296,9 +296,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -324,9 +324,9 @@ def __init__(self, self._norm_epsilon = norm_epsilon self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -335,9 +335,9 @@ def __init__(self, def build(self, input_shape): if self._use_projection: if self._resnetd_shortcut: - self._shortcut0 = tf.keras.layers.AveragePooling2D( + self._shortcut0 = tf_keras.layers.AveragePooling2D( pool_size=2, strides=self._strides, padding='same') - self._shortcut1 = tf.keras.layers.Conv2D( + self._shortcut1 = tf_keras.layers.Conv2D( filters=self._filters * 4, kernel_size=1, strides=1, @@ -347,7 +347,7 @@ def build(self, input_shape): kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer) else: - self._shortcut = tf.keras.layers.Conv2D( + self._shortcut = tf_keras.layers.Conv2D( filters=self._filters * 4, kernel_size=1, strides=self._strides, @@ -365,7 +365,7 @@ def build(self, input_shape): synchronized=self._use_sync_bn, ) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=1, strides=1, @@ -383,7 +383,7 @@ def build(self, input_shape): self._activation1 = tf_utils.get_activation( self._activation, use_keras_layer=True) - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=3, strides=self._strides, @@ -403,7 +403,7 @@ def build(self, input_shape): self._activation2 = tf_utils.get_activation( self._activation, use_keras_layer=True) - self._conv3 = tf.keras.layers.Conv2D( + self._conv3 = tf_keras.layers.Conv2D( filters=self._filters * 4, kernel_size=1, strides=1, @@ -438,7 +438,7 @@ def build(self, input_shape): self._stochastic_depth_drop_rate) else: self._stochastic_depth = None - self._add = tf.keras.layers.Add() + self._add = tf_keras.layers.Add() super(BottleneckBlock, self).build(input_shape) @@ -494,8 +494,8 @@ def call(self, inputs, training=None): return self._activation3(x) -@tf.keras.utils.register_keras_serializable(package='Vision') -class InvertedBottleneckBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class InvertedBottleneckBlock(tf_keras.layers.Layer): """An inverted bottleneck block.""" def __init__(self, @@ -540,9 +540,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. se_inner_activation: A `str` name of squeeze-excitation inner activation. @@ -598,9 +598,9 @@ def __init__(self, self._bias_regularizer = bias_regularizer self._expand_se_in_filters = expand_se_in_filters self._output_intermediate_endpoints = output_intermediate_endpoints - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -621,7 +621,7 @@ def build(self, input_shape): expand_kernel = 1 if self._use_depthwise else self._kernel_size expand_stride = 1 if self._use_depthwise else self._strides - self._conv0 = tf.keras.layers.Conv2D( + self._conv0 = tf_keras.layers.Conv2D( filters=expand_filters, kernel_size=expand_kernel, strides=expand_stride, @@ -642,7 +642,7 @@ def build(self, input_shape): if self._use_depthwise: # Depthwise conv. - self._conv1 = tf.keras.layers.DepthwiseConv2D( + self._conv1 = tf_keras.layers.DepthwiseConv2D( kernel_size=(self._kernel_size, self._kernel_size), strides=self._strides, padding='same', @@ -684,7 +684,7 @@ def build(self, input_shape): self._squeeze_excitation = None # Last 1x1 conv. - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._out_filters, kernel_size=1, strides=1, @@ -705,7 +705,7 @@ def build(self, input_shape): self._stochastic_depth_drop_rate) else: self._stochastic_depth = None - self._add = tf.keras.layers.Add() + self._add = tf_keras.layers.Add() super(InvertedBottleneckBlock, self).build(input_shape) @@ -774,8 +774,8 @@ def call(self, inputs, training=None): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class ResidualInner(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ResidualInner(tf_keras.layers.Layer): """Creates a single inner block of a residual. This corresponds to `F`/`G` functions in the RevNet paper: @@ -789,8 +789,8 @@ def __init__( filters: int, strides: int, kernel_initializer: Union[str, Callable[ - ..., tf.keras.initializers.Initializer]] = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + ..., tf_keras.initializers.Initializer]] = 'VarianceScaling', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, activation: Union[str, Callable[..., tf.Tensor]] = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -802,9 +802,9 @@ def __init__( Args: filters: An `int` of output filter size. strides: An `int` of stride size for convolution for the residual block. - kernel_initializer: A `str` or `tf.keras.initializers.Initializer` + kernel_initializer: A `str` or `tf_keras.initializers.Initializer` instance for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` for Conv2D. + kernel_regularizer: A `tf_keras.regularizers.Regularizer` for Conv2D. activation: A `str` or `callable` instance of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. norm_momentum: A `float` of normalization momentum for the moving average. @@ -817,16 +817,16 @@ def __init__( self.strides = strides self.filters = filters - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) self._kernel_regularizer = kernel_regularizer - self._activation = tf.keras.activations.get(activation) + self._activation = tf_keras.activations.get(activation) self._use_sync_bn = use_sync_bn self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon self._batch_norm_first = batch_norm_first - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -841,7 +841,7 @@ def build(self, input_shape: tf.TensorShape): synchronized=self._use_sync_bn, ) - self._conv2d_1 = tf.keras.layers.Conv2D( + self._conv2d_1 = tf_keras.layers.Conv2D( filters=self.filters, kernel_size=3, strides=self.strides, @@ -857,7 +857,7 @@ def build(self, input_shape: tf.TensorShape): synchronized=self._use_sync_bn, ) - self._conv2d_2 = tf.keras.layers.Conv2D( + self._conv2d_2 = tf_keras.layers.Conv2D( filters=self.filters, kernel_size=3, strides=1, @@ -898,8 +898,8 @@ def call(self, return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckResidualInner(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckResidualInner(tf_keras.layers.Layer): """Creates a single inner block of a bottleneck. This corresponds to `F`/`G` functions in the RevNet paper: @@ -913,8 +913,8 @@ def __init__( filters: int, strides: int, kernel_initializer: Union[str, Callable[ - ..., tf.keras.initializers.Initializer]] = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + ..., tf_keras.initializers.Initializer]] = 'VarianceScaling', + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, activation: Union[str, Callable[..., tf.Tensor]] = 'relu', use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -928,9 +928,9 @@ def __init__( and thus the number of output channels from the bottlneck block is `4*filters` strides: An `int` of stride size for convolution for the residual block. - kernel_initializer: A `str` or `tf.keras.initializers.Initializer` + kernel_initializer: A `str` or `tf_keras.initializers.Initializer` instance for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` for Conv2D. + kernel_regularizer: A `tf_keras.regularizers.Regularizer` for Conv2D. activation: A `str` or `callable` instance of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. norm_momentum: A `float` of normalization momentum for the moving average. @@ -943,16 +943,16 @@ def __init__( self.strides = strides self.filters = filters - self._kernel_initializer = tf.keras.initializers.get(kernel_initializer) + self._kernel_initializer = tf_keras.initializers.get(kernel_initializer) self._kernel_regularizer = kernel_regularizer - self._activation = tf.keras.activations.get(activation) + self._activation = tf_keras.activations.get(activation) self._use_sync_bn = use_sync_bn self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon self._batch_norm_first = batch_norm_first - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -966,7 +966,7 @@ def build(self, input_shape: tf.TensorShape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn, ) - self._conv2d_1 = tf.keras.layers.Conv2D( + self._conv2d_1 = tf_keras.layers.Conv2D( filters=self.filters, kernel_size=1, strides=self.strides, @@ -980,7 +980,7 @@ def build(self, input_shape: tf.TensorShape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn, ) - self._conv2d_2 = tf.keras.layers.Conv2D( + self._conv2d_2 = tf_keras.layers.Conv2D( filters=self.filters, kernel_size=3, strides=1, @@ -994,7 +994,7 @@ def build(self, input_shape: tf.TensorShape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn, ) - self._conv2d_3 = tf.keras.layers.Conv2D( + self._conv2d_3 = tf_keras.layers.Conv2D( filters=self.filters * 4, kernel_size=1, strides=1, @@ -1040,8 +1040,8 @@ def call(self, return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class ReversibleLayer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ReversibleLayer(tf_keras.layers.Layer): """Creates a reversible layer. Computes y1 = x1 + f(x2), y2 = x2 + g(y1), where f and g can be arbitrary @@ -1049,21 +1049,21 @@ class ReversibleLayer(tf.keras.layers.Layer): """ def __init__(self, - f: tf.keras.layers.Layer, - g: tf.keras.layers.Layer, + f: tf_keras.layers.Layer, + g: tf_keras.layers.Layer, manual_grads: bool = True, **kwargs): """Initializes a ReversibleLayer. Args: - f: A `tf.keras.layers.Layer` instance of `f` inner block referred to in + f: A `tf_keras.layers.Layer` instance of `f` inner block referred to in paper. Each reversible layer consists of two inner functions. For example, in RevNet the reversible residual consists of two f/g inner (bottleneck) residual functions. Where the input to the reversible layer is x, the input gets partitioned in the channel dimension and the forward pass follows (eq8): x = [x1; x2], z1 = x1 + f(x2), y2 = x2 + g(z1), y1 = stop_gradient(z1). - g: A `tf.keras.layers.Layer` instance of `g` inner block referred to in + g: A `tf_keras.layers.Layer` instance of `g` inner block referred to in paper. Detailed explanation same as above as `f` arg. manual_grads: A `bool` [Testing Only] of whether to manually take gradients as in Algorithm 1 or defer to autograd. @@ -1075,7 +1075,7 @@ def __init__(self, self._g = g self._manual_grads = manual_grads - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._axis = -1 else: self._axis = 1 @@ -1216,8 +1216,8 @@ def grad_fn( return activations -@tf.keras.utils.register_keras_serializable(package='Vision') -class DepthwiseSeparableConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DepthwiseSeparableConvBlock(tf_keras.layers.Layer): """Creates a depthwise separable convolution block with batch normalization. """ @@ -1229,7 +1229,7 @@ def __init__( regularize_depthwise=False, activation: Text = 'relu6', kernel_initializer: Text = 'VarianceScaling', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, dilation_rate: int = 1, use_sync_bn: bool = False, norm_momentum: float = 0.99, @@ -1249,7 +1249,7 @@ def __init__( activation: A `str` name of the activation function. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. dilation_rate: An `int` or tuple/list of 2 `int`, specifying the dilation rate to use for dilated convolution. Can be a single integer to specify @@ -1271,9 +1271,9 @@ def __init__( self._use_sync_bn = use_sync_bn self._norm_momentum = norm_momentum self._norm_epsilon = norm_epsilon - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -1300,7 +1300,7 @@ def get_config(self): def build(self, input_shape): - self._dwconv0 = tf.keras.layers.DepthwiseConv2D( + self._dwconv0 = tf_keras.layers.DepthwiseConv2D( kernel_size=self._kernel_size, strides=self._strides, padding='same', @@ -1316,7 +1316,7 @@ def build(self, input_shape): synchronized=self._use_sync_bn, ) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=self._filters, kernel_size=1, strides=1, @@ -1343,8 +1343,8 @@ def call(self, inputs, training=None): return self._activation_fn(x) -@tf.keras.utils.register_keras_serializable(package='Vision') -class TuckerConvBlock(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class TuckerConvBlock(tf_keras.layers.Layer): """An Tucker block (generalized bottleneck).""" def __init__(self, @@ -1381,9 +1381,9 @@ def __init__(self, the stochastic depth layer. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -1413,9 +1413,9 @@ def __init__(self, self._norm_epsilon = norm_epsilon self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -1426,7 +1426,7 @@ def build(self, input_shape): divisor=self._divisible_by, round_down_protect=False) - self._conv0 = tf.keras.layers.Conv2D( + self._conv0 = tf_keras.layers.Conv2D( filters=input_compressed_filters, kernel_size=1, strides=1, @@ -1449,7 +1449,7 @@ def build(self, input_shape): divisor=self._divisible_by, round_down_protect=False) - self._conv1 = tf.keras.layers.Conv2D( + self._conv1 = tf_keras.layers.Conv2D( filters=output_compressed_filters, kernel_size=self._kernel_size, strides=self._strides, @@ -1468,7 +1468,7 @@ def build(self, input_shape): self._activation, use_keras_layer=True) # Last 1x1 conv. - self._conv2 = tf.keras.layers.Conv2D( + self._conv2 = tf_keras.layers.Conv2D( filters=self._out_filters, kernel_size=1, strides=1, @@ -1489,7 +1489,7 @@ def build(self, input_shape): self._stochastic_depth_drop_rate) else: self._stochastic_depth = None - self._add = tf.keras.layers.Add() + self._add = tf_keras.layers.Add() super(TuckerConvBlock, self).build(input_shape) @@ -1538,8 +1538,8 @@ def call(self, inputs, training=None): return x -@tf.keras.utils.register_keras_serializable(package='Vision') -class LayerScale(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class LayerScale(tf_keras.layers.Layer): """LayerScale as introduced in CaiT: https://arxiv.org/abs/2103.17239. Attributes: @@ -1557,7 +1557,7 @@ def build(self, inputs_shape): self.gamma = self.add_weight( name='layerscale_gamma', shape=gamma_shape, - initializer=tf.keras.initializers.Constant(self.gamma_init_value), + initializer=tf_keras.initializers.Constant(self.gamma_init_value), trainable=True, dtype=tf.float32, ) @@ -1567,7 +1567,7 @@ def call(self, inputs, inputs_positions=None): return tf.cast(self.gamma, inputs.dtype) * inputs -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class TransformerEncoderBlock(nlp_modeling.layers.TransformerEncoderBlock): """TransformerEncoderBlock layer with stochastic depth and layerscale.""" @@ -1736,7 +1736,7 @@ def call(self, inputs, output_range=None, training=None): return layer_output -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') class TransformerScaffold(nlp_modeling.layers.TransformerScaffold): """TransformerScaffold layer for vision applications.""" diff --git a/official/vision/modeling/layers/nn_blocks_3d.py b/official/vision/modeling/layers/nn_blocks_3d.py index 6940cc9c82c..7887dfe0ddb 100644 --- a/official/vision/modeling/layers/nn_blocks_3d.py +++ b/official/vision/modeling/layers/nn_blocks_3d.py @@ -14,14 +14,14 @@ """Contains common building blocks for 3D networks.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.modeling.layers import nn_layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class SelfGating(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SelfGating(tf_keras.layers.Layer): """Feature gating as used in S3D-G. This implements the S3D-G network from: @@ -42,14 +42,14 @@ def __init__(self, filters, **kwargs): self._filters = filters def build(self, input_shape): - self._spatial_temporal_average = tf.keras.layers.GlobalAveragePooling3D() + self._spatial_temporal_average = tf_keras.layers.GlobalAveragePooling3D() # No BN and activation after conv. - self._transformer_w = tf.keras.layers.Conv3D( + self._transformer_w = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=[1, 1, 1], use_bias=True, - kernel_initializer=tf.keras.initializers.TruncatedNormal( + kernel_initializer=tf_keras.initializers.TruncatedNormal( mean=0.0, stddev=0.01)) super(SelfGating, self).build(input_shape) @@ -67,8 +67,8 @@ def call(self, inputs): return tf.math.multiply(x, inputs) -@tf.keras.utils.register_keras_serializable(package='Vision') -class BottleneckBlock3D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class BottleneckBlock3D(tf_keras.layers.Layer): """Creates a 3D bottleneck block.""" def __init__(self, @@ -104,9 +104,9 @@ def __init__(self, use_self_gating: A `bool` of whether to apply self-gating module or not. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. use_sync_bn: A `bool`. If True, use synchronized batch normalization. @@ -130,22 +130,22 @@ def __init__(self, self._norm_epsilon = norm_epsilon self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - self._norm = tf.keras.layers.BatchNormalization + self._norm = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + 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): - self._shortcut_maxpool = tf.keras.layers.MaxPool3D( + self._shortcut_maxpool = tf_keras.layers.MaxPool3D( pool_size=[1, 1, 1], strides=[ self._temporal_strides, self._spatial_strides, self._spatial_strides ]) - self._shortcut_conv = tf.keras.layers.Conv3D( + self._shortcut_conv = tf_keras.layers.Conv3D( filters=4 * self._filters, kernel_size=1, strides=[ @@ -161,7 +161,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn) - self._temporal_conv = tf.keras.layers.Conv3D( + self._temporal_conv = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=[self._temporal_kernel_size, 1, 1], strides=[self._temporal_strides, 1, 1], @@ -176,7 +176,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn) - self._spatial_conv = tf.keras.layers.Conv3D( + self._spatial_conv = tf_keras.layers.Conv3D( filters=self._filters, kernel_size=[1, 3, 3], strides=[1, self._spatial_strides, self._spatial_strides], @@ -191,7 +191,7 @@ def build(self, input_shape): epsilon=self._norm_epsilon, synchronized=self._use_sync_bn) - self._expand_conv = tf.keras.layers.Conv3D( + self._expand_conv = tf_keras.layers.Conv3D( filters=4 * self._filters, kernel_size=[1, 1, 1], strides=[1, 1, 1], diff --git a/official/vision/modeling/layers/nn_blocks_3d_test.py b/official/vision/modeling/layers/nn_blocks_3d_test.py index 732e05cedea..dbb03af2e5e 100644 --- a/official/vision/modeling/layers/nn_blocks_3d_test.py +++ b/official/vision/modeling/layers/nn_blocks_3d_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import nn_blocks_3d @@ -34,7 +34,7 @@ def test_bottleneck_block_creation(self, block_fn, temporal_kernel_size, temporal_size = 16 spatial_size = 128 filters = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(temporal_size, spatial_size, spatial_size, filters * 4), batch_size=1) block = block_fn( diff --git a/official/vision/modeling/layers/nn_blocks_test.py b/official/vision/modeling/layers/nn_blocks_test.py index e9f6f39a112..0db5bee8dd8 100644 --- a/official/vision/modeling/layers/nn_blocks_test.py +++ b/official/vision/modeling/layers/nn_blocks_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -48,7 +48,7 @@ def test_residual_block_creation(self, block_fn, strides, use_projection, stochastic_depth_drop_rate, se_ratio): input_size = 128 filter_size = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, filter_size), batch_size=1) block = block_fn( filter_size, @@ -98,8 +98,8 @@ def test_layerscale_training(self): layer_scale = nn_blocks.LayerScale(init_values) # Define optimizer and loss function - optimizer = tf.keras.optimizers.Adam() - loss_fn = tf.keras.losses.MeanSquaredError() + optimizer = tf_keras.optimizers.Adam() + loss_fn = tf_keras.losses.MeanSquaredError() # Train the model for one step with tf.GradientTape() as tape: @@ -120,7 +120,7 @@ def test_bottleneck_block_creation(self, block_fn, strides, use_projection, stochastic_depth_drop_rate, se_ratio): input_size = 128 filter_size = 256 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, filter_size * 4), batch_size=1) block = block_fn( filter_size, @@ -148,7 +148,7 @@ def test_invertedbottleneck_block_creation(self, block_fn, expand_ratio, input_size = 128 in_filters = 24 out_filters = 40 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, in_filters), batch_size=1) block = block_fn( in_filters=in_filters, @@ -173,7 +173,7 @@ def test_tucker_conv_block(self, block_fn, strides, input_compression_ratio, input_size = 128 in_filters = 24 out_filters = 24 - inputs = tf.keras.Input( + inputs = tf_keras.Input( shape=(input_size, input_size, in_filters), batch_size=1) block = block_fn( in_filters=in_filters, @@ -265,7 +265,7 @@ def test_downsampling_non_reversible_step(self, distribution): filters=filters // 2, strides=1, batch_norm_first=True) test_layer = nn_blocks.ReversibleLayer(f, g) test_layer.build(input_tensor.shape) - optimizer = tf.keras.optimizers.SGD(learning_rate=0.01) + optimizer = tf_keras.optimizers.SGD(learning_rate=0.01) @tf.function def step_fn(): @@ -300,7 +300,7 @@ def test_reversible_step(self, distribution): filters=filters // 2, strides=1, batch_norm_first=False) test_layer = nn_blocks.ReversibleLayer(f, g) test_layer(input_tensor, training=False) # init weights - optimizer = tf.keras.optimizers.SGD(learning_rate=0.01) + optimizer = tf_keras.optimizers.SGD(learning_rate=0.01) @tf.function def step_fn(): @@ -352,7 +352,7 @@ def test_manual_gradients_correctness(self, distribution): auto_grad_layer = nn_blocks.ReversibleLayer( f_auto, g_auto, manual_grads=False) auto_grad_layer(input_tensor) # init weights - # Clone all weights (tf.keras.layers.Layer has no .clone()) + # Clone all weights (tf_keras.layers.Layer has no .clone()) auto_grad_layer._f.set_weights(manual_grad_layer._f.get_weights()) auto_grad_layer._g.set_weights(manual_grad_layer._g.get_weights()) @@ -391,7 +391,7 @@ def auto_fn(): # at any point, the list passed to the config object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package='TestOnlyAttention') +@tf_keras.utils.register_keras_serializable(package='TestOnlyAttention') class ValidatedAttentionLayer(nn_layers.MultiHeadAttention): def __init__(self, call_list, **kwargs): @@ -422,8 +422,8 @@ def get_config(self): # at any point, the list passed to the config object will be filled with a # boolean 'True'. We register this class as a Keras serializable so we can # test serialization below. -@tf.keras.utils.register_keras_serializable(package='TestOnlyFeedforward') -class ValidatedFeedforwardLayer(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='TestOnlyFeedforward') +class ValidatedFeedforwardLayer(tf_keras.layers.Layer): def __init__(self, call_list, activation, **kwargs): super(ValidatedFeedforwardLayer, self).__init__(**kwargs) @@ -432,7 +432,7 @@ def __init__(self, call_list, activation, **kwargs): def build(self, input_shape): hidden_size = input_shape[-1] - self._feedforward_dense = tf.keras.layers.EinsumDense( + self._feedforward_dense = tf_keras.layers.EinsumDense( '...x,xy->...y', output_shape=hidden_size, bias_axes='y', @@ -454,7 +454,7 @@ class TransformerLayerTest(tf.test.TestCase, parameterized.TestCase): def tearDown(self): super(TransformerLayerTest, self).tearDown() - tf.keras.mixed_precision.set_global_policy('float32') + tf_keras.mixed_precision.set_global_policy('float32') @parameterized.parameters(None, 2) def test_layer_creation(self, max_attention_inference_parallelism): @@ -476,7 +476,7 @@ def test_layer_creation(self, max_attention_inference_parallelism): ) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -512,7 +512,7 @@ def test_layer_creation_with_feedforward_cls(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -543,9 +543,9 @@ def test_layer_creation_with_mask(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output_tensor.shape.as_list()) @@ -573,11 +573,11 @@ def test_layer_invocation(self, max_attention_inference_parallelism): max_attention_inference_parallelism=max_attention_inference_parallelism) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output_tensor = test_layer(data_tensor) # Create a model from the test layer. - model = tf.keras.Model(data_tensor, output_tensor) + model = tf_keras.Model(data_tensor, output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -617,13 +617,13 @@ def test_layer_invocation_with_feedforward_cls(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -661,13 +661,13 @@ def test_layer_invocation_with_mask(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -685,7 +685,7 @@ def test_layer_invocation_with_mask(self): self.assertTrue(call_list[0], "The passed layer class wasn't instantiated.") def test_layer_invocation_with_float16_dtype(self): - tf.keras.mixed_precision.set_global_policy('mixed_float16') + tf_keras.mixed_precision.set_global_policy('mixed_float16') sequence_length = 21 width = 80 @@ -703,13 +703,13 @@ def test_layer_invocation_with_float16_dtype(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -742,10 +742,10 @@ def test_transform_with_initializer(self): num_attention_heads=10, inner_dim=2048, inner_activation='relu', - kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)) + kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02)) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) output = test_layer(data_tensor) # The default output of a transformer layer should be the same as the input. self.assertEqual(data_tensor.shape.as_list(), output.shape.as_list()) @@ -773,13 +773,13 @@ def test_layer_restoration_from_config(self): inner_activation='relu') # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -798,7 +798,7 @@ def test_layer_restoration_from_config(self): # Create a new model from the old config, and copy the weights. These models # should have identical outputs. - new_model = tf.keras.Model.from_config(serialized_data) + new_model = tf_keras.Model.from_config(serialized_data) new_model.set_weights(model.get_weights()) output = new_model.predict([input_data, mask_data]) @@ -839,13 +839,13 @@ def test_layer_with_feedforward_cls_restoration_from_config(self): inner_activation=None) # Create a 3-dimensional input (the first dimension is implicit). - data_tensor = tf.keras.Input(shape=(sequence_length, width)) + data_tensor = tf_keras.Input(shape=(sequence_length, width)) # Create a 2-dimensional input (the first dimension is implicit). - mask_tensor = tf.keras.Input(shape=(sequence_length, sequence_length)) + mask_tensor = tf_keras.Input(shape=(sequence_length, sequence_length)) output_tensor = test_layer([data_tensor, mask_tensor]) # Create a model from the test layer. - model = tf.keras.Model([data_tensor, mask_tensor], output_tensor) + model = tf_keras.Model([data_tensor, mask_tensor], output_tensor) # Invoke the model on test data. We can't validate the output data itself # (the NN is too complex) but this will rule out structural runtime errors. @@ -861,7 +861,7 @@ def test_layer_with_feedforward_cls_restoration_from_config(self): serialized_data = model.get_config() # Create a new model from the old config, and copy the weights. These models # should have identical outputs. - new_model = tf.keras.Model.from_config(serialized_data) + new_model = tf_keras.Model.from_config(serialized_data) new_model.set_weights(model.get_weights()) output = new_model.predict([input_data, mask_data]) diff --git a/official/vision/modeling/layers/nn_layers.py b/official/vision/modeling/layers/nn_layers.py index 604ce7f1ce7..c299df0a88a 100644 --- a/official/vision/modeling/layers/nn_layers.py +++ b/official/vision/modeling/layers/nn_layers.py @@ -17,7 +17,7 @@ from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.modeling import tf_utils from official.vision.ops import spatial_transform_ops @@ -85,8 +85,8 @@ def get_padding_for_kernel_size(kernel_size): kernel_size)) -@tf.keras.utils.register_keras_serializable(package='Vision') -class SqueezeExcitation(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SqueezeExcitation(tf_keras.layers.Layer): """Creates a squeeze and excitation layer.""" def __init__(self, @@ -114,9 +114,9 @@ def __init__(self, use_3d_input: A `bool` of whether input is 2D or 3D image. kernel_initializer: A `str` of kernel_initializer for convolutional layers. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default to None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2d. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2d. Default to None. activation: A `str` name of the activation function. gating_activation: A `str` name of the activation function for final @@ -138,7 +138,7 @@ def __init__(self, self._kernel_initializer = kernel_initializer self._kernel_regularizer = kernel_regularizer self._bias_regularizer = bias_regularizer - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': if not use_3d_input: self._spatial_axis = [1, 2] else: @@ -157,7 +157,7 @@ def build(self, input_shape): divisor=self._divisible_by, round_down_protect=self._round_down_protect) - self._se_reduce = tf.keras.layers.Conv2D( + self._se_reduce = tf_keras.layers.Conv2D( filters=num_reduced_filters, kernel_size=1, strides=1, @@ -167,7 +167,7 @@ def build(self, input_shape): kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer) - self._se_expand = tf.keras.layers.Conv2D( + self._se_expand = tf_keras.layers.Conv2D( filters=self._out_filters, kernel_size=1, strides=1, @@ -223,8 +223,8 @@ def get_stochastic_depth_rate(init_rate, i, n): return rate -@tf.keras.utils.register_keras_serializable(package='Vision') -class StochasticDepth(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class StochasticDepth(tf_keras.layers.Layer): """Creates a stochastic depth layer.""" def __init__(self, stochastic_depth_drop_rate, **kwargs): @@ -247,7 +247,7 @@ def get_config(self): def call(self, inputs, training=None): if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() if not training or self._drop_rate is None or self._drop_rate == 0: return inputs @@ -261,7 +261,7 @@ def call(self, inputs, training=None): return output -@tf.keras.utils.register_keras_serializable(package='Vision') +@tf_keras.utils.register_keras_serializable(package='Vision') def pyramid_feature_fusion(inputs, target_level): """Fuses all feature maps in the feature pyramid at the target level. @@ -299,7 +299,7 @@ def pyramid_feature_fusion(inputs, target_level): return tf.math.add_n(resampled_feats) -class PanopticFPNFusion(tf.keras.Model): +class PanopticFPNFusion(tf_keras.Model): """Creates a Panoptic FPN feature Fusion layer. This implements feature fusion for semantic segmentation head from the paper: @@ -316,8 +316,8 @@ def __init__( num_filters: int = 128, num_fpn_filters: int = 256, activation: str = 'relu', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes panoptic FPN feature fusion layer. @@ -329,9 +329,9 @@ def __init__( num_filters: An `int` number of filters in conv2d layers. num_fpn_filters: An `int` number of filters in the FPN outputs activation: A `str` name of the activation function. - kernel_regularizer: A `tf.keras.regularizers.Regularizer` object for + kernel_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. Default is None. - bias_regularizer: A `tf.keras.regularizers.Regularizer` object for Conv2D. + bias_regularizer: A `tf_keras.regularizers.Regularizer` object for Conv2D. **kwargs: Additional keyword arguments to be passed. Returns: A `float` `tf.Tensor` of shape [batch_size, feature_height, feature_width, @@ -350,10 +350,10 @@ def __init__( 'kernel_regularizer': kernel_regularizer, 'bias_regularizer': bias_regularizer, } - norm = tf.keras.layers.GroupNormalization - conv2d = tf.keras.layers.Conv2D + norm = tf_keras.layers.GroupNormalization + conv2d = tf_keras.layers.Conv2D activation_fn = tf_utils.get_activation(activation) - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': norm_axis = -1 else: norm_axis = 1 @@ -368,7 +368,7 @@ def __init__( filters=num_filters, kernel_size=3, padding='same', - kernel_initializer=tf.keras.initializers.VarianceScaling(), + kernel_initializer=tf_keras.initializers.VarianceScaling(), kernel_regularizer=kernel_regularizer, bias_regularizer=bias_regularizer)(x) x = norm(groups=32, axis=norm_axis)(x) @@ -387,7 +387,7 @@ def _build_inputs(self, num_filters: int, min_level: int, max_level: int): inputs = {} for level in range(min_level, max_level + 1): - inputs[str(level)] = tf.keras.Input(shape=[None, None, num_filters]) + inputs[str(level)] = tf_keras.Input(shape=[None, None, num_filters]) return inputs def get_config(self) -> Mapping[str, Any]: @@ -403,8 +403,8 @@ def output_specs(self) -> Mapping[str, tf.TensorShape]: return self._output_specs -@tf.keras.utils.register_keras_serializable(package='Vision') -class Scale(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Scale(tf_keras.layers.Layer): """Scales the input by a trainable scalar weight. This is useful for applying ReZero to layers, which improves convergence @@ -415,14 +415,14 @@ class Scale(tf.keras.layers.Layer): def __init__( self, - initializer: tf.keras.initializers.Initializer = 'ones', - regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + initializer: tf_keras.initializers.Initializer = 'ones', + regularizer: Optional[tf_keras.regularizers.Regularizer] = None, **kwargs): """Initializes a scale layer. Args: initializer: A `str` of initializer for the scalar weight. - regularizer: A `tf.keras.regularizers.Regularizer` for the scalar weight. + regularizer: A `tf_keras.regularizers.Regularizer` for the scalar weight. **kwargs: Additional keyword arguments to be passed to this layer. Returns: @@ -456,8 +456,8 @@ def call(self, inputs): return scale * inputs -@tf.keras.utils.register_keras_serializable(package='Vision') -class TemporalSoftmaxPool(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class TemporalSoftmaxPool(tf_keras.layers.Layer): """Creates a network layer corresponding to temporal softmax pooling. This is useful for multi-class logits (used in e.g., Charades). Modified from @@ -479,8 +479,8 @@ def call(self, inputs): return outputs -@tf.keras.utils.register_keras_serializable(package='Vision') -class PositionalEncoding(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class PositionalEncoding(tf_keras.layers.Layer): """Creates a network layer that adds a sinusoidal positional encoding. Positional encoding is incremented across frames, and is added to the input. @@ -494,7 +494,7 @@ class PositionalEncoding(tf.keras.layers.Layer): """ def __init__(self, - initializer: tf.keras.initializers.Initializer = 'zeros', + initializer: tf_keras.initializers.Initializer = 'zeros', cache_encoding: bool = False, state_prefix: Optional[str] = None, **kwargs): @@ -597,7 +597,7 @@ def build(self, input_shape): Raises: ValueError: If using 'channels_first' data format. """ - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': raise ValueError('"channels_first" mode is unsupported.') if self._cache_encoding: @@ -647,8 +647,8 @@ def call( return (outputs, states) if output_states else outputs -@tf.keras.utils.register_keras_serializable(package='Vision') -class GlobalAveragePool3D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class GlobalAveragePool3D(tf_keras.layers.Layer): """Creates a global average pooling layer with causal mode. Implements causal mode, which runs a cumulative sum (with `tf.cumsum`) across @@ -716,7 +716,7 @@ def call(self, `[batch_size, num_frames, 1, 1, channels]` if `keepdims=True`. We keep the frame dimension in this case to simulate a cumulative global average as if we are inputting one frame at a time. If `causal=False`, the output - is equivalent to `tf.keras.layers.GlobalAveragePooling3D` with shape + is equivalent to `tf_keras.layers.GlobalAveragePooling3D` with shape `[batch_size, 1, 1, 1, channels]` if `keepdims=True` (plus the optional buffer stored in `states`). @@ -725,7 +725,7 @@ def call(self, """ states = dict(states) if states is not None else {} - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': raise ValueError('"channels_first" mode is unsupported.') # Shape: [batch_size, 1, 1, 1, channels] @@ -781,8 +781,8 @@ def call(self, return (x, states) if output_states else x -@tf.keras.utils.register_keras_serializable(package='Vision') -class SpatialAveragePool3D(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SpatialAveragePool3D(tf_keras.layers.Layer): """Creates a global average pooling layer pooling across spatial dimentions.""" def __init__(self, keepdims: bool = False, **kwargs): @@ -808,7 +808,7 @@ def get_config(self): def build(self, input_shape): """Builds the layer with the given input shape.""" - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': raise ValueError('"channels_first" mode is unsupported.') super(SpatialAveragePool3D, self).build(input_shape) @@ -824,7 +824,7 @@ def call(self, inputs, states=None, output_states: bool = False): class CausalConvMixin: - """Mixin class to implement CausalConv for `tf.keras.layers.Conv` layers.""" + """Mixin class to implement CausalConv for `tf_keras.layers.Conv` layers.""" @property def use_buffered_input(self) -> bool: @@ -852,7 +852,7 @@ def _compute_buffered_causal_padding(self, """ input_shape = tf.shape(inputs)[1:-1] - if tf.keras.backend.image_data_format() == 'channels_first': + if tf_keras.backend.image_data_format() == 'channels_first': raise ValueError('"channels_first" mode is unsupported.') kernel_size_effective = [ @@ -902,11 +902,11 @@ def _buffered_spatial_output_shape(self, spatial_output_shape: List[int]): return spatial_output_shape -@tf.keras.utils.register_keras_serializable(package='Vision') -class Conv2D(tf.keras.layers.Conv2D, CausalConvMixin): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Conv2D(tf_keras.layers.Conv2D, CausalConvMixin): """Conv2D layer supporting CausalConv. - Supports `padding='causal'` option (like in `tf.keras.layers.Conv1D`), + Supports `padding='causal'` option (like in `tf_keras.layers.Conv1D`), which applies causal padding to the temporal dimension, and same padding in the spatial dimensions. """ @@ -950,11 +950,11 @@ def _spatial_output_shape(self, spatial_input_shape: List[int]): return self._buffered_spatial_output_shape(shape) -@tf.keras.utils.register_keras_serializable(package='Vision') -class DepthwiseConv2D(tf.keras.layers.DepthwiseConv2D, CausalConvMixin): +@tf_keras.utils.register_keras_serializable(package='Vision') +class DepthwiseConv2D(tf_keras.layers.DepthwiseConv2D, CausalConvMixin): """DepthwiseConv2D layer supporting CausalConv. - Supports `padding='causal'` option (like in `tf.keras.layers.Conv1D`), + Supports `padding='causal'` option (like in `tf_keras.layers.Conv1D`), which applies causal padding to the temporal dimension, and same padding in the spatial dimensions. """ @@ -1012,11 +1012,11 @@ def _spatial_output_shape(self, spatial_input_shape: List[int]): return self._buffered_spatial_output_shape(shape) -@tf.keras.utils.register_keras_serializable(package='Vision') -class Conv3D(tf.keras.layers.Conv3D, CausalConvMixin): +@tf_keras.utils.register_keras_serializable(package='Vision') +class Conv3D(tf_keras.layers.Conv3D, CausalConvMixin): """Conv3D layer supporting CausalConv. - Supports `padding='causal'` option (like in `tf.keras.layers.Conv1D`), + Supports `padding='causal'` option (like in `tf_keras.layers.Conv1D`), which applies causal padding to the temporal dimension, and same padding in the spatial dimensions. """ @@ -1068,8 +1068,8 @@ def _spatial_output_shape(self, spatial_input_shape: List[int]): return self._buffered_spatial_output_shape(shape) -@tf.keras.utils.register_keras_serializable(package='Vision') -class SpatialPyramidPooling(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SpatialPyramidPooling(tf_keras.layers.Layer): """Implements the Atrous Spatial Pyramid Pooling. References: @@ -1090,7 +1090,7 @@ def __init__( activation: str = 'relu', dropout: float = 0.5, kernel_initializer: str = 'GlorotUniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, interpolation: str = 'bilinear', use_depthwise_convolution: bool = False, **kwargs): @@ -1135,9 +1135,9 @@ def __init__( self._pool_kernel_size = pool_kernel_size self._use_depthwise_convolution = use_depthwise_convolution self._activation_fn = tf_utils.get_activation(activation) - self._bn_op = tf.keras.layers.BatchNormalization + self._bn_op = tf_keras.layers.BatchNormalization - if tf.keras.backend.image_data_format() == 'channels_last': + if tf_keras.backend.image_data_format() == 'channels_last': self._bn_axis = -1 else: self._bn_axis = 1 @@ -1149,7 +1149,7 @@ def build(self, input_shape): self.aspp_layers = [] - conv1 = tf.keras.layers.Conv2D( + conv1 = tf_keras.layers.Conv2D( filters=self._output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), @@ -1168,7 +1168,7 @@ def build(self, input_shape): kernel_size = (3, 3) if self._use_depthwise_convolution: leading_layers += [ - tf.keras.layers.DepthwiseConv2D( + tf_keras.layers.DepthwiseConv2D( depth_multiplier=1, kernel_size=kernel_size, padding='same', @@ -1180,7 +1180,7 @@ def build(self, input_shape): ] kernel_size = (1, 1) conv_dilation = leading_layers + [ - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( filters=self._output_channels, kernel_size=kernel_size, padding='same', @@ -1200,13 +1200,13 @@ def build(self, input_shape): if self._pool_kernel_size is None: pooling = [ - tf.keras.layers.GlobalAveragePooling2D(), - tf.keras.layers.Reshape((1, 1, channels)) + tf_keras.layers.GlobalAveragePooling2D(), + tf_keras.layers.Reshape((1, 1, channels)) ] else: - pooling = [tf.keras.layers.AveragePooling2D(self._pool_kernel_size)] + pooling = [tf_keras.layers.AveragePooling2D(self._pool_kernel_size)] - conv2 = tf.keras.layers.Conv2D( + conv2 = tf_keras.layers.Conv2D( filters=self._output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer(self._kernel_initializer), @@ -1220,11 +1220,11 @@ def build(self, input_shape): self.aspp_layers.append(pooling + [conv2, norm2]) - self._resizing_layer = tf.keras.layers.Resizing( + self._resizing_layer = tf_keras.layers.Resizing( height, width, interpolation=self._interpolation, dtype=tf.float32) self._projection = [ - tf.keras.layers.Conv2D( + tf_keras.layers.Conv2D( filters=self._output_channels, kernel_size=(1, 1), kernel_initializer=tf_utils.clone_initializer( @@ -1237,14 +1237,14 @@ def build(self, input_shape): epsilon=self._batchnorm_epsilon, synchronized=self._use_sync_bn) ] - self._dropout_layer = tf.keras.layers.Dropout(rate=self._dropout) - self._concat_layer = tf.keras.layers.Concatenate(axis=-1) + self._dropout_layer = tf_keras.layers.Dropout(rate=self._dropout) + self._concat_layer = tf_keras.layers.Concatenate(axis=-1) def call(self, inputs: tf.Tensor, training: Optional[bool] = None) -> tf.Tensor: if training is None: - training = tf.keras.backend.learning_phase() + training = tf_keras.backend.learning_phase() result = [] for i, layers in enumerate(self.aspp_layers): x = inputs @@ -1282,8 +1282,8 @@ def get_config(self): return dict(list(base_config.items()) + list(config.items())) -@tf.keras.utils.register_keras_serializable(package='Vision') -class MultiHeadAttention(tf.keras.layers.MultiHeadAttention): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MultiHeadAttention(tf_keras.layers.MultiHeadAttention): """MultiHeadAttention layer. This is an implementation of multi-headed attention as described in the paper diff --git a/official/vision/modeling/layers/nn_layers_test.py b/official/vision/modeling/layers/nn_layers_test.py index a20b0605577..29700997376 100644 --- a/official/vision/modeling/layers/nn_layers_test.py +++ b/official/vision/modeling/layers/nn_layers_test.py @@ -16,7 +16,7 @@ # Import libraries from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import nn_layers @@ -24,7 +24,7 @@ class NNLayersTest(parameterized.TestCase, tf.test.TestCase): def test_scale(self): - scale = nn_layers.Scale(initializer=tf.keras.initializers.constant(10.)) + scale = nn_layers.Scale(initializer=tf_keras.initializers.constant(10.)) output = scale(3.) self.assertAllEqual(output, 30.) @@ -118,7 +118,7 @@ def test_positional_encoding_stream(self): def test_global_average_pool_keras(self): pool = nn_layers.GlobalAveragePool3D(keepdims=False) - keras_pool = tf.keras.layers.GlobalAveragePooling3D() + keras_pool = tf_keras.layers.GlobalAveragePooling3D() inputs = 10 * tf.random.normal([1, 2, 3, 4, 1]) @@ -343,7 +343,7 @@ def test_conv3d_causal_padding_2d(self): use_bias=False, ) - keras_conv3d = tf.keras.layers.Conv3D( + keras_conv3d = tf_keras.layers.Conv3D( filters=1, kernel_size=(1, 3, 3), strides=(1, 2, 2), @@ -378,7 +378,7 @@ def test_conv3d_causal_padding_1d(self): use_bias=False, ) - keras_conv1d = tf.keras.layers.Conv1D( + keras_conv1d = tf_keras.layers.Conv1D( filters=1, kernel_size=3, strides=2, @@ -406,7 +406,7 @@ def test_conv3d_causal_padding_1d(self): ([32, 32], [6, 12, 18]), ) def test_aspp(self, pool_kernel_size, dilation_rates): - inputs = tf.keras.Input(shape=(64, 64, 128), dtype=tf.float32) + inputs = tf_keras.Input(shape=(64, 64, 128), dtype=tf.float32) layer = nn_layers.SpatialPyramidPooling( output_channels=256, dilation_rates=dilation_rates, @@ -422,8 +422,8 @@ def test_multi_head_attention(self, max_inference_parallelism): max_inference_parallelism=max_inference_parallelism, ) # Create a 3-dimensional input (the first dimension is implicit). - query = tf.keras.Input(shape=(40, 80)) - value = tf.keras.Input(shape=(20, 80)) + query = tf_keras.Input(shape=(40, 80)) + value = tf_keras.Input(shape=(20, 80)) output = layer(query=query, value=value) self.assertEqual(output.shape.as_list(), [None, 40, 80]) diff --git a/official/vision/modeling/layers/roi_aligner.py b/official/vision/modeling/layers/roi_aligner.py index e966cddd57d..588b90cea0a 100644 --- a/official/vision/modeling/layers/roi_aligner.py +++ b/official/vision/modeling/layers/roi_aligner.py @@ -15,13 +15,13 @@ """Contains definitions of ROI aligner.""" from typing import Mapping -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import spatial_transform_ops -@tf.keras.utils.register_keras_serializable(package='Vision') -class MultilevelROIAligner(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MultilevelROIAligner(tf_keras.layers.Layer): """Performs ROIAlign for the second stage processing.""" def __init__(self, crop_size: int = 7, sample_offset: float = 0.5, **kwargs): diff --git a/official/vision/modeling/layers/roi_aligner_test.py b/official/vision/modeling/layers/roi_aligner_test.py index 4030c8b9265..f43e0f02c65 100644 --- a/official/vision/modeling/layers/roi_aligner_test.py +++ b/official/vision/modeling/layers/roi_aligner_test.py @@ -15,7 +15,7 @@ """Tests for roi_aligner.py.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import roi_aligner diff --git a/official/vision/modeling/layers/roi_generator.py b/official/vision/modeling/layers/roi_generator.py index 01476b97482..ed5840a7745 100644 --- a/official/vision/modeling/layers/roi_generator.py +++ b/official/vision/modeling/layers/roi_generator.py @@ -15,7 +15,7 @@ """Contains definitions of ROI generator.""" from typing import Optional, Mapping # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops from official.vision.ops import nms @@ -176,8 +176,8 @@ def _multilevel_propose_rois(raw_boxes: Mapping[str, tf.Tensor], return selected_rois, selected_roi_scores -@tf.keras.utils.register_keras_serializable(package='Vision') -class MultilevelROIGenerator(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MultilevelROIGenerator(tf_keras.layers.Layer): """Proposes RoIs for the second stage processing.""" def __init__(self, diff --git a/official/vision/modeling/layers/roi_sampler.py b/official/vision/modeling/layers/roi_sampler.py index fced46ef55f..1111908e118 100644 --- a/official/vision/modeling/layers/roi_sampler.py +++ b/official/vision/modeling/layers/roi_sampler.py @@ -15,7 +15,7 @@ """Contains definitions of ROI sampler.""" from typing import Optional, Tuple, Union # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling.layers import box_sampler from official.vision.ops import box_matcher @@ -28,8 +28,8 @@ Tuple[tf.Tensor, tf.Tensor, tf.Tensor, tf.Tensor, tf.Tensor]] -@tf.keras.utils.register_keras_serializable(package='Vision') -class ROISampler(tf.keras.layers.Layer): +@tf_keras.utils.register_keras_serializable(package='Vision') +class ROISampler(tf_keras.layers.Layer): """Samples ROIs and assigns targets to the sampled ROIs.""" def __init__(self, diff --git a/official/vision/modeling/maskrcnn_model.py b/official/vision/modeling/maskrcnn_model.py index 0e2aa89387e..8f1e628d413 100644 --- a/official/vision/modeling/maskrcnn_model.py +++ b/official/vision/modeling/maskrcnn_model.py @@ -16,30 +16,30 @@ from typing import Any, List, Mapping, Optional, Tuple, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import anchor from official.vision.ops import box_ops -@tf.keras.utils.register_keras_serializable(package='Vision') -class MaskRCNNModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class MaskRCNNModel(tf_keras.Model): """The Mask R-CNN(-RS) and Cascade RCNN-RS models.""" def __init__(self, - backbone: tf.keras.Model, - decoder: tf.keras.Model, - rpn_head: tf.keras.layers.Layer, - detection_head: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_generator: tf.keras.layers.Layer, - roi_sampler: Union[tf.keras.layers.Layer, - List[tf.keras.layers.Layer]], - roi_aligner: tf.keras.layers.Layer, - detection_generator: tf.keras.layers.Layer, - mask_head: Optional[tf.keras.layers.Layer] = None, - mask_sampler: Optional[tf.keras.layers.Layer] = None, - mask_roi_aligner: Optional[tf.keras.layers.Layer] = None, + backbone: tf_keras.Model, + decoder: tf_keras.Model, + rpn_head: tf_keras.layers.Layer, + detection_head: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_generator: tf_keras.layers.Layer, + roi_sampler: Union[tf_keras.layers.Layer, + List[tf_keras.layers.Layer]], + roi_aligner: tf_keras.layers.Layer, + detection_generator: tf_keras.layers.Layer, + mask_head: Optional[tf_keras.layers.Layer] = None, + mask_sampler: Optional[tf_keras.layers.Layer] = None, + mask_roi_aligner: Optional[tf_keras.layers.Layer] = None, class_agnostic_bbox_pred: bool = False, cascade_class_ensemble: bool = False, min_level: Optional[int] = None, @@ -52,8 +52,8 @@ def __init__(self, """Initializes the R-CNN(-RS) model. Args: - backbone: `tf.keras.Model`, the backbone network. - decoder: `tf.keras.Model`, the decoder network. + backbone: `tf_keras.Model`, the backbone network. + decoder: `tf_keras.Model`, the decoder network. rpn_head: the RPN head. detection_head: the detection head or a list of heads. roi_generator: the ROI generator. @@ -487,7 +487,7 @@ def _features_to_mask_outputs(self, features, rois, roi_classes): @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict( backbone=self.backbone, diff --git a/official/vision/modeling/maskrcnn_model_test.py b/official/vision/modeling/maskrcnn_model_test.py index eebfbf67705..f889559af4a 100644 --- a/official/vision/modeling/maskrcnn_model_test.py +++ b/official/vision/modeling/maskrcnn_model_test.py @@ -18,7 +18,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -187,7 +187,7 @@ def test_forward(self, strategy, include_mask, build_anchor_boxes, training, anchor_boxes = None num_anchors_per_location = len(aspect_ratios) * num_scales - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, 3]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, 3]) backbone = resnet.ResNet(model_id=50, input_specs=input_specs) decoder = fpn.FPN( min_level=min_level, @@ -292,7 +292,7 @@ def test_forward(self, strategy, include_mask, build_anchor_boxes, training, (True,), ) def test_serialize_deserialize(self, include_mask): - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, 3]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, 3]) backbone = resnet.ResNet(model_id=50, input_specs=input_specs) decoder = fpn.FPN( min_level=3, max_level=7, input_specs=backbone.output_specs) @@ -344,7 +344,7 @@ def test_serialize_deserialize(self, include_mask): (True,), ) def test_checkpoint(self, include_mask): - input_specs = tf.keras.layers.InputSpec(shape=[None, None, None, 3]) + input_specs = tf_keras.layers.InputSpec(shape=[None, None, None, 3]) backbone = resnet.ResNet(model_id=50, input_specs=input_specs) decoder = fpn.FPN( min_level=3, max_level=7, input_specs=backbone.output_specs) diff --git a/official/vision/modeling/retinanet_model.py b/official/vision/modeling/retinanet_model.py index 38f0cc8d5cc..05ec6fd0a33 100644 --- a/official/vision/modeling/retinanet_model.py +++ b/official/vision/modeling/retinanet_model.py @@ -16,20 +16,20 @@ from typing import Any, Mapping, List, Optional, Union, Sequence # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import anchor -@tf.keras.utils.register_keras_serializable(package='Vision') -class RetinaNetModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class RetinaNetModel(tf_keras.Model): """The RetinaNet model class.""" def __init__(self, - backbone: tf.keras.Model, - decoder: tf.keras.Model, - head: tf.keras.layers.Layer, - detection_generator: tf.keras.layers.Layer, + backbone: tf_keras.Model, + decoder: tf_keras.Model, + head: tf_keras.layers.Layer, + detection_generator: tf_keras.layers.Layer, min_level: Optional[int] = None, max_level: Optional[int] = None, num_scales: Optional[int] = None, @@ -39,8 +39,8 @@ def __init__(self, """Detection initialization function. Args: - backbone: `tf.keras.Model` a backbone network. - decoder: `tf.keras.Model` a decoder network. + backbone: `tf_keras.Model` a backbone network. + decoder: `tf_keras.Model` a decoder network. head: `RetinaNetHead`, the RetinaNet head. detection_generator: the detection generator. min_level: Minimum level in output feature maps. @@ -207,7 +207,7 @@ def _update_decoded_results(): @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.decoder is not None: @@ -216,19 +216,19 @@ def checkpoint_items( return items @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone @property - def decoder(self) -> tf.keras.Model: + def decoder(self) -> tf_keras.Model: return self._decoder @property - def head(self) -> tf.keras.layers.Layer: + def head(self) -> tf_keras.layers.Layer: return self._head @property - def detection_generator(self) -> tf.keras.layers.Layer: + def detection_generator(self) -> tf_keras.layers.Layer: return self._detection_generator def get_config(self) -> Mapping[str, Any]: diff --git a/official/vision/modeling/retinanet_model_test.py b/official/vision/modeling/retinanet_model_test.py index 828f092b8f8..ae72051460b 100644 --- a/official/vision/modeling/retinanet_model_test.py +++ b/official/vision/modeling/retinanet_model_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from tensorflow.python.distribute import combinations from tensorflow.python.distribute import strategy_combinations @@ -155,7 +155,7 @@ def test_build_model(self, use_separable_conv, build_anchor_boxes, def test_forward(self, strategy, image_size, training, has_att_heads, output_intermediate_features, soft_nms_sigma): """Test for creation of a R50-FPN RetinaNet.""" - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') num_classes = 3 min_level = 3 max_level = 7 diff --git a/official/vision/modeling/segmentation_model.py b/official/vision/modeling/segmentation_model.py index b370b9791ca..2bf45eae131 100644 --- a/official/vision/modeling/segmentation_model.py +++ b/official/vision/modeling/segmentation_model.py @@ -16,13 +16,13 @@ from typing import Any, Mapping, Union, Optional, Dict # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class SegmentationModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class SegmentationModel(tf_keras.Model): """A Segmentation class model. Input images are passed through backbone first. Decoder network is then @@ -34,9 +34,9 @@ class SegmentationModel(tf.keras.Model): different backbones, and decoders. """ - def __init__(self, backbone: tf.keras.Model, decoder: tf.keras.Model, - head: tf.keras.layers.Layer, - mask_scoring_head: Optional[tf.keras.layers.Layer] = None, + def __init__(self, backbone: tf_keras.Model, decoder: tf_keras.Model, + head: tf_keras.layers.Layer, + mask_scoring_head: Optional[tf_keras.layers.Layer] = None, **kwargs): """Segmentation initialization function. @@ -77,7 +77,7 @@ def call(self, inputs: tf.Tensor, training: bool = None # pytype: disable=signa @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" items = dict(backbone=self.backbone, head=self.head) if self.decoder is not None: diff --git a/official/vision/modeling/segmentation_model_test.py b/official/vision/modeling/segmentation_model_test.py index 44f02388208..2883b1ce0f5 100644 --- a/official/vision/modeling/segmentation_model_test.py +++ b/official/vision/modeling/segmentation_model_test.py @@ -16,7 +16,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling import backbones from official.vision.modeling import segmentation_model @@ -39,7 +39,7 @@ def test_segmentation_network_creation( """Test for creation of a segmentation network.""" num_classes = 10 inputs = np.random.rand(2, input_size, input_size, 3) - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.ResNet(model_id=50) decoder = fpn.FPN( diff --git a/official/vision/modeling/video_classification_model.py b/official/vision/modeling/video_classification_model.py index 947456c6ea6..15c8d233fbc 100644 --- a/official/vision/modeling/video_classification_model.py +++ b/official/vision/modeling/video_classification_model.py @@ -15,25 +15,25 @@ """Build video classification models.""" from typing import Any, Mapping, Optional, Union, List, Text -import tensorflow as tf +import tensorflow as tf, tf_keras -layers = tf.keras.layers +layers = tf_keras.layers -@tf.keras.utils.register_keras_serializable(package='Vision') -class VideoClassificationModel(tf.keras.Model): +@tf_keras.utils.register_keras_serializable(package='Vision') +class VideoClassificationModel(tf_keras.Model): """A video classification class builder.""" def __init__( self, - backbone: tf.keras.Model, + backbone: tf_keras.Model, num_classes: int, - input_specs: Optional[Mapping[str, tf.keras.layers.InputSpec]] = None, + input_specs: Optional[Mapping[str, tf_keras.layers.InputSpec]] = None, dropout_rate: float = 0.0, aggregate_endpoints: bool = False, kernel_initializer: str = 'random_uniform', - kernel_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, - bias_regularizer: Optional[tf.keras.regularizers.Regularizer] = None, + kernel_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, + bias_regularizer: Optional[tf_keras.regularizers.Regularizer] = None, require_endpoints: Optional[List[Text]] = None, **kwargs): """Video Classification initialization function. @@ -41,14 +41,14 @@ def __init__( Args: backbone: a 3d backbone network. num_classes: `int` number of classes in classification task. - input_specs: `tf.keras.layers.InputSpec` specs of the input tensor. + input_specs: `tf_keras.layers.InputSpec` specs of the input tensor. dropout_rate: `float` rate for dropout regularization. aggregate_endpoints: `bool` aggregate all end ponits or only use the final end point. kernel_initializer: kernel initializer for the dense layer. - kernel_regularizer: tf.keras.regularizers.Regularizer object. Default to + kernel_regularizer: tf_keras.regularizers.Regularizer object. Default to None. - bias_regularizer: tf.keras.regularizers.Regularizer object. Default to + bias_regularizer: tf_keras.regularizers.Regularizer object. Default to None. require_endpoints: the required endpoints for prediction. If None or empty, then only uses the final endpoint. @@ -76,32 +76,32 @@ def __init__( self._backbone = backbone inputs = { - k: tf.keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() + k: tf_keras.Input(shape=v.shape[1:]) for k, v in input_specs.items() } endpoints = backbone(inputs['image']) if aggregate_endpoints: pooled_feats = [] for endpoint in endpoints.values(): - x_pool = tf.keras.layers.GlobalAveragePooling3D()(endpoint) + x_pool = tf_keras.layers.GlobalAveragePooling3D()(endpoint) pooled_feats.append(x_pool) x = tf.concat(pooled_feats, axis=1) else: if not require_endpoints: # Uses the last endpoint for prediction. x = endpoints[max(endpoints.keys())] - x = tf.keras.layers.GlobalAveragePooling3D()(x) + x = tf_keras.layers.GlobalAveragePooling3D()(x) else: # Concats all the required endpoints for prediction. outputs = [] for name in require_endpoints: x = endpoints[name] - x = tf.keras.layers.GlobalAveragePooling3D()(x) + x = tf_keras.layers.GlobalAveragePooling3D()(x) outputs.append(x) x = tf.concat(outputs, axis=1) - x = tf.keras.layers.Dropout(dropout_rate)(x) - x = tf.keras.layers.Dense( + x = tf_keras.layers.Dropout(dropout_rate)(x) + x = tf_keras.layers.Dense( num_classes, kernel_initializer=kernel_initializer, kernel_regularizer=self._kernel_regularizer, bias_regularizer=self._bias_regularizer)( @@ -112,12 +112,12 @@ def __init__( @property def checkpoint_items( - self) -> Mapping[str, Union[tf.keras.Model, tf.keras.layers.Layer]]: + self) -> Mapping[str, Union[tf_keras.Model, tf_keras.layers.Layer]]: """Returns a dictionary of items to be additionally checkpointed.""" return dict(backbone=self.backbone) @property - def backbone(self) -> tf.keras.Model: + def backbone(self) -> tf_keras.Model: return self._backbone def get_config(self) -> Mapping[str, Any]: diff --git a/official/vision/modeling/video_classification_model_test.py b/official/vision/modeling/video_classification_model_test.py index 17089971a32..54b0bd731b6 100644 --- a/official/vision/modeling/video_classification_model_test.py +++ b/official/vision/modeling/video_classification_model_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling import backbones from official.vision.modeling import video_classification_model @@ -33,13 +33,13 @@ def test_resnet3d_network_creation(self, model_id, temporal_size, spatial_size, activation, aggregate_endpoints): """Test for creation of a ResNet3D-50 classifier.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None, temporal_size, spatial_size, spatial_size, 3]) temporal_strides = [1, 1, 1, 1] temporal_kernel_sizes = [(3, 3, 3), (3, 1, 3, 1), (3, 1, 3, 1, 3, 1), (1, 3, 1)] - tf.keras.backend.set_image_data_format('channels_last') + tf_keras.backend.set_image_data_format('channels_last') backbone = backbones.ResNet3D( model_id=model_id, diff --git a/official/vision/ops/anchor.py b/official/vision/ops/anchor.py index bb47aa58b25..6f9536659e4 100644 --- a/official/vision/ops/anchor.py +++ b/official/vision/ops/anchor.py @@ -20,7 +20,7 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import anchor_generator from official.vision.ops import box_matcher diff --git a/official/vision/ops/anchor_generator.py b/official/vision/ops/anchor_generator.py index 7d4cc75b200..7c75b232c42 100644 --- a/official/vision/ops/anchor_generator.py +++ b/official/vision/ops/anchor_generator.py @@ -14,7 +14,7 @@ """Multi scale anchor generator definition.""" -import tensorflow as tf +import tensorflow as tf, tf_keras # (TODO/tanzheny): consider having customized anchor offset. diff --git a/official/vision/ops/anchor_generator_test.py b/official/vision/ops/anchor_generator_test.py index 75aa4d84ba9..cc82122fc43 100644 --- a/official/vision/ops/anchor_generator_test.py +++ b/official/vision/ops/anchor_generator_test.py @@ -15,7 +15,7 @@ """Tests for anchor_generator.py.""" from absl.testing import parameterized -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import anchor_generator diff --git a/official/vision/ops/anchor_test.py b/official/vision/ops/anchor_test.py index 59eb80ce291..84438756b72 100644 --- a/official/vision/ops/anchor_test.py +++ b/official/vision/ops/anchor_test.py @@ -17,7 +17,7 @@ # Import libraries from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import anchor diff --git a/official/vision/ops/augment.py b/official/vision/ops/augment.py index f770fe8694a..92abbf6bbfc 100644 --- a/official/vision/ops/augment.py +++ b/official/vision/ops/augment.py @@ -32,7 +32,7 @@ from typing import Any, List, Iterable, Optional, Tuple, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras # This signifies the max integer that the controller RNN could predict for the diff --git a/official/vision/ops/augment_test.py b/official/vision/ops/augment_test.py index 028d737e7da..1c79c58fdda 100644 --- a/official/vision/ops/augment_test.py +++ b/official/vision/ops/augment_test.py @@ -22,7 +22,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import augment diff --git a/official/vision/ops/box_matcher.py b/official/vision/ops/box_matcher.py index 9479223cc7e..acb54a13f04 100644 --- a/official/vision/ops/box_matcher.py +++ b/official/vision/ops/box_matcher.py @@ -16,7 +16,7 @@ from typing import List, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras class BoxMatcher: diff --git a/official/vision/ops/box_matcher_test.py b/official/vision/ops/box_matcher_test.py index a933cb3a943..b816399c253 100644 --- a/official/vision/ops/box_matcher_test.py +++ b/official/vision/ops/box_matcher_test.py @@ -14,7 +14,7 @@ """Tests for box_matcher.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_matcher diff --git a/official/vision/ops/box_ops.py b/official/vision/ops/box_ops.py index 992250ecb7e..77b2b7510eb 100644 --- a/official/vision/ops/box_ops.py +++ b/official/vision/ops/box_ops.py @@ -16,7 +16,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras EPSILON = 1e-8 diff --git a/official/vision/ops/iou_similarity.py b/official/vision/ops/iou_similarity.py index 32bae29b6c1..2dd86413b65 100644 --- a/official/vision/ops/iou_similarity.py +++ b/official/vision/ops/iou_similarity.py @@ -14,7 +14,7 @@ """Region Similarity Calculators.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def area(box): diff --git a/official/vision/ops/iou_similarity_test.py b/official/vision/ops/iou_similarity_test.py index d8194ae8f32..d58d59ddbae 100644 --- a/official/vision/ops/iou_similarity_test.py +++ b/official/vision/ops/iou_similarity_test.py @@ -14,7 +14,7 @@ """Tests for iou_similarity.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import iou_similarity diff --git a/official/vision/ops/mask_ops.py b/official/vision/ops/mask_ops.py index 39cafdee7db..938e2952ed4 100644 --- a/official/vision/ops/mask_ops.py +++ b/official/vision/ops/mask_ops.py @@ -21,7 +21,7 @@ import cv2 import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import spatial_transform_ops diff --git a/official/vision/ops/mask_ops_test.py b/official/vision/ops/mask_ops_test.py index 620e26a021c..cf54c6b0a07 100644 --- a/official/vision/ops/mask_ops_test.py +++ b/official/vision/ops/mask_ops_test.py @@ -16,7 +16,7 @@ # Import libraries import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import mask_ops diff --git a/official/vision/ops/nms.py b/official/vision/ops/nms.py index 6b810959149..fdea04448d6 100644 --- a/official/vision/ops/nms.py +++ b/official/vision/ops/nms.py @@ -15,7 +15,7 @@ """Tensorflow implementation of non max suppression.""" # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops diff --git a/official/vision/ops/preprocess_ops.py b/official/vision/ops/preprocess_ops.py index 9bf0927e898..0a06a62bc16 100644 --- a/official/vision/ops/preprocess_ops.py +++ b/official/vision/ops/preprocess_ops.py @@ -17,7 +17,7 @@ import math from typing import Optional, Sequence, Tuple, Union from six.moves import range -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import augment from official.vision.ops import box_ops diff --git a/official/vision/ops/preprocess_ops_3d.py b/official/vision/ops/preprocess_ops_3d.py index f3f8d17c406..35430720f58 100644 --- a/official/vision/ops/preprocess_ops_3d.py +++ b/official/vision/ops/preprocess_ops_3d.py @@ -15,7 +15,7 @@ """Utils for processing video dataset features.""" from typing import Optional, Tuple -import tensorflow as tf +import tensorflow as tf, tf_keras def _sample_or_pad_sequence_indices(sequence: tf.Tensor, num_steps: int, diff --git a/official/vision/ops/preprocess_ops_3d_test.py b/official/vision/ops/preprocess_ops_3d_test.py index 02add698286..aefac1ceef3 100644 --- a/official/vision/ops/preprocess_ops_3d_test.py +++ b/official/vision/ops/preprocess_ops_3d_test.py @@ -17,7 +17,7 @@ import itertools import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import preprocess_ops_3d diff --git a/official/vision/ops/preprocess_ops_test.py b/official/vision/ops/preprocess_ops_test.py index f82744cea78..7b1b1c8c56b 100644 --- a/official/vision/ops/preprocess_ops_test.py +++ b/official/vision/ops/preprocess_ops_test.py @@ -21,7 +21,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import preprocess_ops diff --git a/official/vision/ops/sampling_ops.py b/official/vision/ops/sampling_ops.py index c409f1293ff..87f18cb874c 100644 --- a/official/vision/ops/sampling_ops.py +++ b/official/vision/ops/sampling_ops.py @@ -32,7 +32,7 @@ """ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras def combined_static_and_dynamic_shape(tensor): diff --git a/official/vision/ops/spatial_transform_ops.py b/official/vision/ops/spatial_transform_ops.py index fc361c409e3..e34fa7ad135 100644 --- a/official/vision/ops/spatial_transform_ops.py +++ b/official/vision/ops/spatial_transform_ops.py @@ -17,7 +17,7 @@ from typing import Dict, Tuple import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops.box_ops import bbox2mask @@ -541,7 +541,7 @@ def nearest_upsampling(data: tf.Tensor, data. """ if use_keras_layer: - return tf.keras.layers.UpSampling2D(size=(scale, scale), + return tf_keras.layers.UpSampling2D(size=(scale, scale), interpolation='nearest')(data) with tf.name_scope('nearest_upsampling'): bs, _, _, c = data.get_shape().as_list() diff --git a/official/vision/ops/target_gather.py b/official/vision/ops/target_gather.py index f61a2b135a6..6c9676b46d0 100644 --- a/official/vision/ops/target_gather.py +++ b/official/vision/ops/target_gather.py @@ -14,7 +14,7 @@ """Definition of target gather, which gathers targets from indices.""" -import tensorflow as tf +import tensorflow as tf, tf_keras class TargetGather: diff --git a/official/vision/ops/target_gather_test.py b/official/vision/ops/target_gather_test.py index bbe8030db7e..7d73597cfbf 100644 --- a/official/vision/ops/target_gather_test.py +++ b/official/vision/ops/target_gather_test.py @@ -14,7 +14,7 @@ """Tests for target_gather.py.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import target_gather diff --git a/official/vision/serving/detection.py b/official/vision/serving/detection.py index c26d22a6143..a439ea71020 100644 --- a/official/vision/serving/detection.py +++ b/official/vision/serving/detection.py @@ -18,7 +18,7 @@ from typing import Mapping, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision import configs from official.vision.modeling import factory @@ -50,7 +50,7 @@ def _build_model(self): 'does not support with dynamic batch size.', nms_version) self.params.task.model.detection_generator.nms_version = 'batched' - input_specs = tf.keras.layers.InputSpec(shape=[ + input_specs = tf_keras.layers.InputSpec(shape=[ self._batch_size, *self._padded_size, 3]) if isinstance(self.params.task.model, configs.maskrcnn.MaskRCNN): diff --git a/official/vision/serving/detection_test.py b/official/vision/serving/detection_test.py index 41d6e126e53..7808f90d117 100644 --- a/official/vision/serving/detection_test.py +++ b/official/vision/serving/detection_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.vision import registry_imports # pylint: disable=unused-import diff --git a/official/vision/serving/export_base.py b/official/vision/serving/export_base.py index ff4608abcfe..ecf85285dde 100644 --- a/official/vision/serving/export_base.py +++ b/official/vision/serving/export_base.py @@ -17,7 +17,7 @@ import abc from typing import Dict, List, Mapping, Optional, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import export_base @@ -32,7 +32,7 @@ def __init__(self, input_image_size: List[int], input_type: str = 'image_tensor', num_channels: int = 3, - model: Optional[tf.keras.Model] = None, + model: Optional[tf_keras.Model] = None, input_name: Optional[str] = None): """Initializes a module for export. @@ -43,7 +43,7 @@ def __init__(self, it is [height, width]. input_type: The input signature type. num_channels: The number of the image channels. - model: A tf.keras.Model instance to be exported. + model: A tf_keras.Model instance to be exported. input_name: A customized input tensor name. """ self.params = params diff --git a/official/vision/serving/export_base_v2.py b/official/vision/serving/export_base_v2.py index 48a41362b07..83683c7dcb8 100644 --- a/official/vision/serving/export_base_v2.py +++ b/official/vision/serving/export_base_v2.py @@ -16,7 +16,7 @@ from typing import Dict, Optional, Text, Callable, Any, Union -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import export_base @@ -26,7 +26,7 @@ class ExportModule(export_base.ExportModule): def __init__(self, params, - model: tf.keras.Model, + model: tf_keras.Model, input_signature: Union[tf.TensorSpec, Dict[str, tf.TensorSpec]], preprocessor: Optional[Callable[..., Any]] = None, inference_step: Optional[Callable[..., Any]] = None, @@ -35,7 +35,7 @@ def __init__(self, Args: params: A dataclass for parameters to the module. - model: A tf.keras.Model instance to be exported. + model: A tf_keras.Model instance to be exported. input_signature: tf.TensorSpec, e.g. tf.TensorSpec(shape=[None, 224, 224, 3], dtype=tf.uint8) preprocessor: An optional callable to preprocess the inputs. diff --git a/official/vision/serving/export_base_v2_test.py b/official/vision/serving/export_base_v2_test.py index 85cea146dc3..eafa7507e66 100644 --- a/official/vision/serving/export_base_v2_test.py +++ b/official/vision/serving/export_base_v2_test.py @@ -15,17 +15,17 @@ """Tests for official.core.export_base_v2.""" import os -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import export_base from official.vision.serving import export_base_v2 -class TestModel(tf.keras.Model): +class TestModel(tf_keras.Model): def __init__(self): super().__init__() - self._dense = tf.keras.layers.Dense(2) + self._dense = tf_keras.layers.Dense(2) def call(self, inputs): return {'outputs': self._dense(inputs)} diff --git a/official/vision/serving/export_module_factory.py b/official/vision/serving/export_module_factory.py index 76e0696057c..046594048ed 100644 --- a/official/vision/serving/export_module_factory.py +++ b/official/vision/serving/export_module_factory.py @@ -16,7 +16,7 @@ from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.vision import configs @@ -34,7 +34,7 @@ def create_classification_export_module(params: cfg.ExperimentConfig, """Creats classification export module.""" input_signature = export_utils.get_image_input_signatures( input_type, batch_size, input_image_size, num_channels) - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[batch_size] + input_image_size + [num_channels]) model = factory.build_classification_model( diff --git a/official/vision/serving/export_module_factory_test.py b/official/vision/serving/export_module_factory_test.py index e0a33ba5a4f..6b9607b1240 100644 --- a/official/vision/serving/export_module_factory_test.py +++ b/official/vision/serving/export_module_factory_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.core import export_base @@ -71,7 +71,7 @@ def test_export(self, input_type='image_tensor'): module = self._get_classification_module(input_type, input_image_size) # Test that the model restores any attrs that are trackable objects # (eg: tables, resource variables, keras models/layers, tf.hub modules). - module.model.test_trackable = tf.keras.layers.InputLayer(input_shape=(4,)) + module.model.test_trackable = tf_keras.layers.InputLayer(input_shape=(4,)) ckpt_path = tf.train.Checkpoint(model=module.model).save( os.path.join(tmp_dir, 'ckpt')) export_dir = export_base.export( diff --git a/official/vision/serving/export_saved_model_lib.py b/official/vision/serving/export_saved_model_lib.py index ef595010b1b..dee3c447d7f 100644 --- a/official/vision/serving/export_saved_model_lib.py +++ b/official/vision/serving/export_saved_model_lib.py @@ -18,7 +18,7 @@ from typing import Optional, List, Union, Text, Dict from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import export_base diff --git a/official/vision/serving/export_saved_model_lib_test.py b/official/vision/serving/export_saved_model_lib_test.py index df0456a886e..20db4441b7a 100644 --- a/official/vision/serving/export_saved_model_lib_test.py +++ b/official/vision/serving/export_saved_model_lib_test.py @@ -17,7 +17,7 @@ import os from unittest import mock -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import export_base from official.vision import configs diff --git a/official/vision/serving/export_saved_model_lib_v2.py b/official/vision/serving/export_saved_model_lib_v2.py index cdea4f714f6..4d0f94a193b 100644 --- a/official/vision/serving/export_saved_model_lib_v2.py +++ b/official/vision/serving/export_saved_model_lib_v2.py @@ -17,7 +17,7 @@ import os from typing import Optional, List, Union, Text, Dict -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.core import export_base diff --git a/official/vision/serving/export_tfhub_lib.py b/official/vision/serving/export_tfhub_lib.py index 83ca9d453cb..1037a63492d 100644 --- a/official/vision/serving/export_tfhub_lib.py +++ b/official/vision/serving/export_tfhub_lib.py @@ -17,7 +17,7 @@ # Import libraries -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions as cfg from official.vision import configs @@ -28,7 +28,7 @@ def build_model(batch_size: Optional[int], input_image_size: List[int], params: cfg.ExperimentConfig, num_channels: int = 3, - skip_logits_layer: bool = False) -> tf.keras.Model: + skip_logits_layer: bool = False) -> tf_keras.Model: """Builds a model for TF Hub export. Args: @@ -40,12 +40,12 @@ def build_model(batch_size: Optional[int], model. Default is False. Returns: - A tf.keras.Model instance. + A tf_keras.Model instance. Raises: ValueError: If the task is not supported. """ - input_specs = tf.keras.layers.InputSpec(shape=[batch_size] + + input_specs = tf_keras.layers.InputSpec(shape=[batch_size] + input_image_size + [num_channels]) if isinstance(params.task, configs.image_classification.ImageClassificationTask): diff --git a/official/vision/serving/export_tflite.py b/official/vision/serving/export_tflite.py index 6530aba96a8..8ad9fe1e2c0 100644 --- a/official/vision/serving/export_tflite.py +++ b/official/vision/serving/export_tflite.py @@ -36,7 +36,7 @@ from absl import flags from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.modeling import hyperparams from official.vision import registry_imports # pylint: disable=unused-import diff --git a/official/vision/serving/export_tflite_lib.py b/official/vision/serving/export_tflite_lib.py index 9d65e613af6..0934d3476ea 100644 --- a/official/vision/serving/export_tflite_lib.py +++ b/official/vision/serving/export_tflite_lib.py @@ -17,7 +17,7 @@ from typing import Iterator, List, Optional from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import config_definitions as cfg @@ -100,7 +100,7 @@ def convert_tflite_model( Args: saved_model_dir: The directory to the SavedModel. concrete_function: An optional concrete function to be exported. - model: An optional tf.keras.Model instance. If both `saved_model_dir` and + model: An optional tf_keras.Model instance. If both `saved_model_dir` and `concrete_function` are not available, convert this model to TFLite. quant_type: The post training quantization (PTQ) method. It can be one of `default` (dynamic range), `fp16` (float16), `int8` (integer wih float diff --git a/official/vision/serving/export_utils.py b/official/vision/serving/export_utils.py index b2e08dd3686..093b146701c 100644 --- a/official/vision/serving/export_utils.py +++ b/official/vision/serving/export_utils.py @@ -15,7 +15,7 @@ """Helper utils for export library.""" from typing import List, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-long-lambda diff --git a/official/vision/serving/image_classification.py b/official/vision/serving/image_classification.py index c6280bd30b7..68573819a9d 100644 --- a/official/vision/serving/image_classification.py +++ b/official/vision/serving/image_classification.py @@ -14,7 +14,7 @@ """Image classification input and model functions for serving/inference.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling import factory from official.vision.ops import preprocess_ops @@ -25,7 +25,7 @@ class ClassificationModule(export_base.ExportModule): """classification Module.""" def _build_model(self): - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[self._batch_size] + self._input_image_size + [3]) return factory.build_classification_model( diff --git a/official/vision/serving/image_classification_test.py b/official/vision/serving/image_classification_test.py index 1799da08edd..7d757327eea 100644 --- a/official/vision/serving/image_classification_test.py +++ b/official/vision/serving/image_classification_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.vision import registry_imports # pylint: disable=unused-import @@ -81,7 +81,7 @@ def test_export(self, input_type='image_tensor'): module = self._get_classification_module(input_type) # Test that the model restores any attrs that are trackable objects # (eg: tables, resource variables, keras models/layers, tf.hub modules). - module.model.test_trackable = tf.keras.layers.InputLayer(input_shape=(4,)) + module.model.test_trackable = tf_keras.layers.InputLayer(input_shape=(4,)) self._export_from_module(module, input_type, tmp_dir) diff --git a/official/vision/serving/semantic_segmentation.py b/official/vision/serving/semantic_segmentation.py index 8c77c107a4e..e95c47d92d5 100644 --- a/official/vision/serving/semantic_segmentation.py +++ b/official/vision/serving/semantic_segmentation.py @@ -14,7 +14,7 @@ """Semantic segmentation input and model functions for serving/inference.""" -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.modeling import factory from official.vision.ops import preprocess_ops @@ -25,7 +25,7 @@ class SegmentationModule(export_base.ExportModule): """Segmentation Module.""" def _build_model(self): - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[self._batch_size] + self._input_image_size + [3]) return factory.build_segmentation_model( diff --git a/official/vision/serving/semantic_segmentation_test.py b/official/vision/serving/semantic_segmentation_test.py index 7f26bc189ff..2d0458c1ce9 100644 --- a/official/vision/serving/semantic_segmentation_test.py +++ b/official/vision/serving/semantic_segmentation_test.py @@ -20,7 +20,7 @@ from absl.testing import parameterized import numpy as np from PIL import Image -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.vision import registry_imports # pylint: disable=unused-import diff --git a/official/vision/serving/video_classification.py b/official/vision/serving/video_classification.py index 83d2605ea52..ecaac90bd52 100644 --- a/official/vision/serving/video_classification.py +++ b/official/vision/serving/video_classification.py @@ -15,7 +15,7 @@ """Video classification input and model functions for serving/inference.""" from typing import Mapping, Dict, Text -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.dataloaders import video_input from official.vision.serving import export_base diff --git a/official/vision/serving/video_classification_test.py b/official/vision/serving/video_classification_test.py index a11f7ac5118..695813d56a3 100644 --- a/official/vision/serving/video_classification_test.py +++ b/official/vision/serving/video_classification_test.py @@ -19,7 +19,7 @@ from absl.testing import parameterized import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import exp_factory from official.vision import registry_imports # pylint: disable=unused-import diff --git a/official/vision/tasks/image_classification.py b/official/vision/tasks/image_classification.py index 55c991cfb4d..e551f8cf884 100644 --- a/official/vision/tasks/image_classification.py +++ b/official/vision/tasks/image_classification.py @@ -16,7 +16,7 @@ from typing import Any, List, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -40,14 +40,14 @@ class ImageClassificationTask(base_task.Task): def build_model(self): """Builds classification model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_classification_model( @@ -59,11 +59,11 @@ def build_model(self): model.backbone.trainable = False # Builds the model - dummy_inputs = tf.keras.Input(self.task_config.model.input_size) + dummy_inputs = tf_keras.Input(self.task_config.model.input_size) _ = model(dummy_inputs, training=False) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -172,7 +172,7 @@ def build_losses(self, Args: labels: Input groundtruth labels. model_outputs: Output logits of the classifier. - aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf.keras.Model. + aux_losses: The auxiliarly loss tensors, i.e. `losses` in tf_keras.Model. Returns: The total loss tensor. @@ -188,7 +188,7 @@ def build_losses(self, # Average over all object classes inside an image. total_loss = tf.reduce_mean(total_loss, axis=-1) elif losses_config.one_hot: - total_loss = tf.keras.losses.categorical_crossentropy( + total_loss = tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=True, @@ -197,11 +197,11 @@ def build_losses(self, total_loss = tf.nn.softmax_cross_entropy_with_logits( labels, model_outputs) else: - total_loss = tf.keras.losses.sparse_categorical_crossentropy( + total_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, model_outputs, from_logits=True) else: # Multi-label binary cross entropy loss. This will apply `reduce_mean`. - total_loss = tf.keras.losses.binary_crossentropy( + total_loss = tf_keras.losses.binary_crossentropy( labels, model_outputs, from_logits=True, @@ -218,7 +218,7 @@ def build_losses(self, return total_loss def build_metrics(self, - training: bool = True) -> List[tf.keras.metrics.Metric]: + training: bool = True) -> List[tf_keras.metrics.Metric]: """Gets streaming metrics for training/validation.""" is_multilabel = self.task_config.train_data.is_multilabel if not is_multilabel: @@ -226,8 +226,8 @@ def build_metrics(self, if (self.task_config.losses.one_hot or self.task_config.losses.soft_labels): metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy( + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k))] if hasattr( self.task_config.evaluation, 'precision_and_recall_thresholds' @@ -235,13 +235,13 @@ def build_metrics(self, thresholds = self.task_config.evaluation.precision_and_recall_thresholds # pylint: disable=line-too-long # pylint:disable=g-complex-comprehension metrics += [ - tf.keras.metrics.Precision( + tf_keras.metrics.Precision( thresholds=th, name='precision_at_threshold_{}'.format(th), top_k=1) for th in thresholds ] metrics += [ - tf.keras.metrics.Recall( + tf_keras.metrics.Recall( thresholds=th, name='recall_at_threshold_{}'.format(th), top_k=1) for th in thresholds @@ -254,14 +254,14 @@ def build_metrics(self, ) and self.task_config.evaluation.report_per_class_precision_and_recall: for class_id in range(self.task_config.model.num_classes): metrics += [ - tf.keras.metrics.Precision( + tf_keras.metrics.Precision( thresholds=th, class_id=class_id, name=f'precision_at_threshold_{th}/{class_id}', top_k=1) for th in thresholds ] metrics += [ - tf.keras.metrics.Recall( + tf_keras.metrics.Recall( thresholds=th, class_id=class_id, name=f'recall_at_threshold_{th}/{class_id}', @@ -270,8 +270,8 @@ def build_metrics(self, # pylint:enable=g-complex-comprehension else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=k, name='top_{}_accuracy'.format(k))] else: metrics = [] @@ -280,12 +280,12 @@ def build_metrics(self, # TODO(arashwan): Investigate adding following metric to train. if not training: metrics = [ - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( name='globalPR-AUC', curve='PR', multi_label=False, from_logits=True), - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( name='meanPR-AUC', curve='PR', multi_label=True, @@ -296,14 +296,14 @@ def build_metrics(self, def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. optimizer: The optimizer for this training step. metrics: A nested structure of metrics objects. @@ -353,7 +353,7 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables @@ -361,7 +361,7 @@ def train_step(self, # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -380,13 +380,13 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Runs validatation step. Args: inputs: A tuple of input tensors of (features, labels). - model: A tf.keras.Model instance. + model: A tf_keras.Model instance. metrics: A nested structure of metrics objects. Returns: @@ -421,6 +421,6 @@ def validation_step(self, logs.update({m.name: m.result() for m in model.metrics}) return logs - def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model): + def inference_step(self, inputs: tf.Tensor, model: tf_keras.Model): """Performs the forward step.""" return model(inputs, training=False) diff --git a/official/vision/tasks/maskrcnn.py b/official/vision/tasks/maskrcnn.py index 81f867b9666..107bbcfa02a 100644 --- a/official/vision/tasks/maskrcnn.py +++ b/official/vision/tasks/maskrcnn.py @@ -19,7 +19,7 @@ from absl import logging import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn as dataset_fn_lib from official.core import base_task @@ -74,14 +74,14 @@ class MaskRCNNTask(base_task.Task): def build_model(self): """Builds Mask R-CNN model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_maskrcnn( @@ -93,13 +93,13 @@ def build_model(self): model.backbone.trainable = False # Builds the model through warm-up call. - dummy_images = tf.keras.Input(self.task_config.model.input_size) - dummy_image_shape = tf.keras.layers.Input([2]) + dummy_images = tf_keras.Input(self.task_config.model.input_size) + dummy_image_shape = tf_keras.layers.Input([2]) _ = model(dummy_images, image_shape=dummy_image_shape, training=False) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: @@ -351,7 +351,7 @@ def build_metrics(self, training: bool = True): 'model_loss', ] return [ - tf.keras.metrics.Mean(name, dtype=tf.float32) for name in metric_names + tf_keras.metrics.Mean(name, dtype=tf.float32) for name in metric_names ] else: if self._task_config.use_coco_metrics: @@ -389,8 +389,8 @@ def build_metrics(self, training: bool = True): def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. @@ -429,13 +429,13 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -492,7 +492,7 @@ def _update_metrics(self, labels, outputs, logs): def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. diff --git a/official/vision/tasks/retinanet.py b/official/vision/tasks/retinanet.py index 20ad4b50c24..3b9b3f925f8 100644 --- a/official/vision/tasks/retinanet.py +++ b/official/vision/tasks/retinanet.py @@ -16,7 +16,7 @@ from typing import Any, List, Mapping, Optional, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -47,14 +47,14 @@ class RetinaNetTask(base_task.Task): def build_model(self): """Build RetinaNet model.""" - input_specs = tf.keras.layers.InputSpec( + input_specs = tf_keras.layers.InputSpec( shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_retinanet( @@ -67,7 +67,7 @@ def build_model(self): return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loading pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -181,8 +181,8 @@ def build_attribute_loss(self, y_pred_att = loss_utils.multi_level_flatten( outputs['attribute_outputs'][head.name], last_dim=head.size ) - att_loss_fn = tf.keras.losses.Huber( - 1.0, reduction=tf.keras.losses.Reduction.SUM) + att_loss_fn = tf_keras.losses.Huber( + 1.0, reduction=tf_keras.losses.Reduction.SUM) att_loss = att_loss_fn( y_true=y_true_att, y_pred=y_pred_att, @@ -198,7 +198,7 @@ def build_attribute_loss(self, cls_loss_fn = focal_loss.FocalLoss( alpha=params.losses.focal_loss_alpha, gamma=params.losses.focal_loss_gamma, - reduction=tf.keras.losses.Reduction.SUM, + reduction=tf_keras.losses.Reduction.SUM, ) att_loss = cls_loss_fn( y_true=y_true_att, @@ -224,9 +224,9 @@ def build_losses( cls_loss_fn = focal_loss.FocalLoss( alpha=params.losses.focal_loss_alpha, gamma=params.losses.focal_loss_gamma, - reduction=tf.keras.losses.Reduction.SUM) - box_loss_fn = tf.keras.losses.Huber( - params.losses.huber_loss_delta, reduction=tf.keras.losses.Reduction.SUM) + reduction=tf_keras.losses.Reduction.SUM) + box_loss_fn = tf_keras.losses.Huber( + params.losses.huber_loss_delta, reduction=tf_keras.losses.Reduction.SUM) # Sums all positives in a batch for normalization and avoids zero # num_positives_sum, which would lead to inf loss during training @@ -270,7 +270,7 @@ def build_metrics(self, training: bool = True): metrics = [] metric_names = ['total_loss', 'cls_loss', 'box_loss', 'model_loss'] for name in metric_names: - metrics.append(tf.keras.metrics.Mean(name, dtype=tf.float32)) + metrics.append(tf_keras.metrics.Mean(name, dtype=tf.float32)) if not training: if ( @@ -306,8 +306,8 @@ def build_metrics(self, training: bool = True): def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. @@ -335,13 +335,13 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient when LossScaleOptimizer is used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -362,7 +362,7 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. diff --git a/official/vision/tasks/semantic_segmentation.py b/official/vision/tasks/semantic_segmentation.py index a2e6a978ba9..e9235f6808b 100644 --- a/official/vision/tasks/semantic_segmentation.py +++ b/official/vision/tasks/semantic_segmentation.py @@ -16,7 +16,7 @@ from typing import Any, List, Mapping, Optional, Tuple, Union from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import dataset_fn from official.core import base_task @@ -38,7 +38,7 @@ class SemanticSegmentationTask(base_task.Task): def build_model(self): """Builds segmentation model.""" - input_specs = tf.keras.layers.InputSpec(shape=[None] + + input_specs = tf_keras.layers.InputSpec(shape=[None] + self.task_config.model.input_size) l2_weight_decay = self.task_config.losses.l2_weight_decay @@ -46,7 +46,7 @@ def build_model(self): # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) l2_regularizer = ( - tf.keras.regularizers.l2(l2_weight_decay / + tf_keras.regularizers.l2(l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory.build_segmentation_model( @@ -54,11 +54,11 @@ def build_model(self): model_config=self.task_config.model, l2_regularizer=l2_regularizer) # Builds the model - dummy_inputs = tf.keras.Input(self.task_config.model.input_size) + dummy_inputs = tf_keras.Input(self.task_config.model.input_size) _ = model(dummy_inputs, training=False) return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -204,7 +204,7 @@ def build_metrics(self, training: bool = True): dtype=tf.float32)) if self.task_config.model.get('mask_scoring_head'): metrics.append( - tf.keras.metrics.MeanSquaredError(name='mask_scores_mse')) + tf_keras.metrics.MeanSquaredError(name='mask_scores_mse')) if not training: self.iou_metric = segmentation_metrics.PerClassIoU( @@ -218,14 +218,14 @@ def build_metrics(self, training: bool = True): # Masks scores metric can only be computed if labels are scaled to match # preticted mask scores. metrics.append( - tf.keras.metrics.MeanSquaredError(name='mask_scores_mse')) + tf_keras.metrics.MeanSquaredError(name='mask_scores_mse')) return metrics def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. @@ -264,14 +264,14 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -284,7 +284,7 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. @@ -332,7 +332,7 @@ def validation_step(self, return logs - def inference_step(self, inputs: tf.Tensor, model: tf.keras.Model): + def inference_step(self, inputs: tf.Tensor, model: tf_keras.Model): """Performs the forward step.""" return model(inputs, training=False) diff --git a/official/vision/tasks/video_classification.py b/official/vision/tasks/video_classification.py index eb09237850d..40a12d7c047 100644 --- a/official/vision/tasks/video_classification.py +++ b/official/vision/tasks/video_classification.py @@ -16,7 +16,7 @@ from typing import Any, Optional, List, Tuple from absl import logging -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import base_task from official.core import task_factory from official.modeling import tf_utils @@ -57,14 +57,14 @@ def _is_multilabel(self): def build_model(self): """Builds video classification model.""" common_input_shape = self._get_feature_shape() - input_specs = tf.keras.layers.InputSpec(shape=[None] + common_input_shape) + input_specs = tf_keras.layers.InputSpec(shape=[None] + common_input_shape) logging.info('Build model input %r', common_input_shape) l2_weight_decay = float(self.task_config.losses.l2_weight_decay) # Divide weight decay by 2.0 to match the implementation of tf.nn.l2_loss. # (https://www.tensorflow.org/api_docs/python/tf/keras/regularizers/l2) # (https://www.tensorflow.org/api_docs/python/tf/nn/l2_loss) - l2_regularizer = (tf.keras.regularizers.l2( + l2_regularizer = (tf_keras.regularizers.l2( l2_weight_decay / 2.0) if l2_weight_decay else None) model = factory_3d.build_model( @@ -79,7 +79,7 @@ def build_model(self): model.backbone.trainable = False return model - def initialize(self, model: tf.keras.Model): + def initialize(self, model: tf_keras.Model): """Loads pretrained checkpoint.""" if not self.task_config.init_checkpoint: return @@ -176,7 +176,7 @@ def build_losses(self, if self._is_multilabel(): entropy = -tf.reduce_mean( tf.reduce_sum(model_outputs * tf.math.log(model_outputs + 1e-8), -1)) - total_loss = tf.keras.losses.binary_crossentropy( + total_loss = tf_keras.losses.binary_crossentropy( labels, model_outputs, from_logits=False) all_losses.update({ 'class_loss': total_loss, @@ -184,13 +184,13 @@ def build_losses(self, }) else: if losses_config.one_hot: - total_loss = tf.keras.losses.categorical_crossentropy( + total_loss = tf_keras.losses.categorical_crossentropy( labels, model_outputs, from_logits=False, label_smoothing=losses_config.label_smoothing) else: - total_loss = tf.keras.losses.sparse_categorical_crossentropy( + total_loss = tf_keras.losses.sparse_categorical_crossentropy( labels, model_outputs, from_logits=False) total_loss = tf_utils.safe_mean(total_loss) @@ -210,30 +210,30 @@ def build_metrics(self, training: bool = True): """Gets streaming metrics for training/validation.""" if self.task_config.losses.one_hot: metrics = [ - tf.keras.metrics.CategoricalAccuracy(name='accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy(k=1, name='top_1_accuracy'), - tf.keras.metrics.TopKCategoricalAccuracy(k=5, name='top_5_accuracy') + tf_keras.metrics.CategoricalAccuracy(name='accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy(k=1, name='top_1_accuracy'), + tf_keras.metrics.TopKCategoricalAccuracy(k=5, name='top_5_accuracy') ] if self._is_multilabel(): metrics.append( - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( curve='ROC', multi_label=self._is_multilabel(), name='ROC-AUC')) metrics.append( - tf.keras.metrics.RecallAtPrecision( + tf_keras.metrics.RecallAtPrecision( 0.95, name='RecallAtPrecision95')) metrics.append( - tf.keras.metrics.AUC( + tf_keras.metrics.AUC( curve='PR', multi_label=self._is_multilabel(), name='PR-AUC')) if self.task_config.metrics.use_per_class_recall: for i in range(self._get_num_classes()): metrics.append( - tf.keras.metrics.Recall(class_id=i, name=f'recall-{i}')) + tf_keras.metrics.Recall(class_id=i, name=f'recall-{i}')) else: metrics = [ - tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseCategoricalAccuracy(name='accuracy'), + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=1, name='top_1_accuracy'), - tf.keras.metrics.SparseTopKCategoricalAccuracy( + tf_keras.metrics.SparseTopKCategoricalAccuracy( k=5, name='top_5_accuracy') ] return metrics @@ -256,8 +256,8 @@ def process_metrics(self, metrics: List[Any], labels: Any, def train_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, - optimizer: tf.keras.optimizers.Optimizer, + model: tf_keras.Model, + optimizer: tf_keras.optimizers.Optimizer, metrics: Optional[List[Any]] = None): """Does forward and backward. @@ -300,14 +300,14 @@ def train_step(self, # For mixed_precision policy, when LossScaleOptimizer is used, loss is # scaled for numerical stability. if isinstance( - optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + optimizer, tf_keras.mixed_precision.LossScaleOptimizer): scaled_loss = optimizer.get_scaled_loss(scaled_loss) tvars = model.trainable_variables grads = tape.gradient(scaled_loss, tvars) # Scales back gradient before apply_gradients when LossScaleOptimizer is # used. - if isinstance(optimizer, tf.keras.mixed_precision.LossScaleOptimizer): + if isinstance(optimizer, tf_keras.mixed_precision.LossScaleOptimizer): grads = optimizer.get_unscaled_gradients(grads) optimizer.apply_gradients(list(zip(grads, tvars))) @@ -322,7 +322,7 @@ def train_step(self, def validation_step(self, inputs: Tuple[Any, Any], - model: tf.keras.Model, + model: tf_keras.Model, metrics: Optional[List[Any]] = None): """Validatation step. @@ -354,7 +354,7 @@ def validation_step(self, logs.update({m.name: m.result() for m in model.metrics}) return logs - def inference_step(self, features: tf.Tensor, model: tf.keras.Model): + def inference_step(self, features: tf.Tensor, model: tf_keras.Model): """Performs the forward step.""" outputs = model(features, training=False) if self._is_multilabel(): diff --git a/official/vision/train.py b/official/vision/train.py index 729c8e17017..b51ddd9065a 100644 --- a/official/vision/train.py +++ b/official/vision/train.py @@ -18,7 +18,7 @@ from absl import flags from absl import logging import gin -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.common import flags as tfm_flags diff --git a/official/vision/train_spatial_partitioning.py b/official/vision/train_spatial_partitioning.py index 1b89dc102e5..5c20a6fc50d 100644 --- a/official/vision/train_spatial_partitioning.py +++ b/official/vision/train_spatial_partitioning.py @@ -19,7 +19,7 @@ from absl import flags import gin import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.common import distribute_utils from official.common import flags as tfm_flags diff --git a/official/vision/utils/object_detection/argmax_matcher.py b/official/vision/utils/object_detection/argmax_matcher.py index 3b9b2a80499..9048073ab40 100644 --- a/official/vision/utils/object_detection/argmax_matcher.py +++ b/official/vision/utils/object_detection/argmax_matcher.py @@ -26,7 +26,7 @@ Note: matchers are used in TargetAssigners. There is a create_target_assigner factory function for popular implementations. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import matcher from official.vision.utils.object_detection import shape_utils diff --git a/official/vision/utils/object_detection/balanced_positive_negative_sampler.py b/official/vision/utils/object_detection/balanced_positive_negative_sampler.py index 8d0450b1817..b209c46541a 100644 --- a/official/vision/utils/object_detection/balanced_positive_negative_sampler.py +++ b/official/vision/utils/object_detection/balanced_positive_negative_sampler.py @@ -31,7 +31,7 @@ This is originally implemented in TensorFlow Object Detection API. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import minibatch_sampler from official.vision.utils.object_detection import ops diff --git a/official/vision/utils/object_detection/box_coder.py b/official/vision/utils/object_detection/box_coder.py index e0daaa592cd..4dd966f7823 100644 --- a/official/vision/utils/object_detection/box_coder.py +++ b/official/vision/utils/object_detection/box_coder.py @@ -29,7 +29,7 @@ from abc import abstractmethod from abc import abstractproperty -import tensorflow as tf +import tensorflow as tf, tf_keras # Box coder types. FASTER_RCNN = 'faster_rcnn' diff --git a/official/vision/utils/object_detection/box_list.py b/official/vision/utils/object_detection/box_list.py index 16223fdd699..020caa32946 100644 --- a/official/vision/utils/object_detection/box_list.py +++ b/official/vision/utils/object_detection/box_list.py @@ -33,7 +33,7 @@ * Tensors are always provided as (flat) [N, 4] tensors. """ -import tensorflow as tf +import tensorflow as tf, tf_keras class BoxList(object): diff --git a/official/vision/utils/object_detection/box_list_ops.py b/official/vision/utils/object_detection/box_list_ops.py index 394c34f741d..23ca184f305 100644 --- a/official/vision/utils/object_detection/box_list_ops.py +++ b/official/vision/utils/object_detection/box_list_ops.py @@ -27,7 +27,7 @@ from __future__ import print_function from six.moves import range -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import box_list from official.vision.utils.object_detection import ops diff --git a/official/vision/utils/object_detection/faster_rcnn_box_coder.py b/official/vision/utils/object_detection/faster_rcnn_box_coder.py index 3ba92025ea4..3e2a53cc6c2 100644 --- a/official/vision/utils/object_detection/faster_rcnn_box_coder.py +++ b/official/vision/utils/object_detection/faster_rcnn_box_coder.py @@ -27,7 +27,7 @@ See http://arxiv.org/abs/1506.01497 for details. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import box_coder from official.vision.utils.object_detection import box_list diff --git a/official/vision/utils/object_detection/matcher.py b/official/vision/utils/object_detection/matcher.py index b0a1cf72ba1..08879702c9d 100644 --- a/official/vision/utils/object_detection/matcher.py +++ b/official/vision/utils/object_detection/matcher.py @@ -33,7 +33,7 @@ from abc import ABCMeta from abc import abstractmethod -import tensorflow as tf +import tensorflow as tf, tf_keras class Match(object): diff --git a/official/vision/utils/object_detection/minibatch_sampler.py b/official/vision/utils/object_detection/minibatch_sampler.py index 0ef13235cb6..0267314465b 100644 --- a/official/vision/utils/object_detection/minibatch_sampler.py +++ b/official/vision/utils/object_detection/minibatch_sampler.py @@ -32,7 +32,7 @@ from abc import ABCMeta from abc import abstractmethod -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import ops diff --git a/official/vision/utils/object_detection/ops.py b/official/vision/utils/object_detection/ops.py index 896d29427e0..fe4cb9142ed 100644 --- a/official/vision/utils/object_detection/ops.py +++ b/official/vision/utils/object_detection/ops.py @@ -17,7 +17,7 @@ This is originally implemented in TensorFlow Object Detection API. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import shape_utils diff --git a/official/vision/utils/object_detection/preprocessor.py b/official/vision/utils/object_detection/preprocessor.py index a962751106c..554ce407fd1 100644 --- a/official/vision/utils/object_detection/preprocessor.py +++ b/official/vision/utils/object_detection/preprocessor.py @@ -40,7 +40,7 @@ """ import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import box_list diff --git a/official/vision/utils/object_detection/region_similarity_calculator.py b/official/vision/utils/object_detection/region_similarity_calculator.py index a9b10dcc788..5e041457da5 100644 --- a/official/vision/utils/object_detection/region_similarity_calculator.py +++ b/official/vision/utils/object_detection/region_similarity_calculator.py @@ -20,7 +20,7 @@ from abc import ABCMeta from abc import abstractmethod -import tensorflow as tf +import tensorflow as tf, tf_keras def area(boxlist, scope=None): diff --git a/official/vision/utils/object_detection/shape_utils.py b/official/vision/utils/object_detection/shape_utils.py index c65bffef8dd..3f443827f18 100644 --- a/official/vision/utils/object_detection/shape_utils.py +++ b/official/vision/utils/object_detection/shape_utils.py @@ -14,7 +14,7 @@ """Utils used to manipulate tensor shapes.""" -import tensorflow as tf +import tensorflow as tf, tf_keras def assert_shape_equal(shape_a, shape_b): diff --git a/official/vision/utils/object_detection/target_assigner.py b/official/vision/utils/object_detection/target_assigner.py index f383018afdc..56b036c7cf8 100644 --- a/official/vision/utils/object_detection/target_assigner.py +++ b/official/vision/utils/object_detection/target_assigner.py @@ -31,7 +31,7 @@ images must be handled externally. """ -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import box_list from official.vision.utils.object_detection import shape_utils diff --git a/official/vision/utils/object_detection/visualization_utils.py b/official/vision/utils/object_detection/visualization_utils.py index c55b52bca6b..da282f0cb42 100644 --- a/official/vision/utils/object_detection/visualization_utils.py +++ b/official/vision/utils/object_detection/visualization_utils.py @@ -32,7 +32,7 @@ from PIL import ImageDraw from PIL import ImageFont import six -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.ops import box_ops from official.vision.ops import preprocess_ops diff --git a/official/vision/utils/ops_test.py b/official/vision/utils/ops_test.py index 50d4acc5c25..9d9216fa999 100644 --- a/official/vision/utils/ops_test.py +++ b/official/vision/utils/ops_test.py @@ -14,7 +14,7 @@ """Tests for ops.""" import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras from official.vision.utils.object_detection import ops diff --git a/official/vision/utils/summary_manager.py b/official/vision/utils/summary_manager.py index 535fa4da6c1..4819acc1aea 100644 --- a/official/vision/utils/summary_manager.py +++ b/official/vision/utils/summary_manager.py @@ -17,7 +17,7 @@ from typing import Any, Callable, Dict, Optional import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras from official.core import config_definitions diff --git a/orbit/actions/conditional_action.py b/orbit/actions/conditional_action.py index dd3153c9fd3..d84e199f9ce 100644 --- a/orbit/actions/conditional_action.py +++ b/orbit/actions/conditional_action.py @@ -19,7 +19,7 @@ from orbit import controller from orbit import runner -import tensorflow as tf +import tensorflow as tf, tf_keras Condition = Callable[[runner.Output], Union[bool, tf.Tensor]] diff --git a/orbit/actions/conditional_action_test.py b/orbit/actions/conditional_action_test.py index 430d076a890..6602e531abb 100644 --- a/orbit/actions/conditional_action_test.py +++ b/orbit/actions/conditional_action_test.py @@ -16,7 +16,7 @@ from orbit import actions -import tensorflow as tf +import tensorflow as tf, tf_keras class ConditionalActionTest(tf.test.TestCase): diff --git a/orbit/actions/export_saved_model.py b/orbit/actions/export_saved_model.py index 237bed676b1..fd2267d26c7 100644 --- a/orbit/actions/export_saved_model.py +++ b/orbit/actions/export_saved_model.py @@ -19,7 +19,7 @@ from typing import Callable, Optional -import tensorflow as tf +import tensorflow as tf, tf_keras def _id_key(filename): diff --git a/orbit/actions/export_saved_model_test.py b/orbit/actions/export_saved_model_test.py index 38a149b00e8..d6af384057e 100644 --- a/orbit/actions/export_saved_model_test.py +++ b/orbit/actions/export_saved_model_test.py @@ -18,7 +18,7 @@ from orbit import actions -import tensorflow as tf +import tensorflow as tf, tf_keras def _id_key(name): diff --git a/orbit/actions/new_best_metric.py b/orbit/actions/new_best_metric.py index 1b824ee1186..3d9e411199e 100644 --- a/orbit/actions/new_best_metric.py +++ b/orbit/actions/new_best_metric.py @@ -23,7 +23,7 @@ from orbit import runner from orbit import utils -import tensorflow as tf +import tensorflow as tf, tf_keras MetricFn = Callable[[runner.Output], Union[float, tf.Tensor]] diff --git a/orbit/actions/new_best_metric_test.py b/orbit/actions/new_best_metric_test.py index febc09e42b7..9a5ad964569 100644 --- a/orbit/actions/new_best_metric_test.py +++ b/orbit/actions/new_best_metric_test.py @@ -18,7 +18,7 @@ from orbit import actions -import tensorflow as tf +import tensorflow as tf, tf_keras class NewBestMetricTest(tf.test.TestCase): diff --git a/orbit/actions/save_checkpoint_if_preempted.py b/orbit/actions/save_checkpoint_if_preempted.py index 41145d1bf76..9f2aa878b88 100644 --- a/orbit/actions/save_checkpoint_if_preempted.py +++ b/orbit/actions/save_checkpoint_if_preempted.py @@ -16,7 +16,7 @@ from typing import Optional -import tensorflow as tf +import tensorflow as tf, tf_keras class SaveCheckpointIfPreempted: diff --git a/orbit/controller.py b/orbit/controller.py index 78728468a28..46349416683 100644 --- a/orbit/controller.py +++ b/orbit/controller.py @@ -24,7 +24,7 @@ from orbit import runner from orbit import utils -import tensorflow as tf +import tensorflow as tf, tf_keras # pylint: disable=g-direct-tensorflow-import from tensorflow.python.eager import monitoring diff --git a/orbit/controller_test.py b/orbit/controller_test.py index 487e013aa9f..a1ed01e0957 100644 --- a/orbit/controller_test.py +++ b/orbit/controller_test.py @@ -26,13 +26,13 @@ from orbit import standard_runner import orbit.utils -import tensorflow as tf +import tensorflow as tf, tf_keras def create_model(): - x = tf.keras.layers.Input(shape=(3,), name="input") - y = tf.keras.layers.Dense(4, name="dense")(x) - model = tf.keras.Model(x, y) + x = tf_keras.layers.Input(shape=(3,), name="input") + y = tf_keras.layers.Dense(4, name="dense")(x) + model = tf_keras.Model(x, y) return model @@ -65,10 +65,10 @@ class TestRunner(standard_runner.StandardTrainer, def __init__(self, return_numpy=False): self.strategy = tf.distribute.get_strategy() self.model = create_model() - self.optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.1) + self.optimizer = tf_keras.optimizers.RMSprop(learning_rate=0.1) self.global_step = self.optimizer.iterations - self.train_loss = tf.keras.metrics.Mean("train_loss", dtype=tf.float32) - self.eval_loss = tf.keras.metrics.Mean("eval_loss", dtype=tf.float32) + self.train_loss = tf_keras.metrics.Mean("train_loss", dtype=tf.float32) + self.eval_loss = tf_keras.metrics.Mean("eval_loss", dtype=tf.float32) self.return_numpy = return_numpy train_dataset = self.strategy.distribute_datasets_from_function(dataset_fn) eval_dataset = self.strategy.distribute_datasets_from_function(dataset_fn) @@ -82,7 +82,7 @@ def _replicated_step(inputs): inputs, targets = inputs with tf.GradientTape() as tape: outputs = self.model(inputs) - loss = tf.reduce_mean(tf.keras.losses.MSE(targets, outputs)) + loss = tf.reduce_mean(tf_keras.losses.MSE(targets, outputs)) grads = tape.gradient(loss, self.model.variables) self.optimizer.apply_gradients(zip(grads, self.model.variables)) self.train_loss.update_state(loss) @@ -107,7 +107,7 @@ def _replicated_step(inputs): """Replicated evaluation step.""" inputs, targets = inputs outputs = self.model(inputs) - loss = tf.reduce_mean(tf.keras.losses.MSE(targets, outputs)) + loss = tf.reduce_mean(tf_keras.losses.MSE(targets, outputs)) self.eval_loss.update_state(loss) self.strategy.run(_replicated_step, args=(next(iterator),)) @@ -141,7 +141,7 @@ def _replicated_step(inputs): """Replicated evaluation step.""" inputs, targets = inputs outputs = self.model(inputs) - loss = tf.reduce_mean(tf.keras.losses.MSE(targets, outputs)) + loss = tf.reduce_mean(tf_keras.losses.MSE(targets, outputs)) return loss per_replica_losses = self.strategy.run( @@ -170,11 +170,11 @@ def __init__(self): self.model = create_model() dataset = self.strategy.distribute_datasets_from_function(dataset_fn) dataset2 = self.strategy.distribute_datasets_from_function(dataset_fn) - self.loss = tf.keras.metrics.Mean("loss", dtype=tf.float32) - self.accuracy = tf.keras.metrics.CategoricalAccuracy( + self.loss = tf_keras.metrics.Mean("loss", dtype=tf.float32) + self.accuracy = tf_keras.metrics.CategoricalAccuracy( "accuracy", dtype=tf.float32) - self.loss2 = tf.keras.metrics.Mean("loss", dtype=tf.float32) - self.accuracy2 = tf.keras.metrics.CategoricalAccuracy( + self.loss2 = tf_keras.metrics.Mean("loss", dtype=tf.float32) + self.accuracy2 = tf_keras.metrics.CategoricalAccuracy( "accuracy", dtype=tf.float32) standard_runner.StandardEvaluator.__init__( self, eval_dataset={ @@ -188,7 +188,7 @@ def _replicated_step(loss, accuracy, inputs): """Replicated evaluation step.""" inputs, targets = inputs outputs = self.model(inputs) - loss.update_state(tf.keras.losses.MSE(targets, outputs)) + loss.update_state(tf_keras.losses.MSE(targets, outputs)) accuracy.update_state(targets, outputs) self.strategy.run( @@ -217,9 +217,9 @@ class TestTrainerWithSummaries(standard_runner.StandardTrainer): def __init__(self): self.strategy = tf.distribute.get_strategy() self.model = create_model() - self.optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.1) + self.optimizer = tf_keras.optimizers.RMSprop(learning_rate=0.1) self.global_step = self.optimizer.iterations - self.train_loss = tf.keras.metrics.Mean("train_loss", dtype=tf.float32) + self.train_loss = tf_keras.metrics.Mean("train_loss", dtype=tf.float32) train_dataset = self.strategy.distribute_datasets_from_function(dataset_fn) standard_runner.StandardTrainer.__init__( self, @@ -237,7 +237,7 @@ def _replicated_step(inputs): inputs, targets = inputs with tf.GradientTape() as tape: outputs = self.model(inputs) - loss = tf.reduce_mean(tf.keras.losses.MSE(targets, outputs)) + loss = tf.reduce_mean(tf_keras.losses.MSE(targets, outputs)) tf.summary.scalar("loss", loss) grads = tape.gradient(loss, self.model.variables) self.optimizer.apply_gradients(zip(grads, self.model.variables)) diff --git a/orbit/examples/single_task/single_task_evaluator.py b/orbit/examples/single_task/single_task_evaluator.py index fa14844053a..66cb709ba96 100644 --- a/orbit/examples/single_task/single_task_evaluator.py +++ b/orbit/examples/single_task/single_task_evaluator.py @@ -14,7 +14,7 @@ """An evaluator object that can evaluate models with a single output.""" import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras class SingleTaskEvaluator(orbit.StandardEvaluator): @@ -22,7 +22,7 @@ class SingleTaskEvaluator(orbit.StandardEvaluator): This evaluator will handle running a model with one output on a single dataset, and will apply the output of that model to one or more - `tf.keras.metrics.Metric` objects. + `tf_keras.metrics.Metric` objects. """ def __init__(self, @@ -43,8 +43,8 @@ def __init__(self, dictionaries dequeued from `eval_dataset`. This key will be removed from the dictionary before it is passed to the model. model: A `tf.Module` or Keras `Model` object to evaluate. - metrics: A single `tf.keras.metrics.Metric` object, or a list of - `tf.keras.metrics.Metric` objects. + metrics: A single `tf_keras.metrics.Metric` object, or a list of + `tf_keras.metrics.Metric` objects. evaluator_options: An optional `orbit.StandardEvaluatorOptions` object. """ diff --git a/orbit/examples/single_task/single_task_evaluator_test.py b/orbit/examples/single_task/single_task_evaluator_test.py index e544dea6c97..d82c1315e6e 100644 --- a/orbit/examples/single_task/single_task_evaluator_test.py +++ b/orbit/examples/single_task/single_task_evaluator_test.py @@ -17,7 +17,7 @@ from orbit.examples.single_task import single_task_evaluator from orbit.examples.single_task import single_task_trainer -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds @@ -28,25 +28,25 @@ def test_single_task_evaluation(self): iris = tfds.load('iris') train_ds = iris['train'].batch(32) - model = tf.keras.Sequential([ - tf.keras.Input(shape=(4,), name='features'), - tf.keras.layers.Dense(10, activation=tf.nn.relu), - tf.keras.layers.Dense(10, activation=tf.nn.relu), - tf.keras.layers.Dense(3) + model = tf_keras.Sequential([ + tf_keras.Input(shape=(4,), name='features'), + tf_keras.layers.Dense(10, activation=tf.nn.relu), + tf_keras.layers.Dense(10, activation=tf.nn.relu), + tf_keras.layers.Dense(3) ]) trainer = single_task_trainer.SingleTaskTrainer( train_ds, label_key='label', model=model, - loss_fn=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), - optimizer=tf.keras.optimizers.SGD(learning_rate=0.01)) + loss_fn=tf_keras.losses.SparseCategoricalCrossentropy(from_logits=True), + optimizer=tf_keras.optimizers.SGD(learning_rate=0.01)) evaluator = single_task_evaluator.SingleTaskEvaluator( train_ds, label_key='label', model=model, - metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) + metrics=[tf_keras.metrics.SparseCategoricalAccuracy()]) controller = orbit.Controller( trainer=trainer, diff --git a/orbit/examples/single_task/single_task_trainer.py b/orbit/examples/single_task/single_task_trainer.py index 063cc5d5f2a..783f2898f00 100644 --- a/orbit/examples/single_task/single_task_trainer.py +++ b/orbit/examples/single_task/single_task_trainer.py @@ -15,7 +15,7 @@ """A trainer object that can train models with a single output.""" import orbit -import tensorflow as tf +import tensorflow as tf, tf_keras class SingleTaskTrainer(orbit.StandardTrainer): @@ -24,7 +24,7 @@ class SingleTaskTrainer(orbit.StandardTrainer): This trainer will handle running a model with one output on a single dataset. It will apply the provided loss function to the model's output to calculate gradients and will apply them via the provided optimizer. It will - also supply the output of that model to one or more `tf.keras.metrics.Metric` + also supply the output of that model to one or more `tf_keras.metrics.Metric` objects. """ @@ -56,11 +56,11 @@ def __init__(self, loss_fn: A per-element loss function of the form (target, output). The output of this loss function will be reduced via `tf.reduce_mean` to create the final loss. We recommend using the functions in the - `tf.keras.losses` package or `tf.keras.losses.Loss` objects with - `reduction=tf.keras.losses.reduction.NONE`. - optimizer: A `tf.keras.optimizers.Optimizer` instance. - metrics: A single `tf.keras.metrics.Metric` object, or a list of - `tf.keras.metrics.Metric` objects. + `tf_keras.losses` package or `tf_keras.losses.Loss` objects with + `reduction=tf_keras.losses.reduction.NONE`. + optimizer: A `tf_keras.optimizers.Optimizer` instance. + metrics: A single `tf_keras.metrics.Metric` object, or a list of + `tf_keras.metrics.Metric` objects. trainer_options: An optional `orbit.utils.StandardTrainerOptions` object. """ self.label_key = label_key @@ -72,7 +72,7 @@ def __init__(self, self.strategy = tf.distribute.get_strategy() # We always want to report training loss. - self.train_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32) + self.train_loss = tf_keras.metrics.Mean('training_loss', dtype=tf.float32) # We need self.metrics to be an iterable later, so we handle that here. if metrics is None: @@ -109,7 +109,7 @@ def train_fn(inputs): # replicas during the apply_gradients call. # Note, the reduction of loss is explicitly handled and scaled by # num_replicas_in_sync. Recommend to use a plain loss function. - # If you're using tf.keras.losses.Loss object, you may need to set + # If you're using tf_keras.losses.Loss object, you may need to set # reduction argument explicitly. loss = tf.reduce_mean(self.loss_fn(target, output)) scaled_loss = loss / self.strategy.num_replicas_in_sync diff --git a/orbit/examples/single_task/single_task_trainer_test.py b/orbit/examples/single_task/single_task_trainer_test.py index 7837f224238..34dfc22ffa3 100644 --- a/orbit/examples/single_task/single_task_trainer_test.py +++ b/orbit/examples/single_task/single_task_trainer_test.py @@ -16,7 +16,7 @@ import orbit from orbit.examples.single_task import single_task_trainer -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_datasets as tfds @@ -26,20 +26,20 @@ def test_single_task_training(self): iris = tfds.load('iris') train_ds = iris['train'].batch(32).repeat() - model = tf.keras.Sequential([ - tf.keras.Input(shape=(4,), name='features'), - tf.keras.layers.Dense(10, activation=tf.nn.relu), - tf.keras.layers.Dense(10, activation=tf.nn.relu), - tf.keras.layers.Dense(3), - tf.keras.layers.Softmax(), + model = tf_keras.Sequential([ + tf_keras.Input(shape=(4,), name='features'), + tf_keras.layers.Dense(10, activation=tf.nn.relu), + tf_keras.layers.Dense(10, activation=tf.nn.relu), + tf_keras.layers.Dense(3), + tf_keras.layers.Softmax(), ]) trainer = single_task_trainer.SingleTaskTrainer( train_ds, label_key='label', model=model, - loss_fn=tf.keras.losses.sparse_categorical_crossentropy, - optimizer=tf.keras.optimizers.SGD(learning_rate=0.01)) + loss_fn=tf_keras.losses.sparse_categorical_crossentropy, + optimizer=tf_keras.optimizers.SGD(learning_rate=0.01)) controller = orbit.Controller( trainer=trainer, diff --git a/orbit/runner.py b/orbit/runner.py index 2fb2c39c7e9..203632979ff 100644 --- a/orbit/runner.py +++ b/orbit/runner.py @@ -19,7 +19,7 @@ from typing import Dict, Optional, Union import numpy as np -import tensorflow as tf +import tensorflow as tf, tf_keras 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 54181513092..a592c01b977 100644 --- a/orbit/standard_runner.py +++ b/orbit/standard_runner.py @@ -42,7 +42,7 @@ from orbit import runner from orbit.utils import loop_fns -import tensorflow as tf +import tensorflow as tf, tf_keras @dataclasses.dataclass(frozen=True) diff --git a/orbit/standard_runner_test.py b/orbit/standard_runner_test.py index 679ff7d72de..a4d4ce91d7c 100644 --- a/orbit/standard_runner_test.py +++ b/orbit/standard_runner_test.py @@ -19,7 +19,7 @@ from orbit import standard_runner from orbit import utils -import tensorflow as tf +import tensorflow as tf, tf_keras def dataset_fn(input_context=None): diff --git a/orbit/utils/common.py b/orbit/utils/common.py index f44d0ebb507..7233376bfb9 100644 --- a/orbit/utils/common.py +++ b/orbit/utils/common.py @@ -16,7 +16,7 @@ import inspect -import tensorflow as tf +import tensorflow as tf, tf_keras def create_global_step() -> tf.Variable: diff --git a/orbit/utils/common_test.py b/orbit/utils/common_test.py index e98931a29ca..0168f0638ab 100644 --- a/orbit/utils/common_test.py +++ b/orbit/utils/common_test.py @@ -16,7 +16,7 @@ from orbit.utils import common -import tensorflow as tf +import tensorflow as tf, tf_keras class UtilsTest(tf.test.TestCase): diff --git a/orbit/utils/epoch_helper.py b/orbit/utils/epoch_helper.py index 533b9a24c4e..cdc71524f3f 100644 --- a/orbit/utils/epoch_helper.py +++ b/orbit/utils/epoch_helper.py @@ -14,7 +14,7 @@ """Provides a utility class for training in epochs.""" -import tensorflow as tf +import tensorflow as tf, tf_keras class EpochHelper: diff --git a/orbit/utils/loop_fns.py b/orbit/utils/loop_fns.py index 3145d2be82d..d784df26e5f 100644 --- a/orbit/utils/loop_fns.py +++ b/orbit/utils/loop_fns.py @@ -17,7 +17,7 @@ from absl import logging from orbit.utils import tpu_summaries -import tensorflow as tf +import tensorflow as tf, tf_keras def create_loop_fn(step_fn): diff --git a/orbit/utils/summary_manager.py b/orbit/utils/summary_manager.py index 0035eaa2c95..416827f5015 100644 --- a/orbit/utils/summary_manager.py +++ b/orbit/utils/summary_manager.py @@ -18,7 +18,7 @@ from orbit.utils.summary_manager_interface import SummaryManagerInterface -import tensorflow as tf +import tensorflow as tf, tf_keras class SummaryManager(SummaryManagerInterface): diff --git a/orbit/utils/tpu_summaries.py b/orbit/utils/tpu_summaries.py index be039291540..b3d1897104f 100644 --- a/orbit/utils/tpu_summaries.py +++ b/orbit/utils/tpu_summaries.py @@ -17,7 +17,7 @@ import contextlib import functools -import tensorflow as tf +import tensorflow as tf, tf_keras @contextlib.contextmanager diff --git a/orbit/utils/tpu_summaries_test.py b/orbit/utils/tpu_summaries_test.py index 8060ca5fb0e..6aae60a8a6c 100644 --- a/orbit/utils/tpu_summaries_test.py +++ b/orbit/utils/tpu_summaries_test.py @@ -20,7 +20,7 @@ from orbit.utils import common from orbit.utils import tpu_summaries -import tensorflow as tf +import tensorflow as tf, tf_keras class TrainFunctionWithSummaries(tpu_summaries.OptionalSummariesFunction): diff --git a/tensorflow_models/tensorflow_models_test.py b/tensorflow_models/tensorflow_models_test.py index 2fc52b26d61..8fc4d93e88a 100644 --- a/tensorflow_models/tensorflow_models_test.py +++ b/tensorflow_models/tensorflow_models_test.py @@ -14,7 +14,7 @@ """Tests for tensorflow_models imports.""" -import tensorflow as tf +import tensorflow as tf, tf_keras import tensorflow_models as tfm From bf77e8d4de61a4c9834f896c9f1356d9fbf986d3 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Thu, 2 Nov 2023 22:55:30 -0700 Subject: [PATCH 39/42] use tf-keras-nightly to be able to use tf-nightly. PiperOrigin-RevId: 579076319 --- official/nightly_requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/official/nightly_requirements.txt b/official/nightly_requirements.txt index e762d9a826e..54e074d61d6 100644 --- a/official/nightly_requirements.txt +++ b/official/nightly_requirements.txt @@ -10,6 +10,7 @@ scipy>=0.19.1 tensorflow-hub>=0.6.0 tensorflow-model-optimization>=0.4.1 tensorflow-datasets +tf-keras-nightly gin-config tf_slim>=1.1.0 Cython From 799897c261a2e0a3b0898cdfdb4eef3b668e41f0 Mon Sep 17 00:00:00 2001 From: "A. Unique TensorFlower" Date: Fri, 3 Nov 2023 12:54:50 -0700 Subject: [PATCH 40/42] Support stopping inference early when there is an EOS token PiperOrigin-RevId: 579277158 --- official/projects/pix2seq/configs/pix2seq.py | 1 + .../pix2seq/modeling/pix2seq_model.py | 49 ++++++-- .../pix2seq/modeling/pix2seq_model_test.py | 113 ++++++++++++++++++ .../projects/pix2seq/tasks/pix2seq_task.py | 1 + 4 files changed, 152 insertions(+), 12 deletions(-) diff --git a/official/projects/pix2seq/configs/pix2seq.py b/official/projects/pix2seq/configs/pix2seq.py index 79f96857bba..410dd370e7e 100644 --- a/official/projects/pix2seq/configs/pix2seq.py +++ b/official/projects/pix2seq/configs/pix2seq.py @@ -132,6 +132,7 @@ class Pix2Seq(hyperparams.Config): temperature: float = 1.0 top_k: int = 0 top_p: float = 0.4 + eos_token: int | None = None @dataclasses.dataclass diff --git a/official/projects/pix2seq/modeling/pix2seq_model.py b/official/projects/pix2seq/modeling/pix2seq_model.py index 9eaf105901c..b4bf59d3e66 100644 --- a/official/projects/pix2seq/modeling/pix2seq_model.py +++ b/official/projects/pix2seq/modeling/pix2seq_model.py @@ -240,6 +240,7 @@ def __init__( temperature=1.0, top_k=0, top_p=0.4, + eos_token: int | None = None, **kwargs ): super().__init__(**kwargs) @@ -280,6 +281,7 @@ def __init__( self._temperature = temperature self._top_k = top_k self._top_p = top_p + self._eos_token = eos_token @property def backbone(self) -> tf_keras.Model: @@ -304,6 +306,7 @@ def get_config(self): "temperature": self._temperature, "top_k": self._top_k, "top_p": self._top_p, + "eos_token": self._eos_token, "num_heads": self._num_heads, } @@ -369,11 +372,36 @@ def call( temperature=self._temperature, top_k=self._top_k, top_p=self._top_p, + eos_token=self._eos_token, ) return [tokens, logits] +def _create_cond_fn(seq_len: int, eos_token: int | None, prompt_len: int): + """Returns a loop condition for decoder. + + Args: + seq_len: the maximum sequence length. + eos_token: if not None, enable early termination based on end-of-sequence + token. + prompt_len: the length of prompt sequence. + """ + + def cond(step, caches, tokens, logits): + del caches + del logits + within_seq_len = (seq_len > prompt_len) & (step < seq_len - 1) + if eos_token is None: + return within_seq_len + else: + tokens = tokens[prompt_len:step] + reached_eos = tf.reduce_all(tf.reduce_any(tokens == eos_token, axis=0)) + return within_seq_len & tf.logical_not(reached_eos) + + return cond + + class Pix2SeqTransformer(tf_keras.layers.Layer): """Encoder and Decoder of Pix2Seq.""" @@ -521,6 +549,7 @@ def infer( top_k=0, top_p=0.4, sampling_callback=None, + eos_token: int | None = None, ): """Autoregressive (without teacher-forcing) prediction. @@ -542,6 +571,10 @@ def infer( sampling_callback: a callbak `function` that take `next_logits`, and return `next_token`. This is used when users need a specific logic for sampling. Default to `None` with standard free-form sampling. + eos_token: if not None, stop inference early based on this end-of-sequence + (EOS) token. This won't change sequence length. However, for each + sequence, the tokens and logit values after the EOS token will have + undefined behavior based on implementation detail. Returns: sampled tokens with shape of (bsz, max_seq_len-prompt_len). @@ -627,15 +660,6 @@ def loop_body(step, caches, tokens, logits, is_prompt=False): logits = tf.tensor_scatter_nd_update(logits, [[next_step]], [next_logits]) return (next_step, caches, tokens, logits) - def cond(step, caches, tokens, logits): - del caches - del tokens - del logits - return tf.logical_and( - tf.greater(seq_len, prompt_len), - tf.less(step, seq_len - 1) - ) - caches_var = tf.zeros( [seq_len-1, self._num_decoder_layers, bsz, self._hidden_size]) tokens_var = tf.zeros([seq_len, bsz], dtype=tf.int64) @@ -649,11 +673,12 @@ def cond(step, caches, tokens, logits): step, caches_var, tokens_var, logits_var = loop_body( step, caches_var, tokens_var, logits_var, is_prompt=True ) - _, _, tokens_var, logits_var = tf.while_loop( - cond=cond, + cond=_create_cond_fn( + seq_len=seq_len, eos_token=eos_token, prompt_len=prompt_len + ), body=loop_body, - loop_vars=[step, caches_var, tokens_var, logits_var] + loop_vars=[step, caches_var, tokens_var, logits_var], ) sampled_tokens = tf.transpose(tokens_var[prompt_len:], [1, 0]) diff --git a/official/projects/pix2seq/modeling/pix2seq_model_test.py b/official/projects/pix2seq/modeling/pix2seq_model_test.py index 245d12539d7..7fe7a340665 100644 --- a/official/projects/pix2seq/modeling/pix2seq_model_test.py +++ b/official/projects/pix2seq/modeling/pix2seq_model_test.py @@ -96,6 +96,119 @@ def test_forward_infer(self): self.assertLen(tokens, 2) # intermediate decoded outputs. + def test_forward_infer_with_eos(self): + hidden_size = 256 + num_heads = 8 + max_seq_len = 50 + vocab_size = 600 + image_size = 640 + batch_size = 2 + backbone = resnet.ResNet(50, bn_trainable=False) + backbone_endpoint_name = '5' + model = pix2seq_model.Pix2Seq( + backbone, + backbone_endpoint_name, + max_seq_len, + vocab_size, + hidden_size, + num_heads=num_heads, + eos_token=0, + ) + tokens, _ = model( + tf.ones((batch_size, image_size, image_size, 3)), + tf.ones((batch_size, 1), tf.int64) * 10, + False, + ) + + self.assertLen(tokens, 2) # intermediate decoded outputs. + + def test_cond_fn_without_early_stopping(self): + tokens = tf.constant( + # pyformat: disable + [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 0], + [1, 0, 0], + [0, 0, 1], # Should not stop early. + [0, 0, 0], + [0, 0, 0], # Should stop inference here. + ], + # pyformat: enable + dtype=tf.int64 + ) + cond = pix2seq_model._create_cond_fn( + seq_len=tokens.shape[0], + eos_token=None, + prompt_len=1, + ) + expected_results = [True, True, True, True, True, True, False] + + self.assertLen(expected_results, tokens.shape[0]) + for step, expected_result in enumerate(expected_results): + self.assertEqual( + expected_result, + cond(step, None, tokens, None), + msg=f'step={step}', + ) + + def test_cond_fn_with_early_stopping(self): + tokens = tf.constant( + # pyformat: disable + [ + [0, 0, 0], + [0, 0, 0], + [0, 1, 0], + [1, 0, 0], + [0, 0, 1], # Should stop inference here. + [0, 0, 0], + [0, 0, 0], + ], + # pyformat: enable + dtype=tf.int64 + ) + cond = pix2seq_model._create_cond_fn( + seq_len=tokens.shape[0], + eos_token=1, + prompt_len=1, + ) + expected_results = [True, True, True, True, True, False, False] + + self.assertLen(expected_results, tokens.shape[0]) + for step, expected_result in enumerate(expected_results): + self.assertEqual( + expected_result, + cond(step, None, tokens, None), + msg=f'step={step}', + ) + + def test_cond_fn_with_early_stopping_keep_inference_to_end(self): + tokens = tf.constant( + # pyformat: disable + [ + [1, 1, 1], # EOS within prompt should be ignored. + [0, 0, 0], + [0, 1, 0], + [1, 0, 0], # Should keep inferencing until the end. + ], + # pyformat: enable + dtype=tf.int64 + ) + cond = pix2seq_model._create_cond_fn( + seq_len=tokens.shape[0], + eos_token=1, + prompt_len=1, + ) + expected_results = [True, True, True, False] + + self.assertLen(expected_results, tokens.shape[0]) + for step, expected_result in enumerate(expected_results): + self.assertEqual( + expected_result, + cond(step, None, tokens, None), + msg=f'step={step}', + ) + if __name__ == '__main__': tf.test.main() diff --git a/official/projects/pix2seq/tasks/pix2seq_task.py b/official/projects/pix2seq/tasks/pix2seq_task.py index d8b492b4416..cb8bf746ecc 100644 --- a/official/projects/pix2seq/tasks/pix2seq_task.py +++ b/official/projects/pix2seq/tasks/pix2seq_task.py @@ -73,6 +73,7 @@ def build_model(self): temperature=config.temperature, top_p=config.top_p, top_k=config.top_k, + eos_token=config.eos_token, ) return model From 6aba0fc458456023e77940725a73f9891e4c7420 Mon Sep 17 00:00:00 2001 From: sineeli <113718461+sineeli@users.noreply.github.com> Date: Mon, 6 Nov 2023 19:25:30 +0000 Subject: [PATCH 41/42] remove repo cloning and adjust folder paths --- docs/vision/object_detection.ipynb | 118 +++++++++++------------------ 1 file changed, 45 insertions(+), 73 deletions(-) diff --git a/docs/vision/object_detection.ipynb b/docs/vision/object_detection.ipynb index 8c0319382d5..723982ac3b0 100644 --- a/docs/vision/object_detection.ipynb +++ b/docs/vision/object_detection.ipynb @@ -37,20 +37,20 @@ }, "source": [ "# Object detection with Model Garden\n", - "\u003ctable class=\"tfo-notebook-buttons\" align=\"left\"\u003e\n", - " \u003ctd\u003e\n", - " \u003ca target=\"_blank\" href=\"https://www.tensorflow.org/tfmodels/vision/object_detection\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" /\u003eView on TensorFlow.org\u003c/a\u003e\n", - " \u003c/td\u003e\n", - " \u003ctd\u003e\n", - " \u003ca target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/models/blob/master/docs/vision/object_detection.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" /\u003eRun in Google Colab\u003c/a\u003e\n", - " \u003c/td\u003e\n", - " \u003ctd\u003e\n", - " \u003ca target=\"_blank\" href=\"https://github.com/tensorflow/models/blob/master/docs/vision/object_detection.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" /\u003eView on GitHub\u003c/a\u003e\n", - " \u003c/td\u003e\n", - " \u003ctd\u003e\n", - " \u003ca href=\"https://storage.googleapis.com/tensorflow_docs/models/docs/vision/object_detection.ipynb\"\u003e\u003cimg src=\"https://www.tensorflow.org/images/download_logo_32px.png\" /\u003eDownload notebook\u003c/a\u003e\n", - " \u003c/td\u003e\n", - "\u003c/table\u003e" + "\n", + " \n", + " \n", + " \n", + " \n", + "
    \n", + " View on TensorFlow.org\n", + " \n", + " Run in Google Colab\n", + " \n", + " View on GitHub\n", + " \n", + " Download notebook\n", + "
    " ] }, { @@ -87,7 +87,7 @@ }, "outputs": [], "source": [ - "!pip install -U -q \"tensorflow\" \"tf-models-official\"" + "!pip install -U -q \"tf-models-official\"" ] }, { @@ -170,26 +170,6 @@ "Please check [this resource](https://www.tensorflow.org/tutorials/load_data/tfrecord) to learn more about TFRecords data format.\n" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "YcFW-xHRZ1xJ" - }, - "source": [ - "### clone the model-garden repo as the required data conversion codes are within this model-garden repository" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "tZLidUjiY1xt" - }, - "outputs": [], - "source": [ - "!git clone --quiet https://github.com/tensorflow/models.git" - ] - }, { "cell_type": "markdown", "metadata": { @@ -207,31 +187,11 @@ }, "outputs": [], "source": [ - "!curl -L 'https://public.roboflow.com/ds/ZpYLqHeT0W?key=ZXfZLRnhsc' \u003e './BCCD.v1-bccd.coco.zip'\n", + "!curl -L 'https://public.roboflow.com/ds/ZpYLqHeT0W?key=ZXfZLRnhsc' > './BCCD.v1-bccd.coco.zip'\n", "!unzip -q -o './BCCD.v1-bccd.coco.zip' -d './BCC.v1-bccd.coco/'\n", "!rm './BCCD.v1-bccd.coco.zip'" ] }, - { - "cell_type": "markdown", - "metadata": { - "id": "jKJ3MtgeZ5om" - }, - "source": [ - "### Change directory to vision or data where data conversion tools are available" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "IYM7PIFbY5EL" - }, - "outputs": [], - "source": [ - "%cd ./models/" - ] - }, { "cell_type": "markdown", "metadata": { @@ -251,9 +211,9 @@ "source": [ "%%bash\n", "\n", - "TRAIN_DATA_DIR='../BCC.v1-bccd.coco/train'\n", - "TRAIN_ANNOTATION_FILE_DIR='../BCC.v1-bccd.coco/train/_annotations.coco.json'\n", - "OUTPUT_TFRECORD_TRAIN='../bccd_coco_tfrecords/train'\n", + "TRAIN_DATA_DIR='./BCC.v1-bccd.coco/train'\n", + "TRAIN_ANNOTATION_FILE_DIR='./BCC.v1-bccd.coco/train/_annotations.coco.json'\n", + "OUTPUT_TFRECORD_TRAIN='./bccd_coco_tfrecords/train'\n", "\n", "# Need to provide\n", " # 1. image_dir: where images are present\n", @@ -285,9 +245,9 @@ "source": [ "%%bash\n", "\n", - "VALID_DATA_DIR='../BCC.v1-bccd.coco/valid'\n", - "VALID_ANNOTATION_FILE_DIR='../BCC.v1-bccd.coco/valid/_annotations.coco.json'\n", - "OUTPUT_TFRECORD_VALID='../bccd_coco_tfrecords/valid'\n", + "VALID_DATA_DIR='./BCC.v1-bccd.coco/valid'\n", + "VALID_ANNOTATION_FILE_DIR='./BCC.v1-bccd.coco/valid/_annotations.coco.json'\n", + "OUTPUT_TFRECORD_VALID='./bccd_coco_tfrecords/valid'\n", "\n", "python -m official.vision.data.create_coco_tf_record --logtostderr \\\n", " --image_dir=$VALID_DATA_DIR \\\n", @@ -315,8 +275,8 @@ "source": [ "%%bash\n", "\n", - "TEST_DATA_DIR='../BCC.v1-bccd.coco/test'\n", - "TEST_ANNOTATION_FILE_DIR='../BCC.v1-bccd.coco/test/_annotations.coco.json'\n", + "TEST_DATA_DIR='./BCC.v1-bccd.coco/test'\n", + "TEST_ANNOTATION_FILE_DIR='./BCC.v1-bccd.coco/test/_annotations.coco.json'\n", "OUTPUT_TFRECORD_TEST='../bccd_coco_tfrecords/test'\n", "\n", "python -m official.vision.data.create_coco_tf_record --logtostderr \\\n", @@ -345,11 +305,11 @@ }, "outputs": [], "source": [ - "train_data_input_path = '../bccd_coco_tfrecords/train-00000-of-00001.tfrecord'\n", - "valid_data_input_path = '../bccd_coco_tfrecords/valid-00000-of-00001.tfrecord'\n", - "test_data_input_path = '../bccd_coco_tfrecords/test-00000-of-00001.tfrecord'\n", - "model_dir = '../trained_model/'\n", - "export_dir ='../exported_model/'" + "train_data_input_path = './bccd_coco_tfrecords/train-00000-of-00001.tfrecord'\n", + "valid_data_input_path = './bccd_coco_tfrecords/valid-00000-of-00001.tfrecord'\n", + "test_data_input_path = './bccd_coco_tfrecords/test-00000-of-00001.tfrecord'\n", + "model_dir = './trained_model/'\n", + "export_dir ='./exported_model/'" ] }, { @@ -534,7 +494,7 @@ "source": [ "## Create the `Task` object (`tfm.core.base_task.Task`) from the `config_definitions.TaskConfig`.\n", "\n", - "The `Task` object has all the methods necessary for building the dataset, building the model, and running training \u0026 evaluation. These methods are driven by `tfm.core.train_lib.run_experiment`." + "The `Task` object has all the methods necessary for building the dataset, building the model, and running training & evaluation. These methods are driven by `tfm.core.train_lib.run_experiment`." ] }, { @@ -699,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": { "id": "SCjHHXvfZXX1" }, @@ -732,7 +692,7 @@ "outputs": [], "source": [ "%load_ext tensorboard\n", - "%tensorboard --logdir '../trained_model/'" + "%tensorboard --logdir './trained_model/'" ] }, { @@ -840,7 +800,7 @@ "num_of_examples = 3\n", "\n", "test_ds = tf.data.TFRecordDataset(\n", - " '../bccd_coco_tfrecords/test-00000-of-00001.tfrecord').take(\n", + " './bccd_coco_tfrecords/test-00000-of-00001.tfrecord').take(\n", " num_of_examples)\n", "show_batch(test_ds, num_of_examples)" ] @@ -923,6 +883,18 @@ "kernelspec": { "display_name": "Python 3", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.8" } }, "nbformat": 4, From ad1f7b56943998864db8f5db0706950e93bb7d81 Mon Sep 17 00:00:00 2001 From: sineeli <113718461+sineeli@users.noreply.github.com> Date: Mon, 6 Nov 2023 19:26:15 +0000 Subject: [PATCH 42/42] adjust folder path --- docs/vision/object_detection.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/vision/object_detection.ipynb b/docs/vision/object_detection.ipynb index 723982ac3b0..f27c4b0d509 100644 --- a/docs/vision/object_detection.ipynb +++ b/docs/vision/object_detection.ipynb @@ -277,7 +277,7 @@ "\n", "TEST_DATA_DIR='./BCC.v1-bccd.coco/test'\n", "TEST_ANNOTATION_FILE_DIR='./BCC.v1-bccd.coco/test/_annotations.coco.json'\n", - "OUTPUT_TFRECORD_TEST='../bccd_coco_tfrecords/test'\n", + "OUTPUT_TFRECORD_TEST='./bccd_coco_tfrecords/test'\n", "\n", "python -m official.vision.data.create_coco_tf_record --logtostderr \\\n", " --image_dir=$TEST_DATA_DIR \\\n",

    y3pGy(+t2fyeiO3 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