diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/LICENSE b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..12d255f8e0f049d3c3127e71788e219b86cdf55b
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/LICENSE
@@ -0,0 +1,251 @@
+ 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.
+
+## Some of TensorFlow's code is derived from Caffe, which is subject to the following copyright notice:
+
+COPYRIGHT
+
+All contributions by the University of California:
+
+Copyright (c) 2014, The Regents of the University of California (Regents)
+All rights reserved.
+
+All other contributions:
+
+Copyright (c) 2014, the respective contributors
+All rights reserved.
+
+Caffe uses a shared copyright model: each contributor holds copyright over
+their contributions to Caffe. The project versioning records all such
+contribution and copyright details. If a contributor wants to further mark
+their specific copyright on a particular contribution, they should indicate
+their copyright solely in the commit message of the change when it is
+committed.
+
+LICENSE
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+CONTRIBUTION AGREEMENT
+
+By contributing to the BVLC/caffe repository through pull-request, comment,
+or otherwise, the contributor releases their content to the
+license and copyright terms herein.
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/README.md b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..fda58942fdc91d2049c6bae9acdbba22bd9b33b3
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/README.md
@@ -0,0 +1,110 @@
+- [基本信息](#基本信息.md)
+- [概述](#概述.md)
+- [训练环境准备](#训练环境准备.md)
+- [快速上手](#快速上手.md)
+- [训练结果](#训练结果.md)
+- [高级参考](#高级参考.md)
+基本信息
+
+**发布者（Publisher）：Huawei**
+
+**应用领域（Application Domain）：Computer Vision**
+
+**修改时间（Modified） ：2022.12.1**
+
+**框架（Framework）：TensorFlow 2.6.0**
+
+**描述（Description）：基于TensorFlow框架进行车道线识别**
+
+概述
+
+```
+UltraFast是基于点回归的方式进行车道线识别的网络模型
+```
+- 参考论文：
+
+ https://arxiv.org/abs/2004.11757
+
+- 参考实现：
+
+ https://github.com/markus-k/ultrafast-lane-detection-tf2
+
+## 默认配置
+
+- 训练数据集预处理：
+
+ - 图像的输入尺寸为(288, 800, 3)
+
+- 训练超参
+
+ - Batch size： 16
+ - Train epoch: 1
+
+
+快速上手
+
+- 数据集准备
+模型训练使用unsupervised_llamas数据集。
+
+## 模型训练
+
+- 单卡训练
+
+ 1. 配置训练参数。
+
+ 首先在脚本test/train_performance_1p.sh中，配置batch_size、epochs、data_path等参数，请用户根据实际路径配置data_path，或者在启动训练的命令行中以参数形式下发。
+
+ ```
+ batch_size=16
+ epochs=1
+ ```
+
+ 2. 启动训练。
+
+ 启动单卡训练 （脚本为SRFBN_for_TensorFlow/test/train_performance_1p.sh）
+
+ ```
+ bash train_performance_1p.sh --data_path=../data/llamas/labels
+ ```
+
+训练结果
+
+- 精度结果比对
+
+| 精度指标项 | GPU实测 | NPU实测 |
+|---------------|-------|-------|
+| UltraFast Acc | 99.7% | 99.7% |
+
+
+
+高级参考
+
+## 脚本和示例代码
+
+```
+├── README.md //代码说明文档
+├── data //数据集文件夹
+│ ├──llamas //llamas
+│ ├──color_images //单卡全量训练启动脚本
+│ ├──labels //单卡全量训练启动脚本
+├── models //模型定义
+├── unsupervised_llamas //数据集处理文件夹
+├── utils //工具代码文件夹
+├── test_ultrafast.py //测试代码
+├── train_ultrafast.py //训练代码
+├── test
+│ ├──train_performance_1p.sh //单卡训练验证性能启动脚本
+│ ├──train_full_1p.sh //单卡全量训练启动脚本
+```
+
+## 脚本参数
+
+```
+--data_path 数据集路径，默认：./data/llamas
+--batch_size batch size，默认：16
+--epochs 训练epcoh数量，默认：1
+```
+
+## 训练过程
+
+1. 通过“模型训练”中的训练指令启动单卡训练。
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/__init__.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/residual_block.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/residual_block.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e973eb9a727c5a139b399e0c36f68cada3b1185
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/residual_block.py
@@ -0,0 +1,129 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# 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
+
+
+class BasicBlock(tf.keras.layers.Layer):
+
+ def __init__(self, filter_num, stride=1):
+ super(BasicBlock, self).__init__()
+ self.conv1 = tf.keras.layers.Conv2D(filters=filter_num,
+ kernel_size=(3, 3),
+ strides=stride,
+ padding="same")
+ self.bn1 = tf.keras.layers.BatchNormalization()
+ self.conv2 = tf.keras.layers.Conv2D(filters=filter_num,
+ kernel_size=(3, 3),
+ strides=1,
+ padding="same")
+ self.bn2 = tf.keras.layers.BatchNormalization()
+ if stride != 1:
+ self.downsample = tf.keras.Sequential()
+ self.downsample.add(tf.keras.layers.Conv2D(filters=filter_num,
+ kernel_size=(1, 1),
+ strides=stride))
+ self.downsample.add(tf.keras.layers.BatchNormalization())
+ else:
+ self.downsample = lambda x: x
+
+ def call(self, inputs, training=None, **kwargs):
+ residual = self.downsample(inputs)
+
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.conv2(x)
+ x = self.bn2(x, training=training)
+
+ output = tf.nn.relu(tf.keras.layers.add([residual, x]))
+
+ return output
+
+
+class BottleNeck(tf.keras.layers.Layer):
+ def __init__(self, filter_num, stride=1):
+ super(BottleNeck, self).__init__()
+ self.conv1 = tf.keras.layers.Conv2D(filters=filter_num,
+ kernel_size=(1, 1),
+ strides=1,
+ padding='same')
+ self.bn1 = tf.keras.layers.BatchNormalization()
+ self.conv2 = tf.keras.layers.Conv2D(filters=filter_num,
+ kernel_size=(3, 3),
+ strides=stride,
+ padding='same')
+ self.bn2 = tf.keras.layers.BatchNormalization()
+ self.conv3 = tf.keras.layers.Conv2D(filters=filter_num * 4,
+ kernel_size=(1, 1),
+ strides=1,
+ padding='same')
+ self.bn3 = tf.keras.layers.BatchNormalization()
+
+ self.downsample = tf.keras.Sequential()
+ self.downsample.add(tf.keras.layers.Conv2D(filters=filter_num * 4,
+ kernel_size=(1, 1),
+ strides=stride))
+ self.downsample.add(tf.keras.layers.BatchNormalization())
+
+ def call(self, inputs, training=None, **kwargs):
+ residual = self.downsample(inputs)
+
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.conv2(x)
+ x = self.bn2(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.conv3(x)
+ x = self.bn3(x, training=training)
+
+ output = tf.nn.relu(tf.keras.layers.add([residual, x]))
+
+ return output
+
+
+def make_basic_block_layer(filter_num, blocks, stride=1):
+ res_block = tf.keras.Sequential()
+ res_block.add(BasicBlock(filter_num, stride=stride))
+
+ for _ in range(1, blocks):
+ res_block.add(BasicBlock(filter_num, stride=1))
+
+ return res_block
+
+
+def make_bottleneck_layer(filter_num, blocks, stride=1):
+ res_block = tf.keras.Sequential()
+ res_block.add(BottleNeck(filter_num, stride=stride))
+
+ for _ in range(1, blocks):
+ res_block.add(BottleNeck(filter_num, stride=1))
+
+ return res_block
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/resnet.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/resnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..a326bc0dd8e527b5fc0cb96089f28f1ada3a5e25
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/resnet.py
@@ -0,0 +1,139 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# 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
+#from config import NUM_CLASSES
+from models.residual_block import make_basic_block_layer, make_bottleneck_layer
+
+NUM_CLASSES = 1000
+
+class ResNetTypeI(tf.keras.Model):
+ def __init__(self, layer_params):
+ super(ResNetTypeI, self).__init__()
+
+ self.conv1 = tf.keras.layers.Conv2D(filters=64,
+ kernel_size=(7, 7),
+ strides=2,
+ padding="same")
+ self.bn1 = tf.keras.layers.BatchNormalization()
+ self.pool1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3),
+ strides=2,
+ padding="same")
+
+ self.layer1 = make_basic_block_layer(filter_num=64,
+ blocks=layer_params[0])
+ self.layer2 = make_basic_block_layer(filter_num=128,
+ blocks=layer_params[1],
+ stride=2)
+ self.layer3 = make_basic_block_layer(filter_num=256,
+ blocks=layer_params[2],
+ stride=2)
+ self.layer4 = make_basic_block_layer(filter_num=512,
+ blocks=layer_params[3],
+ stride=2)
+
+ self.avgpool = tf.keras.layers.GlobalAveragePooling2D()
+ self.fc = tf.keras.layers.Dense(units=NUM_CLASSES, activation=tf.keras.activations.softmax)
+
+ def call(self, inputs, training=None, mask=None):
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.pool1(x)
+ x = self.layer1(x, training=training)
+ x = self.layer2(x, training=training)
+ x = self.layer3(x, training=training)
+ x = self.layer4(x, training=training)
+ x = self.avgpool(x)
+ output = self.fc(x)
+
+ return output
+
+
+class ResNetTypeII(tf.keras.Model):
+ def __init__(self, layer_params):
+ super(ResNetTypeII, self).__init__()
+ self.conv1 = tf.keras.layers.Conv2D(filters=64,
+ kernel_size=(7, 7),
+ strides=2,
+ padding="same")
+ self.bn1 = tf.keras.layers.BatchNormalization()
+ self.pool1 = tf.keras.layers.MaxPool2D(pool_size=(3, 3),
+ strides=2,
+ padding="same")
+
+ self.layer1 = make_bottleneck_layer(filter_num=64,
+ blocks=layer_params[0])
+ self.layer2 = make_bottleneck_layer(filter_num=128,
+ blocks=layer_params[1],
+ stride=2)
+ self.layer3 = make_bottleneck_layer(filter_num=256,
+ blocks=layer_params[2],
+ stride=2)
+ self.layer4 = make_bottleneck_layer(filter_num=512,
+ blocks=layer_params[3],
+ stride=2)
+
+ self.avgpool = tf.keras.layers.GlobalAveragePooling2D()
+ self.fc = tf.keras.layers.Dense(units=NUM_CLASSES, activation=tf.keras.activations.softmax)
+
+ def call(self, inputs, training=None, mask=None):
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.pool1(x)
+ x = self.layer1(x, training=training)
+ x = self.layer2(x, training=training)
+ x = self.layer3(x, training=training)
+ x = self.layer4(x, training=training)
+ x = self.avgpool(x)
+ output = self.fc(x)
+
+ return output
+
+
+def resnet_18():
+ return ResNetTypeI(layer_params=[2, 2, 2, 2])
+
+
+def resnet_34():
+ return ResNetTypeI(layer_params=[3, 4, 6, 3])
+
+
+def resnet_50():
+ return ResNetTypeII(layer_params=[3, 4, 6, 3])
+
+
+def resnet_101():
+ return ResNetTypeII(layer_params=[3, 4, 23, 3])
+
+
+def resnet_152():
+ return ResNetTypeII(layer_params=[3, 8, 36, 3])
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/ultrafast.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/ultrafast.py
new file mode 100644
index 0000000000000000000000000000000000000000..58bc722d10eb1bb50051ff0a15e2a6fe2d11f625
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/models/ultrafast.py
@@ -0,0 +1,177 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# 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
+import models.resnet as resnet
+
+
+class Backbone(tf.keras.layers.Layer):
+ def __init__(self, weights=None):
+ super(Backbone, self).__init__()
+ model = resnet.resnet_18()
+ model.build(input_shape=(None, 256,256,3))
+ if weights is not None:
+ model.load_weights(weights)
+
+ self.conv1 = model.conv1
+ self.bn1 = model.bn1
+ self.pool1 = model.pool1
+ self.layer1 = model.layer1
+ self.layer2 = model.layer2
+ self.layer3 = model.layer3
+ self.layer4 = model.layer4
+
+ if False:
+ self.conv1.trainable = False
+ self.bn1.trainable = False
+ self.pool1.trainable = False
+
+ for layer in self.layer1.layers:
+ layer.trainable = False
+
+ for layer in self.layer2.layers:
+ layer.trainable = False
+
+ for layer in self.layer3.layers:
+ layer.trainable = False
+
+ for layer in self.layer4.layers:
+ layer.trainable = False
+
+ def call(self, inputs, training=None, **kwargs):
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.nn.relu(x)
+ x = self.pool1(x)
+ x = self.layer1(x, training=training)
+ x2 = self.layer2(x, training=training)
+ x3 = self.layer3(x2, training=training)
+ x4 = self.layer4(x3, training=training)
+
+ return x2,x3,x4
+
+
+class ConvBnRelu(tf.keras.layers.Layer):
+ def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1,bias=False):
+ super(ConvBnRelu, self).__init__()
+ self.conv1 = tf.keras.layers.Conv2D(filters=out_channels,
+ kernel_size=kernel_size,
+ strides=stride,
+ padding='SAME', #padding,
+ dilation_rate=dilation,
+ use_bias=bias,
+ input_shape=(in_channels,))
+ self.bn1 = tf.keras.layers.BatchNormalization()
+
+ def call(self, inputs, training=None, **kwargs):
+ x = self.conv1(inputs)
+ x = self.bn1(x, training=training)
+ x = tf.keras.layers.ReLU()(x) #tf.nn.relu(x)
+
+ return x
+
+
+class UltraFastNet(tf.keras.Model):
+ def __init__(self, num_lanes=4, size=(288, 800), cls_dim=(37, 10, 4), use_aux=False, resnet_weights=None):
+ super(UltraFastNet, self).__init__()
+
+ self.num_lanes = num_lanes
+ self.size = size
+ self.w = size[0]
+ self.h = size[1]
+ self.cls_dim = cls_dim
+ self.use_aux = use_aux
+ self.total_dim = np.prod(cls_dim)
+
+ self.backbone = Backbone(weights=resnet_weights)
+
+ if self.use_aux:
+ self.aux_header2 = tf.keras.Sequential([
+ ConvBnRelu(128, 128, kernel_size=3, stride=1, padding=1),
+ ConvBnRelu(128,128,3,padding=1),
+ ConvBnRelu(128,128,3,padding=1),
+ ConvBnRelu(128,128,3,padding=1),
+ ], name='aux_header2')
+ self.aux_header3 = tf.keras.Sequential([
+ ConvBnRelu(256, 128, kernel_size=3, stride=1, padding=1),
+ ConvBnRelu(128, 128, 3, padding=1),
+ ConvBnRelu(128, 128, 3, padding=1),
+ ], name='aux_header3')
+ self.aux_header4 = tf.keras.Sequential([
+ ConvBnRelu(512, 128, kernel_size=3, stride=1, padding=1),
+ ConvBnRelu(128,128,3,padding=1),
+ ], name='aux_header4')
+ self.aux_combine = tf.keras.Sequential([
+ ConvBnRelu(384, 256, 3, padding=2, dilation=2),
+ ConvBnRelu(256, 128, 3, padding=2, dilation=2),
+ ConvBnRelu(128, 128, 3, padding=2, dilation=2),
+ ConvBnRelu(128, 128, 3, padding=4, dilation=4),
+ tf.keras.layers.Conv2D(128,num_lanes + 1,1)
+ ], name='aux_combine')
+
+ self.cls = tf.keras.Sequential([
+ tf.keras.layers.Dense(2048, input_shape=(1800,)),
+ tf.keras.layers.ReLU(),
+ tf.keras.layers.Dense(self.total_dim, input_shape=(2048,)),
+ ], name='cls')
+
+ self.pool = tf.keras.layers.Conv2D(8, 1, input_shape=(512,), name='pool')
+
+ self.sm = tf.keras.layers.Softmax(axis=1)
+
+ self.build((None, self.h, self.w, 3))
+
+ def call(self, inputs, training=None, mask=None):
+ # n c h w - > n 2048 sh sw
+ # -> n 2048
+ #inputs = tf.keras.layers.InputLayer(input_shape=(None, self.h, self.h, 3))
+ x2,x3,fea = self.backbone(inputs)
+
+ if self.use_aux:
+ x2 = self.aux_header2(x2)
+ x3 = self.aux_header3(x3)
+ x3 = tf.keras.layers.UpSampling2D(size=2, interpolation='bilinear')(x3)
+ x4 = self.aux_header4(fea)
+ x4 = tf.keras.layers.UpSampling2D(size=4, interpolation='bilinear')(x4)
+ aux_seg = tf.keras.layers.Concatenate(axis=1)([x2,x3,x4])
+ aux_seg = self.aux_combine(aux_seg)
+ else:
+ aux_seg = None
+
+ fea = tf.reshape(self.pool(fea), (-1, 1800))
+
+ group_cls = tf.reshape(self.cls(fea), (-1, *self.cls_dim))
+
+ group_cls_sm = self.sm(group_cls)
+
+ if self.use_aux:
+ return group_cls_sm, aux_seg
+
+ return group_cls_sm
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/modelzoo_level.txt b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/modelzoo_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..810a09268cf30040cffd446a4242b3fec735ee66
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/modelzoo_level.txt
@@ -0,0 +1,5 @@
+GPUStatus:OK
+NPUMigrationStatus:OK
+FuncStatus:OK
+PrecisionStatus:OK
+PerfStatus:POK
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/requirements.txt b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c0c051f77601f66cf362d15af78a43deb885f8f2
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/requirements.txt
@@ -0,0 +1,8 @@
+matplotlib==3.5.3
+numpy==1.19.5
+opencv_python==4.6.0.66
+p_tqdm==1.4.0
+scipy==1.7.3
+Shapely==1.7.1
+tensorflow==2.6.5
+tqdm==4.64.1
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_full_1p.sh b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_full_1p.sh
new file mode 100644
index 0000000000000000000000000000000000000000..c409772c9b1c391561dfffbe06327e07ac017e39
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_full_1p.sh
@@ -0,0 +1,157 @@
+#!/bin/bash
+
+##########################################################
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+##########################################################
+# shell脚本所在路径
+cur_path=`echo $(cd $(dirname $0);pwd)`
+
+# 判断当前shell是否是performance
+perf_flag=`echo $0 | grep performance | wc -l`
+
+# 当前执行网络的名称
+Network=`echo $(cd $(dirname $0);pwd) | awk -F"/" '{print $(NF-1)}'`
+
+export RANK_SIZE=1
+export RANK_ID=0
+export JOB_ID=10087
+
+# 路径参数初始化
+data_path=""
+output_path=""
+
+# 帮助信息，不需要修改
+if [[ $1 == --help || $1 == -h ]];then
+ echo"usage:./train_performance_1P.sh "
+ echo " "
+ echo "parameter explain:
+ --data_path # dataset of training
+ --output_path # output of training
+ --train_steps # max_step for training
+ --train_epochs # max_epoch for training
+ --batch_size # batch size
+ -h/--help show help message
+ "
+ exit 1
+fi
+
+# 参数校验，不需要修改
+for para in $*
+do
+ if [[ $para == --data_path* ]];then
+ data_path=`echo ${para#*=}`
+ elif [[ $para == --output_path* ]];then
+ output_path=`echo ${para#*=}`
+ elif [[ $para == --train_steps* ]];then
+ train_steps=`echo ${para#*=}`
+ elif [[ $para == --train_epochs* ]];then
+ train_epochs=`echo ${para#*=}`
+ elif [[ $para == --batch_size* ]];then
+ batch_size=`echo ${para#*=}`
+ fi
+done
+
+# 校验是否传入data_path,不需要修改
+if [[ $data_path == "" ]];then
+ echo "[Error] para \"data_path\" must be config"
+ exit 1
+fi
+
+# 校验是否传入output_path,不需要修改
+if [[ $output_path == "" ]];then
+ output_path="./test/output/${ASCEND_DEVICE_ID}"
+fi
+
+CaseName=""
+function get_casename()
+{
+ if [ x"${perf_flag}" = x1 ];
+ then
+ CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'perf'
+ else
+ CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'acc'
+ fi
+}
+
+# 跳转到code目录
+cd ${cur_path}/../
+rm -rf ./test/output/${ASCEND_DEVICE_ID}
+mkdir -p ./test/output/${ASCEND_DEVICE_ID}
+
+# 训练开始时间记录，不需要修改
+start_time=$(date +%s)
+##########################################################
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+##########################################################
+
+#=========================================================
+#=========================================================
+#========训练执行命令，需要根据您的网络进行修改==============
+#=========================================================
+#=========================================================
+# 基础参数，需要模型审视修改
+# 您的训练数据集在${data_path}路径下，请直接使用这个变量获取
+# 您的训练输出目录在${output_path}路径下，请直接使用这个变量获取
+# 您的其他基础参数，可以自定义增加，但是batch_size请保留，并且设置正确的值
+train_epochs=1
+batch_size=16
+
+print_log="./test/output/${ASCEND_DEVICE_ID}/train_${ASCEND_DEVICE_ID}.log"
+python3.7 ./train_ultrafast.py --data-path=${data_path} --output-path=${output_path} --epochs=${train_epochs} --batch-size=${batch_size} 1>${print_log} 2>&1
+
+
+# 性能相关数据计算
+StepTime= grep "[0-9]*ms/step" ${print_log} -o |grep "[0-9]*" -o | awk '{sum+=$1} sum/NR'
+FPS=`awk 'BEGIN{printf "%.2f\n", '${batch_size}'/'${StepTime}'}'`
+
+# 精度相关数据计算
+train_accuracy=grep "val_ultrafast_accuracy: [0-9.]*" ${print_log} -o |tail -1 |grep "[0-9.]*" -o
+# 提取所有loss打印信息
+grep "loss: " ${print_log} | awk -F ":" '{print $4}' | awk -F "-" '{print $1}' > ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt
+
+###########################################################
+#########后面的所有内容请不要修改###########################
+#########后面的所有内容请不要修改###########################
+#########后面的所有内容请不要修改###########################
+###########################################################
+
+# 获取最终的casename，请保留，case文件名为${CaseName}
+get_casename
+
+# 重命名loss文件
+if [ -f ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ];
+then
+ mv ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ./test/output/${ASCEND_DEVICE_ID}/${CaseName}_loss.txt
+fi
+
+# 训练端到端耗时
+end_time=$(date +%s)
+e2e_time=$(( $end_time - $start_time ))
+
+echo "------------------ Final result ------------------"
+# 输出性能FPS/单step耗时/端到端耗时
+echo "Final Performance images/sec : $FPS"
+echo "Final Performance sec/step : $StepTime"
+echo "E2E Training Duration sec : $e2e_time"
+
+# 输出训练精度
+echo "Final Train Accuracy : ${train_accuracy}"
+
+# 最后一个迭代loss值，不需要修改
+ActualLoss=(`awk 'END {print $NF}' ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt`)
+
+#关键信息打印到${CaseName}.log中，不需要修改
+echo "Network = ${Network}" > $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "RankSize = ${RANK_SIZE}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "BatchSize = ${batch_size}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "DeviceType = `uname -m`" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "CaseName = ${CaseName}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "ActualFPS = ${FPS}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "TrainingTime = ${StepTime}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "ActualLoss = ${ActualLoss}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "E2ETrainingTime = ${e2e_time}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "TrainAccuracy = ${train_accuracy}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_performance_1p.sh b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_performance_1p.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d13219cb7ad0755d34882e965b85d522e367dbc6
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test/train_performance_1p.sh
@@ -0,0 +1,157 @@
+#!/bin/bash
+
+##########################################################
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+##########################################################
+# shell脚本所在路径
+cur_path=`echo $(cd $(dirname $0);pwd)`
+
+# 判断当前shell是否是performance
+perf_flag=`echo $0 | grep performance | wc -l`
+
+# 当前执行网络的名称
+Network=`echo $(cd $(dirname $0);pwd) | awk -F"/" '{print $(NF-1)}'`
+
+export RANK_SIZE=1
+export RANK_ID=0
+export JOB_ID=10087
+
+# 路径参数初始化
+data_path=""
+output_path=""
+
+# 帮助信息，不需要修改
+if [[ $1 == --help || $1 == -h ]];then
+ echo"usage:./train_performance_1P.sh "
+ echo " "
+ echo "parameter explain:
+ --data_path # dataset of training
+ --output_path # output of training
+ --train_steps # max_step for training
+ --train_epochs # max_epoch for training
+ --batch_size # batch size
+ -h/--help show help message
+ "
+ exit 1
+fi
+
+# 参数校验，不需要修改
+for para in $*
+do
+ if [[ $para == --data_path* ]];then
+ data_path=`echo ${para#*=}`
+ elif [[ $para == --output_path* ]];then
+ output_path=`echo ${para#*=}`
+ elif [[ $para == --train_steps* ]];then
+ train_steps=`echo ${para#*=}`
+ elif [[ $para == --train_epochs* ]];then
+ train_epochs=`echo ${para#*=}`
+ elif [[ $para == --batch_size* ]];then
+ batch_size=`echo ${para#*=}`
+ fi
+done
+
+# 校验是否传入data_path,不需要修改
+if [[ $data_path == "" ]];then
+ echo "[Error] para \"data_path\" must be config"
+ exit 1
+fi
+
+# 校验是否传入output_path,不需要修改
+if [[ $output_path == "" ]];then
+ output_path="./test/output/${ASCEND_DEVICE_ID}"
+fi
+
+CaseName=""
+function get_casename()
+{
+ if [ x"${perf_flag}" = x1 ];
+ then
+ CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'perf'
+ else
+ CaseName=${Network}_bs${batch_size}_${RANK_SIZE}'p'_'acc'
+ fi
+}
+
+# 跳转到code目录
+cd ${cur_path}/../
+rm -rf ./test/output/${ASCEND_DEVICE_ID}
+mkdir -p ./test/output/${ASCEND_DEVICE_ID}
+
+# 训练开始时间记录，不需要修改
+start_time=$(date +%s)
+##########################################################
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+#########第3行 至 90行，请一定不要、不要、不要修改##########
+##########################################################
+
+#=========================================================
+#=========================================================
+#========训练执行命令，需要根据您的网络进行修改==============
+#=========================================================
+#=========================================================
+# 基础参数，需要模型审视修改
+# 您的训练数据集在${data_path}路径下，请直接使用这个变量获取
+# 您的训练输出目录在${output_path}路径下，请直接使用这个变量获取
+# 您的其他基础参数，可以自定义增加，但是batch_size请保留，并且设置正确的值
+train_epochs=1
+batch_size=16
+
+print_log="./test/output/${ASCEND_DEVICE_ID}/train_${ASCEND_DEVICE_ID}.log"
+python3.7 ./train_ultrafast.py --data-path=${data_path} --output-path=${output_path} --epochs=${train_epochs} --batch-size=${batch_size} 1>${print_log} 2>&1
+
+
+# 性能相关数据计算
+StepTime= grep "[0-9]*ms/step" ${print_log} -o |grep "[0-9]*" -o | awk '{sum+=$1} sum/NR'
+FPS=`awk 'BEGIN{printf "%.2f\n", '${batch_size}'/'${StepTime}'}'`
+
+# 精度相关数据计算
+train_accuracy=grep "val_ultrafast_accuracy: [0-9.]*" ${print_log} -o |tail -1 |grep "[0-9.]*" -o
+# 提取所有loss打印信息
+grep "loss: " ${print_log} | awk -F ":" '{print $4}' | awk -F "-" '{print $1}' > ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt
+
+
+###########################################################
+#########后面的所有内容请不要修改###########################
+#########后面的所有内容请不要修改###########################
+#########后面的所有内容请不要修改###########################
+###########################################################
+
+# 获取最终的casename，请保留，case文件名为${CaseName}
+get_casename
+
+# 重命名loss文件
+if [ -f ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ];
+then
+ mv ./test/output/${ASCEND_DEVICE_ID}/my_output_loss.txt ./test/output/${ASCEND_DEVICE_ID}/${CaseName}_loss.txt
+fi
+
+# 训练端到端耗时
+end_time=$(date +%s)
+e2e_time=$(( $end_time - $start_time ))
+
+echo "------------------ Final result ------------------"
+# 输出性能FPS/单step耗时/端到端耗时
+echo "Final Performance images/sec : $FPS"
+echo "Final Performance sec/step : $StepTime"
+echo "E2E Training Duration sec : $e2e_time"
+
+# 输出训练精度
+echo "Final Train Accuracy : ${train_accuracy}"
+
+# 最后一个迭代loss值，不需要修改
+ActualLoss=(`awk 'END {print $NF}' ./test/output/${ASCEND_DEVICE_ID}/${CaseName}_loss.txt`)
+
+#关键信息打印到${CaseName}.log中，不需要修改
+echo "Network = ${Network}" > $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "RankSize = ${RANK_SIZE}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "BatchSize = ${batch_size}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "DeviceType = `uname -m`" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "CaseName = ${CaseName}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "ActualFPS = ${FPS}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "TrainingTime = ${StepTime}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "ActualLoss = ${ActualLoss}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
+echo "E2ETrainingTime = ${e2e_time}" >> $cur_path/output/$ASCEND_DEVICE_ID/${CaseName}.log
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test_ultrafast.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test_ultrafast.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f0a1c6f2f8390996381050acd86791ca36b8b27
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/test_ultrafast.py
@@ -0,0 +1,172 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# 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 npu_device as npu
+#npu.open().as_default()
+
+import time
+from unsupervised_llamas.label_scripts.spline_creator import get_horizontal_values_for_four_lanes
+import tensorflow as tf
+import numpy as np
+import json
+import os
+import cv2
+import matplotlib.pyplot as plt
+from utils import losses, metrics
+
+def display(display_list):
+ plt.figure(figsize=(15, 15))
+
+ title = ['Input Image', 'True Mask', 'Predicted Mask']
+
+ for i in range(len(display_list)):
+ plt.subplot(1, len(display_list), i + 1)
+ plt.title(title[i])
+ plt.imshow(tf.keras.preprocessing.image.array_to_img(display_list[i]))
+ plt.savefig('result.png')
+
+BASE_PATH = './data/llamas/labels/'
+PARALLEL_JOBS = 4
+
+NUM_LANES = 2
+INPUT_SHAPE = (288, 800, 3)
+CLS_SHAPE = (100, 20, NUM_LANES)
+IMAGE_SHAPE = (288, 800, 3)
+SHUFFLE_SIZE = 100000
+TAKE_LLAMAS_MAX = 1024
+
+LLAMAS_SHAPE = (717, 1276)
+DTYPE = tf.float32
+
+
+def resize_img(img, shape):
+ w = img.shape[1]
+ h = img.shape[0]
+
+ ratio = shape[1] / shape[0]
+
+ tgt = img[h - int(w / ratio):h, 0:w]
+ tgt = cv2.resize(tgt, (shape[1], shape[0]))
+ return tgt.astype(np.float32) / 255
+ # return tgt
+
+
+class LlamasDS:
+ def __init__(self, cls_shape, image_shape):
+ self.cls_shape = cls_shape
+ self.image_shape = image_shape
+
+ def load_image(self, file):
+ file = file.numpy().decode("utf-8")
+
+ with open(file, 'r') as fp:
+ meta = json.load(fp)
+ image_path = os.path.dirname(file)
+ image_path = image_path.replace('labels', 'color_images')
+ img_name = meta['image_name'] + '_color_rect.png'
+ fname = os.path.join(image_path, img_name)
+ img = cv2.imread(fname)
+
+ return img
+
+ def read_image(self, file):
+ img = self.load_image(file)
+ img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+ return resize_img(img, self.image_shape)
+
+ def generate_grid_llamas(self, file):
+ file = file.numpy().decode("utf-8")
+ lanes = get_horizontal_values_for_four_lanes(file)
+ lanes = np.array(lanes)
+
+ gt = np.zeros(self.cls_shape)
+
+ for y in range(self.cls_shape[1]):
+ yf = y / self.cls_shape[1]
+ ly = int(lanes.shape[1] * yf)
+
+ lx = lanes.T[ly, :]
+
+ invalids = np.where(lx == -1)
+
+ xf = lx / LLAMAS_SHAPE[1]
+ x = np.round(xf * self.cls_shape[0] - 1).astype(np.int)
+
+ x[invalids] = self.cls_shape[0] - 1
+
+ # delete unused lanes
+ x = np.delete(x, (0, 3))
+
+ for i in range(len(x)):
+ gt[x[i], y, i] = 1
+
+ return gt
+
+ def process_json(self, json):
+ img = tf.py_function(self.read_image, [json], Tout=DTYPE)
+ grid = tf.py_function(self.generate_grid_llamas, [json], Tout=DTYPE)
+
+ img = tf.reshape(img, shape=self.image_shape)
+ grid = tf.reshape(grid, shape=self.cls_shape)
+ return img, grid
+
+
+llds = LlamasDS(CLS_SHAPE, INPUT_SHAPE)
+
+llamas_train_ds = tf.data.Dataset.list_files(os.path.join(BASE_PATH, 'train', '*/*.json'))
+llamas_valid_ds = tf.data.Dataset.list_files(os.path.join(BASE_PATH, 'valid', '*/*.json'))
+
+llamas_train_ds = llamas_train_ds.shuffle(SHUFFLE_SIZE)
+llamas_train_ds = llamas_train_ds.take(TAKE_LLAMAS_MAX)
+llamas_train_ds = llamas_train_ds.map(llds.process_json, num_parallel_calls=PARALLEL_JOBS)
+
+llamas_valid_ds = llamas_valid_ds.shard(num_shards=2, index=0)
+llamas_test_ds = llamas_valid_ds.shard(num_shards=2, index=1)
+
+llamas_valid_ds = llamas_valid_ds.map(llds.process_json, num_parallel_calls=PARALLEL_JOBS)
+llamas_test_ds = llamas_test_ds.map(llds.process_json, num_parallel_calls=PARALLEL_JOBS)
+ufm = tf.keras.models.load_model('trained_model/ultrafast.tf', compile=False)
+ufm.compile(optimizer='adam', loss=losses.ultrafast_loss, metrics=[metrics.ultrafast_accuracy])
+for img, mask in llamas_test_ds.take(5):
+ s = time.time()
+ pred = ufm.predict(tf.expand_dims(img, axis=0))
+ e = time.time()
+
+ print(e - s)
+
+ pred = pred[0]
+
+ m = tf.zeros((CLS_SHAPE[0], CLS_SHAPE[1], 3 - CLS_SHAPE[2]), dtype=DTYPE)
+ m = tf.concat([pred, m], -1)
+
+ m2 = tf.zeros((CLS_SHAPE[0], CLS_SHAPE[1], 3 - CLS_SHAPE[2]), dtype=DTYPE)
+ m2 = tf.concat([mask, m2], -1)
+
+ display([img, np.flipud(np.rot90(m2)), np.flipud(np.rot90(m))])
\ No newline at end of file
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/train_ultrafast.py b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/train_ultrafast.py
new file mode 100644
index 0000000000000000000000000000000000000000..582a886367151dd3173f09e096cbe2dc492885f8
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/train_ultrafast.py
@@ -0,0 +1,143 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# 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 npu_device as npu
+npu.open().as_default()
+
+import tensorflow as tf
+import shutil
+import os
+import argparse
+
+
+from models.ultrafast import UltraFastNet
+from utils import losses, metrics
+from utils.datasets import llamas_dataset, labelme_dataset
+
+
+parser = argparse.ArgumentParser(description='Train Ultrafast Net')
+parser.add_argument('--epochs', type=int, default=1)
+parser.add_argument('--batch-size', type=int, default=16)
+parser.add_argument('--max-images', type=int, default=None)
+parser.add_argument('--prefetch-size', type=int, default=256)
+parser.add_argument('--resnet-weights', default=None)
+parser.add_argument('--base-path', default='')
+parser.add_argument('--llamas-path', '--data-path', default='./data/llamas/')
+parser.add_argument('--labelme-path', default=[], action='append')
+parser.add_argument('--output-path', default='./')
+parser.add_argument('--model-name', default='ultrafast')
+
+args = parser.parse_args()
+print(args)
+
+EPOCHS = args.epochs
+BATCH_SIZE = args.batch_size
+PREFETCH_SIZE = args.prefetch_size
+
+NUM_IMAGES = args.max_images
+VAL_SPLIT = 0.3
+
+NUM_LANES = 2
+CLS_SHAPE = (100, 20, NUM_LANES)
+IMAGE_SHAPE = (288, 800, 3)
+
+RESNET_WEIGHTS = args.resnet_weights
+
+BASE_PATH = args.base_path
+LLAMAS_PATH = os.path.join(BASE_PATH, args.llamas_path)
+LABELME_PATHS = [os.path.join(BASE_PATH, path) for path in args.labelme_path]
+
+OUTPUT_PATH = args.output_path
+LOG_DIR = os.path.join(OUTPUT_PATH, 'logs_ultrafast')
+CHECKPOINT_DIR = os.path.join(OUTPUT_PATH, 'checkpoints_ultrafast')
+MODEL_DIR = os.path.join(OUTPUT_PATH, 'model')
+
+MODEL_NAME = '{}.tf'.format(args.model_name)
+MODEL_PATH = os.path.join(MODEL_DIR, MODEL_NAME)
+
+print('Preparing datasets')
+llamas_train_ds = llamas_dataset(os.path.join(LLAMAS_PATH, 'labels', 'train', '*', '*.json'), CLS_SHAPE, IMAGE_SHAPE)
+llamas_valid_ds = llamas_dataset(os.path.join(LLAMAS_PATH, 'labels', 'valid', '*', '*.json'), CLS_SHAPE, IMAGE_SHAPE)
+
+labelme_ds = None
+for path in LABELME_PATHS:
+ ds = llamas_dataset(os.path.join(LLAMAS_PATH, '*.json'), CLS_SHAPE, IMAGE_SHAPE)
+ if labelme_ds is None:
+ labelme_ds = ds
+ else:
+ labelme_ds = labelme_ds.concatenate(ds)
+
+train_ds = llamas_train_ds
+if labelme_ds is not None:
+ train_ds = train_ds.concatenate(labelme_ds)
+
+valid_ds = llamas_valid_ds
+
+train_ds = train_ds.batch(BATCH_SIZE).prefetch(PREFETCH_SIZE)
+valid_ds = valid_ds.batch(BATCH_SIZE).prefetch(PREFETCH_SIZE)
+
+print('Preparing model')
+model = UltraFastNet(num_lanes=NUM_LANES,
+ size=IMAGE_SHAPE[0:2],
+ cls_dim=CLS_SHAPE,
+ use_aux=False,
+ resnet_weights=RESNET_WEIGHTS)
+
+adam = tf.keras.optimizers.Adam()
+
+print('compiling model')
+model.compile(optimizer=adam, loss=losses.ultrafast_loss, metrics=[ metrics.ultrafast_accuracy])
+print('model compiled')
+model.summary()
+
+
+shutil.rmtree(LOG_DIR, ignore_errors=True)
+#tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=LOG_DIR)
+
+os.makedirs(CHECKPOINT_DIR, exist_ok=True)
+checkpoint_filepath = os.path.join(CHECKPOINT_DIR, 'ckpt')
+model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
+ filepath=checkpoint_filepath,
+ save_weights_only=True,
+ monitor='val_ultrafast_accuracy',
+ mode='max',
+ save_best_only=True)
+
+print('Training model')
+history = model.fit(train_ds,
+ epochs=EPOCHS,
+ validation_data=valid_ds,
+ callbacks=[#tensorboard_callback,
+ model_checkpoint_callback],
+ verbose=1)
+model.optimizer = None
+model.compiled_loss = None
+model.compiled_metrics = None
+model.save(MODEL_PATH, save_format='tf')
+
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/LICENSE b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..b2094679905e7dd528b7da3d2c03da529b998e2a
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/LICENSE
@@ -0,0 +1,30 @@
+BSD License
+
+For fb.resnet.torch software
+
+Copyright (c) 2016, Facebook, Inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ * Neither the name Facebook nor the names of its contributors may be used to
+ endorse or promote products derived from this software without specific
+ prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/ParallelCriterion2.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/ParallelCriterion2.lua
new file mode 100644
index 0000000000000000000000000000000000000000..f6943711e9ae5e58f1ce13cb5869b8ce78d6083a
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/ParallelCriterion2.lua
@@ -0,0 +1,43 @@
+local ParallelCriterion2, parent = torch.class('nn.ParallelCriterion2', 'nn.Criterion')
+
+function ParallelCriterion2:__init(repeatTarget)
+ parent.__init(self)
+ self.criterions = {}
+ self.weights = {}
+ self.gradInput = {}
+ self.repeatTarget = repeatTarget
+end
+
+function ParallelCriterion2:add(criterion, weight)
+ assert(criterion, 'no criterion provided')
+ weight = weight or 1
+ table.insert(self.criterions, criterion)
+ table.insert(self.weights, weight)
+ return self
+end
+
+function ParallelCriterion2:updateOutput(input, target)
+ self.output = 0
+ local output = {}
+ for i,criterion in ipairs(self.criterions) do
+ local target = self.repeatTarget and target or target[i]
+ self.output = self.output + self.weights[i]*criterion:updateOutput(input[i],target)
+ table.insert(output, self.weights[i]*criterion:updateOutput(input[i],target))
+ end
+ return self.output, output
+end
+
+function ParallelCriterion2:updateGradInput(input, target)
+ self.gradInput = nn.utils.recursiveResizeAs(self.gradInput, input)
+ nn.utils.recursiveFill(self.gradInput, 0)
+ for i,criterion in ipairs(self.criterions) do
+ local target = self.repeatTarget and target or target[i]
+ nn.utils.recursiveAdd(self.gradInput[i], self.weights[i], criterion:updateGradInput(input[i], target))
+ end
+ return self.gradInput
+end
+
+function ParallelCriterion2:type(type, tensorCache)
+ self.gradInput = {}
+ return parent.type(self, type, tensorCache)
+end
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/README.md b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..87a37adb75843dabd2d7975bfe23d21d0f052312
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/README.md
@@ -0,0 +1,78 @@
+
+## Requirements
+- [Torch](http://torch.ch/docs/getting-started.html), please follow the installation instructions at [fb.resnet.torch](https://github.com/facebook/fb.resnet.torch).
+
+## Before Start
+
+Please follow [train_final.txt](./list/train_final.txt) and [val_final.txt](./list/val_final.txt) to put LLAMAS dataset in the desired folder. We'll call the directory that you cloned ENet-SAD-Simple as `$ENet_ROOT`.
+
+## Testing
+1. Put your trained model to `./experiments/pretrained`
+ ```Shell
+ cd $ENet_ROOT/experiments/pretrained
+ ```
+ You can just train the model by yourself and have a test.
+
+2. Run test script
+ ```Shell
+ cd $ENet_ROOT
+ sh ./experiments/test.sh
+ ```
+ Testing results (probability map of lane markings) are saved in `experiments/predicts/` by default.
+
+3. Submit the results to server
+ Please follow the instructions of LLAMAS to submit your results.
+ The performance of our trained model is as follows (you can also find the result in the [official site](https://unsupervised-llamas.com/llamas/benchmark_multi)):
+
+ 0: {'auc': 0.9999917047921401,
+ 'precision': 0.9973478736332135,
+ 'recall': 0.9971669285812986,
+ 'threshold': 0.8156624779014764},
+
+ 1: {'auc': 0.26641235441069483,
+ 'precision': 0.16706499250242474,
+ 'recall': 0.32421710675084453,
+ 'threshold': 0.467389746285059},
+
+ 2: {'auc': 0.8964441173279966,
+ 'precision': 0.6147108519863974,
+ 'recall': 0.7864514156111525,
+ 'threshold': 0.9866214343733576},
+
+ 3: {'auc': 0.8804212880439664,
+ 'precision': 0.6146173378763694,
+ 'recall': 0.7364950314056325,
+ 'threshold': 0.9923073247646805},
+
+ 4: {'auc': 0.4982252894705332,
+ 'precision': 0.3300198333296339,
+ 'recall': 0.4491891521484192,
+ 'threshold': 0.8424673897462851}
+
+## Training
+1. Download the pre-trained model
+ ```Shell
+ cd $ENet_ROOT/experiments/models
+ ```
+ Download the pre-trained model [here](https://drive.google.com/open?id=1pIMThIsGn8z8rIs6WgSNzom1H8WVvP5Q) and move it to `$ENet_ROOT/experiments/models`.
+2. Training ENet-SAD-Simple model
+ ```Shell
+ cd $ENet_ROOT
+ sh ./experiments/train.sh
+ ```
+ The training process should start and trained models would be saved in `experiments/models/ENet-SAD-Simple` by default.
+ Then you can test the trained model following the Testing steps above. If your model position or name is changed, remember to set them to yours accordingly.
+
+## Citation
+
+If you use this code, please cite the following publication:
+
+```
+@article{hou2019learning,
+ title={Learning Lightweight Lane Detection CNNs by Self Attention Distillation},
+ author={Hou, Yuenan and Ma, Zheng and Liu, Chunxiao and Loy, Chen Change},
+ journal={arXiv preprint arXiv:1908.00821},
+ year={2019}
+}
+```
+
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/checkpoints.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/checkpoints.lua
new file mode 100644
index 0000000000000000000000000000000000000000..0b8491e0dae1d07bffd0f0e0aff812428224b280
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/checkpoints.lua
@@ -0,0 +1,71 @@
+--
+-- Copyright (c) 2016, Facebook, Inc.
+-- All rights reserved.
+--
+-- This source code is licensed under the BSD-style license found in the
+-- LICENSE file in the root directory of this source tree. An additional grant
+-- of patent rights can be found in the PATENTS file in the same directory.
+--
+local checkpoint = {}
+
+local function deepCopy(tbl)
+ -- creates a copy of a network with new modules and the same tensors
+ local copy = {}
+ for k, v in pairs(tbl) do
+ if type(v) == 'table' then
+ copy[k] = deepCopy(v)
+ else
+ copy[k] = v
+ end
+ end
+ if torch.typename(tbl) then
+ torch.setmetatable(copy, torch.typename(tbl))
+ end
+ return copy
+end
+
+function checkpoint.latest(opt)
+ if opt.resume == 'none' then
+ return nil
+ end
+
+ local latestPath = paths.concat(opt.resume, 'latest.t7')
+ if not paths.filep(latestPath) then
+ return nil
+ end
+
+ print('=> Loading checkpoint ' .. latestPath)
+ local latest = torch.load(latestPath)
+ local optimState = torch.load(paths.concat(opt.resume, latest.optimFile))
+
+ return latest, optimState
+end
+
+function checkpoint.save(epoch, model, optimState, isBestModel, opt, iter, bestLoss)
+ -- don't save the DataParallelTable for easier loading on other machines
+ if torch.type(model) == 'nn.DataParallelTable' then
+ model = model:get(1)
+ end
+
+ -- create a clean copy on the CPU without modifying the original network
+ model = deepCopy(model):float():clearState()
+
+ local modelFile = 'model_new.t7'
+ local optimFile = 'optimState_new.t7'
+
+ torch.save(paths.concat(opt.save, modelFile), model)
+ torch.save(paths.concat(opt.save, optimFile), optimState)
+ torch.save(paths.concat(opt.save, 'latest.t7'), {
+ iter = iter,
+ epoch = epoch,
+ bestLoss = bestLoss,
+ modelFile = modelFile,
+ optimFile = optimFile,
+ })
+
+ if isBestModel then
+ torch.save(paths.concat(opt.save, 'model_best.t7'), model)
+ end
+end
+
+return checkpoint
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/dataloader.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/dataloader.lua
new file mode 100644
index 0000000000000000000000000000000000000000..bc08872667f7b8841606acc55a78e18ccf4d5e1d
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/dataloader.lua
@@ -0,0 +1,168 @@
+--
+-- Copyright (c) 2016, Facebook, Inc.
+-- All rights reserved.
+--
+-- This source code is licensed under the BSD-style license found in the
+-- LICENSE file in the root directory of this source tree. An additional grant
+-- of patent rights can be found in the PATENTS file in the same directory.
+--
+-- Multi-threaded data loader
+--
+
+local datasets = require 'datasets/init'
+local Threads = require 'threads'
+Threads.serialization('threads.sharedserialize')
+
+local M = {}
+local DataLoader = torch.class('resnet.DataLoader', M)
+
+function DataLoader.create(opt)
+ -- The train and val loader
+ local loaders = {}
+ local data
+ if opt.dataset == 'lane' then
+ data = {'train', 'val'}
+ elseif opt.dataset == 'laneTest' then
+ data = {'val'}
+ else
+ cmd:error('unknown dataset: ' .. opt.dataset)
+ end
+ for i, split in ipairs(data) do
+ local dataset = datasets.create(opt, split)
+ print("data created")
+ loaders[i] = M.DataLoader(dataset, opt, split)
+ print("data loaded")
+ end
+
+ return table.unpack(loaders)
+end
+
+function DataLoader:__init(dataset, opt, split)
+ local manualSeed = opt.manualSeed
+ local function init()
+ require('datasets/' .. opt.dataset)
+ end
+ local function main(idx)
+ if manualSeed ~= 0 then
+ torch.manualSeed(manualSeed + idx)
+ end
+ torch.setnumthreads(1)
+ _G.dataset = dataset
+ _G.preprocess = dataset:preprocess()
+ _G.preprocess_aug = dataset:preprocess_aug()
+ return dataset:size()
+ end
+
+ local threads, sizes = Threads(opt.nThreads, init, main)
+ -- self.nCrops = (split == 'val' and opt.tenCrop) and 10 or 1
+ self.nCrops = 1
+ self.threads = threads
+ self.__size = sizes[1][1]
+ self.batchSize = math.floor(opt.batchSize / self.nCrops)
+ self.split = split
+ self.dataset = opt.dataset
+end
+
+function DataLoader:size()
+ return math.ceil(self.__size / self.batchSize)
+end
+
+function DataLoader:run()
+ local threads = self.threads
+ local size, batchSize = self.__size, self.batchSize
+ local dataset = self.dataset
+ --if self.split == 'val' then
+ --batchSize = torch.round(batchSize / 2)
+ --end
+ local perm
+ if self.split == 'val' then
+ perm = torch.Tensor(size)
+ for i = 1, size do
+ perm[i] = i
+ end
+ else
+ perm = torch.randperm(size)
+ end
+
+ local idx, sample = 1, nil
+ local function enqueue()
+ while idx <= size and threads:acceptsjob() do
+ local indices = perm:narrow(1, idx, math.min(batchSize, size - idx + 1))
+ threads:addjob(
+ function(indices, nCrops)
+ local sz = indices:size(1)
+ local batch, segLabels, exists, imgpaths
+ for i, idx in ipairs(indices:totable()) do
+ local sample = _G.dataset:get(idx)
+ local input, segLabel, exist
+ if dataset=='laneTest' then
+ input = _G.preprocess(sample.input)
+ elseif dataset=='lane' then
+ input, segLabel, exist = _G.preprocess_aug(sample.input, sample.segLabel, sample.exist)
+ segLabel:resize(segLabel:size(2),segLabel:size(3))
+ else
+ cmd:error('unknown dataset: ' .. dataset)
+ end
+ if not batch then
+ local imageSize = input:size():totable()
+ local pathSize = sample.imgpath:size():totable()
+ batch = torch.FloatTensor(sz, table.unpack(imageSize))
+ imgpaths = torch.CharTensor(sz, table.unpack(pathSize))
+ if dataset=='lane' then
+ local labelSize = segLabel:size():totable()
+ local existSize = exist:size():totable()
+ segLabels = torch.FloatTensor(sz, table.unpack(labelSize))
+ exists = torch.FloatTensor(sz, table.unpack(existSize))
+ end
+ end
+ batch[i]:copy(input)
+ imgpaths[i]:copy(sample.imgpath)
+ if dataset=='lane' then
+ segLabels[i]:copy(segLabel)
+ exists[i]:copy(exist)
+ end
+ end
+ local targets
+ if dataset=='laneTest' then
+ targets = nil
+ elseif dataset=='lane' then
+ targets = {segLabels, exists}
+ else
+ cmd:error('unknown dataset: ' .. dataset)
+ end
+ collectgarbage(); collectgarbage()
+
+ return {
+ input = batch,
+ target = targets,
+ imgpath = imgpaths, -- used in test
+ }
+ end,
+ function(_sample_)
+ sample = _sample_
+ end,
+ indices,
+ self.nCrops
+ )
+ idx = idx + batchSize
+ end
+ end
+
+ local n = 0
+ local function loop()
+ enqueue()
+ if not threads:hasjob() then
+ return nil
+ end
+ threads:dojob()
+ if threads:haserror() then
+ threads:synchronize()
+ end
+ enqueue()
+ n = n + 1
+ return n, sample
+ end
+ return loop
+end
+
+return M.DataLoader
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/init.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/init.lua
new file mode 100644
index 0000000000000000000000000000000000000000..a9a93c067dafbac9786c0165a57c032c73decff2
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/init.lua
@@ -0,0 +1,35 @@
+--
+-- Copyright (c) 2016, Facebook, Inc.
+-- All rights reserved.
+--
+-- This source code is licensed under the BSD-style license found in the
+-- LICENSE file in the root directory of this source tree. An additional grant
+-- of patent rights can be found in the PATENTS file in the same directory.
+--
+-- ImageNet and CIFAR-10 datasets
+--
+
+local M = {}
+
+local function isvalid(opt, cachePath)
+ local imageInfo = torch.load(cachePath)
+ if imageInfo.basedir and imageInfo.basedir ~= opt.data then
+ return false
+ end
+ return true
+end
+
+function M.create(opt, split)
+ local cachePath = paths.concat(opt.gen, opt.dataset .. '.t7')
+ if not paths.filep(cachePath) or not isvalid(opt, cachePath) then
+ paths.mkdir('gen')
+
+ local script = paths.dofile(opt.dataset .. '-gen.lua')
+ script.exec(opt, cachePath)
+ end
+ local imageInfo = torch.load(cachePath)
+ local Dataset = require('datasets/' .. opt.dataset)
+ return Dataset(imageInfo, opt, split)
+end
+
+return M
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane-gen.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane-gen.lua
new file mode 100644
index 0000000000000000000000000000000000000000..e583a35a22ce231a3bb36faf9cab9b0707f5267e
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane-gen.lua
@@ -0,0 +1,128 @@
+local paths = require 'paths'
+local ffi = require 'ffi'
+
+local M = {}
+
+local function getPaths(file)
+ local imagePath = torch.CharTensor()
+ local labelPath = torch.CharTensor()
+
+ local f = io.open(file, 'r')
+ print('load file: ' .. file)
+ local imMaxLength = -1
+ local lbMaxLength = -1
+ local imagePaths = {}
+ local labelPaths = {}
+ local exists = {}
+ while true do
+ local line = f:read()
+ if line == nil then break end
+ local lineSplit = line:split(' ')
+ local impath = lineSplit[1]
+ local lbpath = lineSplit[2]
+ table.insert(imagePaths, impath)
+ table.insert(labelPaths, lbpath)
+ imMaxLength = math.max(imMaxLength, #impath + 1)
+ lbMaxLength = math.max(lbMaxLength, #lbpath + 1)
+ local exist = torch.Tensor(4):zero()
+ for i = 1, 4 do
+ exist[i] = lineSplit[i+2]
+ end
+ table.insert(exists, exist)
+ end
+ f.close()
+
+ local nImages = #imagePaths
+ local imagePath = torch.CharTensor(nImages, imMaxLength):zero()
+ local labelPath = torch.CharTensor(nImages, lbMaxLength):zero()
+ local Exist = torch.Tensor(nImages, 4):zero()
+ for i, path in ipairs(imagePaths) do
+ ffi.copy(imagePath[i]:data(), path)
+ end
+ for i, path in ipairs(labelPaths) do
+ ffi.copy(labelPath[i]:data(), path)
+ end
+ for i, data in ipairs(exists) do
+ Exist[i]:copy(data)
+ end
+ print("finish getPath")
+ return imagePath, labelPath, Exist
+end
+
+local function getPerm(paths, seqLen, split) -- Permute data list order
+ local size = paths:size(1)
+ local perm
+ if split == 'train' then
+ perm = torch.randperm(size)
+ elseif split == 'val' then
+ perm = torch.Tensor(size)
+ for i = 1, size do
+ perm[i] = i
+ end
+ else
+ print('Wrong split: ' .. split)
+ end
+ local seqPerm = {}
+ for i = 1, size do
+ local id = perm[i]
+ if id <= size - seqLen + 1 then
+ local function videoName(impath)
+ local impath = string.sub(impath,2,-1)
+ local j = string.find(impath, '/')
+ if j then
+ local video = string.sub(impath, j+1, -11)
+ return video
+ else
+ return nil
+ end
+ end
+ local impath = ffi.string(paths[id]:data())
+ local impath2 = ffi.string(paths[id+seqLen-1]:data())
+ local video = videoName(impath)
+ local video2 = videoName(impath2)
+ if video == video2 then
+ table.insert(seqPerm, id)
+ end
+ end
+ end
+ local seqPermTensor = torch.Tensor(#seqPerm)
+ for i = 1, #seqPerm do
+ seqPermTensor[i] = seqPerm[i]
+ end
+ return seqPermTensor
+end
+
+
+function M.exec(opt, cacheFile)
+ local imagePath = torch.CharTensor() -- path to each image in dataset
+ local labelPath = torch.CharTensor() -- path to each label
+
+ local listTrain = opt.train
+ local listVal = opt.val
+
+ local trainImagePath, trainLabelPath, trainExist = getPaths(listTrain)
+ local valImagePath, valLabelPath, valExist = getPaths(listVal)
+ local trainPerm = getPerm(trainImagePath, opt.seqLen, 'train') -- set seqLen to 1 if you don't use rnn-based model
+ local valPerm = getPerm(valImagePath, 1, 'val')
+ print("create info")
+ local info = {
+ basedir = opt.data,
+ train = {
+ imagePath = trainImagePath,
+ labelPath = trainLabelPath,
+ Exist = trainExist,
+ perm = trainPerm,
+ },
+ val = {
+ imagePath = valImagePath,
+ labelPath = valLabelPath,
+ Exist = valExist,
+ perm = valPerm,
+ },
+ }
+ print(" | saving list of images to " .. cacheFile)
+ torch.save(cacheFile, info)
+ return info
+end
+
+return M
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane.lua
new file mode 100644
index 0000000000000000000000000000000000000000..b6dd2bba68528a9a78c01a01d1eef3bfa5a35abe
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/lane.lua
@@ -0,0 +1,88 @@
+local image = require 'image'
+local paths = require 'paths'
+local t = require 'datasets/transforms'
+local ffi = require 'ffi'
+
+local M = {}
+local LaneDataset = torch.class('resnet.LaneDataset', M)
+
+function LaneDataset:__init(imageInfo, opt, split)
+ self.imageInfo = imageInfo[split]
+ self.opt = opt
+ self.split = split
+ self.dir = opt.data
+ assert(paths.dirp(self.dir), 'directory does not exist: ' .. self.dir)
+end
+
+function LaneDataset:get(i)
+ local imgpath = ffi.string(self.imageInfo.imagePath[i]:data())
+ local lbpath = ffi.string(self.imageInfo.labelPath[i]:data())
+ --print(self.dir .. imgpath)
+ local image = self:_loadImage(self.dir .. imgpath, 3, 'float')
+ local label = self:_loadImage(self.dir .. lbpath, 1, 'byte')
+ label:add(1)
+ return {
+ input = image,
+ segLabel = label,
+ exist = self.imageInfo.Exist[i],
+ imgpath = self.imageInfo.imagePath[i],
+ }
+end
+
+function LaneDataset:_loadImage(path, channel, ttype)
+ local ok, input = pcall(function()
+ return image.load(path, channel, ttype)
+ end)
+
+ if not ok then
+ print("load image failed!")
+ return -1
+ end
+ return input
+end
+
+function LaneDataset:size()
+ return self.imageInfo.imagePath:size(1)
+end
+
+local meanstd = {
+ mean = { 0.3598, 0.3653, 0.3662 },
+ std = { 0.2573, 0.2663, 0.2756 },
+}
+
+function LaneDataset:preprocess() -- Don't use data augmentation for training RNN
+ if self.split == 'train' then
+ return t.Compose{
+ t.ScaleWH(640, 368),
+ t.ColorNormalize(meanstd),
+ }
+ elseif self.split == 'val' then
+ return t.Compose{
+ t.ScaleWH(640, 368),
+ t.ColorNormalize(meanstd),
+ }
+ else
+ error('invalid split: ' .. self.split)
+ end
+end
+
+function LaneDataset:preprocess_aug()
+ if self.split == 'train' then
+ return t.Compose{
+ t.RandomScaleRatio(920, 1002, 274, 304), -- 760, 842, 274, 304
+ t.ColorNormalize(meanstd),
+ t.Rotation(2),
+ --t.RandomCrop(800, 288),
+ t.RandomCropLane(960, 288), -- 800, 288
+ }
+ elseif self.split == 'val' then
+ return t.Compose{
+ t.ScaleWH(960, 288), -- 800, 288
+ t.ColorNormalize(meanstd),
+ }
+ else
+ error('invalid split: ' .. self.split)
+ end
+end
+
+return M.LaneDataset
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest-gen.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest-gen.lua
new file mode 100644
index 0000000000000000000000000000000000000000..9f4acea128956dd3ae4d59ebd701820403e994fd
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest-gen.lua
@@ -0,0 +1,98 @@
+local paths = require 'paths'
+local ffi = require 'ffi'
+
+local M = {}
+
+local function getPaths(file)
+ local imagePath = torch.CharTensor()
+
+ local f = io.open(file, 'r')
+ print('load file: ' .. file)
+ local imMaxLength = -1
+ local imagePaths = {}
+ while true do
+ local line = f:read()
+ if line == nil then break end
+
+ local impath = line
+ table.insert(imagePaths, impath)
+ imMaxLength = math.max(imMaxLength, #impath + 1)
+ end
+ f.close()
+
+ local nImages = #imagePaths
+ local imagePath = torch.CharTensor(nImages, imMaxLength):zero()
+ for i, path in ipairs(imagePaths) do
+ ffi.copy(imagePath[i]:data(), path)
+ end
+ print("finish getPath")
+ return imagePath
+end
+
+local function getPerm(paths, seqLen, split) -- Permute data list order
+ local size = paths:size(1)
+ local perm
+ if split == 'train' then
+ perm = torch.randperm(size)
+ elseif split == 'val' then
+ perm = torch.Tensor(size)
+ for i = 1, size do
+ perm[i] = i
+ end
+ else
+ print('Wrong split: ' .. split)
+ end
+ local seqPerm = {}
+ for i = 1, size do
+ local id = perm[i]
+ if id <= size - seqLen + 1 then
+ local function videoName(impath)
+ local impath = string.sub(impath,2,-1)
+ local j = string.find(impath, '/')
+ if j then
+ local video = string.sub(impath, j+1, -11)
+ return video
+ else
+ return nil
+ end
+ end
+ local impath = ffi.string(paths[id]:data())
+ local impath2 = ffi.string(paths[id+seqLen-1]:data())
+ local video = videoName(impath)
+ local video2 = videoName(impath2)
+ if video == video2 then
+ table.insert(seqPerm, id)
+ end
+ end
+ end
+ local seqPermTensor = torch.Tensor(#seqPerm)
+ for i = 1, #seqPerm do
+ seqPermTensor[i] = seqPerm[i]
+ end
+ return seqPermTensor
+end
+
+
+function M.exec(opt, cacheFile)
+ local imagePath = torch.CharTensor() -- path to each image in dataset
+ local labelPath = torch.CharTensor() -- path to each label
+
+ local listVal = opt.val
+
+ local valImagePath = getPaths(listVal)
+ local valPerm = getPerm(valImagePath, 1, 'val')
+ print("create info")
+ local info = {
+ basedir = opt.data,
+ train = nil,
+ val = {
+ imagePath = valImagePath,
+ perm = valPerm,
+ },
+ }
+ print(" | saving list of images to " .. cacheFile)
+ torch.save(cacheFile, info)
+ return info
+end
+
+return M
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest.lua
new file mode 100644
index 0000000000000000000000000000000000000000..55f2243adc51b324832cbe56f329fdb08a9ef803
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/laneTest.lua
@@ -0,0 +1,82 @@
+local image = require 'image'
+local paths = require 'paths'
+local t = require 'datasets/transforms'
+local ffi = require 'ffi'
+
+local M = {}
+local LaneDataset = torch.class('resnet.LaneDataset', M)
+
+function LaneDataset:__init(imageInfo, opt, split)
+ self.imageInfo = imageInfo[split]
+ self.opt = opt
+ self.split = split
+ self.dir = opt.data
+ assert(paths.dirp(self.dir), 'directory does not exist: ' .. self.dir)
+end
+
+function LaneDataset:get(i)
+ local imgpath = ffi.string(self.imageInfo.imagePath[i]:data())
+ local image = self:_loadImage(self.dir .. imgpath, 3, 'float')
+ return {
+ input = image,
+ imgpath = self.imageInfo.imagePath[i],
+ }
+end
+
+function LaneDataset:_loadImage(path, channel, ttype)
+ local ok, input = pcall(function()
+ return image.load(path, channel, ttype)
+ end)
+
+ if not ok then
+ print("load image failed!")
+ return -1
+ end
+ return input
+end
+
+function LaneDataset:size()
+ return self.imageInfo.imagePath:size(1)
+end
+
+local meanstd = {
+ mean = { 0.3598, 0.3653, 0.3662 },
+ std = { 0.2573, 0.2663, 0.2756 },
+}
+
+function LaneDataset:preprocess()
+ if self.split == 'train' then
+ return t.Compose{
+ --t.ScaleWH(640, 368),
+ t.ScaleWH(960, 288),
+ t.ColorNormalize(meanstd),
+ }
+ elseif self.split == 'val' then
+ return t.Compose{
+ t.ScaleWH(960, 288), -- 800, 288
+ t.ColorNormalize(meanstd),
+ }
+ else
+ error('invalid split: ' .. self.split)
+ end
+end
+
+function LaneDataset:preprocess_aug()
+ if self.split == 'train' then
+ return t.Compose{
+ t.RandomScaleRatio(735, 898, 267, 326),
+ t.Rotation(2),
+ t.RandomCrop(728, 264),
+ t.ColorNormalize(meanstd),
+ }
+ elseif self.split == 'val' then
+ return t.Compose{
+ t.ScaleWH(800, 288),
+ t.ColorNormalize(meanstd),
+ }
+ else
+ error('invalid split: ' .. self.split)
+ end
+end
+
+return M.LaneDataset
diff --git a/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/transforms.lua b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/transforms.lua
new file mode 100644
index 0000000000000000000000000000000000000000..25ee8c978c5afa0a6d13af2674b46dac0c56a948
--- /dev/null
+++ b/TensorFlow2/contrib/cv/UltraFast_for_TensorFlow2/unsupervised_llamas/ENet-SAD-Simple/datasets/transforms.lua
@@ -0,0 +1,251 @@
+--
+-- Copyright (c) 2016, Facebook, Inc.
+-- All rights reserved.
+--
+-- This source code is licensed under the BSD-style license found in the
+-- LICENSE file in the root directory of this source tree. An additional grant
+-- of patent rights can be found in the PATENTS file in the same directory.
+--
+-- Image transforms for data augmentation and input normalization
+--
+
+require 'image'
+
+local M = {}
+
+function M.Compose(transforms)
+ return function(input, target, exist)
+ for _, transform in ipairs(transforms) do
+ input, target, exist = transform(input, target, exist)
+ end
+ return input, target, exist
+ end
+end
+
+function M.ColorNormalize(meanstd)
+ return function(img, target, exist)
+ img = img:clone()
+ for i=1,3 do
+ img[i]:add(-meanstd.mean[i])
+ img[i]:div(meanstd.std[i])
+ end
+ return img, target, exist
+ end
+end
+
+-- Scales the smaller edge to size
+function M.Scale(size, interpolation)
+ interpolation = interpolation or 'bicubic'
+ return function(input)
+ local w, h = input:size(3), input:size(2)
+ if (w <= h and w == size) or (h <= w and h == size) then
+ return input
+ end
+ if w < h then
+ return image.scale(input, size, h/w * size, interpolation)
+ else
+ return image.scale(input, w/h * size, size, interpolation)
+ end
+ end
+end
+
+-- Added by PanXingang. Scales the width and height for input and target
+function M.ScaleWH(w, h, interpolation)
+ interpolation = interpolation or 'bicubic'
+ return function(input, target, exist)
+ --- newly added part ---
+ input = image.crop(input, 0, 333, 1276, 717)
+ ------------------------
+ if target == nil then
+ return image.scale(input, w, h, interpolation)
+ else
+ target = image.crop(target, 0, 333, 1276, 717)
+ return image.scale(input, w, h, interpolation), image.scale(target, w, h, 'simple'), exist
+ end
+ end
+end
+
+-- Crop to centered rectangle
+function M.CenterCrop(w, h)
+ return function(input, target)
+ local w1 = math.ceil((input:size(3) - w)/2)
+ local h1 = math.ceil((input:size(2) - h)/2)
+ return image.crop(input, w1, h1, w1 + w, h1 + h), image.crop(target, w1, h1, w1 + w, h1 + h) -- center patch
+ end
+end
+
+function M.RandomCrop(w, h, padding)
+ padding = padding or 0
+
+ return function(input, target)
+ if padding > 0 then
+ local temp = input.new(3, input:size(2) + 2*padding, input:size(3) + 2*padding)
+ temp:zero()
+ :narrow(2, padding+1, input:size(2))
+ :narrow(3, padding+1, input:size(3))
+ :copy(input)
+ input = temp
+ end
+
+ local inputW, inputH = input:size(3), input:size(2)
+ if inputW == w and inputH == h then
+ return input, target
+ end
+
+ local x1, y1 = torch.random(0, inputW - w), torch.random(0, inputH - h)
+ local out1 = image.crop(input, x1, y1, x1 + w, y1 + h)
+ local out2 = image.crop(target, x1, y1, x1 + w, y1 + h)
+ assert(out1:size(2) == h and out1:size(3) == w, 'wrong crop size')
+ return out1, out2
+ end
+end
+
+-- Random crop form larger image with optional zero padding
+function M.RandomCropLane(w, h, padding)
+ padding = padding or 0
+
+ return function(input, target, exist)
+ if padding > 0 then
+ local temp = input.new(3, input:size(2) + 2*padding, input:size(3) + 2*padding)
+ temp:zero()
+ :narrow(2, padding+1, input:size(2))
+ :narrow(3, padding+1, input:size(3))
+ :copy(input)
+ input = temp
+ end
+
+ local inputW, inputH = input:size(3), input:size(2)
+ if inputW == w and inputH == h then
+ return input, target, exist
+ end
+
+ target:add(-1)
+ if inputH < h then
+ local pad = h - inputH
+ local temp = input.new(3, h, input:size(3))
+ temp:zero()
+ :narrow(2, pad+1, inputH)
+ :copy(input)
+ input = temp
+ local temp2 = input.new(1, h, input:size(3))
+ temp2:zero()
+ :narrow(2, pad+1, inputH)
+ :copy(target)
+ target = temp2
+ end
+ if inputW < w then
+ local pad = torch.random(0, w - inputW)
+ local temp = input.new(3, input:size(2), w)
+ temp:zero()
+ :narrow(3, pad+1, inputW)
+ :copy(input)
+ input = temp
+ local temp2 = input.new(1, input:size(2), w)
+ temp2:zero()
+ :narrow(3, pad+1, inputW)
+ :copy(target)
+ target = temp2
+ end
+ local inputW, inputH = input:size(3), input:size(2)
+ local x1, y1 = torch.random(0, inputW - w), torch.random(0, inputH - h)
+ local out1 = image.crop(input, x1, y1, x1 + w, y1 + h)
+ local out2 = image.crop(target, x1, y1, x1 + w, y1 + h)
+ out2:add(1)
+ assert(out1:size(2) == h and out1:size(3) == w, 'wrong crop size')
+ return out1, out2, exist
+ end
+end
+
+-- Resized with shorter side randomly sampled from [minSize, maxSize] (ResNet-style)
+function M.RandomScale(minSize, maxSize)
+ return function(input, target)
+ local w, h = input:size(3), input:size(2)
+
+ local targetSz = torch.random(minSize, maxSize)
+ local targetW, targetH = targetSz, targetSz
+ if w < h then
+ targetH = torch.round(h / w * targetW)
+ else
+ targetW = torch.round(w / h * targetH)
+ end
+
+ return image.scale(input, targetW, targetH, 'bicubic'), image.scale(target, targetW, targetH, 'simple')
+ end
+end
+
+--Added by PanXingang. Resized with random scale and ratio
+function M.RandomScaleRatio(minW, maxW, minH, maxH)
+ return function(input, target, exist)
+ --- newly added part ---
+ input = image.crop(input, 0, 333, 1276, 717)
+ target = image.crop(target, 0, 333, 1276, 717)
+ ------------------------
+ local w, h = input:size(3), input:size(2)
+
+ local targetW = torch.random(minW, maxW)
+ local targetH = torch.random(minH, maxH)
+
+ return image.scale(input, targetW, targetH, 'bicubic'), image.scale(target, targetW, targetH, 'simple'), exist
+ end
+end
+
+-- Random crop with size 8%-100% and aspect ratio 3/4 - 4/3 (Inception-style)
+function M.RandomSizedCrop(size)
+ local scale = M.Scale(size)
+ local crop = M.CenterCrop(size)
+
+ return function(input)
+ local attempt = 0
+ repeat
+ local area = input:size(2) * input:size(3)
+ local targetArea = torch.uniform(0.08, 1.0) * area
+
+ local aspectRatio = torch.uniform(3/4, 4/3)
+ local w = torch.round(math.sqrt(targetArea * aspectRatio))
+ local h = torch.round(math.sqrt(targetArea / aspectRatio))
+
+ if torch.uniform() < 0.5 then
+ w, h = h, w
+ end
+
+ if h <= input:size(2) and w <= input:size(3) then
+ local y1 = torch.random(0, input:size(2) - h)
+ local x1 = torch.random(0, input:size(3) - w)
+
+ local out = image.crop(input, x1, y1, x1 + w, y1 + h)
+ assert(out:size(2) == h and out:size(3) == w, 'wrong crop size')
+
+ return image.scale(out, size, size, 'bicubic')
+ end
+ attempt = attempt + 1
+ until attempt >= 10
+
+ -- fallback
+ return crop(scale(input))
+ end
+end
+
+function M.HorizontalFlip(prob)
+ return function(input, target)
+ if torch.uniform() <