Add files using upload-large-folder tool

docker/bloom13b/Model-References/TensorFlow/nlp/bert/LICENSE

@@ -0,0 +1,203 @@
+Copyright (c) 2021 Habana Labs, Ltd. an Intel Company
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

docker/bloom13b/Model-References/TensorFlow/nlp/bert/bf16_config/bert.json

@@ -0,0 +1,60 @@
+{
+    "allowlist": [
+        "_ScopedAllocatorSplit",
+        "_ScopedAllocatorConcat",
+        "_ScopedAllocator",
+        "BatchMatMul",
+        "BatchMatMulV2",
+        "BiasAdd",
+        "BiasAddGrad",
+        "EuclideanNorm",
+        "Exp",
+        "HabanaDropout",
+        "HabanaDropoutGrad",
+        "HabanaDropoutStateful",
+        "HabanaGelu",
+        "HabanaGeluGrad",
+        "HabanaLayerNorm",
+        "HabanaLayerNormV2",
+        "HabanaLayerNormGrad",
+        "HabanaLayerNormGradV2",
+        "HabanaMaskedSoftmax",
+        "HabanaSoftmaxGrad",
+        "HabanaLogSoftmaxGrad",
+        "HorovodAllgather",
+        "HorovodAllreduce",
+        "L2Loss",
+        "Log",
+        "LogSoftmax",
+        "MatMul",
+        "Softmax",
+        "Sum",
+        "Tanh",
+        "TanhGrad"
+    ],
+    "conditional_list": [
+        "Add",
+        "AddV2",
+        "AddN",
+        "ExpandDims",
+        "Identity",
+        "Neg",
+        "Reshape",
+        "Slice",
+        "Split",
+        "StridedSliceGrad",
+        "Transpose"
+    ],
+    "strict_conditional_list": [],
+    "non_convertible_exceptions": [
+        [".*KEEP_FP32_PRECISION.*", ""]
+    ],
+    "convertible_exceptions": [
+        ["bert/encoder/layer_[0-9]+/attention/self/add", "AddV2"],
+        ["bert/encoder/layer_[0-9]+/attention/self/Mul", "Mul"],
+        ["clip_by_global_norm/mul", "Mul"],
+        ["global_norm/mul", "Mul"],
+        ["global_norm/global_norm", "Sqrt"],
+        [".*FORCE_BF16_PRECISION.*", ""]
+    ]
+}

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data/sample_text.txt

@@ -0,0 +1,33 @@
+This text is included to make sure Unicode is handled properly: 力加勝北区ᴵᴺᵀᵃছজটডণত
+Text should be one-sentence-per-line, with empty lines between documents.
+This sample text is public domain and was randomly selected from Project Guttenberg.
+
+The rain had only ceased with the gray streaks of morning at Blazing Star, and the settlement awoke to a moral sense of cleanliness, and the finding of forgotten knives, tin cups, and smaller camp utensils, where the heavy showers had washed away the debris and dust heaps before the cabin doors.
+Indeed, it was recorded in Blazing Star that a fortunate early riser had once picked up on the highway a solid chunk of gold quartz which the rain had freed from its incumbering soil, and washed into immediate and glittering popularity.
+Possibly this may have been the reason why early risers in that locality, during the rainy season, adopted a thoughtful habit of body, and seldom lifted their eyes to the rifted or india-ink washed skies above them.
+"Cass" Beard had risen early that morning, but not with a view to discovery.
+A leak in his cabin roof,--quite consistent with his careless, improvident habits,--had roused him at 4 A. M., with a flooded "bunk" and wet blankets.
+The chips from his wood pile refused to kindle a fire to dry his bed-clothes, and he had recourse to a more provident neighbor's to supply the deficiency.
+This was nearly opposite.
+Mr. Cassius crossed the highway, and stopped suddenly.
+Something glittered in the nearest red pool before him.
+Gold, surely!
+But, wonderful to relate, not an irregular, shapeless fragment of crude ore, fresh from Nature's crucible, but a bit of jeweler's handicraft in the form of a plain gold ring.
+Looking at it more attentively, he saw that it bore the inscription, "May to Cass."
+Like most of his fellow gold-seekers, Cass was superstitious.
+
+The fountain of classic wisdom, Hypatia herself.
+As the ancient sage--the name is unimportant to a monk--pumped water nightly that he might study by day, so I, the guardian of cloaks and parasols, at the sacred doors of her lecture-room, imbibe celestial knowledge.
+From my youth I felt in me a soul above the matter-entangled herd.
+She revealed to me the glorious fact, that I am a spark of Divinity itself.
+A fallen star, I am, sir!' continued he, pensively, stroking his lean stomach--'a fallen star!--fallen, if the dignity of philosophy will allow of the simile, among the hogs of the lower world--indeed, even into the hog-bucket itself. Well, after all, I will show you the way to the Archbishop's.
+There is a philosophic pleasure in opening one's treasures to the modest young.
+Perhaps you will assist me by carrying this basket of fruit?' And the little man jumped up, put his basket on Philammon's head, and trotted off up a neighbouring street.
+Philammon followed, half contemptuous, half wondering at what this philosophy might be, which could feed the self-conceit of anything so abject as his ragged little apish guide;
+but the novel roar and whirl of the street, the perpetual stream of busy faces, the line of curricles, palanquins, laden asses, camels, elephants, which met and passed him, and squeezed him up steps and into doorways, as they threaded their way through the great Moon-gate into the ample street beyond, drove everything from his mind but wondering curiosity, and a vague, helpless dread of that great living wilderness, more terrible than any dead wilderness of sand which he had left behind.
+Already he longed for the repose, the silence of the Laura--for faces which knew him and smiled upon him; but it was too late to turn back now.
+His guide held on for more than a mile up the great main street, crossed in the centre of the city, at right angles, by one equally magnificent, at each end of which, miles away, appeared, dim and distant over the heads of the living stream of passengers, the yellow sand-hills of the desert;
+while at the end of the vista in front of them gleamed the blue harbour, through a network of countless masts.
+At last they reached the quay at the opposite end of the street;
+and there burst on Philammon's astonished eyes a vast semicircle of blue sea, ringed with palaces and towers.
+He stopped involuntarily; and his little guide stopped also, and looked askance at the young monk, to watch the effect which that grand panorama should produce on him.

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/BooksDownloader.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+#
+# Changes:
+# - Modified path hard-coded for Nvidia container
+###############################################################################
+
+import subprocess
+import sys
+
+class BooksDownloader:
+    def __init__(self, save_path):
+        self.save_path = save_path
+        pass
+
+
+    def download(self):
+        import os
+        working_dir = os.getcwd()
+        args = '--list ' + working_dir + '/bookcorpus/url_list.jsonl --out'
+        bookscorpus_download_command = f'{sys.executable} ' + working_dir + '/bookcorpus/download_files.py ' + args
+        bookscorpus_download_command += ' ' + self.save_path + '/bookscorpus'
+        bookscorpus_download_command += ' --trash-bad-count'
+        print("Downloading BookCorpus command: ", bookscorpus_download_command)
+        bookscorpus_download_process = subprocess.run(bookscorpus_download_command, shell=True, check=True)

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/BookscorpusTextFormatting.py

@@ -0,0 +1,32 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+import glob
+import os
+
+class BookscorpusTextFormatting:
+    def __init__(self, books_path, output_filename, recursive = False):
+        self.books_path = books_path
+        self.recursive = recursive
+        self.output_filename = output_filename
+
+
+    # This puts one book per line
+    def merge(self):
+        with open(self.output_filename, mode='w', newline='\n') as ofile:
+            for filename in glob.glob(self.books_path + '/' + '*.txt', recursive=True):
+                with open(filename, mode='r', encoding='utf-8-sig', newline='\n') as file:
+                    for line in file:
+                        if line.strip() != '':
+                            ofile.write(line.strip() + ' ')
+                ofile.write("\n\n")

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/Downloader.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+#
+# Changes:
+# - Removed downloading datasets that are not related to BERT pretrain
+###############################################################################
+
+from GooglePretrainedWeightDownloader import GooglePretrainedWeightDownloader
+from WikiDownloader import WikiDownloader
+from BooksDownloader import BooksDownloader
+
+class Downloader:
+    def __init__(self, dataset_name, save_path):
+        self.dataset_name = dataset_name
+        self.save_path = save_path
+
+
+    def download(self):
+        if self.dataset_name == 'bookscorpus':
+            self.download_bookscorpus()
+
+        elif self.dataset_name == 'wikicorpus_en':
+            self.download_wikicorpus('en')
+
+        elif self.dataset_name == 'wikicorpus_zh':
+            self.download_wikicorpus('zh')
+
+        elif self.dataset_name == 'google_pretrained_weights':
+            self.download_google_pretrained_weights()
+
+        elif self.dataset_name == 'all':
+            self.download_bookscorpus()
+            self.download_wikicorpus('en')
+            self.download_wikicorpus('zh')
+            self.download_google_pretrained_weights()
+
+        else:
+            print(self.dataset_name)
+            assert False, 'Unknown dataset_name provided to downloader'
+
+
+    def download_bookscorpus(self):
+        downloader = BooksDownloader(self.save_path)
+        downloader.download()
+
+
+    def download_wikicorpus(self, language):
+        downloader = WikiDownloader(language, self.save_path)
+        downloader.download()
+
+
+    def download_google_pretrained_weights(self):
+        downloader = GooglePretrainedWeightDownloader(self.save_path)
+        downloader.download()
+

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/GooglePretrainedWeightDownloader.py

@@ -0,0 +1,158 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+import hashlib
+import os
+import urllib.request
+import zipfile
+
+class GooglePretrainedWeightDownloader:
+    def __init__(self, save_path):
+        self.save_path = save_path + '/google_pretrained_weights'
+
+        if not os.path.exists(self.save_path):
+            os.makedirs(self.save_path)
+
+        # Download urls
+        self.model_urls = {
+            'bert_base_uncased': ('https://storage.googleapis.com/bert_models/2018_10_18/uncased_L-12_H-768_A-12.zip', 'uncased_L-12_H-768_A-12.zip'),
+            'bert_large_uncased': ('https://storage.googleapis.com/bert_models/2018_10_18/uncased_L-24_H-1024_A-16.zip', 'uncased_L-24_H-1024_A-16.zip'),
+            'bert_base_cased': ('https://storage.googleapis.com/bert_models/2018_10_18/cased_L-12_H-768_A-12.zip', 'cased_L-12_H-768_A-12.zip'),
+            'bert_large_cased': ('https://storage.googleapis.com/bert_models/2018_10_18/cased_L-24_H-1024_A-16.zip', 'cased_L-24_H-1024_A-16.zip'),
+            'bert_base_multilingual_cased': ('https://storage.googleapis.com/bert_models/2018_11_23/multi_cased_L-12_H-768_A-12.zip', 'multi_cased_L-12_H-768_A-12.zip'),
+            'bert_large_multilingual_uncased': ('https://storage.googleapis.com/bert_models/2018_11_03/multilingual_L-12_H-768_A-12.zip', 'multilingual_L-12_H-768_A-12.zip'),
+            'bert_base_chinese': ('https://storage.googleapis.com/bert_models/2018_11_03/chinese_L-12_H-768_A-12.zip', 'chinese_L-12_H-768_A-12.zip')
+        }
+
+        # SHA256sum verification for file download integrity (and checking for changes from the download source over time)
+        self.bert_base_uncased_sha = {
+            'bert_config.json': '7b4e5f53efbd058c67cda0aacfafb340113ea1b5797d9ce6ee411704ba21fcbc',
+            'bert_model.ckpt.data-00000-of-00001': '58580dc5e0bf0ae0d2efd51d0e8272b2f808857f0a43a88aaf7549da6d7a8a84',
+            'bert_model.ckpt.index': '04c1323086e2f1c5b7c0759d8d3e484afbb0ab45f51793daab9f647113a0117b',
+            'bert_model.ckpt.meta': 'dd5682170a10c3ea0280c2e9b9a45fee894eb62da649bbdea37b38b0ded5f60e',
+            'vocab.txt': '07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3',
+        }
+
+        self.bert_large_uncased_sha = {
+            'bert_config.json': 'bfa42236d269e2aeb3a6d30412a33d15dbe8ea597e2b01dc9518c63cc6efafcb',
+            'bert_model.ckpt.data-00000-of-00001': 'bc6b3363e3be458c99ecf64b7f472d2b7c67534fd8f564c0556a678f90f4eea1',
+            'bert_model.ckpt.index': '68b52f2205ffc64dc627d1120cf399c1ef1cbc35ea5021d1afc889ffe2ce2093',
+            'bert_model.ckpt.meta': '6fcce8ff7628f229a885a593625e3d5ff9687542d5ef128d9beb1b0c05edc4a1',
+            'vocab.txt': '07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3',
+        }
+
+        self.bert_base_cased_sha = {
+            'bert_config.json': 'f11dfb757bea16339a33e1bf327b0aade6e57fd9c29dc6b84f7ddb20682f48bc',
+            'bert_model.ckpt.data-00000-of-00001': '734d5a1b68bf98d4e9cb6b6692725d00842a1937af73902e51776905d8f760ea',
+            'bert_model.ckpt.index': '517d6ef5c41fc2ca1f595276d6fccf5521810d57f5a74e32616151557790f7b1',
+            'bert_model.ckpt.meta': '5f8a9771ff25dadd61582abb4e3a748215a10a6b55947cbb66d0f0ba1694be98',
+            'vocab.txt': 'eeaa9875b23b04b4c54ef759d03db9d1ba1554838f8fb26c5d96fa551df93d02',
+        }
+
+        self.bert_large_cased_sha = {
+            'bert_config.json': '7adb2125c8225da495656c982fd1c5f64ba8f20ad020838571a3f8a954c2df57',
+            'bert_model.ckpt.data-00000-of-00001': '6ff33640f40d472f7a16af0c17b1179ca9dcc0373155fb05335b6a4dd1657ef0',
+            'bert_model.ckpt.index': 'ef42a53f577fbe07381f4161b13c7cab4f4fc3b167cec6a9ae382c53d18049cf',
+            'bert_model.ckpt.meta': 'd2ddff3ed33b80091eac95171e94149736ea74eb645e575d942ec4a5e01a40a1',
+            'vocab.txt': 'eeaa9875b23b04b4c54ef759d03db9d1ba1554838f8fb26c5d96fa551df93d02',
+        }
+
+        self.bert_base_multilingual_cased_sha = {
+            'bert_config.json': 'e76c3964bc14a8bb37a5530cdc802699d2f4a6fddfab0611e153aa2528f234f0',
+            'bert_model.ckpt.data-00000-of-00001': '55b8a2df41f69c60c5180e50a7c31b7cdf6238909390c4ddf05fbc0d37aa1ac5',
+            'bert_model.ckpt.index': '7d8509c2a62b4e300feb55f8e5f1eef41638f4998dd4d887736f42d4f6a34b37',
+            'bert_model.ckpt.meta': '95e5f1997e8831f1c31e5cf530f1a2e99f121e9cd20887f2dce6fe9e3343e3fa',
+            'vocab.txt': 'fe0fda7c425b48c516fc8f160d594c8022a0808447475c1a7c6d6479763f310c',
+        }
+
+        self.bert_large_multilingual_uncased_sha = {
+            'bert_config.json': '49063bb061390211d2fdd108cada1ed86faa5f90b80c8f6fdddf406afa4c4624',
+            'bert_model.ckpt.data-00000-of-00001': '3cd83912ebeb0efe2abf35c9f1d5a515d8e80295e61c49b75c8853f756658429',
+            'bert_model.ckpt.index': '87c372c1a3b1dc7effaaa9103c80a81b3cbab04c7933ced224eec3b8ad2cc8e7',
+            'bert_model.ckpt.meta': '27f504f34f02acaa6b0f60d65195ec3e3f9505ac14601c6a32b421d0c8413a29',
+            'vocab.txt': '87b44292b452f6c05afa49b2e488e7eedf79ea4f4c39db6f2f4b37764228ef3f',
+        }
+
+        self.bert_base_chinese_sha = {
+            'bert_config.json': '7aaad0335058e2640bcb2c2e9a932b1cd9da200c46ea7b8957d54431f201c015',
+            'bert_model.ckpt.data-00000-of-00001': '756699356b78ad0ef1ca9ba6528297bcb3dd1aef5feadd31f4775d7c7fc989ba',
+            'bert_model.ckpt.index': '46315546e05ce62327b3e2cd1bed22836adcb2ff29735ec87721396edb21b82e',
+            'bert_model.ckpt.meta': 'c0f8d51e1ab986604bc2b25d6ec0af7fd21ff94cf67081996ec3f3bf5d823047',
+            'vocab.txt': '45bbac6b341c319adc98a532532882e91a9cefc0329aa57bac9ae761c27b291c',
+        }
+
+        # Relate SHA to urls for loop below
+        self.model_sha = {
+            'bert_base_uncased': self.bert_base_uncased_sha,
+            'bert_large_uncased': self.bert_large_uncased_sha,
+            'bert_base_cased': self.bert_base_cased_sha,
+            'bert_large_cased': self.bert_large_cased_sha,
+            'bert_base_multilingual_cased': self.bert_base_multilingual_cased_sha,
+            'bert_large_multilingual_uncased': self.bert_large_multilingual_uncased_sha,
+            'bert_base_chinese': self.bert_base_chinese_sha
+        }
+
+    # Helper to get sha256sum of a file
+    def sha256sum(self, filename):
+      h  = hashlib.sha256()
+      b  = bytearray(128*1024)
+      mv = memoryview(b)
+      with open(filename, 'rb', buffering=0) as f:
+        for n in iter(lambda : f.readinto(mv), 0):
+          h.update(mv[:n])
+
+      return h.hexdigest()
+
+    def download(self):
+        # Iterate over urls: download, unzip, verify sha256sum
+        found_mismatch_sha = False
+        for model in self.model_urls:
+          url = self.model_urls[model][0]
+          file = self.save_path + '/' + self.model_urls[model][1]
+
+          print('Downloading', url)
+          response = urllib.request.urlopen(url)
+          with open(file, 'wb') as handle:
+            handle.write(response.read())
+
+          print('Unzipping', file)
+          zip = zipfile.ZipFile(file, 'r')
+          zip.extractall(self.save_path)
+          zip.close()
+
+          sha_dict = self.model_sha[model]
+          for extracted_file in sha_dict:
+            sha = sha_dict[extracted_file]
+            if sha != self.sha256sum(file[:-4] + '/' + extracted_file):
+              found_mismatch_sha = True
+              print('SHA256sum does not match on file:', extracted_file, 'from download url:', url)
+            else:
+              print(file[:-4] + '/' + extracted_file, '\t', 'verified')
+
+        if not found_mismatch_sha:
+          print("All downloads pass sha256sum verification.")
+
+    def serialize(self):
+        pass
+
+    def deserialize(self):
+        pass
+
+    def listAvailableWeights(self):
+        print("Available Weight Datasets")
+        for item in self.model_urls:
+            print(item)
+
+    def listLocallyStoredWeights(self):
+        pass
+

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/TextSharding.py

@@ -0,0 +1,331 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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 collections import defaultdict
+from itertools import islice
+
+import multiprocessing
+import os
+import statistics
+
+class Sharding:
+    def __init__(self, input_files, output_name_prefix, n_training_shards, n_test_shards, fraction_test_set):
+        assert len(input_files) > 0, 'The input file list must contain at least one file.'
+        assert n_training_shards > 0, 'There must be at least one output shard.'
+        assert n_test_shards > 0, 'There must be at least one output shard.'
+
+        self.n_training_shards = n_training_shards
+        self.n_test_shards = n_test_shards
+        self.fraction_test_set = fraction_test_set
+
+        self.input_files = input_files
+
+        self.output_name_prefix = output_name_prefix
+        self.output_training_identifier = '_training'
+        self.output_test_identifier = '_test'
+        self.output_file_extension = '.txt'
+
+        self.articles = {}    # key: integer identifier, value: list of articles
+        self.sentences = {}    # key: integer identifier, value: list of sentences
+        self.output_training_files = {}    # key: filename, value: list of articles to go into file
+        self.output_test_files = {}  # key: filename, value: list of articles to go into file
+
+        self.init_output_files()
+
+
+    # Remember, the input files contain one article per line (the whitespace check is to skip extraneous blank lines)
+    def load_articles(self):
+        print('Start: Loading Articles')
+
+        global_article_count = 0
+        for input_file in self.input_files:
+            print('input file:', input_file)
+            with open(input_file, mode='r', newline='\n') as f:
+                for i, line in enumerate(f):
+                    if line.strip():
+                        self.articles[global_article_count] = line.rstrip()
+                        global_article_count += 1
+
+        print('End: Loading Articles: There are', len(self.articles), 'articles.')
+
+
+    def segment_articles_into_sentences(self, segmenter):
+        print('Start: Sentence Segmentation')
+        if len(self.articles) is 0:
+            self.load_articles()
+
+        assert len(self.articles) is not 0, 'Please check that input files are present and contain data.'
+
+        # TODO: WIP: multiprocessing (create independent ranges and spawn processes)
+        use_multiprocessing = 'serial'
+
+        def chunks(data, size=len(self.articles)):
+            it = iter(data)
+            for i in range(0, len(data), size):
+                yield {k: data[k] for k in islice(it, size)}
+
+        if use_multiprocessing == 'manager':
+            manager = multiprocessing.Manager()
+            return_dict = manager.dict()
+            jobs = []
+            n_processes = 7    # in addition to the main process, total = n_proc+1
+
+            def work(articles, return_dict):
+                sentences = {}
+                for i, article in enumerate(articles):
+                    sentences[i] = segmenter.segment_string(articles[article])
+
+                    if i % 5000 == 0:
+                        print('Segmenting article', i)
+
+                return_dict.update(sentences)
+
+            for item in chunks(self.articles, len(self.articles)):
+                p = multiprocessing.Process(target=work, args=(item, return_dict))
+
+                # Busy wait
+                while len(jobs) >= n_processes:
+                    pass
+
+                jobs.append(p)
+                p.start()
+
+            for proc in jobs:
+                proc.join()
+
+        elif use_multiprocessing == 'queue':
+            work_queue = multiprocessing.Queue()
+            jobs = []
+
+            for item in chunks(self.articles, len(self.articles)):
+                pass
+
+        else:    # serial option
+            for i, article in enumerate(self.articles):
+                self.sentences[i] = segmenter.segment_string(self.articles[article])
+
+                if i % 5000 == 0:
+                    print('Segmenting article', i)
+
+        print('End: Sentence Segmentation')
+
+
+    def init_output_files(self):
+        print('Start: Init Output Files')
+        assert len(self.output_training_files) is 0, 'Internal storage self.output_files already contains data. This function is intended to be used by the constructor only.'
+        assert len(self.output_test_files) is 0, 'Internal storage self.output_files already contains data. This function is intended to be used by the constructor only.'
+
+        for i in range(self.n_training_shards):
+            name = self.output_name_prefix + self.output_training_identifier + '_' + str(i) + self.output_file_extension
+            self.output_training_files[name] = []
+
+        for i in range(self.n_test_shards):
+            name = self.output_name_prefix + self.output_test_identifier + '_' + str(i) + self.output_file_extension
+            self.output_test_files[name] = []
+
+        print('End: Init Output Files')
+
+
+    def get_sentences_per_shard(self, shard):
+        result = 0
+        for article_id in shard:
+            result += len(self.sentences[article_id])
+
+        return result
+
+
+    def distribute_articles_over_shards(self):
+        print('Start: Distribute Articles Over Shards')
+        assert len(self.articles) >= self.n_training_shards + self.n_test_shards, 'There are fewer articles than shards. Please add more data or reduce the number of shards requested.'
+
+        # Create dictionary with - key: sentence count per article, value: article id number
+        sentence_counts = defaultdict(lambda: [])
+
+        max_sentences = 0
+        total_sentences = 0
+
+        for article_id in self.sentences:
+            current_length = len(self.sentences[article_id])
+            sentence_counts[current_length].append(article_id)
+            max_sentences = max(max_sentences, current_length)
+            total_sentences += current_length
+
+        n_sentences_assigned_to_training = int((1 - self.fraction_test_set) * total_sentences)
+        nominal_sentences_per_training_shard = n_sentences_assigned_to_training // self.n_training_shards
+        nominal_sentences_per_test_shard = (total_sentences - n_sentences_assigned_to_training) // self.n_test_shards
+
+        consumed_article_set = set({})
+        unused_article_set = set(self.articles.keys())
+
+        # Make first pass and add one article worth of lines per file
+        for file in self.output_training_files:
+            current_article_id = sentence_counts[max_sentences][-1]
+            sentence_counts[max_sentences].pop(-1)
+            self.output_training_files[file].append(current_article_id)
+            consumed_article_set.add(current_article_id)
+            unused_article_set.remove(current_article_id)
+
+            # Maintain the max sentence count
+            while len(sentence_counts[max_sentences]) == 0 and max_sentences > 0:
+                max_sentences -= 1
+
+            if len(self.sentences[current_article_id]) > nominal_sentences_per_training_shard:
+                nominal_sentences_per_training_shard = len(self.sentences[current_article_id])
+                print('Warning: A single article contains more than the nominal number of sentences per training shard.')
+
+        for file in self.output_test_files:
+            current_article_id = sentence_counts[max_sentences][-1]
+            sentence_counts[max_sentences].pop(-1)
+            self.output_test_files[file].append(current_article_id)
+            consumed_article_set.add(current_article_id)
+            unused_article_set.remove(current_article_id)
+
+            # Maintain the max sentence count
+            while len(sentence_counts[max_sentences]) == 0 and max_sentences > 0:
+                max_sentences -= 1
+
+            if len(self.sentences[current_article_id]) > nominal_sentences_per_test_shard:
+                nominal_sentences_per_test_shard = len(self.sentences[current_article_id])
+                print('Warning: A single article contains more than the nominal number of sentences per test shard.')
+
+        training_counts = []
+        test_counts = []
+
+        for shard in self.output_training_files:
+            training_counts.append(self.get_sentences_per_shard(self.output_training_files[shard]))
+
+        for shard in self.output_test_files:
+            test_counts.append(self.get_sentences_per_shard(self.output_test_files[shard]))
+
+        training_median = statistics.median(training_counts)
+        test_median = statistics.median(test_counts)
+
+        # Make subsequent passes over files to find articles to add without going over limit
+        history_remaining = []
+        n_history_remaining = 4
+
+        while len(consumed_article_set) < len(self.articles):
+            for fidx, file in enumerate(self.output_training_files):
+                nominal_next_article_size = min(nominal_sentences_per_training_shard - training_counts[fidx], max_sentences)
+
+                # Maintain the max sentence count
+                while len(sentence_counts[max_sentences]) == 0 and max_sentences > 0:
+                    max_sentences -= 1
+
+                while len(sentence_counts[nominal_next_article_size]) == 0 and nominal_next_article_size > 0:
+                    nominal_next_article_size -= 1
+
+                if nominal_next_article_size not in sentence_counts or nominal_next_article_size is 0 or training_counts[fidx] > training_median:
+                    continue    # skip adding to this file, will come back later if no file can accept unused articles
+
+                current_article_id = sentence_counts[nominal_next_article_size][-1]
+                sentence_counts[nominal_next_article_size].pop(-1)
+
+                self.output_training_files[file].append(current_article_id)
+                consumed_article_set.add(current_article_id)
+                unused_article_set.remove(current_article_id)
+
+            for fidx, file in enumerate(self.output_test_files):
+                nominal_next_article_size = min(nominal_sentences_per_test_shard - test_counts[fidx], max_sentences)
+
+                # Maintain the max sentence count
+                while len(sentence_counts[max_sentences]) == 0 and max_sentences > 0:
+                    max_sentences -= 1
+
+                while len(sentence_counts[nominal_next_article_size]) == 0 and nominal_next_article_size > 0:
+                    nominal_next_article_size -= 1
+
+                if nominal_next_article_size not in sentence_counts or nominal_next_article_size is 0 or test_counts[fidx] > test_median:
+                    continue    # skip adding to this file, will come back later if no file can accept unused articles
+
+                current_article_id = sentence_counts[nominal_next_article_size][-1]
+                sentence_counts[nominal_next_article_size].pop(-1)
+
+                self.output_test_files[file].append(current_article_id)
+                consumed_article_set.add(current_article_id)
+                unused_article_set.remove(current_article_id)
+
+            # If unable to place articles a few times, bump up nominal sizes by fraction until articles get placed
+            if len(history_remaining) == n_history_remaining:
+                history_remaining.pop(0)
+            history_remaining.append(len(unused_article_set))
+
+            history_same = True
+            for i in range(1, len(history_remaining)):
+                history_same = history_same and (history_remaining[i-1] == history_remaining[i])
+
+            if history_same:
+                nominal_sentences_per_training_shard += 1
+                # nominal_sentences_per_test_shard += 1
+
+            training_counts = []
+            test_counts = []
+            for shard in self.output_training_files:
+                training_counts.append(self.get_sentences_per_shard(self.output_training_files[shard]))
+
+            for shard in self.output_test_files:
+                test_counts.append(self.get_sentences_per_shard(self.output_test_files[shard]))
+
+            training_median = statistics.median(training_counts)
+            test_median = statistics.median(test_counts)
+
+            print('Distributing data over shards:', len(unused_article_set), 'articles remaining.')
+
+
+        if len(unused_article_set) != 0:
+            print('Warning: Some articles did not make it into output files.')
+
+
+        for shard in self.output_training_files:
+            print('Training shard:', self.get_sentences_per_shard(self.output_training_files[shard]))
+
+        for shard in self.output_test_files:
+            print('Test shard:', self.get_sentences_per_shard(self.output_test_files[shard]))
+
+        print('End: Distribute Articles Over Shards')
+
+
+    def write_shards_to_disk(self):
+        print('Start: Write Shards to Disk')
+        for shard in self.output_training_files:
+            self.write_single_shard(shard, self.output_training_files[shard], 'training')
+
+        for shard in self.output_test_files:
+            self.write_single_shard(shard, self.output_test_files[shard], 'test')
+
+        print('End: Write Shards to Disk')
+
+
+    def write_single_shard(self, shard_name, shard, split):
+        shard_split = os.path.split(shard_name)
+        shard_name = shard_split[0] + '/' + split + '/' + shard_split[1]
+        
+        with open(shard_name, mode='w', newline='\n') as f:
+            for article_id in shard:
+                for line in self.sentences[article_id]:
+                    f.write(line + '\n')
+
+                f.write('\n')  # Line break between articles
+
+
+import nltk
+
+nltk.download('punkt')
+
+class NLTKSegmenter:
+    def __init(self):
+        pass
+
+    def segment_string(self, article):
+        return nltk.tokenize.sent_tokenize(article)
+

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/WikiDownloader.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+#
+# Changes:
+# - Replaced bzip2 with lbzip2 that uses multiprocessing during decompression
+#   and provides linear speedup.
+# - Added timing code to measure the decompression process duration.
+# - Removed unused imports.
+###############################################################################
+
+import os
+import subprocess
+import time
+
+class WikiDownloader:
+    def __init__(self, language, save_path):
+        self.save_path = save_path + '/wikicorpus_' + language
+
+        if not os.path.exists(self.save_path):
+            os.makedirs(self.save_path)
+
+        self.language = language
+        self.download_urls = {
+            'en' : 'https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-pages-articles.xml.bz2',
+            'zh' : 'https://dumps.wikimedia.org/zhwiki/latest/zhwiki-latest-pages-articles.xml.bz2'
+        }
+
+        self.output_files = {
+            'en' : 'wikicorpus_en.xml.bz2',
+            'zh' : 'wikicorpus_zh.xml.bz2'
+        }
+
+
+    def download(self):
+        if self.language in self.download_urls:
+            url = self.download_urls[self.language]
+            filename = self.output_files[self.language]
+
+            print('Downloading:', url)
+            if os.path.isfile(self.save_path + '/' + filename):
+                print('** Download file already exists, skipping download')
+            else:
+                cmd = ['wget', url, '--output-document={}'.format(self.save_path + '/' + filename)]
+                print('Running:', cmd)
+                status = subprocess.run(cmd)
+                if status.returncode != 0:
+                    raise RuntimeError('Wiki download not successful')
+
+            # Always unzipping since this is relatively fast and will overwrite
+            start = time.time()
+            print('Unzipping:', self.output_files[self.language])
+            subprocess.run('lbzip2 -dk ' + self.save_path + '/' + filename, shell=True, check=True)
+            print("Unzip time:", time.time() - start)
+
+        else:
+            assert False, 'WikiDownloader not implemented for this language yet.'

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/WikicorpusTextFormatting.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+import glob
+import os
+
+class WikicorpusTextFormatting:
+    def __init__(self, wiki_path, output_filename, recursive = False):
+        self.wiki_path = wiki_path
+        self.recursive = recursive
+        self.output_filename = output_filename
+
+
+    # This puts one article per line
+    def merge(self):
+        with open(self.output_filename, mode='w', newline='\n') as ofile:
+            for dirname in glob.glob(self.wiki_path + '/*/', recursive=False):
+                for filename in glob.glob(dirname + 'wiki_*', recursive=self.recursive):
+                    print(filename)
+                    article_lines = []
+                    article_open = False
+
+                    with open(filename, mode='r', newline='\n') as file:
+                        for line in file:
+                            if '<doc id=' in line:
+                                article_open = True
+                            elif '</doc>' in line:
+                                article_open = False
+                                for oline in article_lines[1:]:
+                                    if oline != '\n':
+                                        ofile.write(oline.rstrip() + " ")
+                                ofile.write("\n\n")
+                                article_lines = []
+                            else:
+                                if article_open:
+                                    article_lines.append(line)

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/create_datasets_from_start.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+#
+# Changes:
+# - Removed downloading and preprocessing datasets that are not related to BERT pretrain
+# - Modified file structures originally for NVidia container
+# - Added downloading WikiExtractor and bookcorpus repositories
+###############################################################################
+
+
+to_download=${1:-"wiki_only"} # By default, we don't download BooksCorpus dataset due to recent issues with the host server
+
+data_dir=$(pwd)
+BERT_PREP_WORKING_DIR=${2:-"/data/tensorflow/bert/books_wiki_en_corpus"}
+export BERT_PREP_WORKING_DIR="${BERT_PREP_WORKING_DIR}"
+
+echo "Checkout WikiExtractor repository"
+# checkout WikiExtractor scripts
+git clone https://github.com/attardi/wikiextractor.git && cd wikiextractor && git checkout 6408a430fc504a38b04d37ce5e7fc740191dee16 && cd ..
+
+# Download Wikipedia dataset and/or Bookscorpus dataset
+echo "Download dataset ${to_download}"
+if [ "$to_download" = "wiki_books" ] ; then
+    # checkout BookCorpus download scripts
+    git clone https://github.com/soskek/bookcorpus.git
+    $PYTHON ${data_dir}/bertPrep.py --action download --dataset bookscorpus
+fi
+$PYTHON ${data_dir}/bertPrep.py --action download --dataset wikicorpus_en
+
+echo "Download pretrained weights"
+echo "${data_dir}"
+$PYTHON ${data_dir}/bertPrep.py --action download --dataset google_pretrained_weights  # Includes vocab
+
+DATASET="wikicorpus_en"
+
+# Properly format the text files
+if [ "$to_download" = "wiki_books" ] ; then
+    $PYTHON ${data_dir}/bertPrep.py --action text_formatting --dataset bookscorpus
+    DATASET="books_wiki_en_corpus"
+fi
+$PYTHON ${data_dir}/bertPrep.py --action text_formatting --dataset wikicorpus_en
+
+# Shard the text files
+$PYTHON ${data_dir}/bertPrep.py --action sharding --dataset ${DATASET}
+
+# Create TFRecord files Phase 1
+$PYTHON ${data_dir}/bertPrep.py --action create_tfrecord_files --dataset ${DATASET} --max_seq_length 128 \
+ --max_predictions_per_seq 20 --vocab_file ${BERT_PREP_WORKING_DIR}/download/google_pretrained_weights/uncased_L-24_H-1024_A-16/vocab.txt
+
+
+# Create TFRecord files Phase 2
+$PYTHON ${data_dir}/bertPrep.py --action create_tfrecord_files --dataset ${DATASET} --max_seq_length 512 \
+ --max_predictions_per_seq 80 --vocab_file ${BERT_PREP_WORKING_DIR}/download/google_pretrained_weights/uncased_L-24_H-1024_A-16/vocab.txt

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/create_pretraining_data.py

@@ -0,0 +1,512 @@
+# coding=utf-8
+# Copyright (c) 2019 NVIDIA CORPORATION. All rights reserved.
+# Copyright 2018 The Google AI Language Team Authors.
+#
+# 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.
+
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+#
+# Changes:
+# - Fixed compatibility issues with TensorFlow 2
+###############################################################################
+
+"""Create masked LM/next sentence masked_lm TF examples for BERT."""
+
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import argparse
+import logging
+import os
+import random
+from io import open
+import h5py
+import tensorflow as tf
+import numpy as np
+from tqdm import tqdm, trange
+
+from TensorFlow.nlp.bert.data_preprocessing.tokenization import BertTokenizer
+import tokenization as tokenization
+
+import random
+import collections
+
+class TrainingInstance(object):
+  """A single training instance (sentence pair)."""
+
+  def __init__(self, tokens, segment_ids, masked_lm_positions, masked_lm_labels,
+               is_random_next):
+    self.tokens = tokens
+    self.segment_ids = segment_ids
+    self.is_random_next = is_random_next
+    self.masked_lm_positions = masked_lm_positions
+    self.masked_lm_labels = masked_lm_labels
+
+  def __str__(self):
+    s = ""
+    s += "tokens: %s\n" % (" ".join(
+        [tokenization.printable_text(x) for x in self.tokens]))
+    s += "segment_ids: %s\n" % (" ".join([str(x) for x in self.segment_ids]))
+    s += "is_random_next: %s\n" % self.is_random_next
+    s += "masked_lm_positions: %s\n" % (" ".join(
+        [str(x) for x in self.masked_lm_positions]))
+    s += "masked_lm_labels: %s\n" % (" ".join(
+        [tokenization.printable_text(x) for x in self.masked_lm_labels]))
+    s += "\n"
+    return s
+
+  def __repr__(self):
+    return self.__str__()
+
+
+def write_instance_to_example_files(instances, tokenizer, max_seq_length,
+                                    max_predictions_per_seq, output_files, output_formats="tfrecord"):
+  """Create TF example files from `TrainingInstance`s."""
+  writers = []
+  for output_file in output_files:
+    writers.append(tf.compat.v1.python_io.TFRecordWriter(output_file))
+
+  writer_index = 0
+
+  total_written = 0
+  if 'hdf5' in output_formats:
+    features_hdf5 = collections.OrderedDict()
+    num_instances = len(instances)
+    features_hdf5["input_ids"] = np.zeros([num_instances, max_seq_length], dtype="int32")
+    features_hdf5["input_mask"] = np.zeros([num_instances, max_seq_length], dtype="int32")
+    features_hdf5["segment_ids"] = np.zeros([num_instances, max_seq_length], dtype="int32")
+    features_hdf5["masked_lm_positions"] =  np.zeros([num_instances, max_predictions_per_seq], dtype="int32")
+    features_hdf5["masked_lm_ids"] = np.zeros([num_instances, max_predictions_per_seq], dtype="int32")
+    features_hdf5["next_sentence_labels"] = np.zeros(num_instances, dtype="int32")
+
+  for (inst_index, instance) in enumerate(instances):
+    input_ids = tokenizer.convert_tokens_to_ids(instance.tokens)
+    input_mask = [1] * len(input_ids)
+    segment_ids = list(instance.segment_ids)
+    assert len(input_ids) <= max_seq_length
+
+    while len(input_ids) < max_seq_length:
+      input_ids.append(0)
+      input_mask.append(0)
+      segment_ids.append(0)
+
+    assert len(input_ids) == max_seq_length
+    assert len(input_mask) == max_seq_length
+    assert len(segment_ids) == max_seq_length
+
+    masked_lm_positions = list(instance.masked_lm_positions)
+    masked_lm_ids = tokenizer.convert_tokens_to_ids(instance.masked_lm_labels)
+    masked_lm_weights = [1.0] * len(masked_lm_ids)
+
+    while len(masked_lm_positions) < max_predictions_per_seq:
+      masked_lm_positions.append(0)
+      masked_lm_ids.append(0)
+      masked_lm_weights.append(0.0)
+
+    next_sentence_label = 1 if instance.is_random_next else 0
+
+    features = collections.OrderedDict()
+    features["input_ids"] = create_int_feature(input_ids)
+    features["input_mask"] = create_int_feature(input_mask)
+    features["segment_ids"] = create_int_feature(segment_ids)
+    features["masked_lm_positions"] = create_int_feature(masked_lm_positions)
+    features["masked_lm_ids"] = create_int_feature(masked_lm_ids)
+    features["masked_lm_weights"] = create_float_feature(masked_lm_weights)
+    features["next_sentence_labels"] = create_int_feature([next_sentence_label])
+
+    if 'tfrecord' in output_formats:
+      tf_example = tf.train.Example(features=tf.train.Features(feature=features))
+      writers[writer_index].write(tf_example.SerializeToString())
+    if 'hdf5' in output_formats:
+      features_hdf5["input_ids"][inst_index] = input_ids
+      features_hdf5["input_mask"][inst_index] = input_mask
+      features_hdf5["segment_ids"][inst_index] = segment_ids
+      features_hdf5["masked_lm_positions"][inst_index] = masked_lm_positions
+      features_hdf5["masked_lm_ids"][inst_index] = masked_lm_ids
+      features_hdf5["next_sentence_labels"][inst_index] = next_sentence_label
+    if 'tfrecord' not in output_formats and 'hdf5' not in output_formats:
+      assert False, 'Either empty output_formats list or unsupported type specified. Try: tfrecord or hdf5'
+
+    writer_index = (writer_index + 1) % len(writers)
+
+    total_written += 1
+
+    if inst_index < 20:
+      tf.compat.v1.logging.info("*** Example ***")
+      tf.compat.v1.logging.info("tokens: %s" % " ".join(
+          [tokenization.printable_text(x) for x in instance.tokens]))
+
+      for feature_name in features.keys():
+        feature = features[feature_name]
+        values = []
+        if feature.int64_list.value:
+          values = feature.int64_list.value
+        elif feature.float_list.value:
+          values = feature.float_list.value
+        tf.compat.v1.logging.info(
+            "%s: %s" % (feature_name, " ".join([str(x) for x in values])))
+
+  for writer in writers:
+    writer.close()
+
+  if 'hdf5' in output_formats:
+    f = h5py.File(output_file, 'w')
+    f.create_dataset("input_ids", data=features_hdf5["input_ids"], dtype='i4', compression='gzip')
+    f.create_dataset("input_mask", data=features_hdf5["input_mask"], dtype='i1', compression='gzip')
+    f.create_dataset("segment_ids", data=features_hdf5["segment_ids"], dtype='i1', compression='gzip')
+    f.create_dataset("masked_lm_positions", data=features_hdf5["masked_lm_positions"], dtype='i4', compression='gzip')
+    f.create_dataset("masked_lm_ids", data=features_hdf5["masked_lm_ids"], dtype='i4', compression='gzip')
+    f.create_dataset("next_sentence_labels", data=features_hdf5["next_sentence_labels"], dtype='i1', compression='gzip')
+    f.flush()
+    f.close()
+
+  tf.compat.v1.logging.info("Wrote %d total instances", total_written)
+
+
+def create_int_feature(values):
+  feature = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
+  return feature
+
+
+def create_float_feature(values):
+  feature = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))
+  return feature
+
+
+def create_training_instances(input_files, tokenizer, max_seq_length,
+                              dupe_factor, short_seq_prob, masked_lm_prob,
+                              max_predictions_per_seq, rng):
+    """Create `TrainingInstance`s from raw text."""
+    all_documents = [[]]
+
+    # Input file format:
+    # (1) One sentence per line. These should ideally be actual sentences, not
+    # entire paragraphs or arbitrary spans of text. (Because we use the
+    # sentence boundaries for the "next sentence prediction" task).
+    # (2) Blank lines between documents. Document boundaries are needed so
+    # that the "next sentence prediction" task doesn't span between documents.
+    for input_file in input_files:
+        print("creating instance from {}".format(input_file))
+        with open(input_file, "r") as reader:
+            while True:
+                line = tokenization.convert_to_unicode(reader.readline())
+                if not line:
+                    break
+                line = line.strip()
+
+                # Empty lines are used as document delimiters
+                if not line:
+                    all_documents.append([])
+                tokens = tokenizer.tokenize(line)
+                if tokens:
+                    all_documents[-1].append(tokens)
+
+    # Remove empty documents
+    all_documents = [x for x in all_documents if x]
+    rng.shuffle(all_documents)
+
+    vocab_words = list(tokenizer.vocab.keys())
+    instances = []
+    for _ in range(dupe_factor):
+        for document_index in range(len(all_documents)):
+            instances.extend(
+                create_instances_from_document(
+                    all_documents, document_index, max_seq_length, short_seq_prob,
+                    masked_lm_prob, max_predictions_per_seq, vocab_words, rng))
+
+    rng.shuffle(instances)
+    return instances
+
+
+def create_instances_from_document(
+        all_documents, document_index, max_seq_length, short_seq_prob,
+        masked_lm_prob, max_predictions_per_seq, vocab_words, rng):
+    """Creates `TrainingInstance`s for a single document."""
+    document = all_documents[document_index]
+
+    # Account for [CLS], [SEP], [SEP]
+    max_num_tokens = max_seq_length - 3
+
+    # We *usually* want to fill up the entire sequence since we are padding
+    # to `max_seq_length` anyways, so short sequences are generally wasted
+    # computation. However, we *sometimes*
+    # (i.e., short_seq_prob == 0.1 == 10% of the time) want to use shorter
+    # sequences to minimize the mismatch between pre-training and fine-tuning.
+    # The `target_seq_length` is just a rough target however, whereas
+    # `max_seq_length` is a hard limit.
+    target_seq_length = max_num_tokens
+    if rng.random() < short_seq_prob:
+        target_seq_length = rng.randint(2, max_num_tokens)
+
+    # We DON'T just concatenate all of the tokens from a document into a long
+    # sequence and choose an arbitrary split point because this would make the
+    # next sentence prediction task too easy. Instead, we split the input into
+    # segments "A" and "B" based on the actual "sentences" provided by the user
+    # input.
+    instances = []
+    current_chunk = []
+    current_length = 0
+    i = 0
+    while i < len(document):
+        segment = document[i]
+        current_chunk.append(segment)
+        current_length += len(segment)
+        if i == len(document) - 1 or current_length >= target_seq_length:
+            if current_chunk:
+                # `a_end` is how many segments from `current_chunk` go into the `A`
+                # (first) sentence.
+                a_end = 1
+                if len(current_chunk) >= 2:
+                    a_end = rng.randint(1, len(current_chunk) - 1)
+
+                tokens_a = []
+                for j in range(a_end):
+                    tokens_a.extend(current_chunk[j])
+
+                tokens_b = []
+                # Random next
+                is_random_next = False
+                if len(current_chunk) == 1 or rng.random() < 0.5:
+                    is_random_next = True
+                    target_b_length = target_seq_length - len(tokens_a)
+
+                    # This should rarely go for more than one iteration for large
+                    # corpora. However, just to be careful, we try to make sure that
+                    # the random document is not the same as the document
+                    # we're processing.
+                    for _ in range(10):
+                        random_document_index = rng.randint(0, len(all_documents) - 1)
+                        if random_document_index != document_index:
+                            break
+
+                    #If picked random document is the same as the current document
+                    if random_document_index == document_index:
+                        is_random_next = False
+
+                    random_document = all_documents[random_document_index]
+                    random_start = rng.randint(0, len(random_document) - 1)
+                    for j in range(random_start, len(random_document)):
+                        tokens_b.extend(random_document[j])
+                        if len(tokens_b) >= target_b_length:
+                            break
+                    # We didn't actually use these segments so we "put them back" so
+                    # they don't go to waste.
+                    num_unused_segments = len(current_chunk) - a_end
+                    i -= num_unused_segments
+                # Actual next
+                else:
+                    is_random_next = False
+                    for j in range(a_end, len(current_chunk)):
+                        tokens_b.extend(current_chunk[j])
+                truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng)
+
+                assert len(tokens_a) >= 1
+                assert len(tokens_b) >= 1
+
+                tokens = []
+                segment_ids = []
+                tokens.append("[CLS]")
+                segment_ids.append(0)
+                for token in tokens_a:
+                    tokens.append(token)
+                    segment_ids.append(0)
+
+                tokens.append("[SEP]")
+                segment_ids.append(0)
+
+                for token in tokens_b:
+                    tokens.append(token)
+                    segment_ids.append(1)
+                tokens.append("[SEP]")
+                segment_ids.append(1)
+
+                (tokens, masked_lm_positions,
+                 masked_lm_labels) = create_masked_lm_predictions(
+                    tokens, masked_lm_prob, max_predictions_per_seq, vocab_words, rng)
+                instance = TrainingInstance(
+                    tokens=tokens,
+                    segment_ids=segment_ids,
+                    is_random_next=is_random_next,
+                    masked_lm_positions=masked_lm_positions,
+                    masked_lm_labels=masked_lm_labels)
+                instances.append(instance)
+            current_chunk = []
+            current_length = 0
+        i += 1
+
+    return instances
+
+
+MaskedLmInstance = collections.namedtuple("MaskedLmInstance",
+                                          ["index", "label"])
+
+
+def create_masked_lm_predictions(tokens, masked_lm_prob,
+                                 max_predictions_per_seq, vocab_words, rng):
+    """Creates the predictions for the masked LM objective."""
+
+    cand_indexes = []
+    for (i, token) in enumerate(tokens):
+        if token == "[CLS]" or token == "[SEP]":
+            continue
+        cand_indexes.append(i)
+
+    rng.shuffle(cand_indexes)
+
+    output_tokens = list(tokens)
+
+    num_to_predict = min(max_predictions_per_seq,
+                         max(1, int(round(len(tokens) * masked_lm_prob))))
+
+    masked_lms = []
+    covered_indexes = set()
+    for index in cand_indexes:
+        if len(masked_lms) >= num_to_predict:
+            break
+        if index in covered_indexes:
+            continue
+        covered_indexes.add(index)
+
+        masked_token = None
+        # 80% of the time, replace with [MASK]
+        if rng.random() < 0.8:
+            masked_token = "[MASK]"
+        else:
+            # 10% of the time, keep original
+            if rng.random() < 0.5:
+                masked_token = tokens[index]
+            # 10% of the time, replace with random word
+            else:
+                masked_token = vocab_words[rng.randint(0, len(vocab_words) - 1)]
+
+        output_tokens[index] = masked_token
+
+        masked_lms.append(MaskedLmInstance(index=index, label=tokens[index]))
+
+    masked_lms = sorted(masked_lms, key=lambda x: x.index)
+
+    masked_lm_positions = []
+    masked_lm_labels = []
+    for p in masked_lms:
+        masked_lm_positions.append(p.index)
+        masked_lm_labels.append(p.label)
+
+    return (output_tokens, masked_lm_positions, masked_lm_labels)
+
+
+def truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng):
+    """Truncates a pair of sequences to a maximum sequence length."""
+    while True:
+        total_length = len(tokens_a) + len(tokens_b)
+        if total_length <= max_num_tokens:
+            break
+
+        trunc_tokens = tokens_a if len(tokens_a) > len(tokens_b) else tokens_b
+        assert len(trunc_tokens) >= 1
+
+        # We want to sometimes truncate from the front and sometimes from the
+        # back to add more randomness and avoid biases.
+        if rng.random() < 0.5:
+            del trunc_tokens[0]
+        else:
+            trunc_tokens.pop()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    ## Required parameters
+    parser.add_argument("--vocab_file",
+                        default=None,
+                        type=str,
+                        required=True,
+                        help="The vocabulary the BERT model will train on.")
+    parser.add_argument("--input_file",
+                        default=None,
+                        type=str,
+                        required=True,
+                        help="The input train corpus. can be directory with .txt files or a path to a single file")
+    parser.add_argument("--output_file",
+                        default=None,
+                        type=str,
+                        required=True,
+                        help="The output file where the model checkpoints will be written.")
+
+    ## Other parameters
+    # int
+    parser.add_argument("--max_seq_length",
+                        default=128,
+                        type=int,
+                        help="The maximum total input sequence length after WordPiece tokenization. \n"
+                             "Sequences longer than this will be truncated, and sequences shorter \n"
+                             "than this will be padded.")
+    parser.add_argument("--dupe_factor",
+                        default=10,
+                        type=int,
+                        help="Number of times to duplicate the input data (with different masks).")
+    parser.add_argument("--max_predictions_per_seq",
+                        default=20,
+                        type=int,
+                        help="Maximum sequence length.")
+
+    # floats
+
+    parser.add_argument("--masked_lm_prob",
+                        default=0.15,
+                        type=float,
+                        help="Masked LM probability.")
+
+    parser.add_argument("--short_seq_prob",
+                        default=0.1,
+                        type=float,
+                        help="Probability to create a sequence shorter than maximum sequence length")
+
+    parser.add_argument("--do_lower_case",
+                        action='store_true',
+                        default=True,
+                        help="Whether to lower case the input text. True for uncased models, False for cased models.")
+    parser.add_argument('--random_seed',
+                        type=int,
+                        default=12345,
+                        help="random seed for initialization")
+
+    args = parser.parse_args()
+
+    tokenizer = BertTokenizer(args.vocab_file, do_lower_case=args.do_lower_case)
+
+    input_files = []
+    if os.path.isfile(args.input_file):
+        input_files.append(args.input_file)
+    elif os.path.isdir(args.input_file):
+        input_files = [os.path.join(args.input_file, f) for f in os.listdir(args.input_file) if
+                       (os.path.isfile(os.path.join(args.input_file, f)) and f.endswith('.txt'))]
+    else:
+        raise ValueError("{} is not a valid path".format(args.input_file))
+
+    rng = random.Random(args.random_seed)
+    instances = create_training_instances(
+        input_files, tokenizer, args.max_seq_length, args.dupe_factor,
+        args.short_seq_prob, args.masked_lm_prob, args.max_predictions_per_seq,
+        rng)
+
+    output_files = args.output_file.split(",")
+    print("*** Writing to output files ***")
+    for output_file in output_files:
+        print(output_file)
+
+
+    write_instance_to_example_files(instances, tokenizer, args.max_seq_length,
+                                       args.max_predictions_per_seq, output_files)
+
+
+if __name__ == "__main__":
+    main()

docker/bloom13b/Model-References/TensorFlow/nlp/bert/data_preprocessing/pack_pretraining_data_tfrec.py

@@ -0,0 +1,531 @@
+# Copyright (c) 2020 Graphcore Ltd. 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.
+###############################################################################
+# Copyright (C) 2022 Habana Labs, Ltd. an Intel Company
+###############################################################################
+# Changes:
+# - Added functionality for saving parameters of packing algorithm to metadata file.
+# - Added checks for output_dir parameter. It will be created automatically if passed location does not exist.
+
+
+import argparse
+import gc
+import json
+import os
+import random
+import time
+from collections import OrderedDict, defaultdict, deque
+from concurrent.futures import ProcessPoolExecutor
+from functools import lru_cache
+from itertools import chain, repeat
+from sys import getsizeof, stderr
+
+import numpy as np
+import tensorflow as tf
+from scipy import optimize
+
+@lru_cache(maxsize=None)
+def packing_strategies(start, previous, target, depth):
+    gap = target - start
+
+    # The collection of possible strategies given the
+    # starting sum, the target sum, and the available depth
+    # strategy search is limited to increments greater or equal to previous
+    strategies = []
+    # Complete the packing with exactly 1 number
+    if depth == 1:
+        if gap >= previous:
+            strategies.append([gap])
+
+    # Complete the sample in "depth" steps, recursively
+    else:
+        for new in range(previous, gap + 1):
+
+            new_gap = target - start - new
+            if new_gap == 0:
+                strategies.append([new])
+            else:
+                options = packing_strategies(start + new, new, target, depth - 1)
+
+                for option in options:
+                    if len(option) > 0:
+                        strategies.append([new] + option)
+    return strategies
+
+
+def get_metadata_file_path(output_dir):
+    """Returns path for metadata file one direcotry above output_dir.
+    File will be called the same way as directory with training dataset
+    with appended metadata.json as below:
+    ├── training
+    └── training_metadata.json"""
+    norm_path = os.path.normpath(output_dir)
+    base_path, metadata_file_name = os.path.split(norm_path)
+    metadata_file_name = metadata_file_name + '_metadata.json'
+    return os.path.join(base_path, metadata_file_name)
+
+def get_packing_recipe(output_dir, sequence_lengths, max_sequence_length, max_sequences_per_pack=3):
+    # Histogram of sequence lengths
+    histogram, bins = np.histogram(sequence_lengths, bins=np.arange(1, max_sequence_length + 2))
+    print("Begin packing pass".center(80, "_"))
+    print(f"Unpacked mean sequence length: {sequence_lengths.mean():3.2f}")
+
+    # Make sure all strategies are recipes to pack to the correct sequence length
+    strategy_set = packing_strategies(0, 1, max_sequence_length, max_sequences_per_pack)
+    for strategy in strategy_set:
+        assert(sum(strategy) == max_sequence_length)
+    num_strategies = len(strategy_set)
+    print(f"Found {num_strategies} unique packing strategies.")
+
+    # Solve the packing equation A@mixture = histogram
+    A = np.zeros((max_sequence_length, num_strategies), dtype=np.int32)
+    for i in range(num_strategies):
+        strategy = strategy_set[i]
+        for seq_len in strategy:
+            A[seq_len - 1, i] += 1
+
+    # short sequences are inexpensive to add, so should have low residual weights
+    # to exactly minimize padding use w0 = np.arange(1, max_sequence_length + 1)
+    # in practice the difference is negligible, but this converges faster
+    padding_cutoff = 8
+    w0 = np.ones([max_sequence_length])
+    # w0 = np.linspace(1, max_sequence_length+1, max_sequence_length)/max_sequence_length  # padding minimization weight
+    w0[:padding_cutoff] = padding_cutoff / (2 * max_sequence_length)
+    w0 = np.sqrt(w0)
+
+    # Starting values for the padding and the mixture
+    padding = np.zeros([max_sequence_length], dtype=np.int32)
+    mixture = np.zeros([num_strategies], dtype=np.int32)
+    b = histogram + padding
+
+    # Pack sequences as best as possible, then increase padding accordingly and repeat
+    for i in range(0, 20):
+        print(f"\nIteration: {i}: sequences still to pack: ", b.sum())
+        start = time.time()
+        partial_mixture, rnorm = optimize.nnls(np.expand_dims(w0, -1) * A, w0 * b)
+        print(f"Solving nnls took {time.time() - start:3.2f} seconds.")
+        print(f"Residual norm:  {rnorm:3.5e}")
+
+        # Update mixture (round the floating point solution to integers)
+        partial_mixture = np.where(partial_mixture < 2, np.rint(partial_mixture), np.floor(partial_mixture))
+
+        # If partial mixture is empty (due to rounding) we follow the gradient
+        # this usually happens when the number of examples is small i.e. ~100
+        if partial_mixture.max() == 0:
+            grad = A.T @ (b * np.arange(1, max_sequence_length + 1))
+            k = int(b.sum() // 2) + 1
+            topk = np.argsort(-grad)[:k]
+            partial_mixture[topk] += 1
+
+        # Update mixture
+        mixture = mixture + partial_mixture
+
+        # Compute the residuals
+        residual = b - A @ partial_mixture
+        print(f"Max residual:   {abs(residual).max()}")
+        print(f"Residual on first 8 categories: {np.around(residual[:8], 4)}")
+        print(f"Residual on last 8 categories:  {np.around(residual[-8:], 4)}")
+
+        # Add padding based on deficit (negative residual)
+        partial_padding = np.where(residual < 0, -residual, 0)
+        print(f"Added {(partial_padding*np.arange(1,max_sequence_length+1)).sum():3.2e} tokens of padding.")
+        padding = padding + partial_padding
+
+        # Update the rhs vector (remaining surplus sequences)
+        b = histogram + padding - A @ mixture
+        assert np.all(b >= 0), b
+
+        # Done iterating
+        if b.sum() < 100:
+            break
+
+    # Make sure there is no remainder
+    unpacked_seqlen = np.arange(1, args.max_sequence_length + 1)[b > 0]
+    # Update the mixture to also covered the unpacked sequences
+    for l in unpacked_seqlen:
+        # Get the depth 1 strategy
+        strategy = sorted([l, args.max_sequence_length - l])
+        strategy_index = strategy_set.index(strategy)
+        mixture[strategy_index] += b[l-1]
+    b = histogram - A @ mixture
+    padding = np.where(b < 0, -b, 0)
+    b = histogram + padding - A @ mixture
+    assert b.sum() == 0
+
+    # Analyze result
+    print("Done solving for packing order".center(80, "_"))
+    num_padding_tokens = (np.arange(1, max_sequence_length + 1) * padding).sum()
+    num_padding_tokens_original = (max_sequence_length - sequence_lengths).sum()
+    number_of_sequences_dropped = b.sum()
+    print(f"Number of sequences dropped:  {number_of_sequences_dropped}")
+    number_of_strategies_utilized = np.count_nonzero(mixture)
+    print(f"Number of strategies utilized: {number_of_strategies_utilized}")
+    new_number_of_samples = int(mixture.sum())
+    original_number_of_samples = len(sequence_lengths)
+    compression = 1 - new_number_of_samples / original_number_of_samples
+    print(f"New number of samples: {new_number_of_samples:3.2f}, original {original_number_of_samples}. A compression ratio of {compression:3.3f}")
+    expected_speedup_from_packing = 1 / (1 - compression)
+    print(f"The expected speed-up from packing: {expected_speedup_from_packing}")
+    upper_bound = 1.0 / (1 - ((1 - sequence_lengths / max_sequence_length).mean()))
+    print(f"Theoretical upper bound on speed-up: {upper_bound:3.3f}")
+    avg_sequences_per_sample = ((A.sum(0) * mixture).sum() - padding.sum()) / new_number_of_samples
+    print(f"Average sequences/sample {avg_sequences_per_sample:3.5f}")
+    print(f"Added {num_padding_tokens:3.2e} padding tokens. Original dataset used {num_padding_tokens_original:3.2e} padding tokens")
+    efficiency = (new_number_of_samples*max_sequence_length - num_padding_tokens)/(new_number_of_samples*max_sequence_length)
+    print(f"Packing efficiency (fraction of real tokens): {efficiency:3.4f}")
+
+    print(f"Top 8 strategies")
+    topK = np.argsort(-mixture)[:8]
+    for i in topK:
+        print(f"Strategy {strategy_set[i]} which is used {int(mixture[i])} times")
+    print("".center(80, "_"))
+
+    # Figure out the slicing that each strategy should use
+    slicing = np.zeros_like(A)
+    slicing[:, 1:] = np.cumsum(A * mixture, axis=1)[:, :-1]
+    slicing = slicing.T
+
+    mixture = mixture.astype(np.int64)
+
+    # Save packing parameters to metadata file
+    metadata_file_path = get_metadata_file_path(output_dir)
+    print(f"Saving metadata to file: {metadata_file_path}")
+
+    packing_metadata = {
+        "sequences_dropped": int(number_of_sequences_dropped),
+        "num_strategies_utilized": number_of_strategies_utilized,
+        "new_number_of_samples": new_number_of_samples,
+        "original_number_of_samples": original_number_of_samples,
+        "compression_ratio": compression,
+        "expected_speedup": expected_speedup_from_packing,
+        "theoretical_speedup": float(upper_bound),
+        "avg_seq_per_sample": float(avg_sequences_per_sample),
+        "padding_tokens_original_dataset": int(num_padding_tokens_original),
+        "padding_tokens_packed_dataset": float(num_padding_tokens),
+        "packing_efficiency": float(efficiency),
+        "top_8_strategies": topK.tolist()
+    }
+    with open(metadata_file_path, mode='w') as json_file:
+        json_file.write(json.dumps(packing_metadata, sort_keys=True, indent=2))
+    return strategy_set, mixture, padding, slicing
+
+
+def slice_examples(examples_by_length, slicing, strategy_set, repeat_counts):
+    # Divide the work, firstly between the strategies and then into chunks of 50k
+    slices = []
+    strategies = []
+    part_idx = []
+    for strategy, slice_offsets, repeat_count in zip(strategy_set, slicing, repeat_counts):
+        if repeat_count == 0:
+            continue
+        # Slice out the sequences allocated to this strategy in increments of 50k
+        num_sample_per_slice=4480
+        num_parts = repeat_count // num_sample_per_slice
+        num_parts = num_parts + int(repeat_count != num_parts * num_sample_per_slice)
+        subcounts = (min(num_sample_per_slice, repeat_count - num_sample_per_slice * (i - 1)) for i in range(1, num_parts + 1))
+        for part_id, part_count in enumerate(subcounts):
+            examples = []
+            for k, seq_len in enumerate(strategy):
+                slice_start = int(slice_offsets[seq_len - 1])
+                slice_end = slice_start + int(part_count)
+                slice_offsets[seq_len - 1] = slice_end
+                examples.append(examples_by_length[seq_len][slice_start:slice_end])
+            slices.append(examples)
+            strategies.append(strategy)
+            part_idx.append(part_id)
+    examples_by_length = None
+    return slices, strategies, part_idx
+
+
+def parallel_pack_according_to_strategy(args, part_idx, strategy, examples):
+    # Pack the sequences according to the strategy and write them to disk
+    try:
+        base_filename = os.path.join(args.output_dir, "strategy_" + "_".join(map(str, strategy)))
+        filename = base_filename + f"_part_{part_idx}"
+        print(filename)
+        writer = tf.compat.v1.python_io.TFRecordWriter(filename)
+        for i, multi_sequence in enumerate(zip(*examples)):
+            features = create_multi_sequence_example(multi_sequence, args.max_predictions_per_sequence,
+                                                           args.max_sequence_length, args.max_sequences_per_pack)
+            # Write to file
+            tf_example = tf.train.Example(features=tf.train.Features(feature=features))
+            writer.write(tf_example.SerializeToString())
+        writer.close()
+    except:
+        print('failed to write: ',strategy,part_idx)
+        base_filename = os.path.join(args.output_dir, "FAIL_strategy_" + "_".join(map(str, strategy)))
+        filename = base_filename + f"_part_{part_idx}"
+        print('saved failed examples to: ','FAIL_'+filename)
+
+
+
+def create_multi_sequence_example(multi_sequence, max_predictions_per_sequence, max_sequence_length, max_sequences_per_pack):
+    # SEQ
+    packed_input_ids = np.zeros(max_sequence_length, dtype=np.int32)
+    packed_input_mask = np.zeros(max_sequence_length, dtype=np.int32)
+    packed_segment_ids = np.zeros(max_sequence_length, dtype=np.int32)
+    packed_positions = np.zeros(max_sequence_length, dtype=np.int32)
+
+    # MLM
+    # we are packing up to max_sequences_per_pack, each with a certain percentage of masked tokens
+    # in case that percentege is rounded up for all sequences in the pack, need to add an extra token for
+    # each sequence in the pack
+    packed_masked_lm_positions = np.zeros(max_predictions_per_sequence + max_sequences_per_pack, dtype=np.int32)
+    packed_masked_lm_ids = np.zeros(max_predictions_per_sequence + max_sequences_per_pack, dtype=np.int32)
+    packed_masked_lm_weights = np.zeros(max_predictions_per_sequence + max_sequences_per_pack, dtype=np.int32)
+
+    # NSP
+    packed_next_sentence_positions = np.zeros(max_sequences_per_pack, dtype=np.int32)
+    packed_next_sentence_labels = np.zeros(max_sequences_per_pack, dtype=np.int32)
+    packed_next_sentence_weights = np.zeros(max_sequences_per_pack, dtype=np.int32)
+
+    offset = 0
+    mlm_offset = 0
+    sequence_index = 1  # used in the input mask
+    for sequence in multi_sequence:
+        # Padding sequences are donoted with None
+        if sequence is not None:
+            example = tf.train.Example()
+            example.ParseFromString(sequence.numpy())
+
+            input_ids = np.array(example.features.feature['input_ids'].int64_list.value)
+            input_mask = np.array(example.features.feature['input_mask'].int64_list.value)
+            segment_ids = np.array(example.features.feature['segment_ids'].int64_list.value)
+            masked_lm_positions = np.array(example.features.feature['masked_lm_positions'].int64_list.value)
+            masked_lm_ids = np.array(example.features.feature['masked_lm_ids'].int64_list.value)
+            masked_lm_weights = np.array(example.features.feature['masked_lm_weights'].float_list.value)
+            next_sentence_labels = np.array(example.features.feature['next_sentence_labels'].int64_list.value)
+            seq_len = input_mask.sum()
+
+            del example
+
+            # SEQ
+            packed_input_ids[offset:offset + seq_len] = input_ids[:seq_len]
+            packed_input_mask[offset:offset + seq_len] = sequence_index
+            packed_segment_ids[offset:offset + seq_len] = segment_ids[:seq_len]
+            packed_positions[offset:offset + seq_len] = np.arange(0, seq_len)
+
+            # MLM
+            mlm_len = int(masked_lm_weights.sum())
+            assert mlm_offset + mlm_len < max_predictions_per_sequence + max_sequences_per_pack, "Too many LM predictions per sequences"
+            max_mlm = mlm_offset + mlm_len
+            packed_masked_lm_positions[mlm_offset:max_mlm] = offset + masked_lm_positions[:mlm_len]
+            packed_masked_lm_ids[mlm_offset:max_mlm] = masked_lm_ids[:mlm_len]
+            packed_masked_lm_weights[mlm_offset:max_mlm] = sequence_index
+            # NSP
+            packed_next_sentence_positions[sequence_index - 1] = offset
+            packed_next_sentence_labels[sequence_index - 1] = next_sentence_labels
+            packed_next_sentence_weights[sequence_index - 1] = 1
+
+            # Update offsets
+            sequence_index += 1
+            offset += seq_len
+            mlm_offset = max_mlm
+            input_ids = None; input_mask = None; segment_ids = None; masked_lm_positions = None;
+            masked_lm_ids = None; masked_lm_weights = None; next_sentence_labels = None; seq_len = None;
+    # Pack into binary format and write it
+
+    features = OrderedDict()
+
+    features["input_ids"] = create_int_feature(packed_input_ids)
+    features["input_mask"] = create_int_feature(packed_input_mask)
+    features["segment_ids"] = create_int_feature(packed_segment_ids)
+    features["positions"] = create_int_feature(packed_positions)
+    features["masked_lm_positions"] = create_int_feature(packed_masked_lm_positions)
+    features["masked_lm_ids"] = create_int_feature(packed_masked_lm_ids)
+    features["masked_lm_weights"] = create_float_feature(packed_masked_lm_weights)
+    features["next_sentence_positions"] = create_int_feature(packed_next_sentence_positions)
+    features["next_sentence_labels"] = create_int_feature(packed_next_sentence_labels)
+    features["next_sentence_weights"] = create_float_feature(packed_next_sentence_weights)
+    del packed_input_ids; del packed_input_mask; del packed_segment_ids;  del packed_positions; del packed_masked_lm_positions
+    del packed_masked_lm_weights; del packed_next_sentence_positions; del packed_next_sentence_labels; del packed_next_sentence_weights
+
+    return features
+
+def create_bytes_feature(value):
+    """Returns a bytes_list from a string / byte."""
+    if isinstance(value, type(tf.constant(0))):
+        value = value.numpy() # BytesList won't unpack a string from an EagerTensor.
+    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))
+
+def create_int_feature(values):
+    feature = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
+    return feature
+
+def create_float_feature(values):
+    feature = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))
+    return feature
+
+def total_size(o, handlers={}, verbose=False):
+    """ Returns the approximate memory footprint an object and all of its contents.
+
+    Automatically finds the contents of the following builtin containers and
+    their subclasses:  tuple, list, deque, dict, set and frozenset.
+    To search other containers, add handlers to iterate over their contents:
+
+        handlers = {SomeContainerClass: iter,
+                    OtherContainerClass: OtherContainerClass.get_elements}
+
+    """
+    dict_handler = lambda d: chain.from_iterable(d.items())
+    all_handlers = {tuple: iter,
+                    list: iter,
+                    deque: iter,
+                    dict: dict_handler,
+                    set: iter,
+                    frozenset: iter,
+                   }
+    all_handlers.update(handlers)     # user handlers take precedence
+    seen = set()                      # track which object id's have already been seen
+    default_size = getsizeof(0)       # estimate sizeof object without __sizeof__
+
+    def sizeof(o):
+        if id(o) in seen:       # do not double count the same object
+            return 0
+        seen.add(id(o))
+        s = getsizeof(o, default_size)
+
+        if verbose:
+            print(s, type(o), repr(o), file=stderr)
+
+        for typ, handler in all_handlers.items():
+            if isinstance(o, typ):
+                s += sum(map(sizeof, handler(o)))
+                break
+        return s
+
+    return sizeof(o)
+def compress_zeros(input):
+    return input[0:np.where(input)[0][-1]+1]
+
+def decompress_zeros(input,list_size):
+    output = np.zeros(list_size)
+    output[0:len(input)]=input
+    return output
+
+def compress_seg_ids(segment_ids):
+    tmp=np.where(segment_ids)[0]
+    return np.array([tmp[0],tmp[-1]-tmp[0]])
+
+def decompress_seg_ids(segment_ids):
+    output = np.zeros(512)
+    output[segment_ids[0],segment_ids[0]+segment_ids[1]]=1
+    return output
+
+def getCurrentMemoryUsage():
+    # Getting all memory using os.popen()
+    total_memory, used_memory, free_memory = map(
+        int, os.popen('free -t -m').readlines()[-1].split()[1:])
+
+    # Memory usage
+    print("RAM memory % used:", round((used_memory/total_memory) * 100, 2))
+    return used_memory/total_memory
+
+def parallel_record_loader(record):
+    example = tf.train.Example()
+    example.ParseFromString(record.numpy())
+    im_length = sum(example.features.feature['input_mask'].int64_list.value)
+    return record, im_length
+
+
+def parallel_data_loader(path,filename):
+    sequence_lengths_part = []
+    examples_by_length_part = defaultdict(list)
+    for record in tf.data.TFRecordDataset(path+filename):
+        example = tf.train.Example()
+        example.ParseFromString(record.numpy())
+        im_length = sum(example.features.feature['input_mask'].int64_list.value)
+        examples_by_length_part[im_length].append(record)
+        sequence_lengths_part.append(im_length)
+        del example
+    return sequence_lengths_part,examples_by_length_part
+
+if __name__ == "__main__":
+    tf.compat.v1.enable_eager_execution()
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input-glob", help="A glob expression for the input files to read in and pack", required=True, type=str)
+    parser.add_argument("--output-dir", help="The destination folder for the output files", required=True)
+    parser.add_argument("--max-files", help="At most how many files to process (limited by RAM)", default=100,type=int)
+    parser.add_argument("--duplication-factor", help="Same as the one passed to create input data", default=1, type=int)
+    parser.add_argument("--max-sequence-length", help="The maximum number of tokens in an example", default=512, type=int)
+    parser.add_argument("--max-predictions-per-sequence", help="The maximum number of masked tokens in an un-packed example", default=76, type=int)
+    parser.add_argument("--max-sequences-per-pack", help="The maximum number of sequences per packed example.", choices=[2, 3], default=3, type=int)
+    args = parser.parse_args()
+
+    logger = tf.get_logger()
+    logger.propagate = False
+
+    if not os.path.exists(args.output_dir):
+        logger.warning(
+            f"Output directory: {args.output_dir} does not exists, creating..."
+        )
+        try:
+            os.makedirs(args.output_dir, exist_ok=True)
+        except IOError as error:
+            logger.error(error)
+            raise
+
+    # Input files
+    print("Looping through dataset to collect sequence length information...")
+    input_files = np.random.choice(os.listdir(args.input_glob), size=args.max_files, replace=False)
+    sequence_lengths = []
+    examples_by_length = defaultdict(list)
+
+    with ProcessPoolExecutor(25) as executor:
+        work = repeat(args.input_glob), input_files.tolist()
+        for sequence_lengths_part,examples_by_length_part  in executor.map(parallel_data_loader, *work):
+            pass
+            sequence_lengths += sequence_lengths_part
+            examples_by_length = { key:examples_by_length.get(key,[])+examples_by_length_part.get(key,[]) for key in set(list(examples_by_length.keys())+list(examples_by_length_part.keys())) }
+            del examples_by_length_part
+            sequence_lengths_part=None; examples_by_length_part=None
+    sequence_lengths = np.array(sequence_lengths)
+    print('Done extracting sequance length !!!')
+    del executor
+    gc.collect()
+    # Pass the array of sequence lengths to the packing algorithm
+    strategy_set, mixture, padding, slicing = get_packing_recipe(args.output_dir, sequence_lengths, args.max_sequence_length, args.max_sequences_per_pack)
+    print('Done get_packing_recipe !!!')
+    # Add the calculated padding
+    for i in range(1, args.max_sequence_length + 1):
+        if i not in examples_by_length.keys():
+            examples_by_length[i]=[]
+        examples_by_length[i].extend([None] * int(padding[i - 1]))
+
+    # Shuffle the data
+    for key in examples_by_length:
+        random.shuffle(examples_by_length[key])
+
+    # Pack and store the data
+    print(f"\nPacking and writing packed dataset to {args.output_dir}.")
+
+    # Slice the data into chunks of max 50k packed examples
+    example_slices, strategies, part_idx = slice_examples(examples_by_length, slicing, strategy_set, mixture)
+    gc.collect()
+    print('Done slice_examples !!!')
+    del examples_by_length; del slicing; del strategy_set; del mixture
+    gc.collect()
+    start = time.time()
+    print(f"Splitting work into {len(part_idx)} parts.")
+    for rr in range(1+len(strategies)//500):
+        str_idx,stp_idx=rr*500,min((rr+1)*500,len(strategies))
+        part_idx_prt, strategies_prt, example_slices_prt = part_idx[str_idx:stp_idx], strategies[str_idx:stp_idx], example_slices[str_idx:stp_idx]
+        with ProcessPoolExecutor(25) as executor:
+            work = repeat(args), part_idx_prt, strategies_prt, example_slices_prt
+            for partial_result in executor.map(parallel_pack_according_to_strategy, *work):
+                pass
+        del work
+    print(f"\nDone. Took: {time.time() - start:3.2f} seconds to pack and write dataset.")
+    print('-------------',str_idx,stp_idx)
+    print('Done Cleaning')

docker/bloom13b/Model-References/TensorFlow/nlp/bert/download/download_dataset.py

@@ -0,0 +1,31 @@
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+
+import os
+from pathlib import Path
+import sys
+import socket
+import subprocess
+
+def download_dataset_r(dataset_path):
+    host_name = socket.gethostname()
+    try:
+        if not os.path.isdir(dataset_path):
+            print(f"{host_name}: *** Downloading dataset...\n\n")
+            os.makedirs(dataset_path, exist_ok=True)
+            download_script = Path(__file__).parent.joinpath("download_glue_data.py")
+            sys.stdout.flush()
+            sys.stderr.flush()
+            with subprocess.Popen(f"{sys.executable} {str(download_script)} --data_dir {dataset_path} --tasks MRPC", shell=True, executable='/bin/bash') as proc:
+                proc.wait()
+    except Exception as exc:
+        raise Exception(f"{host_name}: Error in {__file__} download_dataset_r({dataset_path})") from exc
+
+if __name__ == "__main__":
+    host_name = socket.gethostname()
+    print(f"{host_name}: In {sys.argv[0]}")
+    print(f"{host_name}: called with arguments: \"{sys.argv[1]}\"")
+    dataset_path = sys.argv[1]
+    print(f"{host_name}: MULTI_HLS_IPS = {os.environ.get('MULTI_HLS_IPS')}")
+    download_dataset_r(dataset_path)

docker/bloom13b/Model-References/TensorFlow/nlp/bert/download/download_glue_data.py

@@ -0,0 +1,141 @@
+''' Script for downloading all GLUE data.
+
+Note: for legal reasons, we are unable to host MRPC.
+You can either use the version hosted by the SentEval team, which is already tokenized,
+or you can download the original data from (https://download.microsoft.com/download/D/4/6/D46FF87A-F6B9-4252-AA8B-3604ED519838/MSRParaphraseCorpus.msi) and extract the data from it manually.
+For Windows users, you can run the .msi file. For Mac and Linux users, consider an external library such as 'cabextract' (see below for an example).
+You should then rename and place specific files in a folder (see below for an example).
+
+mkdir MRPC
+cabextract MSRParaphraseCorpus.msi -d MRPC
+cat MRPC/_2DEC3DBE877E4DB192D17C0256E90F1D | tr -d $'\r' > MRPC/msr_paraphrase_train.txt
+cat MRPC/_D7B391F9EAFF4B1B8BCE8F21B20B1B61 | tr -d $'\r' > MRPC/msr_paraphrase_test.txt
+rm MRPC/_*
+rm MSRParaphraseCorpus.msi
+
+1/30/19: It looks like SentEval is no longer hosting their extracted and tokenized MRPC data, so you'll need to download the data from the original source for now.
+2/11/19: It looks like SentEval actually *is* hosting the extracted data. Hooray!
+'''
+
+import os
+import sys
+import shutil
+import argparse
+import tempfile
+import urllib.request
+import zipfile
+
+TASKS = ["CoLA", "SST", "MRPC", "QQP", "STS", "MNLI", "SNLI", "QNLI", "RTE", "WNLI", "diagnostic"]
+TASK2PATH = {"CoLA":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FCoLA.zip?alt=media&token=46d5e637-3411-4188-bc44-5809b5bfb5f4',
+             "SST":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSST-2.zip?alt=media&token=aabc5f6b-e466-44a2-b9b4-cf6337f84ac8',
+             "MRPC":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2Fmrpc_dev_ids.tsv?alt=media&token=ec5c0836-31d5-48f4-b431-7480817f1adc',
+             "QQP":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FQQP.zip?alt=media&token=700c6acf-160d-4d89-81d1-de4191d02cb5',
+             "STS":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSTS-B.zip?alt=media&token=bddb94a7-8706-4e0d-a694-1109e12273b5',
+             "MNLI":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FMNLI.zip?alt=media&token=50329ea1-e339-40e2-809c-10c40afff3ce',
+             "SNLI":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FSNLI.zip?alt=media&token=4afcfbb2-ff0c-4b2d-a09a-dbf07926f4df',
+             "QNLI": 'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FQNLIv2.zip?alt=media&token=6fdcf570-0fc5-4631-8456-9505272d1601',
+             "RTE":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FRTE.zip?alt=media&token=5efa7e85-a0bb-4f19-8ea2-9e1840f077fb',
+             "WNLI":'https://firebasestorage.googleapis.com/v0/b/mtl-sentence-representations.appspot.com/o/data%2FWNLI.zip?alt=media&token=068ad0a0-ded7-4bd7-99a5-5e00222e0faf',
+             "diagnostic":'https://storage.googleapis.com/mtl-sentence-representations.appspot.com/tsvsWithoutLabels%2FAX.tsv?GoogleAccessId=firebase-adminsdk-0khhl@mtl-sentence-representations.iam.gserviceaccount.com&Expires=2498860800&Signature=DuQ2CSPt2Yfre0C%2BiISrVYrIFaZH1Lc7hBVZDD4ZyR7fZYOMNOUGpi8QxBmTNOrNPjR3z1cggo7WXFfrgECP6FBJSsURv8Ybrue8Ypt%2FTPxbuJ0Xc2FhDi%2BarnecCBFO77RSbfuz%2Bs95hRrYhTnByqu3U%2FYZPaj3tZt5QdfpH2IUROY8LiBXoXS46LE%2FgOQc%2FKN%2BA9SoscRDYsnxHfG0IjXGwHN%2Bf88q6hOmAxeNPx6moDulUF6XMUAaXCSFU%2BnRO2RDL9CapWxj%2BDl7syNyHhB7987hZ80B%2FwFkQ3MEs8auvt5XW1%2Bd4aCU7ytgM69r8JDCwibfhZxpaa4gd50QXQ%3D%3D'}
+
+MRPC_TRAIN = 'https://dl.fbaipublicfiles.com/senteval/senteval_data/msr_paraphrase_train.txt'
+MRPC_TEST = 'https://dl.fbaipublicfiles.com/senteval/senteval_data/msr_paraphrase_test.txt'
+
+def download_and_extract(task, data_dir):
+    print("Downloading and extracting %s..." % task)
+    data_file = os.path.join(tempfile.gettempdir(), "%s.zip" % task)
+    urllib.request.urlretrieve(TASK2PATH[task], data_file)
+    with zipfile.ZipFile(data_file) as zip_ref:
+        zip_ref.extractall(data_dir)
+    os.remove(data_file)
+    print("\tCompleted!")
+
+def format_mrpc(data_dir, path_to_data):
+    print("Processing MRPC...")
+    mrpc_dir = os.path.join(data_dir, "MRPC")
+    if not os.path.isdir(mrpc_dir):
+        os.mkdir(mrpc_dir)
+    if path_to_data:
+        mrpc_train_file = os.path.join(path_to_data, "msr_paraphrase_train.txt")
+        mrpc_test_file = os.path.join(path_to_data, "msr_paraphrase_test.txt")
+    else:
+        print("Local MRPC data not specified, downloading data from %s" % MRPC_TRAIN)
+        mrpc_train_file = os.path.join(mrpc_dir, "msr_paraphrase_train.txt")
+        mrpc_test_file = os.path.join(mrpc_dir, "msr_paraphrase_test.txt")
+        urllib.request.urlretrieve(MRPC_TRAIN, mrpc_train_file)
+        urllib.request.urlretrieve(MRPC_TEST, mrpc_test_file)
+    assert os.path.isfile(mrpc_train_file), "Train data not found at %s" % mrpc_train_file
+    assert os.path.isfile(mrpc_test_file), "Test data not found at %s" % mrpc_test_file
+    urllib.request.urlretrieve(TASK2PATH["MRPC"], os.path.join(mrpc_dir, "dev_ids.tsv"))
+
+    dev_ids = []
+    with open(os.path.join(mrpc_dir, "dev_ids.tsv"), encoding="utf8") as ids_fh:
+        for row in ids_fh:
+            dev_ids.append(row.strip().split('\t'))
+
+    with open(mrpc_train_file, encoding="utf8") as data_fh, \
+         open(os.path.join(mrpc_dir, "train.tsv"), 'w', encoding="utf8") as train_fh, \
+         open(os.path.join(mrpc_dir, "dev.tsv"), 'w', encoding="utf8") as dev_fh:
+        header = data_fh.readline()
+        train_fh.write(header)
+        dev_fh.write(header)
+        for row in data_fh:
+            label, id1, id2, s1, s2 = row.strip().split('\t')
+            if [id1, id2] in dev_ids:
+                dev_fh.write("%s\t%s\t%s\t%s\t%s\n" % (label, id1, id2, s1, s2))
+            else:
+                train_fh.write("%s\t%s\t%s\t%s\t%s\n" % (label, id1, id2, s1, s2))
+
+    with open(mrpc_test_file, encoding="utf8") as data_fh, \
+            open(os.path.join(mrpc_dir, "test.tsv"), 'w', encoding="utf8") as test_fh:
+        header = data_fh.readline()
+        test_fh.write("index\t#1 ID\t#2 ID\t#1 String\t#2 String\n")
+        for idx, row in enumerate(data_fh):
+            label, id1, id2, s1, s2 = row.strip().split('\t')
+            test_fh.write("%d\t%s\t%s\t%s\t%s\n" % (idx, id1, id2, s1, s2))
+    print("\tCompleted!")
+
+def download_diagnostic(data_dir):
+    print("Downloading and extracting diagnostic...")
+    if not os.path.isdir(os.path.join(data_dir, "diagnostic")):
+        os.mkdir(os.path.join(data_dir, "diagnostic"))
+    data_file = os.path.join(data_dir, "diagnostic", "diagnostic.tsv")
+    urllib.request.urlretrieve(TASK2PATH["diagnostic"], data_file)
+    print("\tCompleted!")
+    return
+
+def get_tasks(task_names):
+    task_names = task_names.split(',')
+    if "all" in task_names:
+        tasks = TASKS
+    else:
+        tasks = []
+        for task_name in task_names:
+            assert task_name in TASKS, "Task %s not found!" % task_name
+            tasks.append(task_name)
+    return tasks
+
+def main(arguments):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--data_dir', help='directory to save data to', type=str, default='glue_data')
+    parser.add_argument('--tasks', help='tasks to download data for as a comma separated string',
+                        type=str, default='all')
+    parser.add_argument('--path_to_mrpc', help='path to directory containing extracted MRPC data, msr_paraphrase_train.txt and msr_paraphrase_text.txt',
+                        type=str, default='')
+    args = parser.parse_args(arguments)
+
+    if not os.path.isdir(args.data_dir):
+        os.mkdir(args.data_dir)
+    tasks = get_tasks(args.tasks)
+
+    for task in tasks:
+        if task == 'MRPC':
+            format_mrpc(args.data_dir, args.path_to_mrpc)
+        elif task == 'diagnostic':
+            download_diagnostic(args.data_dir)
+        else:
+            download_and_extract(task, args.data_dir)
+
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]))

docker/bloom13b/Model-References/TensorFlow/nlp/bert/download/download_pretrained_model.py

@@ -0,0 +1,75 @@
+###############################################################################
+# Copyright (C) 2020-2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+
+import os
+from pathlib import Path
+import sys
+import socket
+import urllib.request
+import zipfile
+import subprocess
+
+
+def run_cmd_as_subprocess(cmd=str):
+    print(cmd)
+    sys.stdout.flush()
+    sys.stderr.flush()
+    with subprocess.Popen(cmd, shell=True, executable='/bin/bash') as proc:
+        proc.wait()
+
+
+def download_pretrained_model_r(pretrained_url, pretrained_model, flatten_archive=False):
+    host_name = socket.gethostname()
+    this_dir = os.getcwd()
+    try:
+        os.chdir(Path(__file__).parent.parent)
+        if not os.path.isdir(pretrained_model):
+            _wget = False
+            if os.path.exists(pretrained_model + ".zip") == False:
+                _wget = True
+            else:
+                if os.path.getsize(pretrained_model + ".zip") == 0:
+                    print(f"{host_name}: *** Broken file, needs download ...\n\n")
+                    _wget = True
+            if _wget == True:
+                print(f"{host_name}: *** Downloading pre-trained model...\n\n")
+                inf = urllib.request.urlopen(pretrained_url + pretrained_model + ".zip")
+                with open(pretrained_model + ".zip", "wb") as outf:
+                    outf.write(inf.read())
+
+            print(f"{host_name}: *** Extracting pre-trained model...\n\n")
+            with zipfile.ZipFile(pretrained_model + ".zip", 'r') as zip_ref:
+                if flatten_archive:
+                    # large model is zipped with subdirectory, flatten archive tree structure
+                    for member in zip_ref.infolist():
+                        # skip directories
+                        if member.is_dir():
+                            continue
+                        zip_ref.extract(member)
+                else:
+                    zip_ref.extractall(pretrained_model)
+
+            if _wget == True:
+                cmd = f"rm -f {pretrained_model}.zip"
+                run_cmd_as_subprocess(cmd)
+        else:
+            print(f"{host_name}: Reusing existing pre-trained model directory \'{pretrained_model}\'")
+        os.chdir(this_dir)
+    except Exception as exc:
+        os.chdir(this_dir)
+        raise Exception(f"{host_name}: Error in {__file__} download_pretrained_model()") from exc
+
+if __name__ == "__main__":
+    host_name = socket.gethostname()
+    print(f"{host_name}: In {sys.argv[0]}")
+    print(f"{host_name}: called with arguments: \"{sys.argv[1]} {sys.argv[2]} {sys.argv[3]}\"")
+    pretrained_url = str(sys.argv[1])
+    pretrained_model = str(sys.argv[2])
+    flatten_archive_str = str(sys.argv[3])
+    if flatten_archive_str == "True":
+        flatten_archive = True
+    else:
+        flatten_archive = False
+    print(f"{host_name}: MULTI_HLS_IPS = {os.environ.get('MULTI_HLS_IPS')}")
+    download_pretrained_model_r(pretrained_url, pretrained_model, flatten_archive)

docker/bloom13b/Model-References/TensorFlow/nlp/bert/optimization.py

@@ -0,0 +1,458 @@
+# coding=utf-8
+# Copyright (c) 2019 NVIDIA CORPORATION. All rights reserved.
+# Copyright 2018 The Google AI Language Team Authors.
+#
+# 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.
+
+"""Functions and classes related to optimization (weight updates)."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import re
+import tensorflow as tf
+from tensorflow.python.ops import array_ops
+from tensorflow.python.ops import linalg_ops
+from tensorflow.python.ops import math_ops
+
+try:
+    import horovod.tensorflow as hvd
+except ImportError:
+    hvd = None
+
+def horovod_enabled():
+  return hvd is not None and hvd.is_initialized()
+
+def create_optimizer(loss, init_lr, num_train_steps, num_warmup_steps, manual_fp16=False, use_fp16=False, num_accumulation_steps=1,
+                     optimizer_type="adam", allreduce_post_accumulation=False, init_loss_scale=2**32, use_tpu=False):
+  """Creates an optimizer training op."""
+  global_step = tf.compat.v1.train.get_or_create_global_step()
+
+  # avoid step change in learning rate at end of warmup phase
+  if optimizer_type == "adam":
+    power = 1.0
+    decayed_learning_rate_at_crossover_point = init_lr * (
+        (1.0 - float(num_warmup_steps) / float(num_train_steps)) ** power)
+  else:
+    power = 0.5
+    decayed_learning_rate_at_crossover_point = init_lr
+
+  adjusted_init_lr = init_lr * (init_lr / decayed_learning_rate_at_crossover_point)
+  print('decayed_learning_rate_at_crossover_point = %e, adjusted_init_lr = %e' %
+        (decayed_learning_rate_at_crossover_point, adjusted_init_lr))
+
+  learning_rate = tf.constant(value=adjusted_init_lr, shape=[], dtype=tf.float32)
+
+  # Implements linear decay of the learning rate.
+  learning_rate = tf.compat.v1.train.polynomial_decay(
+      learning_rate,
+      global_step,
+      num_train_steps,
+      end_learning_rate=0.0,
+      power=power,
+      cycle=False)
+
+  # Implements linear warmup. I.e., if global_step < num_warmup_steps, the
+  # learning rate will be `global_step/num_warmup_steps * init_lr`.
+  if num_warmup_steps:
+    global_steps_int = tf.cast(global_step, tf.int32)
+    warmup_steps_int = tf.constant(num_warmup_steps, dtype=tf.int32)
+
+    global_steps_float = tf.cast(global_steps_int, tf.float32)
+    warmup_steps_float = tf.cast(warmup_steps_int, tf.float32)
+
+    warmup_percent_done = global_steps_float / warmup_steps_float
+    warmup_learning_rate = init_lr * warmup_percent_done
+
+    is_warmup = tf.cast(global_steps_int < warmup_steps_int, tf.float32)
+    learning_rate = (
+        (1.0 - is_warmup) * learning_rate + is_warmup * warmup_learning_rate)
+
+  if optimizer_type == "lamb":
+    print("Initializing LAMB Optimizer")
+    optimizer = LAMBOptimizer(
+        learning_rate=learning_rate,
+        weight_decay_rate=0.01,
+        beta_1=0.9,
+        beta_2=0.999,
+        epsilon=1e-6,
+        exclude_from_weight_decay=["LayerNorm", "layer_norm", "bias"])
+  else:
+    print("Initializing ADAM Weight Decay Optimizer")
+    # It is recommended that you use this optimizer for fine tuning, since this
+    # is how the model was trained (note that the Adam m/v variables are NOT
+    # loaded from init_checkpoint.)
+    optimizer = AdamWeightDecayOptimizer(
+        learning_rate=learning_rate,
+        weight_decay_rate=0.01,
+        beta_1=0.9,
+        beta_2=0.999,
+        epsilon=1e-6,
+        exclude_from_weight_decay=["LayerNorm", "layer_norm", "bias"])
+
+  if horovod_enabled() and (num_accumulation_steps == 1 or (not allreduce_post_accumulation)):
+    optimizer = hvd.DistributedOptimizer(optimizer, sparse_as_dense=True)
+  if use_fp16:
+    loss_scaler = tf.train.experimental.DynamicLossScale(
+        initial_loss_scale=init_loss_scale, increment_period=1000, multiplier=2.0)
+    optimizer = tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer, loss_scaler)
+    loss_scale_value = tf.identity(loss_scaler(), name="loss_scale")
+  if manual_fp16:
+    assert False, "No support for ExponentialUpdateLossScaleManager and LossScaleOptimizer in TF2.0"
+    loss_scale_manager = tf.contrib.mixed_precision.ExponentialUpdateLossScaleManager(init_loss_scale=init_loss_scale,
+                                                                                      incr_every_n_steps=1000,
+                                                                                      decr_every_n_nan_or_inf=2,
+                                                                                      decr_ratio=0.5)
+    optimizer = tf.contrib.mixed_precision.LossScaleOptimizer(optimizer, loss_scale_manager)
+  if use_tpu:
+    optimizer = tf.compat.v1.tpu.CrossShardOptimizer(optimizer)
+  tvars = tf.compat.v1.trainable_variables()
+
+  if num_accumulation_steps > 1:
+    grads_and_vars = optimizer.compute_gradients(loss * 1.0 / num_accumulation_steps, tvars)
+    local_step = tf.compat.v1.get_variable(name="local_step", shape=[], dtype=tf.int32, trainable=False,
+                                           initializer=tf.compat.v1.zeros_initializer)
+    batch_finite = tf.compat.v1.get_variable(name="batch_finite", shape=[], dtype=tf.bool, trainable=False,
+                                             initializer=tf.compat.v1.ones_initializer)
+    accum_vars = [tf.compat.v1.get_variable(
+        name=tvar.name.split(":")[0] + "/accum",
+        shape=tvar.shape.as_list(),
+        dtype=tf.float32,
+        trainable=False,
+        initializer=tf.compat.v1.zeros_initializer()) for tvar in tf.compat.v1.trainable_variables()]
+
+    reset_step = tf.cast(tf.math.equal(local_step % num_accumulation_steps, 0), dtype=tf.bool)
+    local_step = tf.cond(pred=reset_step, true_fn=lambda: local_step.assign(
+        tf.ones_like(local_step)), false_fn=lambda: local_step.assign_add(1))
+
+    grads_and_vars_and_accums = [(gv[0], gv[1], accum_vars[i])
+                                 for i, gv in enumerate(grads_and_vars) if gv[0] is not None]
+    grads, tvars, accum_vars = list(zip(*grads_and_vars_and_accums))
+
+    all_are_finite = tf.reduce_all(input_tensor=[tf.reduce_all(input_tensor=tf.math.is_finite(
+        g)) for g in grads]) if manual_fp16 or use_fp16 else tf.constant(True, dtype=tf.bool)
+    batch_finite = tf.cond(pred=reset_step,
+                           true_fn=lambda: batch_finite.assign(tf.math.logical_and(
+                               tf.constant(True, dtype=tf.bool), all_are_finite)),
+                           false_fn=lambda: batch_finite.assign(tf.math.logical_and(batch_finite, all_are_finite)))
+
+    # This is how the model was pre-trained.
+    # ensure global norm is a finite number
+    # to prevent clip_by_global_norm from having a hizzy fit.
+    (clipped_grads, _) = tf.clip_by_global_norm(
+        grads, clip_norm=1.0,
+        use_norm=tf.cond(
+            pred=all_are_finite,
+            true_fn=lambda: tf.linalg.global_norm(grads),
+            false_fn=lambda: tf.constant(1.0)))
+
+    accum_vars = tf.cond(pred=reset_step,
+                         true_fn=lambda: [accum_vars[i].assign(grad) for i, grad in enumerate(clipped_grads)],
+                         false_fn=lambda: [accum_vars[i].assign_add(grad) for i, grad in enumerate(clipped_grads)])
+
+    update_step = tf.identity(tf.cast(tf.math.equal(local_step % num_accumulation_steps, 0),
+                                      dtype=tf.bool), name="update_step")
+
+    def allreduce_of_batch_finite_required():
+      # In case of bf16 and fp32 batch finite is tf.constant(True, dtype=tf.bool)
+      return horovod_enabled() and manual_fp16 and use_fp16
+
+    # TODO: in future if we want to enable infinite batch iter skiping we will need to change this allreduce.
+    new_global_step = tf.cond(pred=tf.math.logical_and(update_step,
+                                                       tf.cast(hvd.allreduce(tf.cast(batch_finite, tf.int32)), tf.bool) if allreduce_of_batch_finite_required() else batch_finite),
+                              true_fn=lambda: global_step + 1,
+                              false_fn=lambda: global_step)
+    new_global_step = tf.identity(new_global_step, name='step_update')
+
+    def update(accum_vars):
+      with tf.control_dependencies([global_step.assign(new_global_step)]):
+        if allreduce_post_accumulation and horovod_enabled():
+          accum_vars = [hvd.allreduce(tf.convert_to_tensor(value=accum_var)) if isinstance(accum_var, tf.IndexedSlices)
+                        else hvd.allreduce(accum_var) for accum_var in accum_vars]
+
+        return optimizer.apply_gradients(list(zip(accum_vars, tvars)), global_step=global_step)
+
+    train_op = tf.cond(pred=update_step,
+                       true_fn=lambda: update(accum_vars), false_fn=lambda: tf.no_op())
+  else:
+    grads_and_vars = optimizer.compute_gradients(loss, tvars)
+    if horovod_enabled():
+      grads_and_vars = [(g, v) for g, v in grads_and_vars if g is not None]
+      grads, tvars = list(zip(*grads_and_vars))
+    else:
+      grads = tf.gradients(ys=loss, xs=tvars)
+    all_are_finite = tf.reduce_all(
+        input_tensor=[tf.reduce_all(input_tensor=tf.math.is_finite(g)) for g in grads]) if use_fp16 or manual_fp16 else tf.constant(True, dtype=tf.bool)
+
+    # This is how the model was pre-trained.
+    # ensure global norm is a finite number
+    # to prevent clip_by_global_norm from having a hizzy fit.
+    (clipped_grads, _) = tf.clip_by_global_norm(
+        grads, clip_norm=1.0,
+        use_norm=tf.cond(
+            pred=all_are_finite,
+            true_fn=lambda: tf.linalg.global_norm(grads),
+            false_fn=lambda: tf.constant(1.0)))
+
+    new_global_step = tf.cond(pred=all_are_finite, true_fn=lambda: global_step + 1, false_fn=lambda: global_step)
+    new_global_step = tf.identity(new_global_step, name='step_update')
+
+    with tf.control_dependencies([global_step.assign(new_global_step)]):
+      train_op = optimizer.apply_gradients(
+          list(zip(clipped_grads, tvars)), global_step=global_step)
+  return train_op
+
+
+class AdamWeightDecayOptimizer(tf.compat.v1.train.Optimizer):
+  """A basic Adam optimizer that includes "correct" L2 weight decay."""
+
+  def __init__(self,
+               learning_rate,
+               weight_decay_rate=0.0,
+               beta_1=0.9,
+               beta_2=0.999,
+               epsilon=1e-6,
+               exclude_from_weight_decay=None,
+               name="AdamWeightDecayOptimizer"):
+    """Constructs a AdamWeightDecayOptimizer."""
+    super(AdamWeightDecayOptimizer, self).__init__(False, name)
+
+    self.learning_rate = tf.identity(learning_rate, name='learning_rate')
+    self.weight_decay_rate = weight_decay_rate
+    self.beta_1 = beta_1
+    self.beta_2 = beta_2
+    self.epsilon = epsilon
+    self.exclude_from_weight_decay = exclude_from_weight_decay
+
+  def apply_gradients(self, grads_and_vars, global_step=None, name=None,
+                      manual_fp16=False):
+    """See base class."""
+    assignments = []
+    for (grad, param) in grads_and_vars:
+      if grad is None or param is None:
+        continue
+
+      param_name = self._get_variable_name(param.name)
+      has_shadow = manual_fp16 and param.dtype.base_dtype != tf.float32
+      if has_shadow:
+        # create shadow fp32 weights for fp16 variable
+        param_fp32 = tf.compat.v1.get_variable(
+            name=param_name + "/shadow",
+            dtype=tf.float32,
+            trainable=False,
+            initializer=tf.cast(param.initialized_value(), tf.float32))
+      else:
+        param_fp32 = param
+
+      m = tf.compat.v1.get_variable(
+          name=param_name + "/adam_m",
+          shape=param.shape.as_list(),
+          dtype=tf.float32,
+          trainable=False,
+          initializer=tf.compat.v1.zeros_initializer())
+      v = tf.compat.v1.get_variable(
+          name=param_name + "/adam_v",
+          shape=param.shape.as_list(),
+          dtype=tf.float32,
+          trainable=False,
+          initializer=tf.compat.v1.zeros_initializer())
+
+      # Standard Adam update.
+      next_m = (
+          tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))
+      next_v = (
+          tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,
+                                                    tf.square(grad)))
+
+      update = next_m * tf.math.rsqrt(next_v + self.epsilon * self.epsilon)
+
+      # Just adding the square of the weights to the loss function is *not*
+      # the correct way of using L2 regularization/weight decay with Adam,
+      # since that will interact with the m and v parameters in strange ways.
+      #
+      # Instead we want to decay the weights in a manner that doesn't interact
+      # with the m/v parameters. This is equivalent to adding the square
+      # of the weights to the loss with plain (non-momentum) SGD.
+      if self._do_use_weight_decay(param_name):
+        update += self.weight_decay_rate * param_fp32
+
+      update_with_lr = self.learning_rate * update
+
+      next_param = param_fp32 - update_with_lr
+
+      if has_shadow:
+        # cast shadow fp32 weights to fp16 and assign to trainable variable
+        param.assign(tf.cast(next_param, param.dtype.base_dtype))
+      assignments.extend(
+          [param_fp32.assign(next_param),
+           m.assign(next_m),
+           v.assign(next_v)])
+    return tf.group(*assignments, name=name)
+
+  def _do_use_weight_decay(self, param_name):
+    """Whether to use L2 weight decay for `param_name`."""
+    if not self.weight_decay_rate:
+      return False
+    if self.exclude_from_weight_decay:
+      for r in self.exclude_from_weight_decay:
+        if re.search(r, param_name) is not None:
+          return False
+    return True
+
+  def _get_variable_name(self, param_name):
+    """Get the variable name from the tensor name."""
+    m = re.match("^(.*):\\d+$", param_name)
+    if m is not None:
+      param_name = m.group(1)
+    return param_name
+
+  # This code originally was a WA for this issue:
+  #    See: https://jira.habana-labs.com/browse/SW-19371
+  # However, the root issue has been fixed and is no longer required.
+  #
+  # It turned out that this function needs to be uncommented to speed up the BERT finetuning training.
+  #    See: https://jira.habana-labs.com/browse/SW-19126
+  #
+  # At this moment, enabling SAO leads to an immediate crash:
+  #    See: https://jira.habana-labs.com/browse/SW-19688
+  #
+  def compute_gradients(self, loss, var_list=None,
+                        gate_gradients=tf.compat.v1.train.Optimizer.GATE_OP,
+                        aggregation_method=None,
+                        colocate_gradients_with_ops=False,
+                        grad_loss=None):
+    assert gate_gradients == tf.compat.v1.train.Optimizer.GATE_OP
+    assert aggregation_method is None
+    assert not colocate_gradients_with_ops
+    assert grad_loss is None
+
+    grads = tf.gradients(ys=loss, xs=var_list)
+    grads_and_vars = list(zip(grads, var_list))
+    return grads_and_vars
+
+
+class LAMBOptimizer(tf.compat.v1.train.Optimizer):
+  """A LAMB optimizer that includes "correct" L2 weight decay."""
+
+  def __init__(self,
+               learning_rate,
+               weight_decay_rate=0.0,
+               beta_1=0.9,
+               beta_2=0.999,
+               epsilon=1e-6,
+               exclude_from_weight_decay=None,
+               name="LAMBOptimizer"):
+    """Constructs a LAMBOptimizer."""
+    super(LAMBOptimizer, self).__init__(False, name)
+
+    self.learning_rate = tf.identity(learning_rate, name='learning_rate')
+    self.weight_decay_rate = weight_decay_rate
+    self.beta_1 = beta_1
+    self.beta_2 = beta_2
+    self.epsilon = epsilon
+    self.exclude_from_weight_decay = exclude_from_weight_decay
+
+  def apply_gradients(self, grads_and_vars, global_step, name=None,
+                      manual_fp16=False):
+    """See base class."""
+    assignments = []
+    steps = tf.cast(global_step, tf.float32)
+    for (grad, param) in grads_and_vars:
+      if grad is None or param is None:
+        continue
+
+      param_name = self._get_variable_name(param.name)
+      has_shadow = manual_fp16 and param.dtype.base_dtype != tf.float32
+      if has_shadow:
+        # create shadow fp32 weights for fp16 variable
+        param_fp32 = tf.compat.v1.get_variable(
+            name=param_name + "/shadow",
+            dtype=tf.float32,
+            trainable=False,
+            initializer=tf.cast(param.initialized_value(), tf.float32))
+      else:
+        param_fp32 = param
+
+      m = tf.compat.v1.get_variable(
+          name=param_name + "/adam_m",
+          shape=param.shape.as_list(),
+          dtype=tf.float32,
+          trainable=False,
+          initializer=tf.compat.v1.zeros_initializer())
+      v = tf.compat.v1.get_variable(
+          name=param_name + "/adam_v",
+          shape=param.shape.as_list(),
+          dtype=tf.float32,
+          trainable=False,
+          initializer=tf.compat.v1.zeros_initializer())
+
+      # LAMB update
+      next_m = (
+          tf.multiply(self.beta_1, m) + tf.multiply(1.0 - self.beta_1, grad))
+      next_v = (
+          tf.multiply(self.beta_2, v) + tf.multiply(1.0 - self.beta_2,
+                                                    tf.square(grad)))
+
+      beta1_correction = (1 - self.beta_1 ** steps)
+      beta2_correction = (1 - self.beta_2 ** steps)
+
+      next_m_unbiased = next_m / beta1_correction
+      next_v_unbiased = next_v / beta2_correction
+
+      update = next_m_unbiased / (tf.sqrt(next_v_unbiased) + self.epsilon)
+
+      # Just adding the square of the weights to the loss function is *not*
+      # the correct way of using L2 regularization/weight decay with Adam,
+      # since that will interact with the m and v parameters in strange ways.
+      #
+      # Instead we want to decay the weights in a manner that doesn't interact
+      # with the m/v parameters. This is equivalent to adding the square
+      # of the weights to the loss with plain (non-momentum) SGD.
+      if self._do_use_weight_decay(param_name):
+        update += self.weight_decay_rate * param_fp32
+
+      w_norm = linalg_ops.norm(param, ord=2)
+      g_norm = linalg_ops.norm(update, ord=2)
+      ratio = array_ops.where(math_ops.greater(w_norm, 0), array_ops.where(
+          math_ops.greater(g_norm, 0), (w_norm / g_norm), 1.0), 1.0)
+
+      update_with_lr = ratio * self.learning_rate * update
+
+      next_param = param_fp32 - update_with_lr
+
+      if has_shadow:
+        # cast shadow fp32 weights to fp16 and assign to trainable variable
+        param.assign(tf.cast(next_param, param.dtype.base_dtype))
+      assignments.extend(
+          [param_fp32.assign(next_param),
+           m.assign(next_m),
+           v.assign(next_v)])
+    return tf.group(*assignments, name=name)
+
+  def _do_use_weight_decay(self, param_name):
+    """Whether to use L2 weight decay for `param_name`."""
+    if not self.weight_decay_rate:
+      return False
+    if self.exclude_from_weight_decay:
+      for r in self.exclude_from_weight_decay:
+        if re.search(r, param_name) is not None:
+          return False
+    return True
+
+  def _get_variable_name(self, param_name):
+    """Get the variable name from the tensor name."""
+    m = re.match("^(.*):\\d+$", param_name)
+    if m is not None:
+      param_name = m.group(1)
+    return param_name

docker/bloom13b/Model-References/TensorFlow/nlp/bert/utils/fused_layer_norm.py

@@ -0,0 +1,141 @@
+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors.
+# Copyright (c) 2018, NVIDIA CORPORATION.  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.
+
+import collections
+import copy
+import json
+import math
+import re
+import six
+import tensorflow as tf
+
+from tensorflow.python.framework import ops
+from tensorflow.contrib.layers.python.layers import utils
+from tensorflow.contrib.framework.python.ops import variables
+from tensorflow.python.ops import init_ops
+import numpy
+from tensorflow.python.ops import array_ops
+from tensorflow.python.framework import dtypes
+from tensorflow.python.ops import nn
+
+def fused_layer_norm(inputs,
+               center=True,
+               scale=True,
+               activation_fn=None,
+               reuse=None,
+               variables_collections=None,
+               outputs_collections=None,
+               trainable=True,
+               begin_norm_axis=1,
+               begin_params_axis=-1,
+               scope=None,
+               use_fused_batch_norm=False):
+  with tf.compat.v1.variable_scope(
+      scope, 'LayerNorm', [inputs], reuse=reuse) as sc:
+    inputs = ops.convert_to_tensor(inputs)
+    inputs_shape = inputs.shape
+    inputs_rank = inputs_shape.ndims
+    if inputs_rank is None:
+      raise ValueError('Inputs %s has undefined rank.' % inputs.name)
+    dtype = inputs.dtype.base_dtype
+    if begin_norm_axis < 0:
+      begin_norm_axis = inputs_rank + begin_norm_axis
+    if begin_params_axis >= inputs_rank or begin_norm_axis >= inputs_rank:
+      raise ValueError('begin_params_axis (%d) and begin_norm_axis (%d) '
+                       'must be < rank(inputs) (%d)' %
+                       (begin_params_axis, begin_norm_axis, inputs_rank))
+    params_shape = inputs_shape[begin_params_axis:]
+    if not params_shape.is_fully_defined():
+      raise ValueError(
+          'Inputs %s: shape(inputs)[%s:] is not fully defined: %s' %
+          (inputs.name, begin_params_axis, inputs_shape))
+    # Allocate parameters for the beta and gamma of the normalization.
+    beta, gamma = None, None
+    if center:
+      beta_collections = utils.get_variable_collections(variables_collections,
+                                                        'beta')
+      beta = variables.model_variable(
+          'beta',
+          shape=params_shape,
+          dtype=dtype,
+          initializer=init_ops.zeros_initializer(),
+          collections=beta_collections,
+          trainable=trainable)
+    if scale:
+      gamma_collections = utils.get_variable_collections(
+          variables_collections, 'gamma')
+      gamma = variables.model_variable(
+          'gamma',
+          shape=params_shape,
+          dtype=dtype,
+          initializer=init_ops.ones_initializer(),
+          collections=gamma_collections,
+          trainable=trainable)
+    if use_fused_batch_norm:
+      # get static TensorShape if fully defined,
+      # otherwise retrieve shape tensor
+      norm_shape = inputs.shape[begin_norm_axis:]
+      if norm_shape.is_fully_defined():
+        bn_shape = [1, -1, 1, numpy.prod(norm_shape.as_list())]
+      else:
+        norm_shape = tf.shape(input=inputs)[begin_norm_axis:]
+        bn_shape = [1, -1, 1, tf.reduce_prod(input_tensor=norm_shape)]
+      if inputs.get_shape().is_fully_defined():
+        outputs_shape = inputs.get_shape()
+      else:
+        outputs_shape = tf.shape(input=inputs)
+      inputs = array_ops.reshape(inputs, bn_shape)
+      if inputs.get_shape().is_fully_defined():
+        # static inputs TensorShape fully defined after reshape.
+        ones = array_ops.ones(inputs.get_shape()[1], dtype=dtypes.float32)
+        zeros = array_ops.zeros(inputs.get_shape()[1], dtype=dtypes.float32)
+      else:
+        # static inputs TensorShape NOT fully defined after reshape.
+        # must use dynamic shape, which means these input tensors
+        # have to be created at runtime, which causes a slowdown.
+        scale_shape = tf.shape(input=inputs)[1]
+        ones = array_ops.ones(scale_shape, dtype=dtypes.float32)
+        zeros = array_ops.zeros(scale_shape, dtype=dtypes.float32)
+      outputs, mean, variance = nn.fused_batch_norm(
+          inputs,
+          ones, zeros,
+          epsilon=1e-4,
+          data_format="NCHW")
+      outputs = array_ops.reshape(outputs, outputs_shape)
+      if center and scale:
+        outputs = outputs * gamma + beta
+      elif center:
+        outputs = outputs + beta
+      elif scale:
+        outputs = outputs * gamma
+    else:
+      # Calculate the moments on the last axis (layer activations).
+      norm_axes = list(range(begin_norm_axis, inputs_rank))
+      mean, variance = nn.moments(inputs, norm_axes, keep_dims=True)
+      # Compute layer normalization using the batch_normalization function.
+      variance_epsilon = 1e-4
+      outputs = nn.batch_normalization(
+          inputs,
+          mean,
+          variance,
+          offset=beta,
+          scale=gamma,
+          variance_epsilon=variance_epsilon)
+      outputs.set_shape(inputs_shape)
+    if activation_fn is not None:
+      outputs = activation_fn(outputs)
+    return utils.collect_named_outputs(outputs_collections, sc.name, outputs)
+

docker/bloom13b/Model-References/TensorFlow/nlp/bert/utils/gpu_environment.py

@@ -0,0 +1,36 @@
+# coding=utf-8
+# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import tensorflow as tf
+import numpy as np
+
+def float32_variable_storage_getter(getter, name, shape=None, dtype=None,
+                                    initializer=None, regularizer=None,
+                                    trainable=True,
+                                    *args, **kwargs):
+    """Custom variable getter that forces trainable variables to be stored in
+       float32 precision and then casts them to the training precision.
+    """
+    storage_dtype = tf.float32 if trainable else dtype
+    variable = getter(name, shape, dtype=storage_dtype,
+                      initializer=initializer, regularizer=regularizer,
+                      trainable=trainable,
+                      *args, **kwargs)
+    if trainable and dtype != tf.float32:
+        variable = tf.cast(variable, dtype)
+    return variable
+
+def get_custom_getter(compute_type):
+    return float32_variable_storage_getter if compute_type == tf.float16 else None

docker/bloom13b/Model-References/TensorFlow/nlp/bert/utils/utils.py

@@ -0,0 +1,64 @@
+# Copyright (c) 2019 NVIDIA CORPORATION. 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.
+
+import tensorflow as tf
+import time
+
+# report latency and throughput during eval
+class LogEvalRunHook(tf.estimator.SessionRunHook):
+  def __init__(self, global_batch_size, hvd_rank=-1):
+    self.global_batch_size = global_batch_size
+    self.hvd_rank = hvd_rank
+    self.count = 0
+    self.time_list = []
+
+  def before_run(self, run_context):
+    self.t0 = time.time()
+
+  def after_run(self, run_context, run_values):
+    elapsed_secs = time.time() - self.t0
+    self.count += 1
+    self.time_list.append(elapsed_secs)
+
+# report throughput during training
+class LogTrainRunHook(tf.estimator.SessionRunHook):
+  def __init__(self, global_batch_size, hvd_rank=-1, save_checkpoints_steps=1000, num_steps_ignore_xla=100):
+    self.global_batch_size = global_batch_size
+    self.hvd_rank = hvd_rank
+    self.save_checkpoints_steps = save_checkpoints_steps
+
+    self.total_time = 0.0
+    self.count = 0 # Holds number of iterations, including skipped iterations for fp16 loss scaling
+    self.skipped = 0
+    self.num_steps_ignore_xla = num_steps_ignore_xla 
+    #initial steps while xla is still compilingneed to be ignored from throughput computation 
+
+  def after_create_session(self, session, coord):
+    self.init_global_step = session.run(tf.compat.v1.train.get_global_step())
+
+  def before_run(self, run_context):
+    self.t0 = time.time()
+    return tf.estimator.SessionRunArgs(
+        fetches=['step_update:0'])
+
+  def after_run(self, run_context, run_values):
+    elapsed_secs = time.time() - self.t0
+    self.global_step = run_values.results[0]
+    self.count += 1
+
+    # Removing first 100 step + first five steps after every checkpoint save
+    if (self.global_step - self.init_global_step) <= self.num_steps_ignore_xla or (self.global_step - self.init_global_step) % self.save_checkpoints_steps < 5:
+      print("Skipping time record for ", self.global_step, " due to checkpoint-saving/warmup overhead")
+      self.skipped += 1
+    else:
+      self.total_time += elapsed_secs

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/LICENSE

@@ -0,0 +1,203 @@
+Copyright (c) 2021 Habana Labs, Ltd. an Intel Company
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/NOTICE

@@ -0,0 +1,5 @@
+Copyright (C) 2021 Habana Labs, Ltd. an Intel Company
+
+This repository includes software from:
+* Tensor2Tensor, (https://github.com/tensorflow/tensor2tensor) licensed
+  under the Apache License, Version 2.0

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/README.md

@@ -0,0 +1,338 @@
+# Transformer for TensorFlow
+
+This repository provides a script and recipe to train the Transformer model for Tensorflow on Intel® Gaudi® AI Accelerator. For further information on performance, refer to [Habana Model Performance Data page](https://developer.habana.ai/resources/habana-training-models/#performance).
+
+For more information on training deep learning models using Gaudi, refer to [developer.habana.ai](https://developer.habana.ai/resources/).
+
+## Table of Contents
+
+  * [Model-References](../../../README.md)
+  * [Model Overview](#model-overview)
+  * [Setup](#setup)
+  * [Training and Examples](#training-and-examples)
+  * [Evaluating BLEU Score](#evaluating-bleu-score)
+  * [Profile](#profile)
+  * [Supported Configuration](#supported-configuration)
+  * [Changelog](#changelog)
+  * [Known Issues](#known-issues)
+
+## Model Overview
+The Transformer is a Neural Machine Translation (NMT) model which uses attention mechanism to boost training speed and overall accuracy.
+The model was initially introduced in [Attention Is All You Need](https://arxiv.org/abs/1706.03762).
+This implementation is based on [Tensor2Tensor](https://github.com/tensorflow/tensor2tensor) implementation (authors: Google Inc., Artit Wangperawong).
+
+There are three model variants available: tiny, base and big.
+
+### Model Architecture
+The Transformer model uses standard NMT encoder-decoder architecture. Unlike other NMT models, Transformer model does not use recurrent connections and operates on fixed size context window.
+The encoder stack is made up of N identical layers. Each layer is composed of the following sub-layers:
+- Self-attention layer
+- Feedforward network (which is 2 fully-connected layers)
+
+The decoder stack is also made up of N identical layers. Each layer is composed of the sub-layers:
+- Self-attention layer
+- Multi-headed attention layer combining encoder outputs with results from the previous self-attention layer.
+- Feedforward network (2 fully-connected layers)
+
+The encoder uses self-attention to compute a representation of the input sequence. The decoder generates the output sequence one token at a time, taking the encoder output and previous decoder-outputted tokens as inputs.
+The model also applies embeddings on the input and output tokens, and adds a constant positional encoding. The positional encoding adds information about the position of each token.
+
+The complete description of the Transformer architecture can be found in [Attention Is All You Need](https://arxiv.org/abs/1706.03762) paper.
+
+## Setup
+Please follow the instructions provided in the [Gaudi Installation Guide](https://docs.habana.ai/en/latest/Installation_Guide/GAUDI_Installation_Guide.html) to set up the environment including the `$PYTHON` environment variable.  To achieve the best performance, please follow the methods outlined in the [Optimizing Training Platform guide](https://docs.habana.ai/en/latest/TensorFlow/Model_Optimization_TensorFlow/Optimization_Training_Platform.html).  
+The guides will walk you through the process of setting up your system to run the model on Gaudi.  
+
+### Clone Habana Model-References
+In the docker container, clone this repository and switch to the branch that matches your SynapseAI version. You can run the [`hl-smi`](https://docs.habana.ai/en/latest/Management_and_Monitoring/System_Management_Tools_Guide/System_Management_Tools.html#hl-smi-utility-options) utility to determine the SynapseAI version.
+```bash
+git clone -b [SynapseAI version] https://github.com/HabanaAI/Model-References /root/Model-References
+```
+
+**Note:** If Model-References repository path is not in the PYTHONPATH, make sure you update it:
+```bash
+export PYTHONPATH=$PYTHONPATH:/root/Model-References
+```
+### Download and Generate the Dataset
+
+Go to the Transformer directory and generate the dataset. The following script will save the dataset to `/data/tensorflow/wmt32k_packed/train`:
+```bash
+cd Model-References/TensorFlow/nlp/transformer/
+$PYTHON datagen.py \
+    --data_dir=/data/tensorflow/wmt32k_packed/train \
+    --tmp_dir=/tmp/transformer_datagen \
+    --problem=translate_ende_wmt32k_packed \
+    --random_seed=429459
+```
+
+### Install Model Requirements
+
+1. In the docker container, go to the Transformer directory:
+```bash
+cd /root/Model-References/TensorFlow/nlp/transformer
+```
+
+2. Install the required packages using pip:
+```bash
+$PYTHON -m pip install -r requirements.txt
+```
+
+## Training and Examples
+
+### Single card and Multi-Card Training Examples
+
+**NOTE:** All training examples for 1 HPU and 8 HPUs are valid both for first-gen Gaudi and Gaudi2.
+
+**Run training on 1 HPU:**
+
+```bash
+$PYTHON trainer.py \
+    --data_dir=<path_to_dataset>/train \
+    --problem=translate_ende_wmt32k_packed \
+    --model=transformer \
+    --hparams_set=transformer_<model_size> \
+    --hparams=batch_size=<batch_size> \
+    --output_dir=<path_to_output_dir> \
+    --local_eval_frequency=<eval_frequency> \
+    --train_steps=<train_steps> \
+    --schedule=train \
+    --use_hpu=True \
+    --use_bf16=<use_bf16>
+```
+
+Run training on 1 HPU, batch size 4096, bfloat16, transformer_big, 300k steps with a checkpoint saved every 10k steps, last 10 checkpoints kept:
+
+```bash
+$PYTHON trainer.py \
+    --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+    --problem=translate_ende_wmt32k_packed \
+    --model=transformer \
+    --hparams_set=transformer_big \
+    --hparams=batch_size=4096 \
+    --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs4096 \
+    --local_eval_frequency=10000 \
+    --keep_checkpoint_max=10 \
+    --train_steps=300000 \
+    --schedule=train \
+    --use_hpu=True \
+    --use_bf16=True
+```
+
+For Gaudi2, training batch size can be increased for better performance:
+```bash
+$PYTHON trainer.py \
+    --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+    --problem=translate_ende_wmt32k_packed \
+    --model=transformer \
+    --hparams_set=transformer_big \
+    --hparams=batch_size=16384,learning_rate_constant=5.0,learning_rate_warmup_steps=5000 \
+    --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs16384 \
+    --local_eval_frequency=2500 \
+    --keep_checkpoint_max=10 \
+    --train_steps=75000 \
+    --schedule=train \
+    --use_hpu=True \
+    --use_bf16=True
+```
+
+**Run training on 8 HPUs:**
+
+**NOTE:** mpirun map-by PE attribute value may vary on your setup. For the recommended calculation, refer to the instructions detailed in [mpirun Configuration](https://docs.habana.ai/en/latest/TensorFlow/Tensorflow_Scaling_Guide/Horovod_Scaling/index.html#mpirun-configuration).
+
+Run training on 8 HPUs, global batch size 8 * 4096, bfloat16, transformer_big, 300k steps with a checkpoint saved every 10k steps, last 10 checkpoints kept, learning rate constant 2.5:
+
+```bash
+mpirun \
+    --allow-run-as-root --bind-to core --map-by socket:PE=6 --np 8 \
+    --tag-output --merge-stderr-to-stdout \
+    $PYTHON trainer.py \
+        --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+        --problem=translate_ende_wmt32k_packed \
+        --model=transformer \
+        --hparams_set=transformer_big \
+        --hparams=batch_size=4096,learning_rate_constant=2.5 \
+        --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs4096 \
+        --local_eval_frequency=10000 \
+        --keep_checkpoint_max=10 \
+        --train_steps=300000 \
+        --schedule=train \
+        --use_horovod=True \
+        --use_hpu=True \
+        --use_bf16=True
+```
+
+For Gaudi2, training batch size can be increased for better performance:
+
+```bash
+mpirun \
+    --allow-run-as-root --bind-to core --map-by socket:PE=6 --np 8 \
+    --tag-output --merge-stderr-to-stdout \
+    $PYTHON trainer.py \
+        --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+        --problem=translate_ende_wmt32k_packed \
+        --model=transformer \
+        --hparams_set=transformer_big \
+        --hparams=batch_size=16384,learning_rate_constant=5.0,learning_rate_warmup_steps=5000 \
+        --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs16384 \
+        --local_eval_frequency=2500 \
+        --keep_checkpoint_max=10 \
+        --train_steps=75000 \
+        --schedule=train \
+        --use_horovod=True \
+        --use_hpu=True \
+        --use_bf16=True
+```
+
+### Multi-Server Training and Examples
+To run training on multiple servers, make sure to set the `MULTI_HLS_IPS` environment
+variable with the IPs of the used servers.
+
+**NOTE:** Multi-server training is supported only on first-gen Gaudi.
+
+**Run training on 16 HPUs:**
+```bash
+export MULTI_HLS_IPS=192.10.100.174,10.10.100.101
+mpirun \
+    --allow-run-as-root --bind-to core --map-by socket:PE=6 --np 8 \
+    --tag-output --merge-stderr-to-stdout \
+    $PYTHON trainer.py \
+        --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+        --problem=translate_ende_wmt32k_packed \
+        --model=transformer \
+        --hparams_set=transformer_big \
+        --hparams=batch_size=4096,learning_rate_constant=3.0 \
+        --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs4096 \
+        --local_eval_frequency=50000 \
+        --train_steps=150000 \
+        --schedule=train \
+        --use_horovod=True \
+        --use_hpu=True \
+        --use_bf16=True
+```
+
+**Run training on 32 HPUs:**
+
+ **NOTE:** It is recommended to use `learning_rate_constant` 3.5 and `train_steps` 75000.
+
+```bash
+export MULTI_HLS_IPS=192.10.100.174,10.10.100.101,10.10.100.102,10.10.100.103
+mpirun \
+    --allow-run-as-root --bind-to core --map-by socket:PE=6 --np 8 \
+    --tag-output --merge-stderr-to-stdout \
+    $PYTHON trainer.py \
+        --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+        --problem=translate_ende_wmt32k_packed \
+        --model=transformer \
+        --hparams_set=transformer_big \
+        --hparams=batch_size=4096,learning_rate_constant=3.5 \
+        --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs4096 \
+        --local_eval_frequency=50000 \
+        --train_steps=75000 \
+        --schedule=train \
+        --use_horovod=True \
+        --use_hpu=True \
+        --use_bf16=True
+```
+
+## Evaluating BLEU Score
+After training the model, you can evaluate the achieved BLEU score:
+1. Download and tokenize the validation file:
+```bash
+sacrebleu -t wmt14 -l en-de --echo src > wmt14.src
+cat wmt14.src | sacremoses tokenize -l en > wmt14.src.tok
+```
+
+2. Compute BLEU score of a single checkpoint:
+```bash
+$PYTHON decoder.py \
+    --problem=translate_ende_wmt32k_packed \
+    --model=transformer \
+    --hparams_set=transformer_big \
+    --data_dir=<path_to_dataset>/train \
+    --output_dir=<path_to_output_dir> \
+    --checkpoint_path=<path_to_checkpoint> \
+    --use_hpu=True \
+    --decode_from_file=./wmt14.src.tok \
+    --decode_to_file=./wmt14.tgt.tok \
+    --decode_hparams=log_results=False
+cat wmt14.tgt.tok | sacremoses detokenize -l de | sacrebleu -t wmt14 -l en-de
+```
+
+3. Optional: To split BLEU calculation to multiple cards, run `decoder.py` through `mpirun`. For example:
+```bash
+mpirun \
+    --allow-run-as-root --bind-to core --map-by socket:PE=6 --np 8 \
+    --tag-output --merge-stderr-to-stdout \
+    $PYTHON decoder.py \
+        --problem=translate_ende_wmt32k_packed \
+        --model=transformer \
+        --hparams_set=transformer_big \
+        --data_dir=<path_to_dataset>/train \
+        --output_dir=<path_to_output_dir> \
+        --checkpoint_path=<path_to_checkpoint> \
+        --decode_from_file=./wmt14.src.tok \
+        --decode_to_file=./wmt14.tgt.tok \
+        --use_hpu=True \
+        --use_horovod=True \
+        --decode_hparams=log_results=False
+cat wmt14.tgt.tok | sacremoses detokenize -l de | sacrebleu -t wmt14 -l en-de
+```
+**NOTE:** mpirun map-by PE attribute value may vary on your setup. For the recommended calculation, refer to the instructions detailed in [mpirun Configuration](https://docs.habana.ai/en/latest/TensorFlow/Tensorflow_Scaling_Guide/Horovod_Scaling/index.html#mpirun-configuration).
+
+## Profile
+To run with profiling enabled, pass `--profile_steps` flag. It should be a comma separated pair of numbers - on which step to start and end profiling.
+
+Profiler steps are counted individually for each run. Thus, if you run training for 100 steps, with `--profile_steps 99,100`, profiling will be always enabled for the last two steps, no matter the `global_step_count`.
+
+**Run training on 1 HPU with profiler:**
+
+```bash
+ $PYTHON trainer.py \
+    --data_dir=/data/tensorflow/wmt32k_packed/train/ \
+    --problem=translate_ende_wmt32k_packed \
+    --model=transformer \
+    --hparams_set=transformer_big \
+    --hparams=batch_size=4096 \
+    --output_dir=./translate_ende_wmt32k_packed/transformer_big/bs4096 \
+    --local_eval_frequency=10000 \
+    --train_steps=100 \
+    --schedule=train \
+    --use_hpu=True \
+--profile_steps 50,53
+```
+The above example will produce profile trace for 4 steps (50,51,52,53).
+
+## Supported Configuration
+| Validated on | SynapseAI Version | TensorFlow Version(s) | Mode |
+|:------:|:-----------------:|:-----:|:----------:|
+| Gaudi   | 1.14.0             | 2.15.0         | Training |
+| Gaudi2  | 1.14.0             | 2.15.0         | Training |
+
+## Changelog
+### 1.6.0
+* Model enabled on Gaudi2, with the same config as first-gen Gaudi.
+* Added profiling support.
+* Enabled experimental variable clustering to improve performance.
+* Removed advanced parameters section from README.
+
+### 1.4.0
+* Replaced references to custom demo script by community entry points in README.
+* Added support to import horovod-fork package directly instead of using Model-References' TensorFlow.common.horovod_helpers; wrapped horovod import with a try-catch block so that the user is not required to install this library when the model is being run on a single card.
+* Updated requirements.txt.
+* Changed the default value of the log_step_count_steps flag.
+
+### 1.3.0
+* Enabled multi-HPU BLEU calculation.
+* Updated requirements.txt.
+
+### 1.2.0
+* Added support for recipe cache, see `TF_RECIPE_CACHE_PATH` in HabanaAI documentation for details.
+* Enabled multi-server training.
+
+### Training Script Modifications
+* Support for other models than Transformer was removed.
+* Added support for Horovod together with some adjustments in the topology script to allow simplifying the computational graph.
+
+## Known Issues
+
+Only FP32 precision is supported when calculating BLEU on HPU.

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/bf16_config/transformer.json

@@ -0,0 +1,153 @@
+{
+    "allowlist": [
+        "_ScopedAllocatorSplit",
+        "_ScopedAllocatorConcat",
+        "_ScopedAllocator",
+        "BatchMatMul",
+        "BatchMatMulV2",
+        "BiasAdd",
+        "CollectiveReduceV2",
+        "CollectiveReduceV3",
+        "Conv2D",
+        "Conv2DBackpropFilter",
+        "Conv2DBackpropInput",
+        "Cumprod",
+        "Cumsum",
+        "EuclideanNorm",
+        "Exp",
+        "FloorDiv",
+        "FusedBatchNormV2",
+        "FusedBatchNormV3",
+        "FusedBatchNormGradV2",
+        "FusedBatchNormGradV3",
+        "GatherNd",
+        "GatherV2",
+        "Greater",
+        "GreaterEqual",
+        "HabanaConv2DWithPadding",
+        "HabanaConv2DWithPaddingBackpropFilter",
+        "HabanaConv2DWithPaddingBackpropInput",
+        "HabanaDropout",
+        "HabanaDropoutGrad",
+        "HabanaDropoutStateful",
+        "HabanaFusedBatchNormV3",
+        "HabanaGelu",
+        "HabanaGeluGrad",
+        "HabanaLayerNorm",
+        "HabanaLayerNormGrad",
+        "HabanaSoftmaxGrad",
+        "HabanaLogSoftmaxGrad",
+        "HorovodAllgather",
+        "HorovodAllreduce",
+        "HpuCollectiveReduce",
+        "Less",
+        "LessEqual",
+        "Log",
+        "Log1p",
+        "LogSoftmax",
+        "MatMul",
+        "MaxPool",
+        "MaxPoolV2",
+        "MaxPoolGrad",
+        "MaxPoolGradV2",
+        "Mul",
+        "PyramidRoiAlign",
+        "PyramidRoiAlignGradImages",
+        "Relu",
+        "Relu6",
+        "ReluGrad",
+        "Relu6Grad",
+        "Round",
+        "Rsqrt",
+        "RsqrtGrad",
+        "Sigmoid",
+        "SigmoidGrad",
+        "Softmax",
+        "SparseSoftmaxCrossEntropyWithLogits",
+        "Square",
+        "SquaredDifference",
+        "Sqrt",
+        "Tanh",
+        "TanhGrad",
+        "TensorScatterUpdate"
+    ],
+    "conditional_list": [
+        "Abs",
+        "Add",
+        "AddN",
+        "AddV2",
+        "ArgMax",
+        "ArgMin",
+        "BiasAddGrad",
+        "CollectiveReduceV2",
+        "CollectiveReduceV3",
+        "DynamicStitch",
+        "Equal",
+        "ExpandDims",
+        "Fill",
+        "HabanaClampFwd",
+        "HabanaClampBwd",
+        "HabanaMaxGrad",
+        "HabanaMinGrad",
+        "HabanaSparseSegmentSum",
+        "HabanaRandomUniformWithMaxval",
+        "HabanaRandomUniformWithScale",
+        "HabanaSize",
+        "HorovodAllgather",
+        "HorovodAllreduce",
+        "HpuCollectiveReduce",
+        "HpuCollectiveGather",
+        "HpuCollectiveGatherV2",
+        "Identity",
+        "IsFinite",
+        "MatrixBandPart",
+        "Neg",
+        "NotEqual",
+        "Pack",
+        "Pad",
+        "PadV2",
+        "RandomStandardNormal",
+        "RandomUniform",
+        "Rank",
+        "Reshape",
+        "ResizeNearestNeighbor",
+        "ResizeNearestNeighborGrad",
+        "Select",
+        "SelectV2",
+        "Shape",
+        "ShapeN",
+        "Sign",
+        "Size",
+        "Slice",
+        "SparseSegmentSumWithNumSegments",
+        "SplitV",
+        "Split",
+        "Snapshot",
+        "Squeeze",
+        "StridedSlice",
+        "StridedSliceGrad",
+        "Sub",
+        "Tile",
+        "Transpose",
+        "Unpack",
+        "ZerosLike"
+    ],
+    "strict_conditional_list": [
+        "Add",
+        "AddN",
+        "BiasAddGrad",
+        "Sub"
+    ],
+    "non_convertible_exceptions": [
+        [
+            ".*KEEP_FP32_PRECISION.*",
+            ""
+        ]
+    ],
+    "convertible_exceptions": [
+        [
+            ".*FORCE_BF16_PRECISION.*",
+            ""
+        ]
+    ]
+}

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/build_vocab.py

@@ -0,0 +1,77 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+###############################################################################
+# Copyright (C) 2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+# Changes:
+# - updated imports
+
+r"""Build vocab for a subclass of Text2TextProblem.
+
+build_vocab \
+    --problem=program_search_algolisp \
+    --data_dir=~/t2t_data \
+    --tmp_dir=~/t2t_data/tmp
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+from TensorFlow.nlp.transformer.utils import problems as problems_lib  # pylint: disable=unused-import
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.utils import registry
+import tensorflow.compat.v1 as tf
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string("data_dir", "/tmp/t2t/data_dir",
+                    "Directory to place the generated vocabulary file in.")
+
+flags.DEFINE_string("tmp_dir", "/tmp/t2t/tmp_dir",
+                    "Temporary storage directory.")
+
+flags.DEFINE_string("problem", None,
+                    "Problem to generate the vocabulary file for.")
+
+flags.mark_flag_as_required("problem")
+
+
+def main(_):
+  problem = registry.problem(FLAGS.problem)
+
+  # We make the assumption that the problem is a subclass of Text2TextProblem.
+  assert isinstance(problem, text_problems.Text2TextProblem)
+
+  data_dir = os.path.expanduser(FLAGS.data_dir)
+  tmp_dir = os.path.expanduser(FLAGS.tmp_dir)
+
+  tf.gfile.MakeDirs(data_dir)
+  tf.gfile.MakeDirs(tmp_dir)
+
+  tf.logging.info("Saving vocabulary to data_dir: %s" % data_dir)
+
+  problem.get_or_create_vocab(data_dir, tmp_dir)
+
+  tf.logging.info("Saved vocabulary file: " +
+                  os.path.join(data_dir, problem.vocab_filename))
+
+
+if __name__ == "__main__":
+  tf.logging.set_verbosity(tf.logging.INFO)
+  tf.app.run()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/compute_bleu.py

@@ -0,0 +1,42 @@
+###############################################################################
+# Copyright (C) 2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+import subprocess
+from argparse import ArgumentParser
+from TensorFlow.common.tb_utils import TBSummary
+
+
+parser = ArgumentParser()
+parser.add_argument('--decoded_file', '-df', type=str, default='wmt14.tgt.tok',
+                    help='Decoded file produced by t2t-decode command.')
+parser.add_argument('--log_dir', '-ld', type=str, default=None,
+                    help='Where to store TensorBoard summary file, '
+                         'if None summary will not be saved.')
+args = parser.parse_args()
+
+def get_sacremoses_version():
+    ver_line = subprocess.run(['sacremoses', '--version'], stdout=subprocess.PIPE).stdout.decode()
+    return tuple(map(int, ver_line.split()[-1].split('.')))
+
+def get_sacremoses_cmd(version):
+    if version >= (0, 0, 42):
+        return ['sacremoses', '-l', 'de', 'detokenize']
+    else:
+        return ['sacremoses', 'detokenize', '-l', 'de']
+
+def main():
+    detok = subprocess.run(get_sacremoses_cmd(get_sacremoses_version()),
+                           stdin=open(args.decoded_file, 'r'),
+                           stdout=subprocess.PIPE)
+    bleu = subprocess.run(['sacrebleu', '-t', 'wmt14', '-l', 'en-de', '-b'],
+                          input=detok.stdout, stdout=subprocess.PIPE)
+    score = bleu.stdout.decode()
+    print('BLEU:', score)
+
+    if args.log_dir is not None:
+        with TBSummary(args.log_dir) as tb:
+            tb.add_scalar('accuracy', float(score), 0)
+
+
+if __name__ == '__main__':
+    main()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/__init__.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/all_problems.py

@@ -0,0 +1,74 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Imports for problem modules."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import importlib
+import six
+from six.moves import range  # pylint: disable=redefined-builtin
+
+MODULES = [
+    "TensorFlow.nlp.transformer.data_generators.translate_encs_cubbitt",
+    "TensorFlow.nlp.transformer.data_generators.translate_encs",
+    "TensorFlow.nlp.transformer.data_generators.translate_ende",
+    "TensorFlow.nlp.transformer.data_generators.translate_enes",
+    "TensorFlow.nlp.transformer.data_generators.translate_enet",
+    "TensorFlow.nlp.transformer.data_generators.translate_enfr",
+    "TensorFlow.nlp.transformer.data_generators.translate_enid",
+    "TensorFlow.nlp.transformer.data_generators.translate_enmk",
+    "TensorFlow.nlp.transformer.data_generators.translate_envi",
+    "TensorFlow.nlp.transformer.data_generators.translate_enzh",
+]
+ALL_MODULES = list(MODULES)
+
+
+
+def _is_import_err_msg(err_str, module):
+  parts = module.split(".")
+  suffixes = [".".join(parts[i:]) for i in range(len(parts))]
+  prefixes = [".".join(parts[:i]) for i in range(len(parts))]
+  return err_str in (["No module named %s" % suffix for suffix in suffixes] +
+                     ["No module named '%s'" % suffix for suffix in suffixes] +
+                     ["No module named %s" % prefix for prefix in prefixes] +
+                     ["No module named '%s'" % prefix for prefix in prefixes])
+
+
+def _handle_errors(errors):
+  """Log out and possibly reraise errors during import."""
+  if not errors:
+    return
+  log_all = True  # pylint: disable=unused-variable
+  err_msg = "T2T: skipped importing {num_missing} data_generators modules."
+  print(err_msg.format(num_missing=len(errors)))
+  for module, err in errors:
+    err_str = str(err)
+    if log_all:
+      print("Did not import module: %s; Cause: %s" % (module, err_str))
+    if not _is_import_err_msg(err_str, module):
+      print("From module %s" % module)
+      raise err
+
+
+def import_modules(modules):
+  errors = []
+  for module in modules:
+    try:
+      importlib.import_module(module)
+    except ImportError as error:
+      errors.append((module, error))
+  _handle_errors(errors)

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/cleaner_en_xx.py

@@ -0,0 +1,176 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+# encoding=UTF-8
+"""An unsophisticated data cleaner for en-.. sentence translation pairs.
+
+This pattern-based English-... cleaner aims fairly aggressively for clean
+sentence-like pairs. It discards pairs if the English member has signs of
+non-sentence noise or origin, e.g., lacks expected punctuation or has suspicious
+character sequences. It also simplistically detects and corrects some missing
+sentence breaks. It makes minimal assumptions about the other language, mainly
+that its sentences can end in one of '.!?' and that its sentences can start
+with an ASCII capital letter.
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+
+import itertools
+import re
+
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+
+import tensorflow.compat.v1 as tf
+
+
+_RE_GOOD_S_START = re.compile(r'^["“”]?[A-Z]')
+_RE_GOOD_S_END = re.compile(r'\w[.?!]["”]?$', re.UNICODE)
+
+_RE_LABEL_COLON = re.compile(r'^\w+\.?( \w+)?: ', re.UNICODE)
+_RE_DIGIT_SPACE_DIGIT = re.compile(r'\d +\d', re.UNICODE)
+_RE_ALL_CAP_WORDS = re.compile(r'^[A-Z]\S*(\s+[A-Z]\S+)+\s*$')
+
+_RE_DQ_ONE = re.compile(r'^[^"“”]*["“”][^"“”]*$')
+_RE_DQ_INITIAL = re.compile(r'^["“”]([^"“”]+)$')
+_RE_DQ_FINAL = re.compile(r'^[^"“”]+["“”]$')
+_RE_DQ_LINE = re.compile(r'^["“”].*["“”]$')
+
+_RE_DQ_MANY = re.compile(r'(["“”].*){3,}')
+_RE_SQ_MANY = re.compile(r'''(['‘’][^st].*){3,}''')
+_RE_CHARS_QQ = re.compile(r'''["“”'‘’]\s*["“”'‘’]''')
+_RE_SPACE_PUNCT_SPACE = re.compile(r'''\s["“”'‘’,:;]\s''')
+
+_RE_COPYRIGHT = re.compile(r'©|^Copyright|^\(C\)')
+_RE_UNMATCHED_PAREN_LEFT = re.compile(r'[(][^)]*$')
+_RE_UNMATCHED_PAREN_RIGHT = re.compile(r'^[^(]*[)]')
+_RE_TAGLINE_CITY = re.compile(r'^[A-Z]{2,}(\s+[A-Z]+)*\s+-')
+_RE_CHARS_UPPER_UNDERSCORE = re.compile(r'^[A-Z]+[a-z]*_')
+
+
+def paracrawl_v3_pairs(paracrawl_file):
+  """Generates raw (English, other) pairs from a ParaCrawl V3.0 data file.
+
+  Args:
+    paracrawl_file: A ParaCrawl V3.0 en-.. data file.
+  Yields:
+    Pairs of (sentence_en, sentence_xx), as Unicode strings.
+  Raises:
+    StopIteration: If the file ends while this method is in the middle of
+        creating a translation pair.
+  """
+  raw_sentences = _raw_sentences(paracrawl_file)
+  for s_en in raw_sentences:
+    try:
+      s_xx = next(raw_sentences)
+      if s_en and s_xx:  # Prevent empty string examples.
+        yield s_en, s_xx
+    except StopIteration:
+      tf.logging.error(
+          'Unmatched final sentence while reading in sentence pairs: [%s]',
+          s_en)
+
+
+def _raw_sentences(paracrawl_file):
+  """Generates Unicode strings, one for each <seg> in a ParaCrawl data file.
+
+  Also decodes some of the most common HTML entities found in ParaCrawl data.
+
+  Args:
+    paracrawl_file: A ParaCrawl V3.0 en-.. data file.
+  Yields:
+    One Unicode string for each <seg> element in the ParaCrawl data file.
+  """
+  for line_utf8 in paracrawl_file:
+    line_uni = line_utf8.decode('UTF-8')
+    text_match = re.match(r' +<seg>(.*)</seg>$', line_uni)
+    if text_match:
+      txt = text_match.group(1)
+      txt = re.sub(r'&amp;', r'&', txt)
+      txt = re.sub(r'& ?amp;', r'&', txt)
+      txt = re.sub(r'& ?apos;', r"'", txt)
+      txt = re.sub(r'& ?quot;', r'"', txt)
+      txt = re.sub(r'& ?lt;', r'<', txt)
+      txt = re.sub(r'& ?gt;', r'>', txt)
+      yield txt
+
+
+def clean_en_xx_pairs(en_xx_pairs):
+  """Generates a cleaned-up stream of (English, other) translation pairs.
+
+  Cleaning includes both filtering and simplistic sentence splitting, with
+  minimal assumptions on the non-English pair member: (1) All filtering is
+  done based on the English member of the pair, and (2) sentence splitting
+  assumes only that sentences can end with one of '.!?' and begin with an
+  ASCII uppercase letter. Input pairs that would get split into different
+  numbers of sentences (e.g., three English sentences vs. two German ones) are
+  discarded.
+
+  Args:
+    en_xx_pairs: A stream (iterable) of Unicode string pairs. Each item in the
+        stream should be a (sentence_en, sentence_xx) pair.
+  Yields:
+    Cleaned-up (sentence_en, sentence_xx) pairs.
+  """
+  for s1, s2 in en_xx_pairs:
+    if _regex_filter(s1):
+      continue
+    s1_list, s2_list = _split_sentences(s1, s2)
+    if len(s1_list) != len(s2_list):
+      continue  # discard this pair
+    elif len(s1_list) == 1:
+      yield s1, s2
+    else:
+      for s1_subsentence, s2_subsentence in itertools.izip(s1_list, s2_list):
+        if _regex_filter(s1_subsentence):
+          continue
+        yield s1_subsentence, s2_subsentence
+
+
+def _regex_filter(sentence):
+  return (not _is_match(sentence, _RE_GOOD_S_START)
+          or not _is_match(sentence, _RE_GOOD_S_END)
+          or _is_match(sentence, _RE_LABEL_COLON)
+          or _is_match(sentence, _RE_DIGIT_SPACE_DIGIT)
+          or _is_match(sentence, _RE_DQ_ONE)
+          or _is_match(sentence, _RE_DQ_INITIAL)
+          or _is_match(sentence, _RE_DQ_FINAL)
+          or _is_match(sentence, _RE_DQ_LINE)
+          or _is_match(sentence, _RE_DQ_MANY)
+          or _is_match(sentence, _RE_SQ_MANY)
+          or _is_match(sentence, _RE_CHARS_QQ)
+          or _is_match(sentence, _RE_SPACE_PUNCT_SPACE)
+          or _is_match(sentence, _RE_COPYRIGHT)
+          or _is_match(sentence, _RE_UNMATCHED_PAREN_LEFT)
+          or _is_match(sentence, _RE_UNMATCHED_PAREN_RIGHT)
+          or _is_match(sentence, _RE_TAGLINE_CITY)
+          or _is_match(sentence, _RE_CHARS_UPPER_UNDERSCORE))
+
+
+def _is_match(sentence, regex):
+  return regex.search(sentence)
+
+
+def _split_sentences(s1, s2):
+  s1 = text_encoder.native_to_unicode(s1)
+  s2 = text_encoder.native_to_unicode(s2)
+  s1 = re.sub(r'(\w[A-Z]|[0-9a-z])([.!?]) ([A-Z])', r'\1\2__|__\3', s1)
+  s2 = re.sub(r'([^0-9][.!?]) ([A-Z])', r'\1__|__\2', s2)
+  s1_subsentences = s1.split('__|__')
+  s2_subsentences = s2.split('__|__')
+  return s1_subsentences, s2_subsentences

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/generator_utils.py

@@ -0,0 +1,1259 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Utilities for data generators."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import functools
+import gzip
+import math
+import multiprocessing
+import os
+import random
+import stat
+import tarfile
+import tempfile
+import numpy as np
+import requests
+import six
+from six.moves import range  # pylint: disable=redefined-builtin
+# Imports urllib on Python2, urllib.request on Python3
+import six.moves.urllib_request as urllib
+
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+
+import tensorflow.compat.v1 as tf
+
+UNSHUFFLED_SUFFIX = "-unshuffled"
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+def to_example(dictionary):
+  """Helper: build tf.Example from (string -> int/float/str list) dictionary."""
+  features = {}
+  for (k, v) in six.iteritems(dictionary):
+    if not v:
+      raise ValueError("Empty generated field: %s" % str((k, v)))
+    # Subtly in PY2 vs PY3, map is not scriptable in py3. As a result,
+    # map objects will fail with TypeError, unless converted to a list.
+    if six.PY3 and isinstance(v, map):
+      v = list(v)
+    if (isinstance(v[0], six.integer_types) or
+        np.issubdtype(type(v[0]), np.integer)):
+      features[k] = tf.train.Feature(int64_list=tf.train.Int64List(value=v))
+    elif isinstance(v[0], float):
+      features[k] = tf.train.Feature(float_list=tf.train.FloatList(value=v))
+    elif isinstance(v[0], six.string_types):
+      if not six.PY2:  # Convert in python 3.
+        v = [bytes(x, "utf-8") for x in v]
+      features[k] = tf.train.Feature(bytes_list=tf.train.BytesList(value=v))
+    elif isinstance(v[0], bytes):
+      features[k] = tf.train.Feature(bytes_list=tf.train.BytesList(value=v))
+    else:
+      raise ValueError("Value for %s is not a recognized type; v: %s type: %s" %
+                       (k, str(v[0]), str(type(v[0]))))
+  return tf.train.Example(features=tf.train.Features(feature=features))
+
+
+def generate_files_distributed(generator,
+                               output_name,
+                               output_dir,
+                               num_shards=1,
+                               max_cases=None,
+                               task_id=0):
+  """generate_files but with a single writer writing to shard task_id."""
+  assert task_id < num_shards
+  output_filename = sharded_name(output_name, task_id, num_shards)
+  output_file = os.path.join(output_dir, output_filename)
+  tf.logging.info("Writing to file %s", output_file)
+  writer = tf.python_io.TFRecordWriter(output_file)
+
+  counter = 0
+  for case in generator:
+    if counter % 100000 == 0:
+      tf.logging.info("Generating case %d for %s." % (counter, output_name))
+    counter += 1
+    if max_cases and counter > max_cases:
+      break
+    example = to_example(case)
+    writer.write(example.SerializeToString())
+
+  writer.close()
+  return output_file
+
+
+def _data_filenames(output_name, output_dir, num_shards):
+  return [
+      os.path.join(output_dir, fname)
+      for fname in shard_filepath(output_name, num_shards)
+  ]
+
+
+def train_data_filenames(problem, output_dir, num_shards):
+  return _data_filenames(problem + "-train", output_dir, num_shards)
+
+
+def dev_data_filenames(problem, output_dir, num_shards):
+  return _data_filenames(problem + "-dev", output_dir, num_shards)
+
+
+def test_data_filenames(problem, output_dir, num_shards):
+  return _data_filenames(problem + "-test", output_dir, num_shards)
+
+
+def combined_data_filenames(problem, output_dir, num_training_shards):
+  return (train_data_filenames(problem, output_dir, num_training_shards) +
+          dev_data_filenames(problem, output_dir, 1) + test_data_filenames(
+              problem, output_dir, 1))
+
+
+def sharded_name(base_name, shard, total_shards):
+  return "%s-%.5d-of-%.5d" % (base_name, shard, total_shards)
+
+
+def shard_filepath(fname, num_shards):
+  return [
+      sharded_name(fname, shard, num_shards) for shard in range(num_shards)
+  ]
+
+
+def outputs_exist(filenames):
+  for out_fname in filenames:
+    out_fname = out_fname.replace(UNSHUFFLED_SUFFIX, "")
+    if tf.gfile.Exists(out_fname):
+      return out_fname
+
+
+def generate_files(generator, output_filenames,
+                   max_cases=None, cycle_every_n=1):
+  """Generate cases from a generator and save as TFRecord files.
+
+  Generated cases are transformed to tf.Example protos and saved as TFRecords
+  in sharded files named output_dir/output_name-00..N-of-00..M=num_shards.
+
+  Args:
+    generator: a generator yielding (string -> int/float/str list) dictionaries.
+    output_filenames: List of output file paths.
+    max_cases: maximum number of cases to get from the generator;
+      if None (default), we use the generator until StopIteration is raised.
+    cycle_every_n: how many cases from the generator to take before
+      switching to the next shard; by default set to 1, switch every case.
+  """
+  if outputs_exist(output_filenames):
+    tf.logging.info("Skipping generator because outputs files exists at {}"
+                    .format(output_filenames))
+    return
+  tmp_filenames = [fname + ".incomplete" for fname in output_filenames]
+  num_shards = len(output_filenames)
+  # Check if is training or eval, ref: train_data_filenames().
+  if num_shards > 0:
+    if "-train" in output_filenames[0]:
+      tag = "train"
+    elif "-dev" in output_filenames[0]:
+      tag = "eval"
+    else:
+      tag = "other"
+
+  writers = [tf.python_io.TFRecordWriter(fname) for fname in tmp_filenames]
+  counter, shard = 0, 0
+  for case in generator:
+    if case is None:
+      continue
+    if counter % 100000 == 0:
+      tf.logging.info("Generating case %d." % counter)
+    counter += 1
+    if max_cases and counter > max_cases:
+      break
+    example = to_example(case)
+    writers[shard].write(example.SerializeToString())
+    if counter % cycle_every_n == 0:
+      shard = (shard + 1) % num_shards
+
+  for writer in writers:
+    writer.close()
+
+  for tmp_name, final_name in zip(tmp_filenames, output_filenames):
+    tf.gfile.Rename(tmp_name, final_name)
+
+  tf.logging.info("Generated %s Examples", counter)
+
+
+def download_report_hook(count, block_size, total_size):
+  """Report hook for download progress.
+
+  Args:
+    count: current block number
+    block_size: block size
+    total_size: total size
+  """
+  percent = int(count * block_size * 100 / total_size)
+  print("\r%d%%" % percent + " completed", end="\r")
+
+
+def maybe_download(directory, filename, uri):
+  """Download filename from uri unless it's already in directory.
+
+  Copies a remote file to local if that local file does not already exist.  If
+  the local file pre-exists this function call, it does not check that the local
+  file is a copy of the remote.
+
+  Remote filenames can be filepaths, any URI readable by tensorflow.gfile, or a
+  URL.
+
+  Args:
+    directory: path to the directory that will be used.
+    filename: name of the file to download to (do nothing if it already exists).
+    uri: URI to copy (or download) from.
+
+  Returns:
+    The path to the downloaded file.
+  """
+  tf.gfile.MakeDirs(directory)
+  filepath = os.path.join(directory, filename)
+  if tf.gfile.Exists(filepath):
+    tf.logging.info("Not downloading, file already found: %s" % filepath)
+    return filepath
+
+  tf.logging.info("Downloading %s to %s" % (uri, filepath))
+  try:
+    tf.gfile.Copy(uri, filepath)
+  except tf.errors.UnimplementedError:
+    if uri.startswith("http"):
+      inprogress_filepath = filepath + ".incomplete"
+      inprogress_filepath, _ = urllib.urlretrieve(
+          uri, inprogress_filepath, reporthook=download_report_hook)
+      # Print newline to clear the carriage return from the download progress
+      print()
+      tf.gfile.Rename(inprogress_filepath, filepath)
+    else:
+      raise ValueError("Unrecognized URI: " + filepath)
+  statinfo = os.stat(filepath)
+  tf.logging.info("Successfully downloaded %s, %s bytes." %
+                  (filename, statinfo.st_size))
+  return filepath
+
+
+def maybe_download_from_drive(directory, filename, url):
+  """Download filename from Google drive unless it's already in directory.
+
+  Args:
+    directory: path to the directory that will be used.
+    filename: name of the file to download to (do nothing if it already exists).
+    url: URL to download from.
+
+  Returns:
+    The path to the downloaded file.
+  """
+  if not tf.gfile.Exists(directory):
+    tf.logging.info("Creating directory %s" % directory)
+    tf.gfile.MakeDirs(directory)
+  filepath = os.path.join(directory, filename)
+  confirm_token = None
+  if tf.gfile.Exists(filepath):
+    tf.logging.info("Not downloading, file already found: %s" % filepath)
+    return filepath
+
+  # Since the file is big, drive will scan it for virus and take it to a
+  # warning page. We find the confirm token on this page and append it to the
+  # URL to start the download process.
+  confirm_token = None
+  session = requests.Session()
+  response = session.get(url, stream=True)
+  for k, v in response.cookies.items():
+    if k.startswith("download_warning"):
+      confirm_token = v
+
+  if confirm_token:
+    url = url + "&confirm=" + confirm_token
+  tf.logging.info("Downloading %s to %s" % (url, filepath))
+
+  response = session.get(url, stream=True)
+  # Now begin the download.
+  chunk_size = 16 * 1024
+  with open(filepath, "wb") as f:
+    for chunk in response.iter_content(chunk_size):
+      if chunk:
+        f.write(chunk)
+
+  # Print newline to clear the carriage return from the download progress
+  print()
+  statinfo = os.stat(filepath)
+  tf.logging.info("Successfully downloaded %s, %s bytes." % (filename,
+                                                             statinfo.st_size))
+  return filepath
+
+
+def gunzip_file(gz_path, new_path):
+  """Unzips from gz_path into new_path.
+
+  Args:
+    gz_path: path to the zipped file.
+    new_path: path to where the file will be unzipped.
+  """
+  if tf.gfile.Exists(new_path):
+    tf.logging.info("File %s already exists, skipping unpacking" % new_path)
+    return
+  tf.logging.info("Unpacking %s to %s" % (gz_path, new_path))
+  # We may be unpacking into a newly created directory, add write mode.
+  mode = stat.S_IRWXU or stat.S_IXGRP or stat.S_IRGRP or stat.S_IROTH
+  os.chmod(os.path.dirname(new_path), mode)
+  with gzip.open(gz_path, "rb") as gz_file:
+    with tf.gfile.GFile(new_path, mode="wb") as new_file:
+      for line in gz_file:
+        new_file.write(line)
+
+
+def get_or_generate_vocab_inner(data_dir, vocab_filename, vocab_size,
+                                generator, max_subtoken_length=None,
+                                reserved_tokens=None):
+  """Inner implementation for vocab generators.
+
+  Args:
+    data_dir: The base directory where data and vocab files are stored. If None,
+      then do not save the vocab even if it doesn't exist.
+    vocab_filename: relative filename where vocab file is stored
+    vocab_size: target size of the vocabulary constructed by SubwordTextEncoder
+    generator: a generator that produces tokens from the vocabulary
+    max_subtoken_length: an optional integer.  Set this to a finite value to
+      avoid quadratic costs during vocab building.
+    reserved_tokens: List of reserved tokens. `text_encoder.RESERVED_TOKENS`
+      should be a prefix of `reserved_tokens`. If `None`, defaults to
+      `RESERVED_TOKENS`.
+
+  Returns:
+    A SubwordTextEncoder vocabulary object.
+  """
+  if data_dir and vocab_filename:
+    vocab_filepath = os.path.join(data_dir, vocab_filename)
+    if tf.gfile.Exists(vocab_filepath):
+      tf.logging.info("Found vocab file: %s", vocab_filepath)
+      return text_encoder.SubwordTextEncoder(vocab_filepath)
+  else:
+    vocab_filepath = None
+
+  tf.logging.info("Generating vocab file: %s", vocab_filepath)
+  vocab = text_encoder.SubwordTextEncoder.build_from_generator(
+      generator, vocab_size, max_subtoken_length=max_subtoken_length,
+      reserved_tokens=reserved_tokens)
+
+  if vocab_filepath:
+    tf.gfile.MakeDirs(data_dir)
+    vocab.store_to_file(vocab_filepath)
+
+  return vocab
+
+
+def get_or_generate_vocab(data_dir, tmp_dir, vocab_filename, vocab_size,
+                          sources, file_byte_budget=1e6,
+                          max_subtoken_length=None):
+  """Generate a vocabulary from the datasets in sources."""
+
+  vocab_generator = generate_lines_for_vocab(tmp_dir, sources, file_byte_budget)
+  return get_or_generate_vocab_inner(data_dir, vocab_filename, vocab_size,
+                                     vocab_generator, max_subtoken_length)
+
+
+def generate_lines_for_vocab(tmp_dir, sources, file_byte_budget=1e6):
+  """Generate lines for vocabulary generation."""
+  tf.logging.info("Generating vocab from: %s", str(sources))
+  for source in sources:
+    url = source[0]
+    filename = os.path.basename(url)
+    compressed_file = maybe_download(tmp_dir, filename, url)
+
+    for lang_file in source[1]:
+      tf.logging.info("Reading file: %s" % lang_file)
+      filepath = os.path.join(tmp_dir, lang_file)
+
+      # Extract from tar if needed.
+      if not tf.gfile.Exists(filepath):
+        read_type = "r:gz" if filename.endswith("tgz") else "r"
+        with tarfile.open(compressed_file, read_type) as corpus_tar:
+          corpus_tar.extractall(tmp_dir)
+
+      # For some datasets a second extraction is necessary.
+      if lang_file.endswith(".gz"):
+        new_filepath = os.path.join(tmp_dir, lang_file[:-3])
+        if tf.gfile.Exists(new_filepath):
+          tf.logging.info(
+              "Subdirectory %s already exists, skipping unpacking" % filepath)
+        else:
+          tf.logging.info("Unpacking subdirectory %s" % filepath)
+          gunzip_file(filepath, new_filepath)
+        filepath = new_filepath
+
+      with tf.gfile.GFile(filepath, mode="r") as source_file:
+        file_byte_budget_ = file_byte_budget
+        counter = 0
+        countermax = int(source_file.size() / file_byte_budget_ / 2)
+        for line in source_file:
+          if counter < countermax:
+            counter += 1
+          else:
+            if file_byte_budget_ <= 0:
+              break
+            line = line.strip()
+            file_byte_budget_ -= len(line)
+            counter = 0
+            yield line
+
+
+def get_or_generate_tabbed_vocab(data_dir, tmp_dir, source_filename,
+                                 index, vocab_filename, vocab_size):
+  r"""Generate a vocabulary from a tabbed source file.
+
+  The source is a file of source, target pairs, where each line contains
+  a source string and a target string, separated by a tab ('\t') character.
+  The index parameter specifies 0 for the source or 1 for the target.
+
+  Args:
+    data_dir: path to the data directory.
+    tmp_dir: path to the temporary directory.
+    source_filename: the name of the tab-separated source file.
+    index: index.
+    vocab_filename: the name of the vocabulary file.
+    vocab_size: vocabulary size.
+
+  Returns:
+    The vocabulary.
+  """
+  def generate():
+    filepath = os.path.join(tmp_dir, source_filename)
+    tf.logging.info("Generating vocab from %s", filepath)
+    with tf.gfile.GFile(filepath, mode="r") as source_file:
+      for line in source_file:
+        line = line.strip()
+        if line and "\t" in line:
+          parts = line.split("\t", 1)
+          part = parts[index].strip()
+          yield part
+
+  return get_or_generate_vocab_inner(data_dir, vocab_filename, vocab_size,
+                                     generate())
+
+
+def get_or_generate_txt_vocab(data_dir, vocab_filename, vocab_size,
+                              filepatterns):
+  """Generate a vocabulary from txt files with example-per-line."""
+  if isinstance(filepatterns, str):
+    filepatterns = [filepatterns]
+
+  def generate():
+    tf.logging.info("Generating vocab from %s", filepatterns)
+    for filepattern in filepatterns:
+      for filename in tf.gfile.Glob(filepattern):
+        with tf.gfile.GFile(filename, mode="r") as source_file:
+          for line in source_file:
+            yield line.strip()
+
+  return get_or_generate_vocab_inner(data_dir, vocab_filename, vocab_size,
+                                     generate())
+
+
+def read_records(filename):
+  reader = tf.python_io.tf_record_iterator(filename)
+  records = []
+  for record in reader:
+    records.append(record)
+    if len(records) % 100000 == 0:
+      tf.logging.info("read: %d", len(records))
+  return records
+
+
+def write_records(records, out_filename):
+  writer = tf.python_io.TFRecordWriter(out_filename)
+  for count, record in enumerate(records):
+    writer.write(record)
+    if count > 0 and count % 100000 == 0:
+      tf.logging.info("write: %d", count)
+  writer.close()
+
+
+def generate_dataset_and_shuffle(train_gen,
+                                 train_paths,
+                                 dev_gen,
+                                 dev_paths,
+                                 shuffle=True):
+  generate_files(train_gen, train_paths)
+  generate_files(dev_gen, dev_paths)
+  if shuffle:
+    shuffle_dataset(train_paths + dev_paths)
+
+
+def _shuffle_single(fname, extra_fn=None):
+  """Shuffle a single file of records.
+
+  Args:
+    fname: a string
+    extra_fn: an optional function from list of TFRecords to list of TFRecords
+      to be called after shuffling.
+  """
+  records = read_records(fname)
+  random.shuffle(records)
+  if extra_fn is not None:
+    records = extra_fn(records)
+  out_fname = fname.replace(UNSHUFFLED_SUFFIX, "")
+  write_records(records, out_fname)
+  tf.gfile.Remove(fname)
+
+
+def shuffle_dataset(filenames, extra_fn=None):
+  """Shuffles the dataset.
+
+  Args:
+    filenames: a list of strings
+    extra_fn: an optional function from list of records to list of records
+      to be called after shuffling a file.
+  """
+  if outputs_exist(filenames):
+    tf.logging.info("Skipping shuffle because output files exist")
+    return
+  tf.logging.info("Shuffling data...")
+  for filename in filenames:
+    _shuffle_single(filename, extra_fn=extra_fn)
+  tf.logging.info("Data shuffled.")
+
+
+class SequencePacker(object):
+  """Helper for constructing a packed example of sequence examples.
+
+  See comments to pack_examples()
+  """
+
+  def __init__(self, first_sequence, spacing=2):
+    self._spacing = spacing
+    self._ids = first_sequence[:]
+    self._segmentation = [1] * len(first_sequence)
+    self._position = list(range(len(first_sequence)))
+
+  def add(self, ids):
+    padding = [0] * self._spacing
+    self._ids.extend(padding + ids)
+    next_segment_num = self._segmentation[-1] + 1 if self._segmentation else 1
+    self._segmentation.extend(padding + [next_segment_num] * len(ids))
+    self._position.extend(padding + list(range(len(ids))))
+
+  def can_fit(self, ids, packed_length):
+    return len(self._ids) + self._spacing + len(ids) <= packed_length
+
+  def pad(self, packed_length):
+    padding = [0] * (packed_length - len(self._ids))
+    self._ids.extend(padding)
+    self._segmentation.extend(padding)
+    self._position.extend(padding)
+
+  def to_dict(self):
+    return {"inputs": [0],
+            "targets": self._ids,
+            "targets_segmentation": self._segmentation,
+            "targets_position": self._position}
+
+
+class SequencePairPacker(object):
+  """Helper for packing sequence-to-sequence examples into bigger examples.
+
+  See comments to pack_examples()
+  """
+
+  def __init__(self, first_sequence_pair, spacing=2):
+    self._inputs = SequencePacker(first_sequence_pair[0], spacing)
+    self._targets = SequencePacker(first_sequence_pair[1], spacing)
+
+  def add(self, pair):
+    self._inputs.add(pair[0])
+    self._targets.add(pair[1])
+
+  def can_fit(self, pair, packed_length):
+    return (self._inputs.can_fit(pair[0], packed_length) and
+            self._targets.can_fit(pair[1], packed_length))
+
+  def pad(self, packed_length):
+    self._inputs.pad(packed_length)
+    self._targets.pad(packed_length)
+
+  def to_dict(self):
+    ret = self._targets.to_dict()
+    inputs_dict = self._inputs.to_dict()
+    ret["inputs"] = inputs_dict["targets"]
+    ret["inputs_segmentation"] = inputs_dict["targets_segmentation"]
+    ret["inputs_position"] = inputs_dict["targets_position"]
+    return ret
+
+
+def pack_examples(examples,
+                  has_inputs,
+                  packed_length=256,
+                  spacing=2,
+                  queue_size=10,
+                  chop_long_sequences=False):
+  """Pack examples into longer examples.
+
+  If has_inputs=False, we are packing single-sequence examples with
+  targets only and no inputs.
+
+  In this case, we concatenate the targets from several examples to form
+  each new example.  We insert a number of zeros for spacing between the
+  original sequences.  This is to help the sequences stay separate
+  under convolutions.  If chop_long_sequences is set, then any input sequence
+  longer than packed_length gets chopped up into multiple examples.  Otherwise,
+  long sequences are emitted as singletons.
+
+  If has_inputs=True, then we are packing sequence-to-sequence
+  examples.  We combine several examples by concatenating the inputs
+  (as above) and concatenating the targets (as above).  Chopping of
+  long sequences is not supported.
+
+  The packed examples are represented as dictionaries containing:
+    "inputs", "targets": the packed sequences described above
+    "inputs_segmentation", "targets_segmentation":
+       Sequences aligned with "inputs", "targets" specifying to which original
+       sequence each position belongs.  Numbering starts from 1, and 0 is used
+       for spacing.  This information is useful for preventing attention across
+       segments.
+       e.g. [1 1 1 1 1 1 0 0 2 2 2 0 0 3 3 3 3 3 0 0 4 4 4]
+     "inputs_position", "targets_position":
+       Sequences aligned with "inputs", "targets" specifying position within
+       the original sequence.  This is useful for positional encodings.
+       e.g. [0 1 2 3 4 5 0 0 0 1 2 0 0 0 1 2 3 4 0 0 0 1 2]
+
+  Args:
+    examples: a generator returning feature dictionaries.
+    has_inputs: a boolean
+    packed_length: an integer
+    spacing: an integer
+    queue_size: an integer
+    chop_long_sequences: a boolean
+
+  Yields:
+    feature dictionaries.
+  """
+  packer = SequencePairPacker if has_inputs else SequencePacker
+  combined = []
+  for example in examples:
+    x = ((example["inputs"], example["targets"])
+         if has_inputs else example["targets"])
+    if chop_long_sequences and len(x) > packed_length:
+      assert not has_inputs
+      num_fragments = len(x) // packed_length
+      for i in range(num_fragments):
+        yield packer(
+            x[packed_length * i:packed_length * (i + 1)], spacing).to_dict()
+      x = x[packed_length * num_fragments:]
+    added = False
+    for c in combined:
+      if c.can_fit(x, packed_length):
+        c.add(x)
+        added = True
+        break
+    if not added:
+      if len(combined) == queue_size:
+        if FLAGS.with_padding:
+          combined[0].pad(packed_length)
+        yield combined[0].to_dict()
+        combined = combined[1:]
+      combined.append(packer(x, spacing))
+  for c in combined:
+    if FLAGS.with_padding:
+      c.pad(packed_length)
+    yield c.to_dict()
+
+
+def pack_dataset(dataset, length, keys=None, use_custom_ops=False):
+  """Creates a 'packed' version of a dataset on-the-fly.
+
+  This is meant to replace the irritation of having to create a separate
+  "packed" version of a dataset to train efficiently on TPU.
+
+  Each example in the output dataset represents several examples in the
+  input dataset.
+
+  For each key in the input dataset, two additional keys are created:
+  <key>_segmentation: an int32 tensor identifying the parts
+     representing the original example.
+  <key>_position: an int32 tensor identifying the position within the original
+     example.
+
+  Example:
+  Two input examples get combined to form an output example.
+  The input examples are:
+  {"inputs": [8, 7, 1, 0], "targets":[4, 1, 0]}
+  {"inputs": [2, 3, 4, 1], "targets":[5, 6, 1]}
+  The output example is:
+  {
+                 "inputs": [8, 7, 1, 2, 3, 4, 1, 0, 0, 0]
+    "inputs_segmentation": [1, 1, 1, 2, 2, 2, 2, 0, 0, 0]
+        "inputs_position": [0, 1, 2, 0, 1, 2, 3, 0, 0, 0]
+                "targets": [4, 1, 5, 6, 1, 0, 0, 0, 0, 0]
+   "targets_segmentation": [1, 1, 2, 2, 2, 0, 0, 0, 0, 0]
+       "targets_position": [0, 1, 0, 1, 2, 0, 0, 0, 0, 0]
+  }
+
+  0 represents padding in both the inputs and the outputs.
+
+  Sequences in the incoming examples are truncated to length "length", and the
+  sequences in the output examples all have fixed (padded) length "length".
+
+  Args:
+    dataset: a tf.data.Dataset
+    length: an integer
+    keys: a list of strings (e.g. ["inputs", "targets"])
+    use_custom_ops: use a custom c++ op not included in standard tf (faster)
+
+  Returns:
+    a tf.data.Dataset
+  """
+  shapes = dataset.output_shapes
+  if keys is None:
+    keys = shapes.keys()
+
+  for k in keys:
+    if k not in shapes:
+      raise ValueError("Key %s not found in dataset.  Available keys are %s"
+                       % (k, shapes.keys()))
+    if not shapes[k].is_compatible_with(tf.TensorShape([None])):
+      raise ValueError("Tensors to be packed must be one-dimensional.")
+
+  if use_custom_ops:
+    return _pack_with_custom_ops(dataset, keys, length)
+  else:
+    packer = SequenceDatasetPacker(length, spacing=0, queue_size=10)
+    return packer(dataset, cycle_length=10, keys=keys)
+
+
+def _pack_with_custom_ops(dataset, keys, length):
+  """Helper-function for packing a dataset which has already been batched.
+
+  See pack_dataset()
+
+  Relies on custom ops which require a custom compiled binary.
+  Faster than _pack_with_tf_ops(), and denser packing.
+
+  Args:
+    dataset: a dataset containing padded batches of examples.
+    keys: a list of strings (must have length 2)
+    length: an integer
+
+  Returns:
+    a dataset.
+  """
+  from TensorFlow.nlp.transformer.data_generators.ops import pack_sequences_ops  # pylint: disable=g-import-not-at-top
+
+  # trim to length
+  dataset = dataset.map(lambda x: {k: x[k][:length] for k in keys})
+  # Setting batch_size=length ensures that the concatenated sequences (if they
+  # have length >=1) are sufficient to fill at least one packed example.
+  batch_size = length
+  dataset = dataset.padded_batch(
+      batch_size, padded_shapes={k: [-1] for k in keys})
+
+  # better packing (may be faster) but requires custom-built binary.
+  k1, k2 = keys
+  def map_fn_custom(x):
+    """Map-function."""
+    (k1_packed, k1_segmengation, k1_position,
+     k2_packed, k2_segmentation, k2_position) = (
+         pack_sequences_ops.pack_sequences2(x[k1], x[k2], length, length))
+    packed = {
+        k1: k1_packed,
+        k1 + "_segmentation": k1_segmengation,
+        k1 + "_position": k1_position,
+        k2: k2_packed,
+        k2 + "_segmentation": k2_segmentation,
+        k2 + "_position": k2_position,
+    }
+    return tf.data.Dataset.from_tensor_slices(packed)
+  dataset = dataset.flat_map(map_fn_custom)
+  return dataset
+
+
+INDEX_DTYPE = tf.int32
+
+
+class SequenceDatasetPacker(object):
+  """Helper class for packing a dataset of sequences in an online fashon.
+
+  The input sequence is expected to be a tuple of 1D Tensors which will be
+  converted to a dataset which produces a dict of packed examples, example
+  positions, and segment ids.
+
+  If `window_size` or `cycle_length` is specified multiple packing operations
+  will be performed in parallel to increase throughput. A value of None will
+  select default parallelism parameters. If this dataset will be run on a TPU,
+  specifying a cycle_length > 10 is recommended.
+  """
+
+  def __init__(self, packed_length=256, spacing=0, queue_size=10,
+               chop_long_sequences=False):
+    self._packed_length = packed_length
+    self._spacing = spacing
+    self._queue_size = queue_size
+    self._chop_long_sequences = chop_long_sequences
+    self._num_sequences = None
+    self._token_dtype = None
+
+  def __call__(self, dataset, **kwargs):
+    if {"window_size", "cycle_length"}.intersection(kwargs):
+      return self._concurrent_pack(dataset, **kwargs)
+    return self._pack(dataset, **kwargs)
+
+  def _concurrent_pack(self, dataset, window_size=None, cycle_length=None,
+                       keys=None):
+    """Selects sensible default parallelism parameters based for a task."""
+
+    if window_size is None:
+      # This is a heuristic to fill all of the queues 10 times, and should do a
+      # reasonable job balancing parallelism (which benefits from lower window
+      # size) with packing efficiency (which suffers from edge effects when the
+      # window size is too low.)
+      window_size = int(self._packed_length / 8 * self._queue_size * 10)
+
+    if cycle_length is None:
+      # Typically binning one stream will saturate about 3 cores.
+
+      # Note on TPUs:
+      # cycle_length should still be explicitly set when training on TPUs,
+      # since the cpu count will be the local CPU count (which could be quite
+      # small), wereas the transforms will actually run on the TPU host
+      # controller which has a very robust CPU.
+      cycle_length = max([int(multiprocessing.cpu_count() / 3), 1])
+    return self._pack(dataset, window_size=window_size,
+                      cycle_length=cycle_length, keys=keys)
+
+  def _pack(self, dataset, window_size=None, cycle_length=None,
+            deterministic=False, keys=None):
+    """Main method for chaining together packing transformation steps."""
+    (dataset, self._num_sequences, self._token_dtype, keys
+    ) = self._standardize(dataset, keys)
+    if window_size is None:
+      dataset = self._scanning_pack(dataset)
+    else:
+      # Dataset.window splits nested Tensors.
+      re_zip = lambda *x: tf.data.Dataset.zip(x)
+      dataset = dataset.window(window_size).map(re_zip).interleave(
+          self._scanning_pack, cycle_length=cycle_length,
+          block_length=window_size,
+          num_parallel_calls=tf.data.experimental.AUTOTUNE)
+
+      if not deterministic:
+        # Sloppy interleave offers a marginal performance improvement.
+        options = tf.data.Options()
+        options.experimental_deterministic = False
+        dataset = dataset.with_options(options)
+
+    dataset = dataset.map(
+        self._finalize, num_parallel_calls=tf.data.experimental.AUTOTUNE)
+    self._num_sequences, self._token_dtype = None, None
+
+    if keys:
+      def dict_pack(example):
+        output = {}
+        for i, key in enumerate(keys):
+          output[key] = example["contents"][:, i]
+          output[key + "_segmentation"] = example["segment"][:, i]
+          output[key + "_position"] = example["position"][:, i]
+        return output
+      dataset = dataset.map(dict_pack)
+    return dataset
+
+  def _standardize(self, dataset, keys):
+    """Force dataset structure into a tuple of Tensors."""
+    shapes = tf.data.get_output_shapes(dataset)
+
+    if isinstance(shapes, dict):
+      keys = keys or tuple(shapes.keys())
+      dataset = dataset.map(lambda x: tuple(x[k] for k in keys))
+      shapes = tf.data.get_output_shapes(dataset)
+
+    if not all(isinstance(i, tf.TensorShape) for i in shapes):
+      # Internally this class expects tuples of Tensors, even for the degenerate
+      # case of a single sequence.
+      dataset = dataset.map(lambda x: (x,))
+      shapes = tf.data.get_output_shapes(dataset)
+
+    for s in shapes:
+      if not s.is_compatible_with(tf.TensorShape([None])):
+        raise ValueError("Tensors to be packed must be one-dimensional.")
+
+    if not shapes:
+      raise ValueError("Expected sequence dataset.")
+
+    if self._chop_long_sequences and len(shapes) != 1:
+      raise ValueError("chop_long_sequences expects a single sequence dataset.")
+
+    token_types = tf.data.get_output_types(dataset)
+    if len(set(token_types)) > 1:
+      raise ValueError("Inconsistent dtypes: {}".format(token_types))
+
+    return dataset, len(shapes), token_types[0], keys
+
+  def _eviction_fn(self, _):
+    return tuple(-tf.ones((self._packed_length,), dtype=self._token_dtype)
+                 for _ in range(self._num_sequences))
+
+  def _scan_initial_state(self):
+    """Create TensorArrays and indices to track bin assignment.
+
+    availability: TensorArray[queue_size, num_sequences]
+      This represents the number of tokens available in the ith bin.
+      See implementation note below.
+
+    contents: TensorArray[queue_size, num_sequences * 2]
+      This holds the actual contents of the packed strings as well as a bit
+      mask indicating where sequences begin. It is stored in a flat vector and
+      is accessed in offsets of packed_length.
+
+    top_index: scalar [0, queue_size)
+      Integer tensor indicating which index is the "top" bin. See implementation
+      note below.
+
+    IMPLEMENTATION_NOTE:
+      The FFD algorithm periodically pops the topmost queue and pushes a new
+      one to replace it. In order to replicate those semantics with a fixed size
+      TensorArray, indexing operations are shifted by top_index. For example,
+      instead of:
+        `queue_available.read(i)`
+
+      a read is instead performed as:
+        `queue_available.read((i - top_index) % queue_size)`
+
+      to account for the fact that the "ith" logical FFD queue is stored at
+      position j. This means that the pop / push update can be performed by
+      simply incrementing top_index. (And zeroing the old top_index position.)
+
+    Returns:
+      The state for the binning scan.
+    """
+
+    all_available = tf.ones((self._queue_size, self._num_sequences),
+                            dtype=INDEX_DTYPE) * self._packed_length
+    total_size = self._packed_length * self._queue_size
+    total_size_range = tf.range(total_size, dtype=INDEX_DTYPE)
+    empty = tf.zeros((total_size, self._num_sequences * 2),
+                     dtype=self._token_dtype)
+
+    availability = tf.TensorArray(
+        dtype=INDEX_DTYPE, size=self._queue_size, dynamic_size=False,
+        clear_after_read=False, element_shape=(self._num_sequences,)
+        ).scatter(tf.range(self._queue_size, dtype=INDEX_DTYPE), all_available)
+
+    contents = tf.TensorArray(
+        dtype=self._token_dtype, size=total_size, dynamic_size=False,
+        clear_after_read=False, element_shape=(self._num_sequences * 2,)
+        ).scatter(total_size_range, empty)
+
+    # Which index should be considered the "top" bucket for the purpose of
+    # the first-fit descending algorithm.
+    top_index = tf.zeros((), dtype=INDEX_DTYPE)
+
+    return availability, contents, top_index
+
+  def _scanning_pack(self, dataset):
+    """Apply scan based pack to a dataset."""
+    if self._chop_long_sequences:
+      dataset = dataset.map(lambda x: (x[:self._packed_length],))
+    else:
+      dataset = dataset.filter(lambda *x: tf.reduce_max(  # pylint: disable=g-long-lambda
+          tf.stack([tf.shape(i)[0] for i in x]), axis=0) <= self._packed_length)
+
+    # In order to retrieve the sequences which are still in the queue when the
+    # dataset is exhausted, we feed dummy sequences which are guaranteed to
+    # displace the remaining elements.
+    dataset = dataset.concatenate(
+        tf.data.Dataset.range(self._queue_size).map(self._eviction_fn))
+
+    initial_state = self._scan_initial_state()
+    step_fn = functools.partial(
+        tf.autograph.to_graph(_scan_step_fn), packed_length=self._packed_length,
+        queue_size=self._queue_size, spacing=self._spacing,
+        num_sequences=self._num_sequences, token_dtype=self._token_dtype)
+
+    dataset = dataset.apply(tf.data.experimental.scan(initial_state, step_fn))
+
+    is_real_sample = lambda valid_sample, _: valid_sample
+    return dataset.filter(is_real_sample)
+
+  def _compute_auxiliary_structure(self, contents_and_mask):
+    """Compute segment and position metadata."""
+    contents = contents_and_mask[:, :self._num_sequences]
+    start_mask = tf.cast(contents_and_mask[:, self._num_sequences:],
+                         dtype=INDEX_DTYPE)
+
+    segment = tf.cumsum(start_mask, axis=0)
+    uniform_count = tf.ones_like(segment[:, 0])
+    position = []
+    for i in range(self._num_sequences):
+      segment_slice = segment[:, i]
+      counts = tf.math.segment_sum(uniform_count, segment[:, i])
+      position.append(tf.range(self._packed_length) -  tf.cumsum(
+          tf.gather(counts, segment_slice - 1) * start_mask[:, i]))
+    position = tf.concat([i[:, tf.newaxis] for i in position], axis=1)
+
+    # Correct for padding tokens.
+    pad_mask = tf.cast(tf.not_equal(contents, 0), dtype=INDEX_DTYPE)
+    segment *= pad_mask
+    position *= pad_mask
+
+    return segment, position
+
+  def _finalize(self, _, contents):
+    """Structure output and compute segment and position metadata."""
+
+    # The output shape information is lost during the filter; however we can
+    # guarantee the shape. (That's the point of this exercise, after all!)
+    contents.set_shape((self._packed_length, self._num_sequences * 2))
+
+    # Both the dummy branch of the scan step function and the eviction dataset
+    # use vectors of minus one. The cost of this check is negligible and the
+    # leakage of such dummy sequences would be difficult to debug downstream.
+    check_leaks = tf.assert_none_equal(contents, -tf.ones_like(contents))
+    with tf.control_dependencies([check_leaks]):
+      contents = tf.identity(contents)
+
+    segment, position = self._compute_auxiliary_structure(contents)
+    return {"contents": contents[:, :self._num_sequences],
+            "segment": segment, "position": position}
+
+
+def _scan_step_fn(state, example, packed_length, queue_size, spacing,
+                  num_sequences, token_dtype):  # pylint: disable=g-doc-args
+  """Transform function used by tf.data.experimental.scan to process an example.
+
+  This is written as a stateless function rather than a class method because we
+  trace it with AutoGraph (in order to simplify the conditional), and this way
+  we don't have to worry about handling re-tracing semantics.
+
+  Args:
+    See the SequenceDatasetPacker class.
+
+  Returns:
+    The updated queue state, and either a packed example or a dummy sequence
+    which will be filtered out downstream.
+  """
+
+  # Convert TensorArray tuples to lists since we'll need to replace them.
+  availability, contents, top_index = state
+
+  lengths = tf.concat([tf.shape(i) for i in example], axis=0)
+  start_availability = availability.stack()
+  can_fit = tf.reduce_all(tf.greater_equal(start_availability, lengths), axis=1)
+  any_can_fit = tf.reduce_any(can_fit, axis=0)
+
+  # AutoGraph will convert this block to a tf.cond
+  if any_can_fit:
+    # This indicates where in the FFD queue rotation a given index sits
+    shifted_range = (
+        tf.range(queue_size, dtype=INDEX_DTYPE) - top_index) % queue_size
+
+    # Mark any indices which cannot accommodate the current example.
+    exclusion_mask = tf.cast(tf.logical_not(can_fit), INDEX_DTYPE) * queue_size
+
+    # Index in [0, queue_size) in which to place the sample. Note, this index
+    # is the position in the actual TensorArray, not the index of the FFD queue.
+    queue_index = (tf.reduce_min(shifted_range + exclusion_mask) +
+                   top_index) % queue_size
+
+    # NOTE(taylorrobie): We emit a non-empty Tensor for downstream checks.
+    output_contents = -tf.ones((1, num_sequences), dtype=token_dtype)
+
+  else:
+    index_range = top_index * packed_length + tf.range(packed_length)
+    output_contents = contents.gather(index_range)
+
+    # Reset the queue state.
+    availability = availability.write(
+        top_index, packed_length * tf.ones((num_sequences,), dtype=INDEX_DTYPE))
+    empty_contents = tf.zeros((packed_length, num_sequences * 2),
+                              dtype=token_dtype)
+    contents = contents.scatter(index_range, empty_contents)
+
+    queue_index = top_index
+    top_index = (top_index + 1) % queue_size
+
+  pre_assign_availability = availability.read(queue_index)
+  space_left = pre_assign_availability - lengths - spacing
+  availability = availability.write(queue_index, space_left)
+
+  # ============================================================================
+  # == Update contents =========================================================
+  # ============================================================================
+  # Consider the following case for a seq-to-seq packing:
+  #   (padding is represented as underscores)
+  #
+  #   Queue starting state:
+  #     [1, 3, 2, 4, 6, 1, _, _, _, _, _, ...]
+  #     [5, 9, _, _, _, _, _, _, _, _, _, ...]
+  #
+  #   Examples:
+  #     [4, 2, 4], [3]
+  #
+  #   Desired new queue state:
+  #     [1, 3, 2, 4, 6, 1, _, _, 4, 2, 4, _, _, ...]
+  #     [5, 9, _, _, 3, _, _, _, _, _, _, _, _, ...]
+  #
+  # This could be acomplished by creating a TensorArray for each of the two
+  # sequences, and scattering into the respective arrays. However TensorArray
+  # writes are extremely expensive relative to other operations. So instead we
+  # store the contents in a single TensorArray of shape (packed_length, 2), and
+  # we pad and concatenate the examples such that they can be added in a single
+  # assign:
+  #
+  #              [_, _, _, _, 4, 2, 4]
+  #              [3, _, _, _, _, _, _]
+  #                        +
+  #  [1, 3, 2, 4, 6, 1, _, _, _, _, _, ...]
+  #  [5, 9, _, _, _, _, _, _, _, _, _, ...]
+  #
+  # And in practice, the extra work of padding is neglidgable compared to
+  # the gain from vectorizing the TensorArray assign. We also store a bit mask
+  # denoting where sequences start which is used to compute segment and
+  # position metadata:
+  #
+  #              [_, _, _, _, 1, _, _]
+  #              [1, _, _, _, _, _, _]
+  #                        +
+  #  [1, _, _, _, _, _, _, _, _, _, _, ...]
+  #  [1, _, _, _, _, _, _, _, _, _, _, ...]
+  #
+  # Both the contents and the mask are concatenated in the same TensorArray
+  # for performance.
+
+  start_index = packed_length - pre_assign_availability
+  end_index = start_index + lengths
+  leftmost = tf.reduce_min(start_index, axis=0)
+  rightmost = tf.reduce_max(end_index, axis=0)
+  delta = rightmost - leftmost
+  pad_indices = [tf.stack((start_index[i] - leftmost, rightmost - end_index[i]))
+                 for i in range(num_sequences)]
+
+  padded_examples = [tf.pad(ex, padding[tf.newaxis, :])
+                     for ex, padding in zip(example, pad_indices)]
+  padded_examples = tf.transpose(tf.stack(padded_examples))
+  mask_update = tf.one_hot(start_index - leftmost, delta,
+                           dtype=contents.dtype, axis=0)
+
+  content_update = tf.concat([padded_examples, mask_update], axis=1)
+
+  index_range = (queue_index * packed_length +  # Offset into the right section.
+                 tf.range(delta, dtype=INDEX_DTYPE) + leftmost)
+  contents = contents.scatter(index_range, contents.gather(index_range) +
+                              content_update)
+
+  state = (availability, contents, top_index)
+  return state, (tf.logical_not(any_can_fit), output_contents)
+
+
+def make_tmp_dir(suffix="", prefix="tmp", dir=None):  # pylint: disable=redefined-builtin
+  """Make a temporary directory."""
+  if dir is None:
+    return tempfile.mkdtemp(suffix, prefix, dir)
+  else:
+    while True:
+      rand_term = random.randint(1, 9999)
+      tmp_dir = os.path.join(dir, "%s%d%s" % (prefix, rand_term, suffix))
+      if tf.gfile.Exists(tmp_dir):
+        continue
+      tf.gfile.MakeDirs(tmp_dir)
+      break
+    return tmp_dir
+
+
+def tfrecord_iterator_for_problem(problem, data_dir,
+                                  dataset_split=tf.estimator.ModeKeys.TRAIN):
+  """Iterate over the records on disk for the Problem."""
+  filenames = tf.gfile.Glob(problem.filepattern(data_dir, mode=dataset_split))
+  example_spec = problem.example_reading_spec()[0]
+  return tfrecord_iterator(filenames, example_spec=example_spec)
+
+
+def tfrecord_iterator(filenames, gzipped=False, example_spec=None):
+  """Yields records from TFRecord files.
+
+  Args:
+    filenames: list<str>, list of TFRecord filenames to read from.
+    gzipped: bool, whether the TFRecord files are gzip-encoded.
+    example_spec: dict<str feature name, tf.VarLenFeature/tf.FixedLenFeature>,
+      if provided, will parse each record as a tensorflow.Example proto.
+
+  Yields:
+    Records (or parsed Examples, if example_spec is provided) from files.
+  """
+  with tf.Graph().as_default():
+    dataset = tf.data.Dataset.from_tensor_slices(filenames)
+
+    def _load_records(filename):
+      return tf.data.TFRecordDataset(
+          filename,
+          compression_type=tf.constant("GZIP") if gzipped else None,
+          buffer_size=16 * 1000 * 1000)
+
+    dataset = dataset.flat_map(_load_records)
+
+    def _parse_example(ex_ser):
+      return tf.parse_single_example(ex_ser, example_spec)
+
+    if example_spec:
+      dataset = dataset.map(_parse_example, num_parallel_calls=32)
+    dataset = dataset.prefetch(100)
+    record_it = dataset.make_one_shot_iterator().get_next()
+
+    with tf.Session() as sess:
+      while True:
+        try:
+          ex = sess.run(record_it)
+          yield ex
+        except tf.errors.OutOfRangeError:
+          break
+
+
+def random_deinterleave(text, separator_symbol="X"):
+  """Create a fill-in-the-blanks training example from text.
+
+  Split on spaces, then cut into segments at random points.  Alternate segments
+  are assigned to the two output strings. separator_symbol separates segments
+  within each of the outputs.
+
+  example:
+    text="The quick brown fox jumps over the lazy dog."
+    returns: ("X quick brown X the lazy X", "The X fox jumps over X dog.")
+
+  The two outputs can also be reversed to yield an instance of the same problem.
+
+  Args:
+    text: a string
+    separator_symbol: a string
+  Returns:
+    a pair of strings
+  """
+  words = text.strip().split(" ")
+  n = len(words)
+  if n <= 1:
+    return text, ""
+  cut = [False] * n
+  cut[0] = True
+  num_cuts = int(math.exp(random.uniform(0, math.log(n))))
+  for _ in range(num_cuts):
+    cut[random.randint(1, n -1)] = True
+  out = [[], []]
+  part = random.randint(0, 1)
+  for i in range(n):
+    if cut[i]:
+      out[part].append(separator_symbol)
+      part = 1 - part
+    out[part].append(words[i])
+  return " ".join(out[0]), " ".join(out[1])

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/text_encoder.py

@@ -0,0 +1,1064 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Encoders for text data.
+
+* TextEncoder: base class
+* ByteTextEncoder: for ascii text
+* TokenTextEncoder: with user-supplied vocabulary file
+* SubwordTextEncoder: invertible
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+from itertools import chain
+import math
+import re
+import tempfile
+import time
+import numpy as np
+import six
+from six.moves import range  # pylint: disable=redefined-builtin
+from TensorFlow.nlp.transformer.data_generators import tokenizer
+
+import tensorflow.compat.v1 as tf
+
+# Reserved tokens for things like padding and EOS symbols.
+PAD = "<pad>"
+EOS = "<EOS>"
+RESERVED_TOKENS = [PAD, EOS]
+NUM_RESERVED_TOKENS = len(RESERVED_TOKENS)
+PAD_ID = RESERVED_TOKENS.index(PAD)  # Normally 0
+EOS_ID = RESERVED_TOKENS.index(EOS)  # Normally 1
+
+if six.PY2:
+  RESERVED_TOKENS_BYTES = RESERVED_TOKENS
+else:
+  RESERVED_TOKENS_BYTES = [bytes(PAD, "ascii"), bytes(EOS, "ascii")]
+
+# Regular expression for unescaping token strings.
+# '\u' is converted to '_'
+# '\\' is converted to '\'
+# '\213;' is converted to unichr(213)
+_UNESCAPE_REGEX = re.compile(r"\\u|\\\\|\\([0-9]+);")
+_ESCAPE_CHARS = set(u"\\_u;0123456789")
+
+
+# Unicode utility functions that work with Python 2 and 3
+def native_to_unicode(s):
+  if is_unicode(s):
+    return s
+  try:
+    return to_unicode(s)
+  except UnicodeDecodeError:
+    res = to_unicode(s, ignore_errors=True)
+    tf.logging.info("Ignoring Unicode error, outputting: %s" % res)
+    return res
+
+
+def unicode_to_native(s):
+  if six.PY2:
+    return s.encode("utf-8") if is_unicode(s) else s
+  else:
+    return s
+
+
+def is_unicode(s):
+  return isinstance(s, six.text_type)
+
+
+def to_unicode(s, ignore_errors=False):
+  if is_unicode(s):
+    return s
+  error_mode = "ignore" if ignore_errors else "strict"
+  return s.decode("utf-8", errors=error_mode)
+
+
+def to_unicode_ignore_errors(s):
+  return to_unicode(s, ignore_errors=True)
+
+
+def to_unicode_utf8(s):
+  return unicode(s, "utf-8") if six.PY2 else s.decode("utf-8")
+
+
+def strip_ids(ids, ids_to_strip):
+  """Strip ids_to_strip from the end ids."""
+  ids = list(ids)
+  while ids and ids[-1] in ids_to_strip:
+    ids.pop()
+  return ids
+
+
+class TextEncoder(object):
+  """Base class for converting from ints to/from human readable strings."""
+
+  def __init__(self, num_reserved_ids=NUM_RESERVED_TOKENS):
+    self._num_reserved_ids = num_reserved_ids
+
+  @property
+  def num_reserved_ids(self):
+    return self._num_reserved_ids
+
+  def encode(self, s):
+    """Transform a human-readable string into a sequence of int ids.
+
+    The ids should be in the range [num_reserved_ids, vocab_size). Ids [0,
+    num_reserved_ids) are reserved.
+
+    EOS is not appended.
+
+    Args:
+      s: human-readable string to be converted.
+
+    Returns:
+      ids: list of integers
+    """
+    return [int(w) + self._num_reserved_ids for w in s.split()]
+
+  def decode(self, ids, strip_extraneous=False):
+    """Transform a sequence of int ids into a human-readable string.
+
+    EOS is not expected in ids.
+
+    Args:
+      ids: list of integers to be converted.
+      strip_extraneous: bool, whether to strip off extraneous tokens
+        (EOS and PAD).
+
+    Returns:
+      s: human-readable string.
+    """
+    if strip_extraneous:
+      ids = strip_ids(ids, list(range(self._num_reserved_ids or 0)))
+    return " ".join(self.decode_list(ids))
+
+  def decode_list(self, ids):
+    """Transform a sequence of int ids into a their string versions.
+
+    This method supports transforming individual input/output ids to their
+    string versions so that sequence to/from text conversions can be visualized
+    in a human readable format.
+
+    Args:
+      ids: list of integers to be converted.
+
+    Returns:
+      strs: list of human-readable string.
+    """
+    decoded_ids = []
+    for id_ in ids:
+      if 0 <= id_ < self._num_reserved_ids:
+        decoded_ids.append(RESERVED_TOKENS[int(id_)])
+      else:
+        decoded_ids.append(id_ - self._num_reserved_ids)
+    return [str(d) for d in decoded_ids]
+
+  @property
+  def vocab_size(self):
+    raise NotImplementedError()
+
+
+class ByteTextEncoder(TextEncoder):
+  """Encodes each byte to an id. For 8-bit strings only."""
+
+  def encode(self, s):
+    numres = self._num_reserved_ids
+    if six.PY2:
+      if isinstance(s, unicode):
+        s = s.encode("utf-8")
+      return [ord(c) + numres for c in s]
+    # Python3: explicitly convert to UTF-8
+    return [c + numres for c in s.encode("utf-8")]
+
+  def decode(self, ids, strip_extraneous=False):
+    if strip_extraneous:
+      ids = strip_ids(ids, list(range(self._num_reserved_ids or 0)))
+    numres = self._num_reserved_ids
+    decoded_ids = []
+    int2byte = six.int2byte
+    for id_ in ids:
+      if 0 <= id_ < numres:
+        decoded_ids.append(RESERVED_TOKENS_BYTES[int(id_)])
+      else:
+        decoded_ids.append(int2byte(id_ - numres))
+    if six.PY2:
+      return "".join(decoded_ids)
+    # Python3: join byte arrays and then decode string
+    return b"".join(decoded_ids).decode("utf-8", "replace")
+
+  def decode_list(self, ids):
+    numres = self._num_reserved_ids
+    decoded_ids = []
+    int2byte = six.int2byte
+    for id_ in ids:
+      if 0 <= id_ < numres:
+        decoded_ids.append(RESERVED_TOKENS_BYTES[int(id_)])
+      else:
+        decoded_ids.append(int2byte(id_ - numres))
+    # Python3: join byte arrays and then decode string
+    return decoded_ids
+
+  @property
+  def vocab_size(self):
+    return 2**8 + self._num_reserved_ids
+
+
+class ClassLabelEncoder(TextEncoder):
+  """Encoder for class labels."""
+
+  def __init__(self, class_labels=None, class_labels_fname=None):
+    super(ClassLabelEncoder, self).__init__(num_reserved_ids=0)
+
+    if class_labels_fname:
+      with tf.gfile.Open(class_labels_fname) as f:
+        class_labels = [label.strip() for label in f.readlines()]
+
+    assert class_labels
+    self._class_labels = class_labels
+
+  def encode(self, s):
+    label_str = s
+    return self._class_labels.index(label_str)
+
+  def decode(self, ids, strip_extraneous=False):
+    del strip_extraneous
+    label_id = ids
+    if isinstance(label_id, list):
+      assert len(label_id) == 1
+      label_id, = label_id
+    if isinstance(label_id, np.ndarray):
+      label_id = np.squeeze(label_id)
+    return self._class_labels[label_id]
+
+  def decode_list(self, ids):
+    return [self._class_labels[i] for i in ids]
+
+  @property
+  def vocab_size(self):
+    return len(self._class_labels)
+
+
+class OneHotClassLabelEncoder(ClassLabelEncoder):
+  """One-hot encoder for class labels."""
+
+  def encode(self, label_str, on_value=1, off_value=0):  # pylint: disable=arguments-differ
+    e = np.full(self.vocab_size, off_value, dtype=np.int32)
+    e[self._class_labels.index(label_str)] = on_value
+    return e.tolist()
+
+  def decode(self, ids, strip_extraneous=False):
+    del strip_extraneous
+    label_id = ids
+    if isinstance(label_id, np.ndarray):
+      label_id = np.squeeze(label_id).astype(np.int8).tolist()
+    assert isinstance(label_id, list)
+    assert len(label_id) == self.vocab_size
+    return self._class_labels[label_id.index(1)]
+
+  @property
+  def vocab_size(self):
+    return len(self._class_labels)
+
+
+class TokenTextEncoder(TextEncoder):
+  """Encoder based on a user-supplied vocabulary (file or list)."""
+
+  def __init__(self,
+               vocab_filename,
+               reverse=False,
+               vocab_list=None,
+               replace_oov=None,
+               num_reserved_ids=NUM_RESERVED_TOKENS):
+    """Initialize from a file or list, one token per line.
+
+    Handling of reserved tokens works as follows:
+    - When initializing from a list, we add reserved tokens to the vocab.
+    - When initializing from a file, we do not add reserved tokens to the vocab.
+    - When saving vocab files, we save reserved tokens to the file.
+
+    Args:
+      vocab_filename: If not None, the full filename to read vocab from. If this
+         is not None, then vocab_list should be None.
+      reverse: Boolean indicating if tokens should be reversed during encoding
+         and decoding.
+      vocab_list: If not None, a list of elements of the vocabulary. If this is
+         not None, then vocab_filename should be None.
+      replace_oov: If not None, every out-of-vocabulary token seen when
+         encoding will be replaced by this string (which must be in vocab).
+      num_reserved_ids: Number of IDs to save for reserved tokens like <EOS>.
+    """
+    super(TokenTextEncoder, self).__init__(num_reserved_ids=num_reserved_ids)
+    self._reverse = reverse
+    self._replace_oov = replace_oov
+    if vocab_filename:
+      self._init_vocab_from_file(vocab_filename)
+    else:
+      assert vocab_list is not None
+      self._init_vocab_from_list(vocab_list)
+
+  def encode(self, s):
+    """Converts a space-separated string of tokens to a list of ids."""
+    sentence = s
+    tokens = sentence.strip().split()
+    if self._replace_oov is not None:
+      tokens = [t if t in self._token_to_id else self._replace_oov
+                for t in tokens]
+    ret = [self._token_to_id[tok] for tok in tokens]
+    return ret[::-1] if self._reverse else ret
+
+  def decode(self, ids, strip_extraneous=False):
+    return " ".join(self.decode_list(ids))
+
+  def decode_list(self, ids):
+    seq = reversed(ids) if self._reverse else ids
+    return [self._safe_id_to_token(i) for i in seq]
+
+  @property
+  def vocab_size(self):
+    return len(self._id_to_token)
+
+  def _safe_id_to_token(self, idx):
+    return self._id_to_token.get(idx, "ID_%d" % idx)
+
+  def _init_vocab_from_file(self, filename):
+    """Load vocab from a file.
+
+    Args:
+      filename: The file to load vocabulary from.
+    """
+    with tf.gfile.Open(filename) as f:
+      tokens = [token.strip() for token in f.readlines()]
+
+    def token_gen():
+      for token in tokens:
+        yield token
+
+    self._init_vocab(token_gen(), add_reserved_tokens=False)
+
+  def _init_vocab_from_list(self, vocab_list):
+    """Initialize tokens from a list of tokens.
+
+    It is ok if reserved tokens appear in the vocab list. They will be
+    removed. The set of tokens in vocab_list should be unique.
+
+    Args:
+      vocab_list: A list of tokens.
+    """
+    def token_gen():
+      for token in vocab_list:
+        if token not in RESERVED_TOKENS:
+          yield token
+
+    self._init_vocab(token_gen())
+
+  def _init_vocab(self, token_generator, add_reserved_tokens=True):
+    """Initialize vocabulary with tokens from token_generator."""
+
+    self._id_to_token = {}
+    non_reserved_start_index = 0
+
+    if add_reserved_tokens:
+      self._id_to_token.update(enumerate(RESERVED_TOKENS))
+      non_reserved_start_index = len(RESERVED_TOKENS)
+
+    self._id_to_token.update(
+        enumerate(token_generator, start=non_reserved_start_index))
+
+    # _token_to_id is the reverse of _id_to_token
+    self._token_to_id = dict((v, k)
+                             for k, v in six.iteritems(self._id_to_token))
+
+  def store_to_file(self, filename):
+    """Write vocab file to disk.
+
+    Vocab files have one token per line. The file ends in a newline. Reserved
+    tokens are written to the vocab file as well.
+
+    Args:
+      filename: Full path of the file to store the vocab to.
+    """
+    with tf.gfile.Open(filename, "w") as f:
+      for i in range(len(self._id_to_token)):
+        f.write(self._id_to_token[i] + "\n")
+
+
+def _escape_token(token, alphabet):
+  """Escape away underscores and OOV characters and append '_'.
+
+  This allows the token to be expressed as the concatenation of a list
+  of subtokens from the vocabulary. The underscore acts as a sentinel
+  which allows us to invertibly concatenate multiple such lists.
+
+  Args:
+    token: A unicode string to be escaped.
+    alphabet: A set of all characters in the vocabulary's alphabet.
+
+  Returns:
+    escaped_token: An escaped unicode string.
+
+  Raises:
+    ValueError: If the provided token is not unicode.
+  """
+  if not isinstance(token, six.text_type):
+    raise ValueError("Expected string type for token, got %s" % type(token))
+
+  token = token.replace(u"\\", u"\\\\").replace(u"_", u"\\u")
+  ret = [c if c in alphabet and c != u"\n" else r"\%d;" % ord(c) for c in token]
+  return u"".join(ret) + "_"
+
+
+def _unescape_token(escaped_token):
+  """Inverse of _escape_token().
+
+  Args:
+    escaped_token: a unicode string
+
+  Returns:
+    token: a unicode string
+  """
+
+  def match(m):
+    if m.group(1) is None:
+      return u"_" if m.group(0) == u"\\u" else u"\\"
+
+    try:
+      return six.unichr(int(m.group(1)))
+    except (ValueError, OverflowError) as _:
+      return u"\u3013"  # Unicode for undefined character.
+
+  trimmed = escaped_token[:-1] if escaped_token.endswith("_") else escaped_token
+  return _UNESCAPE_REGEX.sub(match, trimmed)
+
+
+class SubwordTextEncoder(TextEncoder):
+  """Class for invertibly encoding text using a limited vocabulary.
+
+  Invertibly encodes a native string as a sequence of subtokens from a limited
+  vocabulary.
+
+  A SubwordTextEncoder is built from a corpus (so it is tailored to the text in
+  the corpus), and stored to a file. See text_encoder_build_subword.py.
+
+  It can then be loaded and used to encode/decode any text.
+
+  Encoding has four phases:
+
+  1. Tokenize into a list of tokens.  Each token is a unicode string of either
+     all alphanumeric characters or all non-alphanumeric characters.  We drop
+     tokens consisting of a single space that are between two alphanumeric
+     tokens.
+
+  2. Escape each token.  This escapes away special and out-of-vocabulary
+     characters, and makes sure that each token ends with an underscore, and
+     has no other underscores.
+
+  3. Represent each escaped token as a the concatenation of a list of subtokens
+     from the limited vocabulary.  Subtoken selection is done greedily from
+     beginning to end.  That is, we construct the list in order, always picking
+     the longest subtoken in our vocabulary that matches a prefix of the
+     remaining portion of the encoded token.
+
+  4. Concatenate these lists.  This concatenation is invertible due to the
+     fact that the trailing underscores indicate when one list is finished.
+
+  """
+
+  def __init__(self, filename=None):
+    """Initialize and read from a file, if provided.
+
+    Args:
+      filename: filename from which to read vocab. If None, do not load a
+        vocab
+    """
+    self._alphabet = set()
+    self.filename = filename
+    if filename is not None:
+      self._load_from_file(filename)
+    super(SubwordTextEncoder, self).__init__()
+
+  def encode(self, s):
+    """Converts a native string to a list of subtoken ids.
+
+    Args:
+      s: a native string.
+    Returns:
+      a list of integers in the range [0, vocab_size)
+    """
+    return self._tokens_to_subtoken_ids(
+        tokenizer.encode(native_to_unicode(s)))
+
+  def encode_without_tokenizing(self, token_text):
+    """Converts string to list of subtoken ids without calling tokenizer.
+
+    This treats `token_text` as a single token and directly converts it
+    to subtoken ids. This may be useful when the default tokenizer doesn't
+    do what we want (e.g., when encoding text with tokens composed of lots of
+    nonalphanumeric characters). It is then up to the caller to make sure that
+    raw text is consistently converted into tokens. Only use this if you are
+    sure that `encode` doesn't suit your needs.
+
+    Args:
+      token_text: A native string representation of a single token.
+    Returns:
+      A list of subword token ids; i.e., integers in the range [0, vocab_size).
+    """
+    return self._tokens_to_subtoken_ids([native_to_unicode(token_text)])
+
+  def decode(self, ids, strip_extraneous=False):
+    """Converts a sequence of subtoken ids to a native string.
+
+    Args:
+      ids: a list of integers in the range [0, vocab_size)
+      strip_extraneous: bool, whether to strip off extraneous tokens
+        (EOS and PAD).
+
+    Returns:
+      a native string
+    """
+    if strip_extraneous:
+      ids = strip_ids(ids, list(range(self._num_reserved_ids or 0)))
+    return unicode_to_native(
+        tokenizer.decode(self._subtoken_ids_to_tokens(ids)))
+
+  def decode_list(self, ids):
+    return [self._subtoken_id_to_subtoken_string(s) for s in ids]
+
+  @property
+  def vocab_size(self):
+    """The subtoken vocabulary size."""
+    return len(self._all_subtoken_strings)
+
+  def _tokens_to_subtoken_ids(self, tokens):
+    """Converts a list of tokens to a list of subtoken ids.
+
+    Args:
+      tokens: a list of strings.
+    Returns:
+      a list of integers in the range [0, vocab_size)
+    """
+    ret = []
+    for token in tokens:
+      ret.extend(self._token_to_subtoken_ids(token))
+    return ret
+
+  def _token_to_subtoken_ids(self, token):
+    """Converts token to a list of subtoken ids.
+
+    Args:
+      token: a string.
+    Returns:
+      a list of integers in the range [0, vocab_size)
+    """
+    cache_location = hash(token) % self._cache_size
+    cache_key, cache_value = self._cache[cache_location]
+    if cache_key == token:
+      return cache_value
+    ret = self._escaped_token_to_subtoken_ids(
+        _escape_token(token, self._alphabet))
+    self._cache[cache_location] = (token, ret)
+    return ret
+
+  def _subtoken_ids_to_tokens(self, subtokens):
+    """Converts a list of subtoken ids to a list of tokens.
+
+    Args:
+      subtokens: a list of integers in the range [0, vocab_size)
+    Returns:
+      a list of strings.
+    """
+    concatenated = "".join(
+        [self._subtoken_id_to_subtoken_string(s) for s in subtokens])
+    split = concatenated.split("_")
+    ret = []
+    for t in split:
+      if t:
+        unescaped = _unescape_token(t + "_")
+        if unescaped:
+          ret.append(unescaped)
+    return ret
+
+  def _subtoken_id_to_subtoken_string(self, subtoken):
+    """Converts a subtoken integer ID to a subtoken string."""
+    if 0 <= subtoken < self.vocab_size:
+      return self._all_subtoken_strings[subtoken]
+    return u""
+
+  def _escaped_token_to_subtoken_strings(self, escaped_token):
+    """Converts an escaped token string to a list of subtoken strings.
+
+    Args:
+      escaped_token: An escaped token as a unicode string.
+    Returns:
+      A list of subtokens as unicode strings.
+    """
+    # NOTE: This algorithm is greedy; it won't necessarily produce the "best"
+    # list of subtokens.
+    ret = []
+    start = 0
+    token_len = len(escaped_token)
+    while start < token_len:
+      for end in range(
+          min(token_len, start + self._max_subtoken_len), start, -1):
+        subtoken = escaped_token[start:end]
+        if subtoken in self._subtoken_string_to_id:
+          ret.append(subtoken)
+          start = end
+          break
+
+      else:  # Did not break
+        # If there is no possible encoding of the escaped token then one of the
+        # characters in the token is not in the alphabet. This should be
+        # impossible and would be indicative of a bug.
+        assert False, "Token substring not found in subtoken vocabulary."
+
+    return ret
+
+  def _escaped_token_to_subtoken_ids(self, escaped_token):
+    """Converts an escaped token string to a list of subtoken IDs.
+
+    Args:
+      escaped_token: An escaped token as a unicode string.
+    Returns:
+      A list of subtoken IDs as integers.
+    """
+    return [
+        self._subtoken_string_to_id[subtoken]
+        for subtoken in self._escaped_token_to_subtoken_strings(escaped_token)
+    ]
+
+  @classmethod
+  def build_from_generator(cls,
+                           generator,
+                           target_size,
+                           max_subtoken_length=None,
+                           reserved_tokens=None):
+    """Builds a SubwordTextEncoder from the generated text.
+
+    Args:
+      generator: yields text.
+      target_size: int, approximate vocabulary size to create.
+      max_subtoken_length: Maximum length of a subtoken. If this is not set,
+        then the runtime and memory use of creating the vocab is quadratic in
+        the length of the longest token. If this is set, then it is instead
+        O(max_subtoken_length * length of longest token).
+      reserved_tokens: List of reserved tokens. The global variable
+        `RESERVED_TOKENS` must be a prefix of `reserved_tokens`. If this
+        argument is `None`, it will use `RESERVED_TOKENS`.
+
+    Returns:
+      SubwordTextEncoder with `vocab_size` approximately `target_size`.
+    """
+    token_counts = collections.defaultdict(int)
+    for item in generator:
+      for tok in tokenizer.encode(native_to_unicode(item)):
+        token_counts[tok] += 1
+    encoder = cls.build_to_target_size(
+        target_size, token_counts, 1, 1e3,
+        max_subtoken_length=max_subtoken_length,
+        reserved_tokens=reserved_tokens)
+    return encoder
+
+  @classmethod
+  def build_to_target_size(cls,
+                           target_size,
+                           token_counts,
+                           min_val,
+                           max_val,
+                           max_subtoken_length=None,
+                           reserved_tokens=None,
+                           num_iterations=4):
+    """Builds a SubwordTextEncoder that has `vocab_size` near `target_size`.
+
+    Uses simple recursive binary search to find a minimum token count that most
+    closely matches the `target_size`.
+
+    Args:
+      target_size: Desired vocab_size to approximate.
+      token_counts: A dictionary of token counts, mapping string to int.
+      min_val: An integer; lower bound for the minimum token count.
+      max_val: An integer; upper bound for the minimum token count.
+      max_subtoken_length: Maximum length of a subtoken. If this is not set,
+        then the runtime and memory use of creating the vocab is quadratic in
+        the length of the longest token. If this is set, then it is instead
+        O(max_subtoken_length * length of longest token).
+      reserved_tokens: List of reserved tokens. The global variable
+        `RESERVED_TOKENS` must be a prefix of `reserved_tokens`. If this
+        argument is `None`, it will use `RESERVED_TOKENS`.
+      num_iterations: An integer; how many iterations of refinement.
+
+    Returns:
+      A SubwordTextEncoder instance.
+
+    Raises:
+      ValueError: If `min_val` is greater than `max_val`.
+    """
+    if min_val > max_val:
+      raise ValueError("Lower bound for the minimum token count "
+                       "is greater than the upper bound.")
+    if target_size < 1:
+      raise ValueError("Target size must be positive.")
+
+    if reserved_tokens is None:
+      reserved_tokens = RESERVED_TOKENS
+
+    def bisect(min_val, max_val):
+      """Bisection to find the right size."""
+      present_count = (max_val + min_val) // 2
+      tf.logging.info("Trying min_count %d" % present_count)
+      subtokenizer = cls()
+      subtokenizer.build_from_token_counts(
+          token_counts, present_count, num_iterations,
+          max_subtoken_length=max_subtoken_length,
+          reserved_tokens=reserved_tokens)
+
+      # Being within 1% of the target size is ok.
+      is_ok = abs(subtokenizer.vocab_size - target_size) * 100 < target_size
+      # If min_val == max_val, we can't do any better than this.
+      if is_ok or min_val >= max_val or present_count < 2:
+        return subtokenizer
+
+      if subtokenizer.vocab_size > target_size:
+        other_subtokenizer = bisect(present_count + 1, max_val)
+      else:
+        other_subtokenizer = bisect(min_val, present_count - 1)
+
+      if other_subtokenizer is None:
+        return subtokenizer
+
+      if (abs(other_subtokenizer.vocab_size - target_size) <
+          abs(subtokenizer.vocab_size - target_size)):
+        return other_subtokenizer
+      return subtokenizer
+
+    return bisect(min_val, max_val)
+
+  def build_from_token_counts(self,
+                              token_counts,
+                              min_count,
+                              num_iterations=4,
+                              reserved_tokens=None,
+                              max_subtoken_length=None):
+    """Train a SubwordTextEncoder based on a dictionary of word counts.
+
+    Args:
+      token_counts: a dictionary of Unicode strings to int.
+      min_count: an integer - discard subtokens with lower counts.
+      num_iterations: an integer.  how many iterations of refinement.
+      reserved_tokens: List of reserved tokens. The global variable
+        `RESERVED_TOKENS` must be a prefix of `reserved_tokens`. If this
+        argument is `None`, it will use `RESERVED_TOKENS`.
+      max_subtoken_length: Maximum length of a subtoken. If this is not set,
+        then the runtime and memory use of creating the vocab is quadratic in
+        the length of the longest token. If this is set, then it is instead
+        O(max_subtoken_length * length of longest token).
+
+    Raises:
+      ValueError: if reserved is not 0 or len(RESERVED_TOKENS). In this case, it
+        is not clear what the space is being reserved for, or when it will be
+        filled in.
+    """
+    if reserved_tokens is None:
+      reserved_tokens = RESERVED_TOKENS
+    else:
+      # There is not complete freedom in replacing RESERVED_TOKENS.
+      for default, proposed in zip(RESERVED_TOKENS, reserved_tokens):
+        if default != proposed:
+          raise ValueError("RESERVED_TOKENS must be a prefix of "
+                           "reserved_tokens.")
+
+    # Initialize the alphabet. Note, this must include reserved tokens or it can
+    # result in encoding failures.
+    alphabet_tokens = chain(six.iterkeys(token_counts),
+                            [native_to_unicode(t) for t in reserved_tokens])
+
+    self._init_alphabet_from_tokens(alphabet_tokens)
+
+    # Bootstrap the initial list of subtokens with the characters from the
+    # alphabet plus the escaping characters.
+    self._init_subtokens_from_list(list(self._alphabet),
+                                   reserved_tokens=reserved_tokens)
+
+    # We build iteratively.  On each iteration, we segment all the words,
+    # then count the resulting potential subtokens, keeping the ones
+    # with high enough counts for our new vocabulary.
+    if min_count < 1:
+      min_count = 1
+    for i in range(num_iterations):
+      tf.logging.info("Iteration {0}".format(i))
+
+      # Collect all substrings of the encoded token that break along current
+      # subtoken boundaries.
+      subtoken_counts = collections.defaultdict(int)
+      for token, count in six.iteritems(token_counts):
+        iter_start_time = time.time()
+        escaped_token = _escape_token(token, self._alphabet)
+        subtokens = self._escaped_token_to_subtoken_strings(escaped_token)
+        start = 0
+        for subtoken in subtokens:
+          last_position = len(escaped_token) + 1
+          if max_subtoken_length is not None:
+            last_position = min(last_position, start + max_subtoken_length)
+
+          for end in range(start + 1, last_position):
+            new_subtoken = escaped_token[start:end]
+            subtoken_counts[new_subtoken] += count
+          start += len(subtoken)
+        iter_time_secs = time.time() - iter_start_time
+        if iter_time_secs > 0.1:
+          tf.logging.info(u"Processing token [{0}] took {1} seconds, consider "
+                          "setting Text2TextProblem.max_subtoken_length to a "
+                          "smaller value.".format(token, iter_time_secs))
+
+      # Array of sets of candidate subtoken strings, by length.
+      len_to_subtoken_strings = []
+      for subtoken_string, count in six.iteritems(subtoken_counts):
+        lsub = len(subtoken_string)
+        if count >= min_count:
+          while len(len_to_subtoken_strings) <= lsub:
+            len_to_subtoken_strings.append(set())
+          len_to_subtoken_strings[lsub].add(subtoken_string)
+
+      # Consider the candidates longest to shortest, so that if we accept
+      # a longer subtoken string, we can decrement the counts of its prefixes.
+      new_subtoken_strings = []
+      for lsub in range(len(len_to_subtoken_strings) - 1, 0, -1):
+        subtoken_strings = len_to_subtoken_strings[lsub]
+        for subtoken_string in subtoken_strings:
+          count = subtoken_counts[subtoken_string]
+          if count >= min_count:
+            # Exclude alphabet tokens here, as they must be included later,
+            # explicitly, regardless of count.
+            if subtoken_string not in self._alphabet:
+              new_subtoken_strings.append((count, subtoken_string))
+            for l in range(1, lsub):
+              subtoken_counts[subtoken_string[:l]] -= count
+
+      # Include the alphabet explicitly to guarantee all strings are encodable.
+      new_subtoken_strings.extend((subtoken_counts.get(a, 0), a)
+                                  for a in self._alphabet)
+      new_subtoken_strings.sort(reverse=True)
+
+      # Reinitialize to the candidate vocabulary.
+      new_subtoken_strings = [subtoken for _, subtoken in new_subtoken_strings]
+      if reserved_tokens:
+        escaped_reserved_tokens = [
+            _escape_token(native_to_unicode(t), self._alphabet)
+            for t in reserved_tokens
+        ]
+        new_subtoken_strings = escaped_reserved_tokens + new_subtoken_strings
+
+      self._init_subtokens_from_list(new_subtoken_strings)
+      tf.logging.info("vocab_size = %d" % self.vocab_size)
+
+  @property
+  def all_subtoken_strings(self):
+    return tuple(self._all_subtoken_strings)
+
+  def dump(self):
+    """Debugging dump of the current subtoken vocabulary."""
+    subtoken_strings = [(i, s)
+                        for s, i in six.iteritems(self._subtoken_string_to_id)]
+    print(u", ".join(u"{0} : '{1}'".format(i, s)
+                     for i, s in sorted(subtoken_strings)))
+
+  def _init_subtokens_from_list(self, subtoken_strings, reserved_tokens=None):
+    """Initialize token information from a list of subtoken strings.
+
+    Args:
+      subtoken_strings: a list of subtokens
+      reserved_tokens: List of reserved tokens. We must have `reserved_tokens`
+        as None or the empty list, or else the global variable `RESERVED_TOKENS`
+        must be a prefix of `reserved_tokens`.
+
+    Raises:
+      ValueError: if reserved is not 0 or len(RESERVED_TOKENS). In this case, it
+        is not clear what the space is being reserved for, or when it will be
+        filled in.
+    """
+    if reserved_tokens is None:
+      reserved_tokens = []
+
+    if reserved_tokens:
+      self._all_subtoken_strings = reserved_tokens + subtoken_strings
+    else:
+      self._all_subtoken_strings = subtoken_strings
+
+    # we remember the maximum length of any subtoken to avoid having to
+    # check arbitrarily long strings.
+    self._max_subtoken_len = max([len(s) for s in subtoken_strings])
+    self._subtoken_string_to_id = {
+        s: i + len(reserved_tokens)
+        for i, s in enumerate(subtoken_strings) if s
+    }
+    # Initialize the cache to empty.
+    self._cache_size = 2 ** 20
+    self._cache = [(None, None)] * self._cache_size
+
+  def _init_alphabet_from_tokens(self, tokens):
+    """Initialize alphabet from an iterable of token or subtoken strings."""
+    # Include all characters from all tokens in the alphabet to guarantee that
+    # any token can be encoded. Additionally, include all escaping characters.
+    self._alphabet = {c for token in tokens for c in token}
+    self._alphabet |= _ESCAPE_CHARS
+
+  def _load_from_file_object(self, f):
+    """Load from a file object.
+
+    Args:
+      f: File object to load vocabulary from
+    """
+    subtoken_strings = []
+    for line in f:
+      s = line.rstrip()
+      # Some vocab files wrap words in single quotes, but others don't
+      if ((s.startswith("'") and s.endswith("'")) or
+          (s.startswith("\"") and s.endswith("\""))):
+        s = s[1:-1]
+      subtoken_strings.append(native_to_unicode(s))
+    self._init_subtokens_from_list(subtoken_strings)
+    self._init_alphabet_from_tokens(subtoken_strings)
+
+  def _load_from_file(self, filename):
+    """Load from a vocab file."""
+    if not tf.gfile.Exists(filename):
+      raise ValueError("File %s not found" % filename)
+    with tf.gfile.Open(filename) as f:
+      self._load_from_file_object(f)
+
+  def store_to_file(self, filename, add_single_quotes=True):
+    with tf.gfile.Open(filename, "w") as f:
+      for subtoken_string in self._all_subtoken_strings:
+        if add_single_quotes:
+          f.write("'" + unicode_to_native(subtoken_string) + "'\n")
+        else:
+          f.write(unicode_to_native(subtoken_string) + "\n")
+
+
+class ImageEncoder(object):
+  """Encoder class for saving and loading images."""
+
+  def __init__(self, num_reserved_ids=0, height=None, width=None, channels=3):
+    assert num_reserved_ids == 0
+    self._height = height
+    self._width = width
+    self._channels = channels
+
+  @property
+  def num_reserved_ids(self):
+    return 0
+
+  def encode(self, s):
+    """Transform a string with a filename into a list of RGB integers.
+
+    Args:
+      s: path to the file with an image.
+
+    Returns:
+      ids: list of integers
+    """
+    try:
+      import matplotlib.image as im  # pylint: disable=g-import-not-at-top
+    except ImportError as e:
+      tf.logging.warning(
+          "Reading an image requires matplotlib to be installed: %s", e)
+      raise NotImplementedError("Image reading not implemented.")
+    return im.imread(s)
+
+  def decode(self, ids, strip_extraneous=False):
+    """Transform a sequence of int ids into an image file.
+
+    Args:
+      ids: list of integers to be converted.
+      strip_extraneous: unused
+
+    Returns:
+      Path to the temporary file where the image was saved.
+
+    Raises:
+      ValueError: if the ids are not of the appropriate size.
+    """
+    del strip_extraneous
+    _, tmp_file_path = tempfile.mkstemp("_decode.png")
+    if self._height is None or self._width is None:
+      size = int(math.sqrt(len(ids) / self._channels))
+      length = size * size * self._channels
+    else:
+      size = None
+      length = self._height * self._width * self._channels
+    if len(ids) != length:
+      raise ValueError("Length of ids (%d) must be height (%d) x width (%d) x "
+                       "channels (%d); %d != %d.\n Ids: %s"
+                       % (len(ids), self._height, self._width, self._channels,
+                          len(ids), length, " ".join([str(i) for i in ids])))
+    with tf.Graph().as_default():
+      raw = tf.constant(ids, dtype=tf.uint8)
+      if size is None:
+        img = tf.reshape(raw, [self._height, self._width, self._channels])
+      else:
+        img = tf.reshape(raw, [size, size, self._channels])
+      png = tf.image.encode_png(img)
+      op = tf.write_file(tmp_file_path, png)
+      with tf.Session() as sess:
+        sess.run(op)
+    return tmp_file_path
+
+  def decode_list(self, ids):
+    """Transform a sequence of int ids into an image file.
+
+    Args:
+      ids: list of integers to be converted.
+
+    Returns:
+      Singleton list: path to the temporary file where the image was saved.
+    """
+    return [self.decode(ids)]
+
+  @property
+  def vocab_size(self):
+    return 256
+
+
+class RealEncoder(object):
+  """Encoder class for saving and loading float values."""
+
+  def encode(self, s):
+    """Transform a string (space separated float values) into a float array.
+
+    Args:
+      s: space separated float values.
+
+    Returns:
+      Array of float values.
+    """
+    return [float(w) for w in s.split()]
+
+  def decode(self, ids, strip_extraneous=False):
+    """Transform sequence of float values into string (float values).
+
+    Args:
+      ids: array of floats to be converted.
+      strip_extraneous: unused
+
+    Returns:
+      String having space separated float values.
+
+    Raises:
+      ValueError: if the ids are not of the appropriate size.
+    """
+    del strip_extraneous
+    return " ".join([str(i) for i in ids])

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/text_encoder_build_subword.py

@@ -0,0 +1,79 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+r"""Program to build a SubwordTextEncoder.
+
+The flags --min_count and --corpus_max_lines will affect the size of the
+vocabulary.  Try changing these flags until you get a vocabulary
+of the size you want.
+
+Example usage:
+
+python data_generators/text_encoder_build_subword.py \
+    --corpus_filepattern=$DATA_DIR/my_problem-train-* \
+    --corpus_max_lines=12345 \
+    --output_filename=$DATA_DIR/my_problem.subword_text_encoder \
+    --logtostderr
+
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.data_generators import tokenizer
+
+import tensorflow.compat.v1 as tf
+
+tf.flags.DEFINE_string('output_filename', '/tmp/my.subword_text_encoder',
+                       'where to store the SubwordTextEncoder')
+tf.flags.DEFINE_string('corpus_filepattern', '',
+                       'Corpus of one or more text files')
+tf.flags.DEFINE_string('vocab_filepattern', '', 'One or more vocabulary files '
+                       '(one word per line as "word,count")')
+tf.flags.DEFINE_integer('min_count', 5, 'Minimum subtoken count in corpus')
+tf.flags.DEFINE_integer('corpus_max_lines', 10000,
+                        'How many lines of corpus to read')
+tf.flags.DEFINE_integer('num_iterations', 4, 'Number of iterations')
+tf.flags.DEFINE_bool('split_on_newlines', True, 'Break corpus into lines.')
+FLAGS = tf.flags.FLAGS
+
+
+def main(unused_argv):
+  if FLAGS.corpus_filepattern and FLAGS.vocab_filepattern:
+    raise ValueError(
+        'Must only provide one of --corpus_filepattern or --vocab_filepattern')
+
+  elif FLAGS.corpus_filepattern:
+    token_counts = tokenizer.corpus_token_counts(
+        FLAGS.corpus_filepattern,
+        FLAGS.corpus_max_lines,
+        split_on_newlines=FLAGS.split_on_newlines)
+
+  elif FLAGS.vocab_filepattern:
+    token_counts = tokenizer.vocab_token_counts(FLAGS.vocab_filepattern,
+                                                FLAGS.corpus_max_lines)
+
+  else:
+    raise ValueError(
+        'Must provide one of --corpus_filepattern or --vocab_filepattern')
+
+  encoder = text_encoder.SubwordTextEncoder()
+  encoder.build_from_token_counts(token_counts, FLAGS.min_count,
+                                  FLAGS.num_iterations)
+  encoder.store_to_file(FLAGS.output_filename)
+
+
+if __name__ == '__main__':
+  tf.app.run()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/tokenizer.py

@@ -0,0 +1,194 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A simple invertible tokenizer.
+
+Converts from a unicode string to a list of tokens
+(represented as Unicode strings).
+
+This tokenizer has the following desirable properties:
+ - It is invertible.
+ - Alphanumeric characters are broken away from non-alphanumeric characters.
+ - A single space between words does not produce an extra token.
+ - The full Unicode punctuation and separator set is recognized.
+
+The tokenization algorithm is as follows:
+
+1.  Split the text into a list of tokens, splitting at every boundary of an
+    alphanumeric character and a non-alphanumeric character.  This produces
+    a list which alternates between "alphanumeric tokens"
+    (strings of alphanumeric characters) and "non-alphanumeric tokens"
+    (strings of non-alphanumeric characters).
+
+2.  Remove every token consisting of a single space, unless it is
+    the very first or very last token in the list.  These tokens are now
+    implied by the fact that there are two adjacent alphanumeric tokens.
+
+e.g.  u"Dude - that's so cool."
+        -> [u"Dude", u" - ", u"that", u"'", u"s", u"so", u"cool", u"."]
+"""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import collections
+import sys
+import unicodedata
+import six
+from six.moves import range  # pylint: disable=redefined-builtin
+import tensorflow.compat.v1 as tf
+
+# Conversion between Unicode and UTF-8, if required (on Python2)
+_native_to_unicode = (lambda s: s.decode("utf-8")) if six.PY2 else (lambda s: s)
+
+
+# This set contains all letter and number characters.
+_ALPHANUMERIC_CHAR_SET = set(
+    six.unichr(i) for i in range(sys.maxunicode)
+    if (unicodedata.category(six.unichr(i)).startswith("L") or
+        unicodedata.category(six.unichr(i)).startswith("N")))
+
+
+def encode(text):
+  """Encode a unicode string as a list of tokens.
+
+  Args:
+    text: a unicode string
+  Returns:
+    a list of tokens as Unicode strings
+  """
+  if not text:
+    return []
+  ret = []
+  token_start = 0
+  # Classify each character in the input string
+  is_alnum = [c in _ALPHANUMERIC_CHAR_SET for c in text]
+  for pos in range(1, len(text)):
+    if is_alnum[pos] != is_alnum[pos - 1]:
+      token = text[token_start:pos]
+      if token != u" " or token_start == 0:
+        ret.append(token)
+      token_start = pos
+  final_token = text[token_start:]
+  ret.append(final_token)
+  return ret
+
+
+def decode(tokens):
+  """Decode a list of tokens to a unicode string.
+
+  Args:
+    tokens: a list of Unicode strings
+  Returns:
+    a unicode string
+  """
+  token_is_alnum = [t[0] in _ALPHANUMERIC_CHAR_SET for t in tokens]
+  ret = []
+  for i, token in enumerate(tokens):
+    if i > 0 and token_is_alnum[i - 1] and token_is_alnum[i]:
+      ret.append(u" ")
+    ret.append(token)
+  return "".join(ret)
+
+
+def _read_filepattern(filepattern, max_lines=None, split_on_newlines=True):
+  """Reads files matching a wildcard pattern, yielding the contents.
+
+  Args:
+    filepattern: A wildcard pattern matching one or more files.
+    max_lines: If set, stop reading after reading this many lines.
+    split_on_newlines: A boolean. If true, then split files by lines and strip
+        leading and trailing whitespace from each line. Otherwise, treat each
+        file as a single string.
+
+  Yields:
+    The contents of the files as lines, if split_on_newlines is True, or
+    the entire contents of each file if False.
+  """
+  filenames = sorted(tf.gfile.Glob(filepattern))
+  lines_read = 0
+  for filename in filenames:
+    with tf.gfile.Open(filename) as f:
+      if split_on_newlines:
+        for line in f:
+          yield line.strip()
+          lines_read += 1
+          if max_lines and lines_read >= max_lines:
+            return
+
+      else:
+        if max_lines:
+          doc = []
+          for line in f:
+            doc.append(line)
+            lines_read += 1
+            if max_lines and lines_read >= max_lines:
+              yield "".join(doc)
+              return
+          yield "".join(doc)
+
+        else:
+          yield f.read()
+
+
+def corpus_token_counts(
+    text_filepattern, corpus_max_lines, split_on_newlines=True):
+  """Read the corpus and compute a dictionary of token counts.
+
+  Args:
+    text_filepattern: A pattern matching one or more files.
+    corpus_max_lines: An integer; maximum total lines to read.
+    split_on_newlines: A boolean. If true, then split files by lines and strip
+        leading and trailing whitespace from each line. Otherwise, treat each
+        file as a single string.
+
+  Returns:
+    a dictionary mapping token to count.
+  """
+  counts = collections.Counter()
+  for doc in _read_filepattern(
+      text_filepattern,
+      max_lines=corpus_max_lines,
+      split_on_newlines=split_on_newlines):
+    counts.update(encode(_native_to_unicode(doc)))
+
+  return counts
+
+
+def vocab_token_counts(text_filepattern, max_lines):
+  """Read a vocab file and return a dictionary of token counts.
+
+  Reads a two-column CSV file of tokens and their frequency in a dataset. The
+  tokens are presumed to be generated by encode() or the equivalent.
+
+  Args:
+    text_filepattern: A pattern matching one or more files.
+    max_lines: An integer; maximum total lines to read.
+
+  Returns:
+    a dictionary mapping token to count.
+  """
+  ret = {}
+  for i, line in enumerate(
+      _read_filepattern(text_filepattern, max_lines=max_lines)):
+    if "," not in line:
+      tf.logging.warning("Malformed vocab line #%d '%s'", i, line)
+      continue
+
+    token, count = line.rsplit(",", 1)
+    ret[_native_to_unicode(token)] = int(count)
+
+  return ret

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_encs.py

@@ -0,0 +1,99 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for translation data-sets."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+
+# End-of-sentence marker.
+EOS = text_encoder.EOS_ID
+
+_ENCS_TRAIN_DATASETS = [
+    [("https://lindat.mff.cuni.cz/repository/xmlui/bitstream/handle/"
+      "11234/1-1458/data-plaintext-format.tar"),
+     ("tsv", 3, 2, "data.plaintext-format/*train.gz")],
+    [
+        "http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz",  # pylint: disable=line-too-long
+        ("training-parallel-nc-v13/news-commentary-v13.cs-en.en",
+         "training-parallel-nc-v13/news-commentary-v13.cs-en.cs")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz",
+        ("commoncrawl.cs-en.en", "commoncrawl.cs-en.cs")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz",
+        ("training/europarl-v7.cs-en.en", "training/europarl-v7.cs-en.cs")
+    ],
+]
+_ENCS_TEST_DATASETS = [
+    [
+        "http://data.statmt.org/wmt17/translation-task/dev.tgz",
+        ("dev/newstest2013.en", "dev/newstest2013.cs")
+    ],
+]
+
+
+@registry.register_problem
+class TranslateEncsWmt32k(translate.TranslateProblem):
+  """Problem spec for WMT English-Czech translation."""
+
+  @property
+  def approx_vocab_size(self):
+    return 2**15  # 32768
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    return _ENCS_TRAIN_DATASETS if train else _ENCS_TEST_DATASETS
+
+  def vocab_data_files(self):
+    datasets = self.source_data_files(problem.DatasetSplit.TRAIN)
+    vocab_datasets = []
+    if datasets[0][0].endswith("data-plaintext-format.tar"):
+      vocab_datasets.append([
+          datasets[0][0], [
+              "%s-compiled-train.lang1" % self.name,
+              "%s-compiled-train.lang2" % self.name
+          ]
+      ])
+      datasets = datasets[1:]
+    vocab_datasets += [[item[0], [item[1][0], item[1][1]]] for item in datasets]
+    return vocab_datasets
+
+
+@registry.register_problem
+class TranslateEncsWmtCharacters(translate.TranslateProblem):
+  """Problem spec for WMT En-Cs character-based translation."""
+
+  @property
+  def vocab_type(self):
+    return text_problems.VocabType.CHARACTER
+
+  def generate_samples(self, data_dir, tmp_dir, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    datasets = _ENCS_TRAIN_DATASETS if train else _ENCS_TEST_DATASETS
+    tag = "train" if train else "dev"
+    data_path = translate.compile_data(tmp_dir, datasets,
+                                       "wmt_encs_chr_%s" % tag)
+    return text_problems.text2text_txt_iterator(data_path + ".lang1",
+                                                data_path + ".lang2")

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_ende.py

@@ -0,0 +1,218 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for translation data-sets."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+
+_ENDE_TRAIN_DATASETS = [
+    [
+        "http://data.statmt.org/wmt18/translation-task/training-parallel-nc-v13.tgz",  # pylint: disable=line-too-long
+        ("training-parallel-nc-v13/news-commentary-v13.de-en.en",
+         "training-parallel-nc-v13/news-commentary-v13.de-en.de")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz",
+        ("commoncrawl.de-en.en", "commoncrawl.de-en.de")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz",
+        ("training/europarl-v7.de-en.en", "training/europarl-v7.de-en.de")
+    ],
+]
+
+_ENDE_EVAL_DATASETS = [
+    [
+        "http://data.statmt.org/wmt17/translation-task/dev.tgz",
+        ("dev/newstest2013.en", "dev/newstest2013.de")
+    ],
+]
+
+_ENDE_RAPID_TRAIN_DATASET = [
+    # additional training data available for WMT 18 news task training data
+    # as defined by http://www.statmt.org/wmt18/translation-task.html
+    [
+        "http://data.statmt.org/wmt18/translation-task/rapid2016.tgz",
+        ("rapid2016.de-en.en", "rapid2016.de-en.de"),
+    ],
+]
+
+_ENDE_PARACRAWL_DATASETS = [
+    [
+        "https://s3.amazonaws.com/web-language-models/paracrawl/release4/en-de.bicleaner07.tmx.gz",  # pylint: disable=line-too-long
+        ("tmx", "en-de.bicleaner07.tmx.gz")
+    ]
+]
+
+
+@registry.register_problem
+class TranslateEndeWmt32k(translate.TranslateProblem):
+  """En-de translation trained on WMT corpus."""
+
+  @property
+  def additional_training_datasets(self):
+    """Allow subclasses to add training datasets."""
+    return []
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    train_datasets = _ENDE_TRAIN_DATASETS + self.additional_training_datasets
+    return train_datasets if train else _ENDE_EVAL_DATASETS
+
+
+@registry.register_problem
+class TranslateEnde2018Wmt32k(translate.TranslateProblem):
+  """En-de translation trained on WMT18 corpus."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt32k()
+
+  @property
+  def additional_training_datasets(self):
+    """WMT18 adds rapid data."""
+    return _ENDE_RAPID_TRAIN_DATASET
+
+
+@registry.register_problem
+class TranslateEndeWmtClean32k(TranslateEndeWmt32k):
+  """En-de translation trained on WMT with further cleaning."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt32k()
+
+  @property
+  def datatypes_to_clean(self):
+    return ["txt"]
+
+
+@registry.register_problem
+class TranslateEndePc32k(translate.TranslateProblem):
+  """En-de translation trained on Paracrawl (bicleaner corpus)."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt32k()
+
+  @property
+  def additional_training_datasets(self):
+    """Allow subclasses to add training datasets."""
+    return []
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    train_datasets = (
+        _ENDE_PARACRAWL_DATASETS + self.additional_training_datasets)
+    return train_datasets if train else _ENDE_EVAL_DATASETS
+
+
+@registry.register_problem
+class TranslateEndePcClean32k(TranslateEndePc32k):
+  """En-de translation trained on Paracrawl with further cleaning."""
+
+  @property
+  def datatypes_to_clean(self):
+    return ["tmx"]
+
+
+@registry.register_problem
+class TranslateEndeWmtPc32k(TranslateEndeWmt32k):
+  """En-de translation trained on WMT plus Paracrawl."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt32k()
+
+  @property
+  def additional_training_datasets(self):
+    return _ENDE_PARACRAWL_DATASETS
+
+
+@registry.register_problem
+class TranslateEndeWmtCleanPc32k(TranslateEndeWmtPc32k):
+  """En-de translation trained on cleaned WMT plus Paracrawl."""
+
+  @property
+  def datatypes_to_clean(self):
+    return ["txt"]
+
+
+@registry.register_problem
+class TranslateEndeWmtPcClean32k(TranslateEndeWmtPc32k):
+  """En-de translation trained on WMT plus cleaned Paracrawl."""
+
+  @property
+  def datatypes_to_clean(self):
+    return ["tmx"]
+
+
+@registry.register_problem
+class TranslateEndeWmtCleanPcClean32k(TranslateEndeWmtPcClean32k):
+  """En-de translation trained on cleaned WMT plus cleaned Paracrawl."""
+
+  @property
+  def datatypes_to_clean(self):
+    return ["txt", "tmx"]
+
+
+@registry.register_problem
+class TranslateEndeWmt32kPacked(TranslateEndeWmt32k):
+
+  @property
+  def packed_length(self):
+    return 256
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt32k()
+
+
+@registry.register_problem
+class TranslateEndeWmt8k(TranslateEndeWmt32k):
+  """Problem spec for WMT En-De translation."""
+
+  @property
+  def approx_vocab_size(self):
+    return 2**13  # 8192
+
+
+@registry.register_problem
+class TranslateEndeWmt8kPacked(TranslateEndeWmt8k):
+
+  @property
+  def packed_length(self):
+    return 256
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEndeWmt8k()
+
+
+@registry.register_problem
+class TranslateEndeWmtCharacters(TranslateEndeWmt8k):
+  """Problem spec for WMT En-De translation."""
+
+  @property
+  def vocab_type(self):
+    return text_problems.VocabType.CHARACTER

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_enfr.py

@@ -0,0 +1,235 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for translation data-sets."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+
+# End-of-sentence marker.
+EOS = text_encoder.EOS_ID
+
+_ENFR_TRAIN_SMALL_DATA = [
+    [
+        "https://s3.amazonaws.com/opennmt-trainingdata/baseline-1M-enfr.tgz",
+        ("baseline-1M-enfr/baseline-1M_train.en",
+         "baseline-1M-enfr/baseline-1M_train.fr")
+    ],
+]
+_ENFR_TEST_SMALL_DATA = [
+    [
+        "https://s3.amazonaws.com/opennmt-trainingdata/baseline-1M-enfr.tgz",
+        ("baseline-1M-enfr/baseline-1M_valid.en",
+         "baseline-1M-enfr/baseline-1M_valid.fr")
+    ],
+]
+_ENFR_TRAIN_LARGE_DATA = [
+    [
+        "http://www.statmt.org/wmt13/training-parallel-commoncrawl.tgz",
+        ("commoncrawl.fr-en.en", "commoncrawl.fr-en.fr")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-europarl-v7.tgz",
+        ("training/europarl-v7.fr-en.en", "training/europarl-v7.fr-en.fr")
+    ],
+    [
+        "http://www.statmt.org/wmt14/training-parallel-nc-v9.tgz",
+        ("training/news-commentary-v9.fr-en.en",
+         "training/news-commentary-v9.fr-en.fr")
+    ],
+    [
+        "http://www.statmt.org/wmt10/training-giga-fren.tar",
+        ("giga-fren.release2.fixed.en.gz",
+         "giga-fren.release2.fixed.fr.gz")
+    ],
+    [
+        "http://www.statmt.org/wmt13/training-parallel-un.tgz",
+        ("un/undoc.2000.fr-en.en", "un/undoc.2000.fr-en.fr")
+    ],
+]
+_ENFR_TEST_LARGE_DATA = [
+    [
+        "http://data.statmt.org/wmt17/translation-task/dev.tgz",
+        ("dev/newstest2013.en", "dev/newstest2013.fr")
+    ],
+]
+
+
+@registry.register_problem
+class TranslateEnfrWmtSmall8k(translate.TranslateProblem):
+  """Problem spec for WMT En-Fr translation."""
+
+  @property
+  def approx_vocab_size(self):
+    return 2**13  # 8192
+
+  @property
+  def use_small_dataset(self):
+    return True
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    if self.use_small_dataset:
+      datasets = _ENFR_TRAIN_SMALL_DATA if train else _ENFR_TEST_SMALL_DATA
+    else:
+      datasets = _ENFR_TRAIN_LARGE_DATA if train else _ENFR_TEST_LARGE_DATA
+    return datasets
+
+  def vocab_data_files(self):
+    return (_ENFR_TRAIN_SMALL_DATA if self.use_small_dataset
+            else _ENFR_TRAIN_LARGE_DATA)
+
+
+@registry.register_problem
+class TranslateEnfrWmtSmall32k(TranslateEnfrWmtSmall8k):
+
+  @property
+  def approx_vocab_size(self):
+    return 2**15  # 32768
+
+
+@registry.register_problem
+class TranslateEnfrWmt8k(TranslateEnfrWmtSmall8k):
+
+  @property
+  def use_small_dataset(self):
+    return False
+
+
+@registry.register_problem
+class TranslateEnfrWmt32k(TranslateEnfrWmtSmall32k):
+
+  @property
+  def use_small_dataset(self):
+    return False
+
+
+@registry.register_problem
+class TranslateEnfrWmt32kPacked(TranslateEnfrWmt32k):
+
+  @property
+  def packed_length(self):
+    return 256
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEnfrWmt32k()
+
+
+@registry.register_problem
+class TranslateEnfrWmt32kWithBacktranslateFr(TranslateEnfrWmt32k):
+  """En-Fr translation with added French data, back-translated."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return TranslateEnfrWmt32k()
+
+  @property
+  def already_shuffled(self):
+    return True
+
+  @property
+  def skip_random_fraction_when_training(self):
+    return False
+
+  @property
+  def backtranslate_data_filenames(self):
+    """List of pairs of files with matched back-translated data."""
+    # Files must be placed in tmp_dir, each similar size to authentic data.
+    return [("fr_mono_en.txt", "fr_mono_fr.txt")]
+
+  @property
+  def dataset_splits(self):
+    """Splits of data to produce and number of output shards for each."""
+    return [{
+        "split": problem.DatasetSplit.TRAIN,
+        "shards": 1,  # Use just 1 shard so as to not mix data.
+    }, {
+        "split": problem.DatasetSplit.EVAL,
+        "shards": 1,
+    }]
+
+  def generate_samples(self, data_dir, tmp_dir, dataset_split):
+    datasets = self.source_data_files(dataset_split)
+    tag = "train" if dataset_split == problem.DatasetSplit.TRAIN else "dev"
+    data_path = translate.compile_data(
+        tmp_dir, datasets, "%s-compiled-%s" % (self.name, tag))
+    # For eval, use authentic data.
+    if dataset_split != problem.DatasetSplit.TRAIN:
+      for example in text_problems.text2text_txt_iterator(
+          data_path + ".lang1", data_path + ".lang2"):
+        yield example
+    else:  # For training, mix synthetic and authentic data as follows.
+      for (file1, file2) in self.backtranslate_data_filenames:
+        path1 = os.path.join(tmp_dir, file1)
+        path2 = os.path.join(tmp_dir, file2)
+        # Synthetic data first.
+        for example in text_problems.text2text_txt_iterator(path1, path2):
+          yield example
+        # Now authentic data.
+        for example in text_problems.text2text_txt_iterator(
+            data_path + ".lang1", data_path + ".lang2"):
+          yield example
+
+
+@registry.register_problem
+class TranslateEnfrWmt32kWithBacktranslateEn(
+    TranslateEnfrWmt32kWithBacktranslateFr):
+  """En-Fr translation with added English data, back-translated."""
+
+  @property
+  def backtranslate_data_filenames(self):
+    """List of pairs of files with matched back-translated data."""
+    # Files must be placed in tmp_dir, each similar size to authentic data.
+    return [("en_mono_en.txt%d" % i, "en_mono_fr.txt%d" % i) for i in [0, 1, 2]]
+
+
+@registry.register_problem
+class TranslateEnfrWmtSmallCharacters(translate.TranslateProblem):
+  """Problem spec for WMT En-Fr translation."""
+
+  @property
+  def vocab_type(self):
+    return text_problems.VocabType.CHARACTER
+
+  @property
+  def use_small_dataset(self):
+    return True
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    if self.use_small_dataset:
+      datasets = _ENFR_TRAIN_SMALL_DATA if train else _ENFR_TEST_SMALL_DATA
+    else:
+      datasets = _ENFR_TRAIN_LARGE_DATA if train else _ENFR_TEST_LARGE_DATA
+    return datasets
+
+
+@registry.register_problem
+class TranslateEnfrWmtCharacters(TranslateEnfrWmtSmallCharacters):
+
+  @property
+  def use_small_dataset(self):
+    return False

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_enro.py

@@ -0,0 +1,142 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for translation data-sets."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import random
+
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+
+_ENRO_TRAIN_DATASETS = [
+    [
+        "http://www.statmt.org/europarl/v7/ro-en.tgz",
+        ("europarl-v7.ro-en.en", "europarl-v7.ro-en.ro")
+    ],
+    [
+        "http://opus.nlpl.eu/download.php?f=SETIMES/v2/moses/en-ro.txt.zip",
+        ("SETIMES.en-ro.en", "SETIMES.en-ro.ro")
+    ]
+]
+_ENRO_TEST_DATASETS = [
+    [
+        ("http://data.statmt.org/wmt16/translation-task/"
+         "dev-romanian-updated.tgz"),
+        ("dev/newsdev2016-roen-ref.en.sgm", "dev/newsdev2016-roen-src.ro.sgm")
+    ],
+]
+
+
+@registry.register_problem
+class TranslateEnroWmt8k(translate.TranslateProblem):
+  """Problem spec for WMT En-Ro translation."""
+
+  @property
+  def approx_vocab_size(self):
+    return 2**13  # 8192
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    return _ENRO_TRAIN_DATASETS if train else _ENRO_TEST_DATASETS
+
+
+@registry.register_problem
+class TranslateEnroWmt32k(TranslateEnroWmt8k):
+
+  @property
+  def approx_vocab_size(self):
+    return 2**15  # 32768
+
+
+@registry.register_problem
+class TranslateEnroWmtCharacters(TranslateEnroWmt8k):
+  """Problem spec for WMT En-Ro translation."""
+
+  @property
+  def vocab_type(self):
+    return text_problems.VocabType.CHARACTER
+
+
+@registry.register_problem
+class TranslateEnroWmtMulti64k(TranslateEnroWmt8k):
+  """Translation with muli-lingual vocabulary."""
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return wiki_lm.LanguagemodelDeEnFrRoWiki64k()
+
+
+@registry.register_problem
+class TranslateEnroWmtMultiSmall64k(TranslateEnroWmt8k):
+  """Translation with muli-lingual vocabulary, small (6K) training data."""
+
+  @property
+  def dataset_splits(self):
+    """Splits of data to produce and number of output shards for each."""
+    return [{
+        "split": problem.DatasetSplit.TRAIN,
+        "shards": 16,  # It's a small dataset, TPUs like at least a few shards.
+    }, {
+        "split": problem.DatasetSplit.EVAL,
+        "shards": 1,
+    }]
+
+  @property
+  def use_vocab_from_other_problem(self):
+    return wiki_lm.LanguagemodelDeEnFrRoWiki64k()
+
+  @property
+  def how_many_examples_to_sample(self):
+    return 6000
+
+  def generate_samples(self, data_dir, tmp_dir, dataset_split):
+    """Generate just the first 6k samples for training."""
+    # If not training, do the same as before.
+    if dataset_split != problem.DatasetSplit.TRAIN:
+      for x in super(TranslateEnroWmtMultiSmall64k, self).generate_samples(
+          data_dir, tmp_dir, dataset_split):
+        yield x
+      raise StopIteration
+    # Now we assume we're training.
+    counter = 0
+    # The size of this data-set in total is around 614K, we want to sample so
+    # that in expectation we take the requested number of samples in 1 go.
+    sample_prob = self.how_many_examples_to_sample / float(614000)
+    # Let's sample.
+    for x in super(TranslateEnroWmtMultiSmall64k, self).generate_samples(
+        data_dir, tmp_dir, dataset_split):
+      if random.random() > sample_prob:
+        continue
+      counter += 1
+      if counter > self.how_many_examples_to_sample:
+        raise StopIteration
+      yield x
+    # We do it again if we don't have enough samples.
+    if counter < self.how_many_examples_to_sample:
+      for x in super(TranslateEnroWmtMultiSmall64k, self).generate_samples(
+          data_dir, tmp_dir, dataset_split):
+        if random.random() > sample_prob:
+          continue
+        counter += 1
+        if counter > self.how_many_examples_to_sample:
+          raise StopIteration
+        yield x

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_envi.py

@@ -0,0 +1,58 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for En-Vi translation."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+# End-of-sentence marker.
+EOS = text_encoder.EOS_ID
+
+# For English-Vietnamese the IWSLT'15 corpus
+# from https://nlp.stanford.edu/projects/nmt/ is used.
+# The original dataset has 133K parallel sentences.
+_ENVI_TRAIN_DATASETS = [[
+    "https://github.com/stefan-it/nmt-en-vi/raw/master/data/train-en-vi.tgz",  # pylint: disable=line-too-long
+    ("train.en", "train.vi")
+]]
+
+# For development 1,553 parallel sentences are used.
+_ENVI_TEST_DATASETS = [[
+    "https://github.com/stefan-it/nmt-en-vi/raw/master/data/dev-2012-en-vi.tgz",  # pylint: disable=line-too-long
+    ("tst2012.en", "tst2012.vi")
+]]
+
+
+# See this PR on github for some results with Transformer on this Problem.
+# https://github.com/tensorflow/tensor2tensor/pull/611
+
+
+@registry.register_problem
+class TranslateEnviIwslt32k(translate.TranslateProblem):
+  """Problem spec for IWSLT'15 En-Vi translation."""
+
+  @property
+  def approx_vocab_size(self):
+    return 2**15  # 32768
+
+  def source_data_files(self, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    return _ENVI_TRAIN_DATASETS if train else _ENVI_TEST_DATASETS

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/data_generators/translate_enzh.py

@@ -0,0 +1,280 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Data generators for translation data-sets."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+from TensorFlow.nlp.transformer.data_generators import generator_utils
+from TensorFlow.nlp.transformer.data_generators import problem
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.data_generators import text_problems
+from TensorFlow.nlp.transformer.data_generators import translate
+from TensorFlow.nlp.transformer.utils import registry
+
+import tensorflow.compat.v1 as tf
+
+
+# End-of-sentence marker.
+EOS = text_encoder.EOS_ID
+
+# This is far from being the real WMT18 task - only toyset here
+# you need to register to get UN data and CWT data. Also, by convention,
+# this is EN to ZH - use translate_enzh_wmt8k_rev for ZH to EN task
+#
+# News Commentary, around 252k lines
+# This dataset is only a small fraction of full WMT18 task
+_STAT_MT_URL = "http://data.statmt.org/wmt18/translation-task/"
+_NC_TRAIN_DATASETS = [[
+    _STAT_MT_URL + "training-parallel-nc-v13.tgz", [
+        "training-parallel-nc-v13/news-commentary-v13.zh-en.en",
+        "training-parallel-nc-v13/news-commentary-v13.zh-en.zh"
+    ]
+]]
+
+# Test set from News Commentary. 2000 lines
+_NC_TEST_DATASETS = [[
+    _STAT_MT_URL + "dev.tgz",
+    ("dev/newsdev2017-enzh-src.en.sgm", "dev/newsdev2017-enzh-ref.zh.sgm")
+]]
+
+# UN parallel corpus. 15,886,041 lines
+# Visit source website to download manually:
+# https://conferences.unite.un.org/UNCorpus
+#
+# NOTE: You need to register to download dataset from official source
+# place into tmp directory e.g. /tmp/t2t_datagen/dataset.tgz
+_UN_TRAIN_DATASETS = [[
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/UNv1.0.en-zh.tar"
+    ".gz", ["en-zh/UNv1.0.en-zh.en", "en-zh/UNv1.0.en-zh.zh"]
+]]
+
+# CWMT corpus
+# Visit source website to download manually:
+# http://nlp.nju.edu.cn/cwmt-wmt/
+#
+# casia2015: 1,050,000 lines
+# casict2015: 2,036,833 lines
+# datum2015:  1,000,003 lines
+# datum2017: 1,999,968 lines
+# NEU2017:  2,000,000 lines
+#
+# NOTE: You need to register to download dataset from official source
+# place into tmp directory e.g. /tmp/t2t_datagen/dataset.tgz
+
+_CWMT_TRAIN_DATASETS = [[
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/casia2015/casia2015_en.txt", "cwmt/casia2015/casia2015_ch.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/casict2015/casict2015_en.txt", "cwmt/casict2015/casict2015_ch.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/neu2017/NEU_en.txt", "cwmt/neu2017/NEU_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2015/datum_en.txt", "cwmt/datum2015/datum_ch.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book1_en.txt", "cwmt/datum2017/Book1_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book2_en.txt", "cwmt/datum2017/Book2_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book3_en.txt", "cwmt/datum2017/Book3_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book4_en.txt", "cwmt/datum2017/Book4_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book5_en.txt", "cwmt/datum2017/Book5_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book6_en.txt", "cwmt/datum2017/Book6_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book7_en.txt", "cwmt/datum2017/Book7_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book8_en.txt", "cwmt/datum2017/Book8_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book9_en.txt", "cwmt/datum2017/Book9_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book10_en.txt", "cwmt/datum2017/Book10_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book11_en.txt", "cwmt/datum2017/Book11_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book12_en.txt", "cwmt/datum2017/Book12_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book13_en.txt", "cwmt/datum2017/Book13_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book14_en.txt", "cwmt/datum2017/Book14_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book15_en.txt", "cwmt/datum2017/Book15_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book16_en.txt", "cwmt/datum2017/Book16_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book17_en.txt", "cwmt/datum2017/Book17_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book18_en.txt", "cwmt/datum2017/Book18_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book19_en.txt", "cwmt/datum2017/Book19_cn.txt"]
+], [
+    "https://s3-us-west-2.amazonaws.com/twairball.wmt17.zh-en/cwmt.tgz",
+    ["cwmt/datum2017/Book20_en.txt", "cwmt/datum2017/Book20_cn.txt"]
+]]
+
+
+def get_filename(dataset):
+  return dataset[0][0].split("/")[-1]
+
+
+@registry.register_problem
+class TranslateEnzhWmt32k(translate.TranslateProblem):
+  """Problem spec for WMT En-Zh translation.
+
+  Attempts to use full training dataset, which needs website
+  registration and downloaded manually from official sources:
+
+  CWMT:
+    - http://nlp.nju.edu.cn/cwmt-wmt/
+    - Website contains instructions for FTP server access.
+    - You'll need to download CASIA, CASICT, DATUM2015, DATUM2017,
+        NEU datasets
+
+  UN Parallel Corpus:
+    - https://conferences.unite.un.org/UNCorpus
+    - You'll need to register your to download the dataset.
+
+  NOTE: place into tmp directory e.g. /tmp/t2t_datagen/dataset.tgz
+  """
+
+  @property
+  def approx_vocab_size(self):
+    return 2**15  # 32k
+
+  @property
+  def source_vocab_name(self):
+    return "%s.en" % self.vocab_filename
+
+  @property
+  def target_vocab_name(self):
+    return "%s.zh" % self.vocab_filename
+
+  def get_training_dataset(self, tmp_dir):
+    """UN Parallel Corpus and CWMT Corpus need to be downloaded manually.
+
+    Append to training dataset if available
+
+    Args:
+      tmp_dir: path to temporary dir with the data in it.
+
+    Returns:
+      paths
+    """
+    full_dataset = _NC_TRAIN_DATASETS
+    for dataset in [_CWMT_TRAIN_DATASETS, _UN_TRAIN_DATASETS]:
+      filename = get_filename(dataset)
+      tmp_filepath = os.path.join(tmp_dir, filename)
+      if tf.gfile.Exists(tmp_filepath):
+        full_dataset += dataset
+      else:
+        tf.logging.info("[TranslateEzhWmt] dataset incomplete, you need to "
+                        "manually download %s" % filename)
+    return full_dataset
+
+  def generate_encoded_samples(self, data_dir, tmp_dir, dataset_split):
+    train = dataset_split == problem.DatasetSplit.TRAIN
+    train_dataset = self.get_training_dataset(tmp_dir)
+    datasets = train_dataset if train else _NC_TEST_DATASETS
+    source_datasets = [[item[0], [item[1][0]]] for item in train_dataset]
+    target_datasets = [[item[0], [item[1][1]]] for item in train_dataset]
+    source_vocab = generator_utils.get_or_generate_vocab(
+        data_dir,
+        tmp_dir,
+        self.source_vocab_name,
+        self.approx_vocab_size,
+        source_datasets,
+        file_byte_budget=1e8,
+        max_subtoken_length=self.max_subtoken_length)
+    target_vocab = generator_utils.get_or_generate_vocab(
+        data_dir,
+        tmp_dir,
+        self.target_vocab_name,
+        self.approx_vocab_size,
+        target_datasets,
+        file_byte_budget=1e8,
+        max_subtoken_length=self.max_subtoken_length)
+    tag = "train" if train else "dev"
+    filename_base = "wmt_enzh_%sk_tok_%s" % (self.approx_vocab_size, tag)
+    data_path = translate.compile_data(tmp_dir, datasets, filename_base)
+    return text_problems.text2text_generate_encoded(
+        text_problems.text2text_txt_iterator(data_path + ".lang1",
+                                             data_path + ".lang2"),
+        source_vocab, target_vocab)
+
+  def feature_encoders(self, data_dir):
+    source_vocab_filename = os.path.join(data_dir, self.source_vocab_name)
+    target_vocab_filename = os.path.join(data_dir, self.target_vocab_name)
+    source_token = text_encoder.SubwordTextEncoder(source_vocab_filename)
+    target_token = text_encoder.SubwordTextEncoder(target_vocab_filename)
+    return {
+        "inputs": source_token,
+        "targets": target_token,
+    }
+
+
+@registry.register_problem
+class TranslateEnzhWmt8k(TranslateEnzhWmt32k):
+  """Problem spec for WMT En-Zh translation.
+
+  This is far from being the real WMT17 task - only toyset here
+  """
+
+  @property
+  def approx_vocab_size(self):
+    return 2**13  # 8192
+
+  @property
+  def dataset_splits(self):
+    return [
+        {
+            "split": problem.DatasetSplit.TRAIN,
+            "shards": 10,  # this is a small dataset
+        },
+        {
+            "split": problem.DatasetSplit.EVAL,
+            "shards": 1,
+        }
+    ]
+
+  def get_training_dataset(self, tmp_dir):
+    """Uses only News Commentary Dataset for training."""
+    return _NC_TRAIN_DATASETS

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/datagen.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+###############################################################################
+# Copyright (C) 2021 Habana Labs, Ltd. an Intel Company
+###############################################################################
+# Changes:
+# - added shebang
+# - organized imports
+# - removed unsupported problem generators
+# - renamed from t2t_datagen.py to datagen.py
+
+"""Produces the training and dev data for --problem into --data_dir.
+
+Produces sharded and shuffled TFRecord files of tensorflow.Example protocol
+buffers for a variety of registered datasets.
+
+All Problems are registered with @registry.register_problem or are in
+_SUPPORTED_PROBLEM_GENERATORS in this file. Each entry maps a string name
+(selectable on the command-line with --problem) to a function that takes 2
+arguments - input_directory and mode (one of "train" or "dev") - and yields for
+each training example a dictionary mapping string feature names to lists of
+{string, int, float}. The generator will be run once for each mode.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import multiprocessing
+import os
+import random
+import tempfile
+
+import numpy as np
+
+from TensorFlow.nlp.transformer.utils import problems as problems_lib  # pylint: disable=unused-import
+from TensorFlow.nlp.transformer.data_generators import generator_utils
+from TensorFlow.nlp.transformer.utils import registry
+from TensorFlow.nlp.transformer.utils import usr_dir
+
+# Improrting here to prevent pylint from ungrouped-imports warning.
+import tensorflow.compat.v1 as tf  # pylint: disable=g-import-not-at-top
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+flags.DEFINE_string("data_dir", "", "Data directory.")
+flags.DEFINE_string("tmp_dir", "/tmp/t2t_datagen",
+                    "Temporary storage directory.")
+flags.DEFINE_string("problem", "",
+                    "The name of the problem to generate data for.")
+flags.DEFINE_string("exclude_problems", "",
+                    "Comma-separates list of problems to exclude.")
+flags.DEFINE_integer(
+    "num_shards", 0, "How many shards to use. Ignored for "
+    "registered Problems.")
+flags.DEFINE_integer("max_cases", 0,
+                     "Maximum number of cases to generate (unbounded if 0).")
+flags.DEFINE_integer(
+    "env_problem_max_env_steps", 0,
+    "Maximum number of steps to take for environment-based problems. "
+    "Actions are chosen randomly")
+flags.DEFINE_integer(
+    "env_problem_batch_size", 0,
+    "Number of environments to simulate for environment-based problems.")
+flags.DEFINE_bool("only_list", False,
+                  "If true, we only list the problems that will be generated.")
+flags.DEFINE_integer("random_seed", 429459, "Random seed to use.")
+flags.DEFINE_integer("task_id", -1, "For distributed data generation.")
+flags.DEFINE_integer("task_id_start", -1, "For distributed data generation.")
+flags.DEFINE_integer("task_id_end", -1, "For distributed data generation.")
+flags.DEFINE_integer(
+    "num_concurrent_processes", None,
+    "Applies only to problems for which multiprocess_generate=True.")
+flags.DEFINE_string(
+    "t2t_usr_dir", "", "Path to a Python module that will be imported. The "
+    "__init__.py file should include the necessary imports. "
+    "The imported files should contain registrations, "
+    "e.g. @registry.register_problem calls, that will then be "
+    "available to t2t-datagen.")
+flags.DEFINE_bool("with_padding", False, "If true dataset features will be padded")
+
+# Mapping from problems that we can generate data for to their generators.
+_SUPPORTED_PROBLEM_GENERATORS = {}
+
+
+def set_random_seed():
+  """Set the random seed from flag everywhere."""
+  tf.set_random_seed(FLAGS.random_seed)
+  random.seed(FLAGS.random_seed)
+  np.random.seed(FLAGS.random_seed)
+
+
+def main(_):
+  usr_dir.import_usr_dir(FLAGS.t2t_usr_dir)
+
+  # Calculate the list of problems to generate.
+  problems = sorted(
+      list(_SUPPORTED_PROBLEM_GENERATORS) + registry.list_base_problems() +
+      registry.list_env_problems())
+  for exclude in FLAGS.exclude_problems.split(","):
+    if exclude:
+      problems = [p for p in problems if exclude not in p]
+  if FLAGS.problem and FLAGS.problem[-1] == "*":
+    problems = [p for p in problems if p.startswith(FLAGS.problem[:-1])]
+  elif FLAGS.problem and "," in FLAGS.problem:
+    problems = [p for p in problems if p in FLAGS.problem.split(",")]
+  elif FLAGS.problem:
+    problems = [p for p in problems if p == FLAGS.problem]
+  else:
+    problems = []
+
+  # Remove TIMIT if paths are not given.
+  if getattr(FLAGS, "timit_paths", None):
+    problems = [p for p in problems if "timit" not in p]
+  # Remove parsing if paths are not given.
+  if getattr(FLAGS, "parsing_path", None):
+    problems = [p for p in problems if "parsing_english_ptb" not in p]
+
+  if not problems:
+    problems_str = "\n  * ".join(
+        sorted(
+            list(_SUPPORTED_PROBLEM_GENERATORS) +
+            registry.list_base_problems() + registry.list_env_problems()))
+    error_msg = ("You must specify one of the supported problems to "
+                 "generate data for:\n  * " + problems_str + "\n")
+    error_msg += ("TIMIT and parsing need data_sets specified with "
+                  "--timit_paths and --parsing_path.")
+    raise ValueError(error_msg)
+
+  if not FLAGS.data_dir:
+    FLAGS.data_dir = tempfile.gettempdir()
+    tf.logging.warning(
+        "It is strongly recommended to specify --data_dir. "
+        "Data will be written to default data_dir=%s.", FLAGS.data_dir)
+  FLAGS.data_dir = os.path.expanduser(FLAGS.data_dir)
+  tf.gfile.MakeDirs(FLAGS.data_dir)
+
+  tf.logging.info("Generating problems:\n%s" %
+                  registry.display_list_by_prefix(problems, starting_spaces=4))
+  if FLAGS.only_list:
+    return
+  for problem in problems:
+    set_random_seed()
+
+    if problem in _SUPPORTED_PROBLEM_GENERATORS:
+      generate_data_for_problem(problem)
+    elif problem in registry.list_base_problems():
+      generate_data_for_registered_problem(problem)
+    elif problem in registry.list_env_problems():
+      generate_data_for_env_problem(problem)
+    else:
+      tf.logging.error("Problem %s is not a supported problem for datagen.",
+                       problem)
+
+
+def generate_data_for_problem(problem):
+  """Generate data for a problem in _SUPPORTED_PROBLEM_GENERATORS."""
+  training_gen, dev_gen, test_gen = _SUPPORTED_PROBLEM_GENERATORS[problem]
+
+  num_train_shards = FLAGS.num_shards or 10
+  tf.logging.info("Generating training data for %s.", problem)
+  train_output_files = generator_utils.train_data_filenames(
+      problem + generator_utils.UNSHUFFLED_SUFFIX, FLAGS.data_dir,
+      num_train_shards)
+  generator_utils.generate_files(training_gen(), train_output_files,
+                                 FLAGS.max_cases)
+  num_dev_shards = int(num_train_shards * 0.1)
+  tf.logging.info("Generating development data for %s.", problem)
+  dev_output_files = generator_utils.dev_data_filenames(
+      problem + generator_utils.UNSHUFFLED_SUFFIX, FLAGS.data_dir,
+      num_dev_shards)
+  generator_utils.generate_files(dev_gen(), dev_output_files)
+  num_test_shards = int(num_train_shards * 0.1)
+  test_output_files = []
+  test_gen_data = test_gen()
+  if test_gen_data is not None:
+    tf.logging.info("Generating test data for %s.", problem)
+    test_output_files = generator_utils.test_data_filenames(
+        problem + generator_utils.UNSHUFFLED_SUFFIX, FLAGS.data_dir,
+        num_test_shards)
+    generator_utils.generate_files(test_gen_data, test_output_files)
+  all_output_files = train_output_files + dev_output_files + test_output_files
+  generator_utils.shuffle_dataset(all_output_files)
+
+
+def generate_data_in_process(arg):
+  problem_name, data_dir, tmp_dir, task_id = arg
+  problem = registry.problem(problem_name)
+  problem.generate_data(data_dir, tmp_dir, task_id)
+
+
+def generate_data_for_env_problem(problem_name):
+  """Generate data for `EnvProblem`s."""
+  assert FLAGS.env_problem_max_env_steps > 0, ("--env_problem_max_env_steps "
+                                               "should be greater than zero")
+  assert FLAGS.env_problem_batch_size > 0, ("--env_problem_batch_size should be"
+                                            " greather than zero")
+  problem = registry.env_problem(problem_name)
+  task_id = None if FLAGS.task_id < 0 else FLAGS.task_id
+  data_dir = os.path.expanduser(FLAGS.data_dir)
+  tmp_dir = os.path.expanduser(FLAGS.tmp_dir)
+  # TODO(msaffar): Handle large values for env_problem_batch_size where we
+  #  cannot create that many environments within the same process.
+  problem.initialize(batch_size=FLAGS.env_problem_batch_size)
+  env_problem_utils.play_env_problem_randomly(
+      problem, num_steps=FLAGS.env_problem_max_env_steps)
+  problem.generate_data(data_dir=data_dir, tmp_dir=tmp_dir, task_id=task_id)
+
+
+def generate_data_for_registered_problem(problem_name):
+  """Generate data for a registered problem."""
+  tf.logging.info("Generating data for %s.", problem_name)
+  if FLAGS.num_shards:
+    raise ValueError("--num_shards should not be set for registered Problem.")
+  problem = registry.problem(problem_name)
+  task_id = None if FLAGS.task_id < 0 else FLAGS.task_id
+  data_dir = os.path.expanduser(FLAGS.data_dir)
+  tmp_dir = os.path.expanduser(FLAGS.tmp_dir)
+  if task_id is None and problem.multiprocess_generate:
+    if FLAGS.task_id_start != -1:
+      assert FLAGS.task_id_end != -1
+      task_id_start = FLAGS.task_id_start
+      task_id_end = FLAGS.task_id_end
+    else:
+      task_id_start = 0
+      task_id_end = problem.num_generate_tasks
+    pool = multiprocessing.Pool(processes=FLAGS.num_concurrent_processes)
+    problem.prepare_to_generate(data_dir, tmp_dir)
+    args = [(problem_name, data_dir, tmp_dir, task_id)
+            for task_id in range(task_id_start, task_id_end)]
+    pool.map(generate_data_in_process, args)
+  else:
+    problem.generate_data(data_dir, tmp_dir, task_id)
+
+
+if __name__ == "__main__":
+  tf.logging.set_verbosity(tf.logging.INFO)
+  tf.app.run()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/decoder.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+###############################################################################
+# Copyright (C) 2021-2022 Habana Labs, Ltd. an Intel Company
+###############################################################################
+# Changes:
+# - renamed from t2t_decoder.py to decoder.py
+# - added shebang
+# - organized imports
+# - added support for HPU
+# - renamed t2t_trainer to trainer
+# - added use_hpu hparam
+# - added workarounds to run on HPU
+# - added support for recipe cache
+# - added support for fast inference
+# - added support for horovod
+
+r"""Decode from trained T2T models.
+
+This binary performs inference using the Estimator API.
+
+Example usage to decode from dataset:
+
+  ./decoder.py \
+      --data_dir ~/data \
+      --problem=algorithmic_identity_binary40 \
+      --model=transformer
+      --hparams_set=transformer_base
+
+Set FLAGS.decode_interactive or FLAGS.decode_from_file for alternative decode
+sources.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import shutil
+from TensorFlow.nlp.transformer import trainer
+from TensorFlow.nlp.transformer.data_generators import problem  # pylint: disable=unused-import
+from TensorFlow.nlp.transformer.data_generators import text_encoder
+from TensorFlow.nlp.transformer.utils import decoding
+from TensorFlow.nlp.transformer.utils import registry
+from TensorFlow.nlp.transformer.utils import trainer_lib
+from TensorFlow.nlp.transformer.utils import usr_dir
+
+import tensorflow.compat.v1 as tf
+
+flags = tf.flags
+FLAGS = flags.FLAGS
+
+# Additional flags in trainer.py and utils/flags.py
+flags.DEFINE_string("checkpoint_path", None,
+                    "Path to the model checkpoint. Overrides output_dir.")
+flags.DEFINE_bool("keep_timestamp", False,
+                  "Set the mtime of the decoded file to the "
+                  "checkpoint_path+'.index' mtime.")
+flags.DEFINE_bool("decode_interactive", False,
+                  "Interactive local inference mode.")
+flags.DEFINE_integer("decode_shards", 1, "Number of decoding replicas.")
+flags.DEFINE_string("score_file", "", "File to score. Each line in the file "
+                    "must be in the format input \t target.")
+flags.DEFINE_bool("decode_in_memory", False, "Decode in memory.")
+flags.DEFINE_bool("disable_grappler_optimizations", False,
+                  "Disable Grappler if need be to avoid tensor format errors.")
+flags.DEFINE_bool("use_fast_inference", True, "Use fast inference with static shapes")
+
+def create_hparams():
+  hparams_path = None
+  if FLAGS.output_dir:
+    hparams_path = os.path.join(FLAGS.output_dir, "hparams.json")
+  return trainer_lib.create_hparams(
+      FLAGS.hparams_set,
+      FLAGS.hparams,
+      data_dir=os.path.expanduser(FLAGS.data_dir),
+      problem_name=FLAGS.problem,
+      hparams_path=hparams_path)
+
+
+def create_decode_hparams():
+  decode_hp = decoding.decode_hparams(FLAGS.decode_hparams)
+  decode_hp.shards = FLAGS.decode_shards
+  decode_hp.shard_id = FLAGS.worker_id
+  decode_in_memory = FLAGS.decode_in_memory or decode_hp.decode_in_memory
+  decode_hp.decode_in_memory = decode_in_memory
+  decode_hp.decode_to_file = FLAGS.decode_to_file
+  decode_hp.decode_reference = FLAGS.decode_reference
+  return decode_hp
+
+
+def decode(estimator, hparams, decode_hp):
+  """Decode from estimator. Interactive, from file, or from dataset."""
+  if FLAGS.decode_interactive:
+    if estimator.config.use_tpu:
+      raise ValueError("TPU can only decode from dataset.")
+    decoding.decode_interactively(estimator, hparams, decode_hp,
+                                  checkpoint_path=FLAGS.checkpoint_path)
+  elif FLAGS.decode_from_file:
+    decoding.decode_from_file(estimator, FLAGS.decode_from_file, hparams,
+                              decode_hp, FLAGS.decode_to_file,
+                              checkpoint_path=FLAGS.checkpoint_path)
+    if FLAGS.checkpoint_path and FLAGS.keep_timestamp:
+      ckpt_time = os.path.getmtime(FLAGS.checkpoint_path + ".index")
+      os.utime(FLAGS.decode_to_file, (ckpt_time, ckpt_time))
+  else:
+    decoding.decode_from_dataset(
+        estimator,
+        FLAGS.problem,
+        hparams,
+        decode_hp,
+        decode_to_file=FLAGS.decode_to_file,
+        dataset_split="test" if FLAGS.eval_use_test_set else None,
+        checkpoint_path=FLAGS.checkpoint_path)
+
+
+def score_file(filename):
+  """Score each line in a file and return the scores."""
+  # Prepare model.
+  hparams = create_hparams()
+  encoders = registry.problem(FLAGS.problem).feature_encoders(FLAGS.data_dir)
+  has_inputs = "inputs" in encoders
+
+  # Prepare features for feeding into the model.
+  if has_inputs:
+    inputs_ph = tf.placeholder(dtype=tf.int32)  # Just length dimension.
+    batch_inputs = tf.reshape(inputs_ph, [1, -1, 1, 1])  # Make it 4D.
+  targets_ph = tf.placeholder(dtype=tf.int32)  # Just length dimension.
+  batch_targets = tf.reshape(targets_ph, [1, -1, 1, 1])  # Make it 4D.
+  if has_inputs:
+    features = {"inputs": batch_inputs, "targets": batch_targets}
+  else:
+    features = {"targets": batch_targets}
+
+  # Prepare the model and the graph when model runs on features.
+  model = registry.model(FLAGS.model)(hparams, tf.estimator.ModeKeys.EVAL)
+  _, losses = model(features)
+  saver = tf.train.Saver()
+
+  with tf.Session() as sess:
+    # Load weights from checkpoint.
+    if FLAGS.checkpoint_path is None:
+      ckpts = tf.train.get_checkpoint_state(FLAGS.output_dir)
+      ckpt = ckpts.model_checkpoint_path
+    else:
+      ckpt = FLAGS.checkpoint_path
+    saver.restore(sess, ckpt)
+    # Run on each line.
+    with tf.gfile.Open(filename) as f:
+      lines = f.readlines()
+    results = []
+    for line in lines:
+      tab_split = line.split("\t")
+      if len(tab_split) > 2:
+        raise ValueError("Each line must have at most one tab separator.")
+      if len(tab_split) == 1:
+        targets = tab_split[0].strip()
+      else:
+        targets = tab_split[1].strip()
+        inputs = tab_split[0].strip()
+      # Run encoders and append EOS symbol.
+      targets_numpy = encoders["targets"].encode(
+          targets) + [text_encoder.EOS_ID]
+      if has_inputs:
+        inputs_numpy = encoders["inputs"].encode(inputs) + [text_encoder.EOS_ID]
+      # Prepare the feed.
+      if has_inputs:
+        feed = {inputs_ph: inputs_numpy, targets_ph: targets_numpy}
+      else:
+        feed = {targets_ph: targets_numpy}
+      # Get the score.
+      np_loss = sess.run(losses["training"], feed)
+      results.append(np_loss)
+  return results
+
+def get_workaround_flag(name):
+    return f'WA_{name}'
+
+def is_workaround_enabled(name):
+    flag = get_workaround_flag(name)
+    is_enabled = os.environ.get(flag, 'true') == 'true'
+    if is_enabled:
+        print(f"Warning! Workaround {flag} is enabled. Run with {flag}=false to disable it.")
+    return is_enabled
+
+def main(_):
+  tf.disable_v2_behavior()
+  tf.enable_resource_variables()
+  tf.logging.set_verbosity(tf.logging.INFO)
+  trainer_lib.set_random_seed(FLAGS.random_seed)
+  usr_dir.import_usr_dir(FLAGS.t2t_usr_dir)
+
+  if FLAGS.use_hpu:
+    from habana_frameworks.tensorflow import load_habana_module
+    load_habana_module()
+
+  hvd = trainer.init_multinode()
+
+  if FLAGS.use_hpu:
+    if FLAGS.recipe_cache:
+      trainer.prepare_recipe_cache()
+    if FLAGS.use_bf16:
+      if not is_workaround_enabled('FORCE_FP32'):
+          os.environ['TF_BF16_CONVERSION'] = FLAGS.bf16_config_path
+      else:
+          print("Warning! BF16 precision is not supported in inference mode. Switching back to fp32...")
+    if is_workaround_enabled('DISABLE_DYNAMIC_SHAPES'):
+        os.environ['TF_ENABLE_DYNAMIC_SHAPES'] = 'false'
+
+  if FLAGS.score_file:
+    filename = os.path.expanduser(FLAGS.score_file)
+    if not tf.gfile.Exists(filename):
+      raise ValueError("The file to score doesn't exist: %s" % filename)
+    results = score_file(filename)
+    if not FLAGS.decode_to_file:
+      raise ValueError("To score a file, specify --decode_to_file for results.")
+    write_file = tf.gfile.Open(os.path.expanduser(FLAGS.decode_to_file), "w")
+    for score in results:
+      write_file.write("%.6f\n" % score)
+    write_file.close()
+    return
+
+  hp = create_hparams()
+  hp.add_hparam("use_hpu", FLAGS.use_hpu)
+  hp.add_hparam("use_horovod", FLAGS.use_horovod)
+  decode_hp = create_decode_hparams()
+  decode_hp.add_hparam("use_horovod", hp.use_horovod)
+
+  if FLAGS.use_horovod:
+    hp.add_hparam("hvd_worker_id", hvd.rank())
+    hp.add_hparam("hvd_size", hvd.size())
+    decode_hp.add_hparam("hvd_worker_id", hp.hvd_worker_id)
+    decode_hp.add_hparam("hvd_size", hp.hvd_size)
+  run_config = trainer.create_run_config(hp)
+  if FLAGS.disable_grappler_optimizations:
+    run_config.session_config.graph_options.rewrite_options.disable_meta_optimizer = True
+
+  assert FLAGS.use_fast_inference or not FLAGS.use_horovod, "Multinode inference is only supported with use_fast_inference=True"
+
+  # summary-hook in tf.estimator.EstimatorSpec requires
+  # hparams.model_dir to be set.
+  hp.add_hparam("model_dir", run_config.model_dir)
+
+  estimator = trainer_lib.create_estimator(
+      FLAGS.model,
+      hp,
+      run_config,
+      decode_hparams=decode_hp,
+      use_tpu=FLAGS.use_tpu)
+
+  decode(estimator, hp, decode_hp)
+
+
+if __name__ == "__main__":
+  tf.logging.set_verbosity(tf.logging.INFO)
+  tf.app.run()

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/layers/__init__.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/layers/area_attention.py

@@ -0,0 +1,433 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Utilities for area attention."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+from six.moves import range  # pylint: disable=redefined-builtin
+from TensorFlow.nlp.transformer.layers import common_layers
+import tensorflow.compat.v1 as tf
+
+
+def lengths_to_area_mask(feature_length, length, max_area_size):
+  """Generates a non-padding mask for areas based on lengths.
+
+  Args:
+    feature_length: a tensor of [batch_size]
+    length: the length of the batch
+    max_area_size: the maximum area size considered
+  Returns:
+    mask: a tensor in shape of [batch_size, num_areas]
+  """
+
+  paddings = tf.cast(tf.expand_dims(
+      tf.logical_not(
+          tf.sequence_mask(feature_length, maxlen=length)), 2), tf.float32)
+  _, _, area_sum, _, _ = compute_area_features(paddings,
+                                               max_area_width=max_area_size)
+  mask = tf.squeeze(tf.logical_not(tf.cast(area_sum, tf.bool)), [2])
+  return mask
+
+
+def _pool_one_shape(features_2d, area_width, area_height, batch_size,
+                    width, height, depth, fn=tf.reduce_max, name=None):
+  """Pools for an area in features_2d.
+
+  Args:
+    features_2d: a Tensor in a shape of [batch_size, height, width, depth].
+    area_width: the max width allowed for an area.
+    area_height: the max height allowed for an area.
+    batch_size: the batch size.
+    width: the width of the memory.
+    height: the height of the memory.
+    depth: the depth of the features.
+    fn: the TF function for the pooling.
+    name: the op name.
+  Returns:
+    pool_tensor: A Tensor of shape [batch_size, num_areas, depth]
+  """
+  with tf.name_scope(name, default_name="pool_one_shape"):
+    images = []
+    for y_shift in range(area_height):
+      image_height = tf.maximum(height - area_height + 1 + y_shift, 0)
+      for x_shift in range(area_width):
+        image_width = tf.maximum(width - area_width + 1 + x_shift, 0)
+        area = features_2d[:, y_shift:image_height, x_shift:image_width, :]
+        flatten_area = tf.reshape(area, [batch_size, -1, depth, 1])
+        images.append(flatten_area)
+    image_tensor = tf.concat(images, axis=3)
+    max_tensor = fn(image_tensor, axis=3)
+  return max_tensor
+
+
+def basic_pool(features, max_area_width, max_area_height=1, height=1,
+               fn=tf.reduce_max, name=None):
+  """Pools for each area based on a given pooling function (fn).
+
+  Args:
+    features: a Tensor in a shape of [batch_size, height * width, depth].
+    max_area_width: the max width allowed for an area.
+    max_area_height: the max height allowed for an area.
+    height: the height of the image.
+    fn: the TF function for the pooling.
+    name: the namescope.
+  Returns:
+    pool_results: A Tensor of shape [batch_size, num_areas, depth]
+    area_heights: A Tensor of shape [batch_size, num_areas, 1]
+    area_widths: A Tensor of shape [batch_size, num_areas, 1]
+  """
+  with tf.name_scope(name, default_name="basic_pool"):
+    feature_shape = common_layers.shape_list(features)
+    batch_size = feature_shape[0]
+    length = feature_shape[-2]
+    depth = feature_shape[-1]
+    width = length // height
+    features_2d = tf.reshape(features, [batch_size, height, width, depth])
+    height_list = []
+    width_list = []
+    pool_list = []
+    size_tensor = tf.ones_like(features_2d[:, :, :, 0], dtype=tf.int32)
+    for area_height in range(max_area_height):
+      for area_width in range(max_area_width):
+        pool_tensor = _pool_one_shape(features_2d,
+                                      area_width=area_width + 1,
+                                      area_height=area_height + 1,
+                                      batch_size=batch_size,
+                                      width=width,
+                                      height=height,
+                                      depth=depth,
+                                      fn=fn)
+        pool_list.append(
+            tf.reshape(pool_tensor, [batch_size, -1, depth]))
+        height_list.append(
+            tf.reshape(
+                size_tensor[:, area_height:, area_width:] *\
+                (area_height + 1), [batch_size, -1]))
+        width_list.append(
+            tf.reshape(
+                size_tensor[:, area_height:, area_width:] *\
+                (area_width + 1), [batch_size, -1]))
+    pool_results = tf.concat(pool_list, axis=1)
+    area_heights = tf.expand_dims(tf.concat(height_list, axis=1), 2)
+    area_widths = tf.expand_dims(tf.concat(width_list, axis=1), 2)
+  return pool_results, area_heights, area_widths
+
+
+def _compute_sum_image(features, max_area_width, max_area_height=1, height=1,
+                       name=None):
+  """Computes area sums for features.
+
+  Args:
+    features: a Tensor in a shape of [batch_size, height * width, depth].
+    max_area_width: the max width allowed for an area.
+    max_area_height: the max height allowed for an area.
+    height: the height of the image.
+    name: the namescope.
+  Returns:
+    sum_image: A Tensor of shape [batch_size, num_areas, depth]
+    area_heights: A Tensor of shape [batch_size, num_areas, 1]
+    area_widths: A Tensor of shape [batch_size, num_areas, 1]
+  """
+  with tf.name_scope(name, default_name="compute_sum_image"):
+    feature_shape = common_layers.shape_list(features)
+    batch_size = feature_shape[0]
+    length = feature_shape[-2]
+    depth = feature_shape[-1]
+    width = length // height
+    features_2d = tf.reshape(features, [batch_size, height, width, depth])
+    width_cum = tf.cumsum(features_2d, axis=-2, name="compute_integral_h")
+    integral_image = tf.cumsum(width_cum, axis=-3, name="compute_integral_v")
+    padded_image = tf.pad(
+        integral_image, [[0, 0], [1, 0], [1, 0], [0, 0]], constant_values=0)
+    height_list = []
+    width_list = []
+    dst_images = []
+    src_images_diag = []
+    src_images_h = []
+    src_images_v = []
+    size_tensor = tf.ones_like(padded_image[:, :, :, 0],
+                               dtype=tf.int32)
+    for area_height in range(max_area_height):
+      for area_width in range(max_area_width):
+        dst_images.append(
+            tf.reshape(
+                padded_image[:, area_height + 1:, area_width + 1:, :],
+                [batch_size, -1, depth]))
+        src_images_diag.append(
+            tf.reshape(
+                padded_image[:, :-area_height - 1, :-area_width - 1, :],
+                [batch_size, -1, depth]))
+        src_images_h.append(
+            tf.reshape(
+                padded_image[:, area_height + 1:, :-area_width - 1, :],
+                [batch_size, -1, depth]))
+        src_images_v.append(
+            tf.reshape(
+                padded_image[:, :-area_height - 1, area_width + 1:, :],
+                [batch_size, -1, depth]))
+        height_list.append(
+            tf.reshape(
+                size_tensor[:, area_height + 1:, area_width + 1:] *\
+                (area_height + 1), [batch_size, -1]))
+        width_list.append(
+            tf.reshape(
+                size_tensor[:, area_height + 1:, area_width + 1:] *\
+                (area_width + 1), [batch_size, -1]))
+    sum_image = tf.subtract(
+        tf.concat(dst_images, axis=1) + tf.concat(src_images_diag, axis=1),
+        tf.concat(src_images_v, axis=1) + tf.concat(src_images_h, axis=1))
+    area_heights = tf.expand_dims(tf.concat(height_list, axis=1), 2)
+    area_widths = tf.expand_dims(tf.concat(width_list, axis=1), 2)
+  return sum_image, area_heights, area_widths
+
+
+def compute_area_features(features, max_area_width, max_area_height=1, height=1,
+                          epsilon=1e-6):
+  """Computes features for each area.
+
+  Args:
+    features: a Tensor in a shape of [batch_size, height * width, depth].
+    max_area_width: the max width allowed for an area.
+    max_area_height: the max height allowed for an area.
+    height: the height of the image.
+    epsilon: the epsilon added to the variance for computing standard deviation.
+  Returns:
+    area_mean: A Tensor of shape [batch_size, num_areas, depth]
+    area_std: A Tensor of shape [batch_size, num_areas, depth]
+    area_sum: A Tensor of shape [batch_size, num_areas, depth]
+    area_heights: A Tensor of shape [batch_size, num_areas, 1]
+    area_widths: A Tensor of shape [batch_size, num_areas, 1]
+  """
+  with tf.name_scope("compute_area_features"):
+    tf.logging.info("area_attention compute_area_features: %d x %d",
+                    max_area_height, max_area_width)
+    area_sum, area_heights, area_widths = _compute_sum_image(
+        features, max_area_width=max_area_width,
+        max_area_height=max_area_height, height=height)
+    area_squared_sum, _, _ = _compute_sum_image(
+        tf.pow(features, 2), max_area_width=max_area_width,
+        max_area_height=max_area_height, height=height)
+    sizes = tf.multiply(area_heights, area_widths)
+    float_area_sizes = tf.cast(sizes, tf.float32)
+    area_mean = tf.div(area_sum, float_area_sizes)
+    s2_n = tf.div(area_squared_sum, float_area_sizes)
+    area_variance = tf.subtract(s2_n, tf.pow(area_mean, 2))
+    area_std = tf.sqrt(tf.abs(area_variance) + epsilon)
+    return area_mean, area_std, area_sum, area_heights, area_widths
+
+
+def compute_area_key(features, max_area_width, max_area_height=1, height=1,
+                     mode="mean", training=True, name=None):
+  """Computes the key for each area.
+
+  Args:
+    features: a Tensor in a shape of [batch_size, height * width, depth].
+    max_area_width: the max width allowed for an area.
+    max_area_height: the max height allowed for an area.
+    height: the height of the image.
+    mode: whether to combine different area features or only use
+        the vector mean of each area, which can be "mean", "concat", "sum",
+        "sample_concat", and "sample_sum".
+    training: indicating if it is in the training mode.
+    name: the name for setting the variable scope.
+  Returns:
+    area_key: a Tensor in the shape of [batch_size, num_areas, depth]
+  """
+
+  tf.logging.info("area_attention mode=%s", mode)
+  area_mean, area_std, _, area_heights, area_widths =\
+      compute_area_features(features, max_area_width=max_area_width,
+                            max_area_height=max_area_height, height=height)
+  if mode == "mean":
+    return area_mean
+  elif mode == "max":
+    area_max, _, _ = basic_pool(features, max_area_width=max_area_width,
+                                max_area_height=max_area_height, height=height)
+    return area_max
+  elif mode == "sample":
+    if training:
+      area_mean += (area_std * tf.random_normal(tf.shape(area_std)))
+    return area_mean
+  with tf.variable_scope(
+      name, default_name="combine_area_features",
+      values=[area_mean, area_std, area_heights, area_widths]):
+    depth = common_layers.shape_list(area_mean)[-1]
+    height_embed = tf.nn.embedding_lookup(
+        params=tf.get_variable("area_height_emb",
+                               [max_area_height, depth // 2]),
+        ids=area_heights[:, :, 0] - 1)
+    width_embed = tf.nn.embedding_lookup(
+        params=tf.get_variable("area_width_emb",
+                               [max_area_width, depth // 2]),
+        ids=area_widths[:, :, 0] - 1)
+    size_embed = tf.concat([height_embed, width_embed], -1)
+    if mode == "concat":
+      feature_concat = tf.concat([area_mean, area_std, size_embed], -1)
+    elif mode == "max_concat":
+      area_max, _, _ = basic_pool(features, max_area_width=max_area_width,
+                                  max_area_height=max_area_height,
+                                  height=height)
+      feature_concat = tf.concat([area_max, size_embed], -1)
+    elif mode == "sum":
+      feature_concat = size_embed + area_mean + area_std
+    elif mode == "sample_concat":
+      if training:
+        area_mean += (area_std * tf.random_normal(tf.shape(area_std)))
+      feature_concat = tf.concat([area_mean, size_embed], -1)
+    elif mode == "sample_sum":
+      if training:
+        area_mean += (area_std * tf.random_normal(tf.shape(area_std)))
+      feature_concat = area_mean + size_embed
+    else:
+      raise ValueError("Unsupported area key mode=%s" % mode)
+    feature_hidden = tf.layers.dense(inputs=feature_concat,
+                                     units=depth,
+                                     activation=tf.nn.relu)
+    area_key = tf.layers.dense(feature_hidden, units=depth)
+    return area_key
+
+
+def dot_product_area_attention(q,
+                               k,
+                               v,
+                               bias,
+                               dropout_rate=0.0,
+                               image_shapes=None,
+                               name=None,
+                               attention_image_summary=None,
+                               save_weights_to=None,
+                               dropout_broadcast_dims=None,
+                               max_area_width=1,
+                               max_area_height=1,
+                               memory_height=1,
+                               area_key_mode="mean",
+                               area_value_mode="sum",
+                               top_k_areas=0,
+                               area_temperature=1.0,
+                               training=True):
+  """Dot-product area attention.
+
+  Args:
+    q: Tensor with shape [..., length_q, depth_k].
+    k: Tensor with shape [..., length_kv, depth_k]. Leading dimensions must
+      match with q.
+    v: Tensor with shape [..., length_kv, depth_v] Leading dimensions must
+      match with q.
+    bias: bias Tensor (see attention_bias())
+    dropout_rate: a float.
+    image_shapes: optional tuple of integer scalars.
+      see comments for attention_image_summary()
+    name: an optional string
+    attention_image_summary: the callback for making image summary of attention.
+    save_weights_to: an optional dictionary to capture attention weights
+      for visualization; the weights tensor will be appended there under
+      a string key created from the variable scope (including name).
+    dropout_broadcast_dims: an optional list of integers less than rank of q.
+      Specifies in which dimensions to broadcast the dropout decisions.
+    max_area_width: the max width allowed for an area.
+    max_area_height: the max height allowed for an area.
+    memory_height: the height of the memory.
+    area_key_mode: the mode for computing area keys, which can be "mean",
+      "concat", "sum", "sample_concat", and "sample_sum".
+    area_value_mode: the mode for computing area values, which can be either
+      "mean", or "sum".
+    top_k_areas: Use the top key areas for attention.
+    area_temperature: the temperature for attention softmax.
+    training: indicating if it is in the training mode.
+  Returns:
+    Tensor with shape [..., length_q, depth_v].
+  """
+
+  tf.logging.info("dot_product_area_attention: "
+                  "area_h=%d, area_w=%d, mem_h=%d, "
+                  "area_key_mode=%s, area_value_mode=%s, "
+                  "area_temperature=%f",
+                  max_area_height, max_area_width, memory_height,
+                  area_key_mode, area_value_mode,
+                  area_temperature)
+  with tf.variable_scope(
+      name, default_name="dot_product_area_attention",
+      values=[q, k, v]) as scope:
+    mem_shape = common_layers.shape_list(k)
+    batch_size = mem_shape[0]
+    head_size = mem_shape[1]
+    length = mem_shape[2]
+    depth = mem_shape[3]
+    k_area = compute_area_key(
+        tf.reshape(k, [-1, length, depth]),
+        max_area_width=max_area_width,
+        max_area_height=max_area_height,
+        height=memory_height,
+        mode=area_key_mode,
+        training=training)
+    if area_value_mode == "mean":
+      v_area, _, _, _, _ = compute_area_features(
+          tf.reshape(v, [-1, length, depth]), max_area_width=max_area_width,
+          max_area_height=max_area_height, height=memory_height)
+    elif area_value_mode == "max":
+      v_area, _, _ = basic_pool(tf.reshape(v, [-1, length, depth]),
+                                max_area_width=max_area_width,
+                                max_area_height=max_area_height,
+                                height=memory_height,
+                                fn=tf.reduce_max)
+    elif area_value_mode == "sum":
+      _, _, v_area, _, _ = compute_area_features(
+          tf.reshape(v, [-1, length, depth]), max_area_width=max_area_width,
+          max_area_height=max_area_height, height=memory_height)
+    else:
+      raise ValueError("Unsupported area value mode=%s" % area_value_mode)
+    k = tf.reshape(k_area, [batch_size, head_size, -1, depth])
+    v = tf.reshape(v_area, [batch_size, head_size, -1, depth])
+    logits = tf.matmul(q, k, transpose_b=True)  # [..., length_q, length_kv]
+    if bias is not None:
+      bias = common_layers.cast_like(bias, logits)
+      with tf.name_scope("compute_area_att_bias", values=[bias]):
+        bias_shape = common_layers.shape_list(bias)
+        mem_length = bias_shape[-1]
+        bias_values = tf.reshape(
+            tf.cast(tf.less(bias, -1), tf.float32), [-1, mem_length, 1])
+        _, _, padding_sum, _, _ = compute_area_features(
+            bias_values, max_area_width=max_area_width,
+            max_area_height=max_area_height, height=memory_height)
+        bias = tf.where(
+            tf.cast(tf.to_int32(padding_sum), tf.bool),
+            tf.fill(tf.shape(padding_sum), -np.inf),
+            tf.zeros_like(padding_sum, dtype=tf.float32))
+        bias = tf.reshape(bias,
+                          [bias_shape[0], bias_shape[1],
+                           bias_shape[2], -1])
+      logits += bias
+    logits = logits / area_temperature
+    weights = tf.nn.softmax(logits, name="attention_weights")
+    if top_k_areas > 0:
+      tf.logging.info("area_attention top_k_areas=%d", top_k_areas)
+      top_k = tf.minimum(common_layers.shape_list(weights)[-1], top_k_areas)
+      top_weights, _ = tf.nn.top_k(weights, k=top_k)
+      min_values = tf.reduce_min(top_weights, -1, keepdims=True)
+      weights = tf.where(tf.greater_equal(weights, min_values),
+                         weights, tf.zeros_like(weights))
+      weights = tf.div(weights, tf.reduce_sum(weights, -1, keepdims=True))
+    if save_weights_to is not None:
+      save_weights_to[scope.name] = weights
+      save_weights_to[scope.name + "/logits"] = logits
+    # Drop out attention links for each head.
+    weights = common_layers.dropout_with_broadcast_dims(
+        weights, 1.0 - dropout_rate, broadcast_dims=dropout_broadcast_dims)
+    if common_layers.should_generate_summaries() and attention_image_summary:
+      attention_image_summary(weights, image_shapes)
+    return tf.matmul(weights, v)

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/layers/modalities.py

@@ -0,0 +1,302 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Modalities, which specify a feature's domain.
+
+T2TModel applies a default transformation to each feature according to its
+modality. Override them by specifying a model's
+hparams.{bottom,loss,top,weights_fn}.
+"""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from six.moves import range  # pylint: disable=redefined-builtin
+
+from TensorFlow.nlp.transformer.layers import common_attention
+from TensorFlow.nlp.transformer.layers import common_layers
+
+import tensorflow.compat.v1 as tf
+import tensorflow_probability as tfp
+
+
+class ModalityType(object):
+  """Types of modalities."""
+
+  IDENTITY = "identity"  # identity top and bottom
+  IDENTITY_SYMBOL = "identity_symbol"  # symbol with identity top and bottom
+  SYMBOL = "symbol"
+
+
+  @staticmethod
+  def get_choices():
+    return [
+        ModalityType.IDENTITY,
+        ModalityType.IDENTITY_SYMBOL,
+        ModalityType.SYMBOL,
+    ]
+
+
+def class_label_targets_bottom(x, model_hparams, vocab_size):
+  with tf.variable_scope("class_label_modality_%d_%d" % (
+      vocab_size, model_hparams.hidden_size)):
+    return tf.zeros([common_layers.shape_list(x)[0],
+                     1,
+                     1,
+                     model_hparams.hidden_size])
+
+
+def identity_bottom(x, model_hparams, vocab_size):
+  del model_hparams, vocab_size  # unused arg
+  return tf.cast(x, tf.float32)
+
+
+def make_targets_bottom(bottom):
+  def targets_bottom(x, model_hparams, vocab_size):
+    with tf.variable_scope("targets_bottom"):
+      return bottom(x, model_hparams, vocab_size)
+  return targets_bottom
+
+
+def real_bottom(x, model_hparams, vocab_size):
+  del vocab_size  # unused arg
+  with tf.variable_scope("real"):
+    return tf.layers.dense(
+        tf.cast(x, tf.float32), model_hparams.hidden_size, name="bottom")
+
+
+def get_weights(model_hparams, vocab_size, hidden_dim=None):
+  """Create or get concatenated embedding or softmax variable.
+
+  Args:
+    model_hparams: HParams, model hyperparmeters.
+    vocab_size: int, vocabulary size.
+    hidden_dim: dim of the variable. Defaults to _model_hparams' hidden_size
+
+  Returns:
+     a list of num_shards Tensors.
+  """
+  if hidden_dim is None:
+    hidden_dim = model_hparams.hidden_size
+  num_shards = model_hparams.symbol_modality_num_shards
+  shards = []
+  for i in range(num_shards):
+    shard_size = (vocab_size // num_shards) + (
+        1 if i < vocab_size % num_shards else 0)
+    var_name = "weights_%d" % i
+    shards.append(
+        tf.get_variable(
+            var_name, [shard_size, hidden_dim],
+            initializer=tf.random_normal_initializer(0.0, hidden_dim**-0.5)))
+  if num_shards == 1:
+    ret = shards[0]
+  else:
+    ret = tf.concat(shards, 0)
+  # Convert ret to tensor.
+  if not tf.executing_eagerly():
+    ret = common_layers.convert_gradient_to_tensor(ret)
+  return ret
+
+
+def _symbol_bottom_simple(x, model_hparams, vocab_size, name, reuse):
+  """Bottom transformation for symbols."""
+  with tf.variable_scope(name, reuse=reuse):
+    # Ensure the inputs are 3-D
+    if len(x.get_shape()) == 4:
+      x = tf.squeeze(x, axis=3)
+    while len(x.get_shape()) < 3:
+      x = tf.expand_dims(x, axis=-1)
+
+    var = get_weights(model_hparams, vocab_size)
+    x = common_layers.dropout_no_scaling(
+        x, 1.0 - model_hparams.symbol_dropout)
+    ret = common_layers.gather(var, x)
+    if model_hparams.multiply_embedding_mode == "sqrt_depth":
+      ret *= model_hparams.hidden_size**0.5
+    ret *= tf.expand_dims(
+        common_layers.cast_like(tf.not_equal(x, 0), ret), -1)
+    return ret
+
+
+def symbol_bottom(x, model_hparams, vocab_size):
+  if (model_hparams.shared_embedding_and_softmax_weights or
+      model_hparams.get("shared_embedding")):
+    return _symbol_bottom_simple(
+        x, model_hparams, vocab_size, "shared", reuse=None)
+  return _symbol_bottom_simple(
+      x, model_hparams, vocab_size, "input_emb", reuse=None)
+
+
+def symbol_targets_bottom(x, model_hparams, vocab_size):
+  if (model_hparams.shared_embedding_and_softmax_weights or
+      model_hparams.get("shared_embedding")):
+    try:
+      return _symbol_bottom_simple(
+          x, model_hparams, vocab_size, "shared", reuse=True)
+    except ValueError:
+      # perhaps there were no inputs, and this is a new variable.
+      return _symbol_bottom_simple(
+          x, model_hparams, vocab_size, "shared", reuse=None)
+  else:
+    return _symbol_bottom_simple(
+        x, model_hparams, vocab_size, "target_emb", reuse=None)
+
+
+# Loss transformations, applied to target features
+
+
+def generic_loss(top_out, targets, model_hparams, vocab_size, weights_fn):
+  """Compute loss numerator and denominator for one shard of output."""
+  del vocab_size  # unused arg
+  logits = top_out
+  logits = common_attention.maybe_upcast(logits, hparams=model_hparams)
+  cutoff = getattr(model_hparams, "video_modality_loss_cutoff", 0.0)
+
+  return common_layers.padded_cross_entropy(
+      logits,
+      targets,
+      model_hparams.label_smoothing,
+      cutoff=cutoff,
+      weights_fn=weights_fn)
+
+
+# Top transformations, applied to target features
+
+
+def is_pointwise(func):
+  """Decorator for whether the function is pointwise.
+
+  An example of a pointwise function is a linear layer followed by
+  a softmax. Given a tensor [batch, length, height, depth] it operates
+  only on the last axis, on every point in [batch, length, height] fully
+  independently. In contrast, a classifier that first averages over length
+  and height is not pointwise, as it depends on the whole field. It is useful
+  to know if top functions are pointwise to speed up decoding in certain models.
+
+  Args:
+    func: Function to decorate.
+
+  Returns:
+    Original function with an attribute pointwise set to True.
+  """
+  func.pointwise = True
+  return func
+
+
+def identity_top(body_output, targets, model_hparams, vocab_size):
+  del targets, model_hparams, vocab_size  # unused arg
+  return body_output
+
+
+@is_pointwise
+def symbol_top(body_output, targets, model_hparams, vocab_size):
+  """Generate logits.
+
+  Args:
+    body_output: A Tensor with shape
+      [batch, p0, p1, model_hparams.hidden_size].
+    targets: Unused.
+    model_hparams: HParams, model hyperparmeters.
+    vocab_size: int, vocabulary size.
+
+  Returns:
+    logits: A Tensor with shape  [batch, p0, p1, ?, vocab_size].
+  """
+  del targets  # unused arg
+  if model_hparams.shared_embedding_and_softmax_weights:
+    scope_name = "shared"
+    reuse = tf.AUTO_REUSE
+  else:
+    scope_name = "softmax"
+    reuse = False
+  with tf.variable_scope(scope_name, reuse=reuse):
+    body_output_shape = common_layers.shape_list(body_output)
+    var = get_weights(model_hparams, vocab_size, body_output_shape[-1])
+    if (model_hparams.factored_logits and
+        model_hparams.mode == tf.estimator.ModeKeys.TRAIN):
+      # insert channels dimension
+      body_output = tf.expand_dims(body_output, 3)
+      return common_layers.FactoredTensor(body_output, var)
+    else:
+      body_output = tf.reshape(body_output, [-1, body_output_shape[-1]])
+      logits = tf.matmul(body_output, var, transpose_b=True)
+      return tf.reshape(logits,
+                        body_output_shape[:-1] + [1, vocab_size])
+
+
+# Utility functions similar to tf.keras for default transformations
+
+
+def get_bottom(modality_type, value=None):
+  """Gets default bottom transformation; if none available, return value."""
+  if modality_type == ModalityType.SYMBOL:
+    return symbol_bottom
+  elif modality_type in (ModalityType.IDENTITY,
+                         ModalityType.IDENTITY_SYMBOL):
+    return identity_bottom
+  return value
+
+
+def get_loss(modality_type, value=None):
+  """Gets default loss transformation; if none available, return value."""
+  if modality_type in (ModalityType.IDENTITY,
+                       ModalityType.IDENTITY_SYMBOL,
+                       ModalityType.SYMBOL):
+    return generic_loss
+  return value
+
+
+def get_name(modality_type, value=None):
+  """Gets default name for transformations; if none available, return value."""
+  # For legacy reasons, modalities vary in their naming scheme. Future plans are
+  # to remove any need for get_name. We do not recommend using it.
+  if modality_type == ModalityType.IDENTITY:
+    return lambda model_hparams, vocab_size: "identity_modality"
+  elif modality_type == ModalityType.SYMBOL:
+    def name(model_hparams, vocab_size):
+      return "symbol_modality_%d_%d" % (vocab_size, model_hparams.hidden_size)
+    return name
+  return value
+
+
+def get_targets_bottom(modality_type, value=None):
+  """Gets default bottom transformation for targets; if none, return value."""
+  if modality_type == ModalityType.SYMBOL:
+    return symbol_targets_bottom
+  elif modality_type == ModalityType.IDENTITY_SYMBOL:
+    return identity_bottom
+  elif modality_type == ModalityType.IDENTITY:
+    return make_targets_bottom(identity_bottom)
+  return value
+
+
+def get_top(modality_type, value=None):
+  """Gets default top transformation; if none available, return value."""
+  if modality_type in (ModalityType.IDENTITY,
+                       ModalityType.IDENTITY_SYMBOL):
+    return identity_top
+  elif modality_type == ModalityType.SYMBOL:
+    return symbol_top
+  return value
+
+
+def get_weights_fn(modality_type, value=None):
+  """Gets default weights function; if none available, return value."""
+  if modality_type in (ModalityType.IDENTITY_SYMBOL,
+                       ModalityType.SYMBOL):
+    return common_layers.weights_nonzero
+  elif modality_type in ModalityType.get_choices():
+    return common_layers.weights_all
+  return value

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/layers/transformer_layers.py

@@ -0,0 +1,366 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""Commonly re-used transformer layers."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from TensorFlow.nlp.transformer.layers import common_attention
+from TensorFlow.nlp.transformer.layers import common_layers
+from TensorFlow.nlp.transformer.utils import expert_utils
+
+import tensorflow.compat.v1 as tf
+
+
+# TODO(lukaszkaiser): remove this function when not needed any more.
+def layers():
+  return common_layers.layers()
+
+
+def transformer_prepare_encoder(inputs, target_space, hparams, features=None,
+                                type_ids=None, num_types=None,
+                                reuse_target_embedding=tf.AUTO_REUSE):
+  """Prepare one shard of the model for the encoder.
+
+  Args:
+    inputs: a Tensor.
+    target_space: a Tensor.
+    hparams: run hyperparameters
+    features: optionally pass the entire features dictionary as well.
+      This is needed now for "packed" datasets.
+    type_ids: optional, an int64 Tensor of shape [batch, length] that allows
+      for adding type embeddings, similar to positional embeddings.
+    num_types: optional, an int that decides the number of types in type_ids.
+    reuse_target_embedding: option to reuse variable name in the case that
+      symbol modalities are reused between inputs/targets.
+
+  Returns:
+    encoder_input: a Tensor, bottom of encoder stack
+    encoder_self_attention_bias: a bias tensor for use in encoder self-attention
+    encoder_decoder_attention_bias: a bias tensor for use in encoder-decoder
+      attention
+  """
+  ishape_static = inputs.shape.as_list()
+  encoder_input = inputs
+  if features and "inputs_segmentation" in features:
+    # Packed dataset.  Keep the examples from seeing each other.
+    inputs_segmentation = features["inputs_segmentation"]
+    inputs_position = features["inputs_position"]
+    targets_segmentation = features["targets_segmentation"]
+    if (hasattr(hparams, "unidirectional_encoder") and
+        hparams.unidirectional_encoder):
+      tf.logging.info("Using unidirectional encoder")
+      encoder_self_attention_bias = (
+          common_attention.attention_bias_lower_triangle(
+              common_layers.shape_list(inputs)[1]))
+    else:
+      encoder_self_attention_bias = (
+          common_attention.attention_bias_same_segment(
+              inputs_segmentation, inputs_segmentation))
+    encoder_decoder_attention_bias = (
+        common_attention.attention_bias_same_segment(targets_segmentation,
+                                                     inputs_segmentation))
+  else:
+    encoder_padding = common_attention.embedding_to_padding(encoder_input)
+    ignore_padding = common_attention.attention_bias_ignore_padding(
+        encoder_padding)
+    if (hasattr(hparams, "unidirectional_encoder") and
+        hparams.unidirectional_encoder):
+      tf.logging.info("Using unidirectional encoder")
+      encoder_self_attention_bias = (
+          common_attention.attention_bias_lower_triangle(
+              common_layers.shape_list(inputs)[1]))
+    else:
+      # Usual case - not a packed dataset.
+      encoder_self_attention_bias = ignore_padding
+    encoder_decoder_attention_bias = ignore_padding
+    inputs_position = None
+  if hparams.proximity_bias:
+    encoder_self_attention_bias += common_attention.attention_bias_proximal(
+        common_layers.shape_list(inputs)[1])
+  if target_space is not None and hparams.get("use_target_space_embedding",
+                                              True):
+    # Append target_space_id embedding to inputs.
+    emb_target_space = common_layers.embedding(
+        target_space,
+        32,
+        ishape_static[-1],
+        name="target_space_embedding",
+        dtype=hparams.get("activation_dtype", "float32"),
+        reuse=reuse_target_embedding)
+    emb_target_space = tf.reshape(emb_target_space, [1, 1, -1])
+    encoder_input += emb_target_space
+  if hparams.pos == "timing":
+    if inputs_position is not None:
+      encoder_input = common_attention.add_timing_signal_1d_given_position(
+          encoder_input, inputs_position)
+    else:
+      encoder_input = common_attention.add_timing_signal_1d(encoder_input)
+  elif hparams.pos == "timing_from_features":
+    encoder_input = common_attention.add_timing_signals_from_features(
+        encoder_input, features, hparams.position_features)
+  elif hparams.pos == "emb":
+    encoder_input = common_attention.add_positional_embedding(
+        encoder_input, hparams.max_length, "inputs_positional_embedding",
+        inputs_position)
+
+  # Add type embeddings
+  if type_ids is not None:
+    if not num_types:
+      raise ValueError("Need to set num_types as well.")
+    encoder_input = common_attention.add_positional_embedding(
+        encoder_input, num_types, "inputs_type_embedding", type_ids)
+
+  encoder_self_attention_bias = common_layers.cast_like(
+      encoder_self_attention_bias, encoder_input)
+  encoder_decoder_attention_bias = common_layers.cast_like(
+      encoder_decoder_attention_bias, encoder_input)
+  return (encoder_input, encoder_self_attention_bias,
+          encoder_decoder_attention_bias)
+
+
+def transformer_encoder(encoder_input,
+                        encoder_self_attention_bias,
+                        hparams,
+                        name="encoder",
+                        nonpadding=None,
+                        save_weights_to=None,
+                        make_image_summary=False,
+                        losses=None,
+                        attn_bias_for_padding=None):
+  """A stack of transformer layers.
+
+  Args:
+    encoder_input: a Tensor
+    encoder_self_attention_bias: bias Tensor for self-attention
+       (see common_attention.attention_bias())
+    hparams: hyperparameters for model
+    name: a string
+    nonpadding: optional Tensor with shape [batch_size, encoder_length]
+      indicating what positions are not padding.  This must either be
+      passed in, which we do for "packed" datasets, or inferred from
+      encoder_self_attention_bias.  The knowledge about padding is used
+      for pad_remover(efficiency) and to mask out padding in convolutional
+      layers.
+    save_weights_to: an optional dictionary to capture attention weights
+      for visualization; the weights tensor will be appended there under
+      a string key created from the variable scope (including name).
+    make_image_summary: Whether to make an attention image summary.
+    losses: optional list onto which to append extra training losses
+    attn_bias_for_padding: Padded attention bias in case a unidirectional
+      encoder is being used where future attention is masked.
+
+  Returns:
+    y: a Tensors
+  """
+  x = encoder_input
+  attention_dropout_broadcast_dims = (
+      common_layers.comma_separated_string_to_integer_list(
+          getattr(hparams, "attention_dropout_broadcast_dims", "")))
+
+  with tf.variable_scope(name):
+    if nonpadding is not None:
+      padding = 1.0 - nonpadding
+    else:
+      attention_bias = encoder_self_attention_bias
+      if attn_bias_for_padding is not None:
+        attention_bias = attn_bias_for_padding
+      padding = common_attention.attention_bias_to_padding(attention_bias)
+      nonpadding = 1.0 - padding
+    pad_remover = None
+    if hparams.use_pad_remover and not common_layers.is_xla_compiled():
+      pad_remover = expert_utils.PadRemover(padding)
+    for layer in range(hparams.num_encoder_layers or hparams.num_hidden_layers):
+      with tf.variable_scope("layer_%d" % layer):
+        with tf.variable_scope("self_attention"):
+          if layer < hparams.get("num_area_layers", 0):
+            max_area_width = hparams.get("max_area_width", 1)
+            max_area_height = hparams.get("max_area_height", 1)
+            memory_height = hparams.get("memory_height", 1)
+          else:
+            max_area_width = 1
+            max_area_height = 1
+            memory_height = 1
+          y = common_attention.multihead_attention(
+              common_layers.layer_preprocess(x, hparams),
+              None,
+              encoder_self_attention_bias,
+              hparams.attention_key_channels or hparams.hidden_size,
+              hparams.attention_value_channels or hparams.hidden_size,
+              hparams.hidden_size,
+              hparams.num_heads,
+              hparams.attention_dropout,
+              attention_type=hparams.self_attention_type,
+              max_relative_position=hparams.max_relative_position,
+              heads_share_relative_embedding=(
+                  hparams.heads_share_relative_embedding),
+              add_relative_to_values=hparams.add_relative_to_values,
+              save_weights_to=save_weights_to,
+              make_image_summary=make_image_summary,
+              dropout_broadcast_dims=attention_dropout_broadcast_dims,
+              max_length=hparams.get("max_length"),
+              vars_3d=hparams.get("attention_variables_3d"),
+              activation_dtype=hparams.get("activation_dtype", "float32"),
+              weight_dtype=hparams.get("weight_dtype", "float32"),
+              hard_attention_k=hparams.get("hard_attention_k", 0),
+              gumbel_noise_weight=hparams.get("gumbel_noise_weight", 0.0),
+              max_area_width=max_area_width,
+              max_area_height=max_area_height,
+              memory_height=memory_height,
+              area_key_mode=hparams.get("area_key_mode", "none"),
+              area_value_mode=hparams.get("area_value_mode", "none"),
+              training=(hparams.get("mode", tf.estimator.ModeKeys.TRAIN)
+                        == tf.estimator.ModeKeys.TRAIN))
+          x = common_layers.layer_postprocess(x, y, hparams)
+        with tf.variable_scope("ffn"):
+          y = transformer_ffn_layer(
+              common_layers.layer_preprocess(x, hparams),
+              hparams,
+              pad_remover,
+              conv_padding="SAME",
+              nonpadding_mask=nonpadding,
+              losses=losses)
+          x = common_layers.layer_postprocess(x, y, hparams)
+    # if normalization is done in layer_preprocess, then it should also be done
+    # on the output, since the output can grow very large, being the sum of
+    # a whole stack of unnormalized layer outputs.
+    return common_layers.layer_preprocess(x, hparams)
+
+
+def transformer_ffn_layer(x,
+                          hparams,
+                          pad_remover=None,
+                          conv_padding="LEFT",
+                          nonpadding_mask=None,
+                          losses=None,
+                          cache=None,
+                          decode_loop_step=None,
+                          readout_filter_size=0,
+                          layer_collection=None):
+  """Feed-forward layer in the transformer.
+
+  Args:
+    x: a Tensor of shape [batch_size, length, hparams.hidden_size]
+    hparams: hyperparameters for model
+    pad_remover: an expert_utils.PadRemover object tracking the padding
+      positions. If provided, when using convolutional settings, the padding
+      is removed before applying the convolution, and restored afterward. This
+      can give a significant speedup.
+    conv_padding: a string - either "LEFT" or "SAME".
+    nonpadding_mask: an optional Tensor with shape [batch_size, length].
+      needed for convolutional layers with "SAME" padding.
+      Contains 1.0 in positions corresponding to nonpadding.
+    losses: optional list onto which to append extra training losses
+    cache: dict, containing tensors which are the results of previous
+        attentions, used for fast decoding.
+    decode_loop_step: An integer, step number of the decoding loop.
+        Only used for inference on TPU.
+    readout_filter_size: if it's greater than 0, then it will be used instead of
+      filter_size
+    layer_collection: A tensorflow_kfac.LayerCollection. Only used by the
+      KFAC optimizer. Default is None.
+
+
+  Returns:
+    a Tensor of shape [batch_size, length, hparams.hidden_size]
+
+  Raises:
+    ValueError: If losses arg is None, but layer generates extra losses.
+  """
+  ffn_layer = hparams.ffn_layer
+  relu_dropout_broadcast_dims = (
+      common_layers.comma_separated_string_to_integer_list(
+          getattr(hparams, "relu_dropout_broadcast_dims", "")))
+  if ffn_layer == "conv_hidden_relu":
+    # Backwards compatibility
+    ffn_layer = "dense_relu_dense"
+  if ffn_layer == "dense_relu_dense":
+    if pad_remover:
+      original_shape = common_layers.shape_list(x)
+      # Collapse `x` across examples, and remove padding positions.
+      x = tf.reshape(x, tf.concat([[-1], original_shape[2:]], axis=0))
+      x = tf.expand_dims(pad_remover.remove(x), axis=0)
+    conv_output = common_layers.dense_relu_dense(
+        x,
+        hparams.filter_size,
+        hparams.hidden_size,
+        dropout=hparams.relu_dropout,
+        dropout_broadcast_dims=relu_dropout_broadcast_dims,
+        layer_collection=layer_collection)
+    if pad_remover:
+      # Restore `conv_output` to the original shape of `x`, including padding.
+      conv_output = tf.reshape(
+          pad_remover.restore(tf.squeeze(conv_output, axis=0)), original_shape)
+    return conv_output
+  elif ffn_layer == "conv_relu_conv":
+    return common_layers.conv_relu_conv(
+        x,
+        readout_filter_size or hparams.filter_size,
+        hparams.hidden_size,
+        first_kernel_size=hparams.conv_first_kernel,
+        second_kernel_size=1,
+        padding=conv_padding,
+        nonpadding_mask=nonpadding_mask,
+        dropout=hparams.relu_dropout,
+        cache=cache,
+        decode_loop_step=decode_loop_step)
+  elif ffn_layer == "parameter_attention":
+    return common_attention.parameter_attention(
+        x, hparams.parameter_attention_key_channels or hparams.hidden_size,
+        hparams.parameter_attention_value_channels or hparams.hidden_size,
+        hparams.hidden_size, readout_filter_size or hparams.filter_size,
+        hparams.num_heads,
+        hparams.attention_dropout)
+  elif ffn_layer == "conv_hidden_relu_with_sepconv":
+    return common_layers.conv_hidden_relu(
+        x,
+        readout_filter_size or hparams.filter_size,
+        hparams.hidden_size,
+        kernel_size=(3, 1),
+        second_kernel_size=(31, 1),
+        padding="LEFT",
+        dropout=hparams.relu_dropout)
+  elif ffn_layer == "sru":
+    return common_layers.sru(x)
+  elif ffn_layer == "local_moe_tpu":
+    overhead = hparams.moe_overhead_eval
+    if hparams.mode == tf.estimator.ModeKeys.TRAIN:
+      overhead = hparams.moe_overhead_train
+    ret, loss = expert_utils.local_moe_tpu(
+        x,
+        hparams.filter_size // 2,
+        hparams.hidden_size,
+        hparams.moe_num_experts,
+        overhead=overhead,
+        loss_coef=hparams.moe_loss_coef)
+  elif ffn_layer == "local_moe":
+    overhead = hparams.moe_overhead_eval
+    if hparams.mode == tf.estimator.ModeKeys.TRAIN:
+      overhead = hparams.moe_overhead_train
+    ret, loss = expert_utils.local_moe(
+        x,
+        True,
+        expert_utils.ffn_expert_fn(hparams.hidden_size, [hparams.filter_size],
+                                   hparams.hidden_size),
+        hparams.moe_num_experts,
+        k=hparams.moe_k,
+        hparams=hparams)
+    losses.append(loss)
+    return ret
+  else:
+    assert ffn_layer == "none"
+    return x

docker/bloom13b/Model-References/TensorFlow/nlp/transformer/layers/transformer_memory.py

@@ -0,0 +1,393 @@
+# coding=utf-8
+# Copyright 2021 The Tensor2Tensor Authors.
+#
+# 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.
+
+"""The memory unit for Transformer."""
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from TensorFlow.nlp.transformer.layers import common_layers
+import tensorflow.compat.v1 as tf
+
+
+class RecurrentMemory(object):
+  """Base class for recurrent memory.
+
+  This class defines the memory interface, but behaves like a no-op.
+  """
+
+  def pre_attention(self, segment, query_antecedent, memory_antecedent, bias):
+    """Called prior to self-attention, to incorporate memory items.
+
+    Args:
+      segment: an integer Tensor with shape [batch]
+      query_antecedent: a Tensor with shape [batch, length_q, channels]
+      memory_antecedent: must be None. Attention normally allows this to be a
+        Tensor with shape [batch, length_m, channels], but we currently only
+        support memory for decoder-side self-attention.
+      bias: bias Tensor (see attention_bias())
+    Returns:
+      (data, new_query_antecedent, new_memory_antecedent, new_bias)
+    """
+    del segment
+    return None, query_antecedent, memory_antecedent, bias
+
+  def post_attention(self, token, x):
+    """Called after self-attention. The memory can be updated here.
+
+    Args:
+      token: Data returned by pre_attention, which can be used to carry over
+        state related to the current memory operation.
+      x: a Tensor of data after self-attention and feed-forward
+    Returns:
+      a (possibly modified) version of the input x
+    """
+    assert token is None
+    return x
+
+
+class RecentTokensMemory(RecurrentMemory):
+  """A memory module that caches features for recent tokens.
+
+  When the number of tokens cached is equal to the chunk size, this is
+  equivalent to the memory used by Transformer-XL
+  (https://arxiv.org/abs/1901.02860)
+  """
+
+  def __init__(self, name, hparams):
+    hidden_size = hparams.hidden_size
+    self.chunk_length = hparams.split_targets_chunk_length
+    assert self.chunk_length > 0, "Chunking is required to use recurrent memory"
+
+    if hasattr(hparams, "num_memory_items") and hparams.num_memory_items > 0:
+      self.tokens_to_cache = hparams.num_memory_items
+    else:
+      self.tokens_to_cache = self.chunk_length
+
+    # TODO(kitaev): The implementation of the chunking code makes it somewhat
+    # convoluted to figure out how many actual sequences we can have per batch.
+    # The data pipeline should be revisited at some point.
+    if (hasattr(hparams, "recurrent_memory_batch_size")
+        and hparams.recurrent_memory_batch_size > 0):
+      batch_size_in_sequences = hparams.recurrent_memory_batch_size
+    else:
+      batch_size_in_sequences = hparams.batch_size / hparams.max_length
+
+    memory_shape = [batch_size_in_sequences, self.tokens_to_cache, hidden_size]
+    bias_shape = [batch_size_in_sequences, 1, 1, self.tokens_to_cache]
+
+    with tf.variable_scope(name):
+      self.previous_segment = tf.get_variable(
+          "memsegment", (batch_size_in_sequences,),
+          dtype=tf.int32, trainable=False,
+          collections=[tf.GraphKeys.LOCAL_VARIABLES],
+          initializer=tf.constant_initializer(0))
+
+      self.previous_vals = tf.get_variable(
+          "memvals", memory_shape,
+          dtype=tf.float32, trainable=False,
+          collections=[tf.GraphKeys.LOCAL_VARIABLES],
+          initializer=tf.constant_initializer(.0))
+
+      self.previous_bias = tf.get_variable(
+          "membias", bias_shape,
+          dtype=tf.float32, trainable=False,
+          collections=[tf.GraphKeys.LOCAL_VARIABLES],
+          initializer=tf.constant_initializer(-1e9))
+
+  def pre_attention(self, segment, query_antecedent, memory_antecedent, bias):
+    """Called prior to self-attention, to incorporate memory items.
+
+    Args:
+      segment: an integer Tensor with shape [batch]
+      query_antecedent: a Tensor with shape [batch, length_q, channels]
+      memory_antecedent: must be None. Attention normally allows this to be a
+        Tensor with shape [batch, length_m, channels], but we currently only
+        support memory for decoder-side self-attention.
+      bias: bias Tensor (see attention_bias())
+    Returns:
+      (data, new_query_antecedent, new_memory_antecedent, new_bias)
+    """
+    assert memory_antecedent is None, "We only support language modeling"
+
+    # In eval mode, batch size may be variable
+    memory_batch_size = tf.shape(self.previous_vals)[0]
+    current_batch_size = tf.shape(query_antecedent)[0]
+    amount_to_pad = memory_batch_size - current_batch_size
+
+    # If segment id is zero, don't attend back to the memory
+    previous_bias = self.previous_bias[:current_batch_size, :, :, :] + tf.cast(
+        tf.equal(segment[:, None, None, None], 0), tf.float32) * -1e9
+
+    sliced_previous_vals = self.previous_vals[:current_batch_size, :, :]
+
+    new_memory_antecedent = tf.concat(
+        [tf.stop_gradient(sliced_previous_vals), query_antecedent], 1)
+    new_bias = tf.concat([
+        tf.tile(tf.stop_gradient(previous_bias), [1, 1, self.chunk_length, 1]),
+        tf.tile(bias, [current_batch_size, 1, 1, 1]),
+    ], -1)
+
+    remember_segment = tf.pad(segment, [[0, amount_to_pad]])
+    # TODO(kitaev): The code assumes that we always either increment the chunk
+    # number or reset it to zero. This assumption will not hold if we re-run the
+    # model for each token, e.g. for autoregressive greedy/beam/sampling decode.
+    remember_vals = tf.pad(query_antecedent,
+                           [[0, amount_to_pad], [0, 0], [0, 0]])
+    # Query position is on axis -2 for bias: as long as a token can be attended
+    # to from at least one query position (i.e. it's not padding), memorize it.
+    remember_bias = tf.tile(
+        tf.reduce_max(bias, -2, keepdims=True), [memory_batch_size, 1, 1, 1])
+    # Assume that query_antecedent is always a full chunk (i.e. not truncated)
+    if self.chunk_length < self.tokens_to_cache:
+      remember_vals = tf.concat([self.previous_vals, remember_vals], 1)
+      remember_bias = tf.concat([
+          self.previous_bias - 1e9 * tf.cast(
+              tf.equal(
+                  tf.pad(segment, [[0, amount_to_pad]])[:, None, None, None],
+                  0), tf.float32),
+          remember_bias
+      ], -1)
+    if self.chunk_length != self.tokens_to_cache:
+      remember_vals = remember_vals[:, -self.tokens_to_cache:, :]
+      remember_bias = remember_bias[:, :, :, -self.tokens_to_cache:]
+    token = (remember_segment, remember_vals, remember_bias)
+
+    return token, query_antecedent, new_memory_antecedent, new_bias
+
+  def post_attention(self, token, x):
+    """Called after self-attention. The memory can be updated here.
+
+    Args:
+      token: Data returned by pre_attention, which can be used to carry over
+        state related to the current memory operation.
+      x: a Tensor of data after self-attention and feed-forward
+    Returns:
+      a (possibly modified) version of the input x
+    """
+    with tf.control_dependencies([
+        self.previous_segment.assign(token[0]),
+        self.previous_vals.assign(token[1]),
+        self.previous_bias.assign(token[2]),
+        ]):
+      return tf.identity(x)
+
+
+class TransformerMemory(object):
+  """Implements the Memory module.
+
+  Based on Neural Turing Machines: arXiv:1410.5401 [cs.NE]
+  """
+
+  def __init__(self, batch_size, key_depth, val_depth, memory_size,
+               sharpen_factor=1., name="neural_memory"):
+    """Initialize the memory object.
+
+    Args:
+      batch_size: the batch size.
+      key_depth: the depth of the memory keys.
+      val_depth: the depth of the memory values.
+      memory_size: the number of items in the memory.
+      sharpen_factor: the sharpen_factor for addressing the memory.
+      name: the optional variable scope.
+    """
+    self.name = name
+    self.batch_size = batch_size
+    self.key_depth = key_depth
+    self.val_depth = val_depth
+    self.memory_size = memory_size
+    self.sharpen_factor = sharpen_factor
+    with tf.variable_scope(name):
+      self.segment_number = tf.get_variable(
+          "segment_number", [self.batch_size],
+          dtype=tf.int32, trainable=False,
+          initializer=tf.constant_initializer(100000))
+      self.mem_vals = tf.get_variable(
+          "memvals", [self.batch_size, self.memory_size, self.val_depth],
+          dtype=tf.float32, trainable=False,
+          initializer=tf.constant_initializer(.0))
+      self.mean_logits = tf.get_variable(
+          "meanlogits", [self.batch_size, self.memory_size],
+          dtype=tf.float32, trainable=False,
+          initializer=tf.constant_initializer(.0))
+
+  def _norm(self, x):
+    """Compute the safe norm."""
+    return tf.sqrt(tf.reduce_sum(tf.square(x), keepdims=True, axis=-1) + 1e-7)
+
+  def _address_content(self, x):
+    """Address the memory based on content similarity.
+
+    Args:
+      x: a tensor in the shape of [batch_size, length, depth].
+    Returns:
+      the logits for each memory entry [batch_size, length, memory_size].
+    """
+    mem_keys = tf.layers.dense(self.mem_vals, self.key_depth,
+                               bias_initializer=tf.constant_initializer(1.0),
+                               name="mem_key")
+    mem_query = tf.layers.dense(x, self.key_depth,
+                                bias_initializer=tf.constant_initializer(1.0),
+                                name="mem_query")
+    norm = tf.matmul(self._norm(mem_query), self._norm(mem_keys),
+                     transpose_b=True)
+    dot_product = tf.matmul(mem_query, mem_keys, transpose_b=True)
+    cos_dist = tf.div(dot_product, norm + 1e-7, name="cos_dist")
+    access_logits = self.sharpen_factor * cos_dist
+    return access_logits
+
+  def read(self, x):
+    """Read from the memory.
+
+    An external component can use the results via a simple MLP,
+    e.g., fn(x W_x + retrieved_mem W_m).
+
+    Args:
+      x: a tensor in the shape of [batch_size, length, depth].
+    Returns:
+      access_logits: the logits for accessing the memory in shape of
+          [batch_size, length, memory_size].
+      retrieved_mem: the retrieved results in the shape of
+          [batch_size, length, val_depth].
+    """
+    access_logits = self._address_content(x)
+    weights = tf.nn.softmax(access_logits)
+    retrieved_mem = tf.reduce_sum(
+        tf.multiply(tf.expand_dims(weights, 3),
+                    tf.expand_dims(self.mem_vals, axis=1)), axis=2)
+    return access_logits, retrieved_mem
+
+  def write(self, x, access_logits):
+    """Write to the memory based on a combination of similarity and least used.
+
+    Based on arXiv:1607.00036v2 [cs.LG].
+
+    Args:
+      x: a tensor in the shape of [batch_size, length, depth].
+      access_logits: the logits for accessing the memory.
+    Returns:
+      the update op.
+    """
+    gamma = tf.layers.dense(x, 1, activation=tf.sigmoid, name="gamma")
+    write_logits = access_logits - gamma * tf.expand_dims(self.mean_logits, 1)
+    candidate_value = tf.layers.dense(x, self.val_depth,
+                                      activation=tf.nn.relu,
+                                      name="candidate_value")
+    erase_gates = tf.layers.dense(x, self.memory_size,
+                                  activation=tf.nn.sigmoid,
+                                  name="erase")
+    write_weights = tf.nn.softmax(write_logits)
+    erase_weights = tf.expand_dims(1 - erase_gates * write_weights, 3)
+    erase = tf.multiply(erase_weights,
+                        tf.expand_dims(self.mem_vals, 1))
+    addition = tf.multiply(
+        tf.expand_dims(write_weights, 3),
+        tf.expand_dims(candidate_value, 2))
+    update_value_op = self.mem_vals.assign(
+        tf.reduce_mean(erase + addition, axis=1))
+    with tf.control_dependencies([update_value_op]):
+      write_op = self.mean_logits.assign(
+          self.mean_logits * 0.1 + tf.reduce_mean(write_logits * 0.9, axis=1))
+      return write_op
+
+  def set(self, mem_vals, mean_logits):
+    set_op = tf.group([
+        self.mem_vals.assign(mem_vals),
+        self.mean_logits.assign(mean_logits)])
+    return set_op
+
+  def get(self):
+    return self.mem_vals, self.mean_logits
+
+  def update_segment_number(self, segment_number):
+    return self.segment_number.assign(segment_number)
+
+  def reset(self, entries_to_reset):
+    """Reset the entries in the memory.
+
+    Args:
+      entries_to_reset: a 1D tensor.
+    Returns:
+      the reset op.
+    """
+    num_updates = tf.size(entries_to_reset)
+    update_vals = tf.scatter_update(
+        self.mem_vals, entries_to_reset,
+        tf.tile(tf.expand_dims(
+            tf.fill([self.memory_size, self.val_depth], .0), 0),
+                [num_updates, 1, 1]))
+    update_logits = tf.scatter_update(
+        self.mean_logits, entries_to_reset,
+        tf.tile(tf.expand_dims(
+            tf.fill([self.memory_size], .0), 0),
+                [num_updates, 1]))
+    reset_op = tf.group([update_vals, update_logits])
+    return reset_op
+
+  def pre_attention(self, segment_number, query_antecedent,
+                    memory_antecedent, bias):
+    """Called prior to self-attention, to incorporate memory items.
+
+    Args:
+      segment_number: an integer Tensor with shape [batch]
+      query_antecedent: a Tensor with shape [batch, length_q, channels]
+      memory_antecedent: must be None. Attention normally allows this to be a
+        Tensor with shape [batch, length_m, channels], but we currently only
+        support memory for decoder-side self-attention.
+      bias: bias Tensor (see attention_bias())
+    Returns:
+      (data, new_query_antecedent, new_memory_antecedent, new_bias)
+    """
+    with tf.variable_scope(self.name + "/pre_attention", reuse=tf.AUTO_REUSE):
+      assert memory_antecedent is None, "We only support language modeling"
+      with tf.control_dependencies([
+          tf.assert_greater_equal(self.batch_size, tf.size(segment_number))]):
+        difference = self.batch_size - tf.size(segment_number)
+        segment_number = tf.pad(segment_number, [[0, difference]])
+        reset_op = self.reset(tf.reshape(tf.where(
+            tf.less(segment_number, self.segment_number)), [-1]))
+      memory_results = {}
+      with tf.control_dependencies([reset_op]):
+        with tf.control_dependencies([
+            self.update_segment_number(segment_number)]):
+          x = tf.pad(query_antecedent, [
+              [0, difference], [0, 0], [0, 0]])
+          access_logits, retrieved_mem = self.read(x)
+      memory_results["x"] = x
+      memory_results["access_logits"] = access_logits
+      memory_results["retrieved_mem"] = retrieved_mem
+      return memory_results, query_antecedent, memory_antecedent, bias
+
+  def post_attention(self, token, x):
+    """Called after self-attention. The memory can be updated here.
+
+    Args:
+      token: Data returned by pre_attention, which can be used to carry over
+        state related to the current memory operation.
+      x: a Tensor of data after self-attention and feed-forward
+    Returns:
+      a (possibly modified) version of the input x
+    """
+    with tf.variable_scope(self.name + "/post_attention", reuse=tf.AUTO_REUSE):
+      depth = common_layers.shape_list(x)[-1]
+      actual_batch_size = common_layers.shape_list(x)[0]
+      memory_output = tf.gather(token["retrieved_mem"],
+                                tf.range(actual_batch_size))
+      output = tf.add(tf.layers.dense(x, depth, use_bias=False),
+                      tf.layers.dense(memory_output, depth))
+      with tf.control_dependencies([output]):
+        with tf.control_dependencies([
+            self.write(token["x"], token["access_logits"])]):
+          return tf.identity(output)