+
+## Introduction
+
+PaddleOCR aims to create multilingual, awesome, leading, and practical OCR tools that help users train better models and apply them into practice.
+
+
+
+
+
+
+
+
+
+## 📣 Recent updates
+- **🔥2022.8.24 Release PaddleOCR [release/2.6](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.6)**
+ - Release [PP-Structurev2](./ppstructure/)，with functions and performance fully upgraded, adapted to Chinese scenes, and new support for [Layout Recovery](./ppstructure/recovery) and **one line command to convert PDF to Word**;
+ - [Layout Analysis](./ppstructure/layout) optimization: model storage reduced by 95%, while speed increased by 11 times, and the average CPU time-cost is only 41ms;
+ - [Table Recognition](./ppstructure/table) optimization: 3 optimization strategies are designed, and the model accuracy is improved by 6% under comparable time consumption;
+ - [Key Information Extraction](./ppstructure/kie) optimization：a visual-independent model structure is designed, the accuracy of semantic entity recognition is increased by 2.8%, and the accuracy of relation extraction is increased by 9.1%.
+- **🔥2022.8 Release [OCR scene application collection](./applications/README_en.md)**
+ - Release **9 vertical models** such as digital tube, LCD screen, license plate, handwriting recognition model, high-precision SVTR model, etc, covering the main OCR vertical applications in general, manufacturing, finance, and transportation industries.
+- **2022.8 Add implementation of [8 cutting-edge algorithms](doc/doc_en/algorithm_overview_en.md)**
+ - Text Detection: [FCENet](doc/doc_en/algorithm_det_fcenet_en.md), [DB++](doc/doc_en/algorithm_det_db_en.md)
+ - Text Recognition: [ViTSTR](doc/doc_en/algorithm_rec_vitstr_en.md), [ABINet](doc/doc_en/algorithm_rec_abinet_en.md), [VisionLAN](doc/doc_en/algorithm_rec_visionlan_en.md), [SPIN](doc/doc_en/algorithm_rec_spin_en.md), [RobustScanner](doc/doc_en/algorithm_rec_robustscanner_en.md)
+ - Table Recognition: [TableMaster](doc/doc_en/algorithm_table_master_en.md)
+- **2022.5.9 Release PaddleOCR [release/2.5](https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.5)**
+ - Release [PP-OCRv3](./doc/doc_en/ppocr_introduction_en.md#pp-ocrv3): With comparable speed, the effect of Chinese scene is further improved by 5% compared with PP-OCRv2, the effect of English scene is improved by 11%, and the average recognition accuracy of 80 language multilingual models is improved by more than 5%.
+ - Release [PPOCRLabelv2](./PPOCRLabel): Add the annotation function for table recognition task, key information extraction task and irregular text image.
+ - Release interactive e-book [*"Dive into OCR"*](./doc/doc_en/ocr_book_en.md), covers the cutting-edge theory and code practice of OCR full stack technology.
+- [more](./doc/doc_en/update_en.md)
+
+
+## 🌟 Features
+
+PaddleOCR support a variety of cutting-edge algorithms related to OCR, and developed industrial featured models/solution [PP-OCR](./doc/doc_en/ppocr_introduction_en.md) and [PP-Structure](./ppstructure/README.md) on this basis, and get through the whole process of data production, model training, compression, inference and deployment.
+
+
+
+
+
+> It is recommended to start with the “quick experience” in the document tutorial
+
+
+## ⚡ Quick Experience
+
+- Web online experience for the ultra-lightweight OCR: [Online Experience](https://www.paddlepaddle.org.cn/hub/scene/ocr)
+- Mobile DEMO experience (based on EasyEdge and Paddle-Lite, supports iOS and Android systems): [Sign in to the website to obtain the QR code for installing the App](https://ai.baidu.com/easyedge/app/openSource?from=paddlelite)
+- One line of code quick use: [Quick Start](./doc/doc_en/quickstart_en.md)
+
+
+
+## 📚 E-book: *Dive Into OCR*
+- [Dive Into OCR ](./doc/doc_en/ocr_book_en.md)
+
+
+## 👫 Community
+
+- For international developers, we regard [PaddleOCR Discussions](https://github.com/PaddlePaddle/PaddleOCR/discussions) as our international community platform. All ideas and questions can be discussed here in English.
+
+- For Chinese develops, Scan the QR code below with your Wechat, you can join the official technical discussion group. For richer community content, please refer to [中文README](README_ch.md), looking forward to your participation.
+
+
+
+
+
+
+
+## 🛠️ PP-OCR Series Model List（Update on September 8th）
+
+| Model introduction | Model name | Recommended scene | Detection model | Direction classifier | Recognition model |
+| ------------------------------------------------------------ | ---------------------------- | ----------------- | ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
+| Chinese and English ultra-lightweight PP-OCRv3 model（16.2M） | ch_PP-OCRv3_xx | Mobile & Server | [inference model](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_det_distill_train.tar) | [inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) | [inference model](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_rec_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv3/chinese/ch_PP-OCRv3_rec_train.tar) |
+| English ultra-lightweight PP-OCRv3 model（13.4M） | en_PP-OCRv3_xx | Mobile & Server | [inference model](https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_det_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_det_distill_train.tar) | [inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) | [inference model](https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_rec_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv3/english/en_PP-OCRv3_rec_train.tar) |
+| Chinese and English ultra-lightweight PP-OCRv2 model（11.6M） | ch_PP-OCRv2_xx |Mobile & Server|[inference model](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_det_distill_train.tar)| [inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |[inference model](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/PP-OCRv2/chinese/ch_PP-OCRv2_rec_train.tar)|
+| Chinese and English ultra-lightweight PP-OCR model (9.4M) | ch_ppocr_mobile_v2.0_xx | Mobile & server |[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_train.tar)|[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_train.tar) |
+| Chinese and English general PP-OCR model (143.4M) | ch_ppocr_server_v2.0_xx | Server |[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_train.tar) |[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_cls_train.tar) |[inference model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_infer.tar) / [trained model](https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_train.tar) |
+
+
+- For more model downloads (including multiple languages), please refer to [PP-OCR series model downloads](./doc/doc_en/models_list_en.md).
+- For a new language request, please refer to [Guideline for new language_requests](#language_requests).
+- For structural document analysis models, please refer to [PP-Structure models](./ppstructure/docs/models_list_en.md).
+
+## 📖 Tutorials
+- [Environment Preparation](./doc/doc_en/environment_en.md)
+- [PP-OCR 🔥](./doc/doc_en/ppocr_introduction_en.md)
+ - [Quick Start](./doc/doc_en/quickstart_en.md)
+ - [Model Zoo](./doc/doc_en/models_en.md)
+ - [Model training](./doc/doc_en/training_en.md)
+ - [Text Detection](./doc/doc_en/detection_en.md)
+ - [Text Recognition](./doc/doc_en/recognition_en.md)
+ - [Text Direction Classification](./doc/doc_en/angle_class_en.md)
+ - Model Compression
+ - [Model Quantization](./deploy/slim/quantization/README_en.md)
+ - [Model Pruning](./deploy/slim/prune/README_en.md)
+ - [Knowledge Distillation](./doc/doc_en/knowledge_distillation_en.md)
+ - [Inference and Deployment](./deploy/README.md)
+ - [Python Inference](./doc/doc_en/inference_ppocr_en.md)
+ - [C++ Inference](./deploy/cpp_infer/readme.md)
+ - [Serving](./deploy/pdserving/README.md)
+ - [Mobile](./deploy/lite/readme.md)
+ - [Paddle2ONNX](./deploy/paddle2onnx/readme.md)
+ - [PaddleCloud](./deploy/paddlecloud/README.md)
+ - [Benchmark](./doc/doc_en/benchmark_en.md)
+- [PP-Structure 🔥](./ppstructure/README.md)
+ - [Quick Start](./ppstructure/docs/quickstart_en.md)
+ - [Model Zoo](./ppstructure/docs/models_list_en.md)
+ - [Model training](./doc/doc_en/training_en.md)
+ - [Layout Analysis](./ppstructure/layout/README.md)
+ - [Table Recognition](./ppstructure/table/README.md)
+ - [Key Information Extraction](./ppstructure/kie/README.md)
+ - [Inference and Deployment](./deploy/README.md)
+ - [Python Inference](./ppstructure/docs/inference_en.md)
+ - [C++ Inference](./deploy/cpp_infer/readme.md)
+ - [Serving](./deploy/hubserving/readme_en.md)
+- [Academic Algorithms](./doc/doc_en/algorithm_overview_en.md)
+ - [Text detection](./doc/doc_en/algorithm_overview_en.md)
+ - [Text recognition](./doc/doc_en/algorithm_overview_en.md)
+ - [End-to-end OCR](./doc/doc_en/algorithm_overview_en.md)
+ - [Table Recognition](./doc/doc_en/algorithm_overview_en.md)
+ - [Key Information Extraction](./doc/doc_en/algorithm_overview_en.md)
+ - [Add New Algorithms to PaddleOCR](./doc/doc_en/add_new_algorithm_en.md)
+- Data Annotation and Synthesis
+ - [Semi-automatic Annotation Tool: PPOCRLabel](./PPOCRLabel/README.md)
+ - [Data Synthesis Tool: Style-Text](./StyleText/README.md)
+ - [Other Data Annotation Tools](./doc/doc_en/data_annotation_en.md)
+ - [Other Data Synthesis Tools](./doc/doc_en/data_synthesis_en.md)
+- Datasets
+ - [General OCR Datasets(Chinese/English)](doc/doc_en/dataset/datasets_en.md)
+ - [HandWritten_OCR_Datasets(Chinese)](doc/doc_en/dataset/handwritten_datasets_en.md)
+ - [Various OCR Datasets(multilingual)](doc/doc_en/dataset/vertical_and_multilingual_datasets_en.md)
+ - [Layout Analysis](doc/doc_en/dataset/layout_datasets_en.md)
+ - [Table Recognition](doc/doc_en/dataset/table_datasets_en.md)
+ - [Key Information Extraction](doc/doc_en/dataset/kie_datasets_en.md)
+- [Code Structure](./doc/doc_en/tree_en.md)
+- [Visualization](#Visualization)
+- [Community](#Community)
+- [New language requests](#language_requests)
+- [FAQ](./doc/doc_en/FAQ_en.md)
+- [References](./doc/doc_en/reference_en.md)
+- [License](#LICENSE)
+
+
+
+## 👀 Visualization [more](./doc/doc_en/visualization_en.md)
+
+
+PP-OCRv3 Chinese model
+
>',
+ ])
+ return self.graph.node(label,
+ prefix="param",
+ description=name,
+ shape="none",
+ style="rounded,filled,bold",
+ width="1.3",
+ color="#148b97" if not highlight else "orange",
+ fontcolor="#ffffff",
+ fontname="Arial")
+
+ def add_op(self, opType, **kwargs):
+ highlight = False
+ if 'highlight' in kwargs:
+ highlight = kwargs['highlight']
+ del kwargs['highlight']
+ return self.graph.node(
+ "<%s>" % opType,
+ prefix="op",
+ description=opType,
+ shape="box",
+ style="rounded, filled, bold",
+ color="#303A3A" if not highlight else "orange",
+ fontname="Arial",
+ fontcolor="#ffffff",
+ width="1.3",
+ height="0.84",
+ )
+
+ def add_arg(self, name, highlight=False):
+ return self.graph.node(crepr(name),
+ prefix="arg",
+ description=name,
+ shape="box",
+ style="rounded,filled,bold",
+ fontname="Arial",
+ fontcolor="#999999",
+ color="#dddddd" if not highlight else "orange")
+
+ def add_edge(self, source, target, **kwargs):
+ highlight = False
+ if 'highlight' in kwargs:
+ highlight = kwargs['highlight']
+ del kwargs['highlight']
+ return self.graph.edge(source,
+ target,
+ color="#00000" if not highlight else "orange",
+ **kwargs)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..76c5c6391fde3cafbd9a94e1d11e0ef4401420ed
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (c) 2019 PaddlePaddle 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
+
+# incubate directory is mainly for internal use
+# after we have tested incubate APIs in industrial application for a period
+# we will move stable functions into fluid
+__version__ = '0.1.0'
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..abf198b97e6e818e1fbe59006f98492640bcee54
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/auto_checkpoint.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/auto_checkpoint.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5dd3222b8ff5c9b3281178141191747b7e7ee56
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/auto_checkpoint.py
@@ -0,0 +1,685 @@
+# Copyright (c) 2020 PaddlePaddle 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 sys
+import logging
+import hashlib
+import json
+import os
+import six
+import time
+import collections
+from threading import Thread, current_thread
+from contextlib import contextmanager
+
+from paddle.fluid import unique_name, compiler
+from .checkpoint_saver import SerializableBase, CheckpointSaver, PaddleModel
+from paddle.fluid.framework import _non_static_mode, Program
+
+g_train_epoch_range = None
+g_checker = None
+
+logger = None
+
+generator = unique_name.UniqueNameGenerator()
+
+CONST_CHECKPOINT = "checkpoint"
+CONST_MEMORYINIT = "memory_init"
+
+# auto checkpoint by dataloader event.
+CONST_DACP_TYPE = "dacp"
+# auto checkpoint by loop range.
+CONST_ACP_TYPE = "acp"
+g_acp_type = None
+g_program_attr = {} # program_name->can_be_auto_checkpoint
+
+
+def _get_logger(log_level, name="auto_checkpoint"):
+ global logger
+ if logger != None:
+ return logger
+
+ logger = logging.getLogger(name)
+ logger.setLevel(log_level)
+ logger.propagate = False
+
+ log_handler = logging.StreamHandler()
+ log_format = logging.Formatter(
+ '%(levelname)s %(asctime)s %(filename)s:%(lineno)d] %(message)s')
+ log_handler.setFormatter(log_format)
+ logger.addHandler(log_handler)
+
+ return logger
+
+
+def _thread_checker():
+ assert current_thread().name == "MainThread", \
+ "auto checkpoint must run under main thread"
+
+
+class AutoCheckpointChecker(object):
+
+ def __init__(self):
+ self._run_env = None
+ self._platform = None
+ self._job_id = None
+ self._hdfs_home = None
+ self._hdfs_name = None
+ self._hdfs_ugi = None
+ self._hdfs_checkpoint_path = None
+ self._trainer_id = None
+ self._ce_test = None
+
+ self._run_env = os.getenv("PADDLE_RUNNING_ENV")
+ if self._run_env != "PADDLE_EDL_AUTO_CHECKPOINT":
+ return
+
+ try:
+ self._platform = os.environ["PADDLE_RUNNING_PLATFORM"]
+ self._job_id = os.environ["PADDLE_JOB_ID"]
+ self._hdfs_home = os.environ["PADDLE_EDL_HDFS_HOME"]
+ self._hdfs_name = os.environ["PADDLE_EDL_HDFS_NAME"]
+ self._hdfs_ugi = os.environ["PADDLE_EDL_HDFS_UGI"]
+ self._hdfs_checkpoint_path = os.environ[
+ "PADDLE_EDL_HDFS_CHECKPOINT_PATH"]
+ self._trainer_id = int(os.environ["PADDLE_TRAINER_ID"])
+
+ self._ce_test = int(os.getenv("PADDLE_EDL_ONLY_FOR_CE_TEST", "0"))
+ self._fs_cache = os.getenv("PADDLE_EDL_FS_CACHE", ".cache")
+
+ self._save_checkpoint_inter = int(
+ os.getenv("PADDLE_EDL_SAVE_CHECKPOINT_INTER", "900")) # s
+
+ if not self._ce_test:
+ assert len(self._hdfs_home) > 3 and \
+ len(self._hdfs_name) > 6 and \
+ len(self._hdfs_ugi) > 3 and \
+ len(self._hdfs_checkpoint_path) > 0, "hdfs environ must set"
+ else:
+ assert len(self._hdfs_home) > 3 and \
+ len(self._hdfs_checkpoint_path) > 0, "hdfs environ must set"
+
+ except Exception as e:
+ logger.fatal("exception:{}".format(e))
+ sys.exit(1)
+
+ def get_range_checkpoint_path(self, name):
+ return "{}/{}/range/{}".format(self.hdfs_checkpoint_path, self.job_id,
+ name)
+
+ def get_exe_checkpoint_path(self, name):
+ return "{}/{}/exe/{}".format(self.hdfs_checkpoint_path, self.job_id,
+ name)
+
+ def get_job_path(self):
+ return "{}/{}".format(self.hdfs_checkpoint_path, self.job_id)
+
+ @property
+ def save_checkpoint_inter(self):
+ return self._save_checkpoint_inter
+
+ def valid(self):
+ if _non_static_mode():
+ return False
+
+ return self._run_env is not None and \
+ self._platform is not None and \
+ self._job_id is not None and \
+ self._hdfs_home is not None and \
+ self._hdfs_name is not None and \
+ self._hdfs_ugi is not None and \
+ self._hdfs_checkpoint_path is not None and \
+ self._trainer_id is not None
+
+ def __str__(self):
+ return "run_env:{} platform:{} job_id:{} \
+ hdfs_home:{} hdfs_name:{} hdfs_ugi:{} \
+ hdfs_checkpoint_path:{} trainer_id:{} ce_test".format(
+ self._run_env, self._platform, self._hdfs_home, self._hdfs_name,
+ self._hdfs_ugi, self._hdfs_checkpoint_path, self._trainer_id,
+ self._ce_test)
+
+ @property
+ def trainer_id(self):
+ return self._trainer_id
+
+ @property
+ def run_env(self):
+ return self._run_env
+
+ @property
+ def platform(self):
+ return self._platform
+
+ @property
+ def job_id(self):
+ return self._job_id
+
+ @property
+ def hdfs_home(self):
+ return self._hdfs_home
+
+ @property
+ def hdfs_name(self):
+ return self._hdfs_name
+
+ @property
+ def ce_test(self):
+ return self._ce_test
+
+ @property
+ def hdfs_ugi(self):
+ return self._hdfs_ugi
+
+ @property
+ def hdfs_checkpoint_path(self):
+ return self._hdfs_checkpoint_path
+
+ @staticmethod
+ def generate_range_name():
+ return generator("_range_")
+
+
+class ExeTrainStatus(SerializableBase):
+
+ def __init__(self):
+ self._epoch_no = -1 # start epoch_no
+ self._hash_key = None
+ self._key = None
+ self._checkpoint_path = None
+ self._checkpoint_no = None
+ self._restored_from = None
+ self._exe = None
+ self._program = None
+ self._exe_name = None
+ self._program_name = None
+
+ self._file_name = "exe_train_status"
+
+ def __eq__(self, t):
+ return self._epoch_no == t._epoch_no and \
+ self._hash_key == t._hash_key and \
+ self._key == t._key and \
+ self._checkpoint_path == t._checkpoint_path and \
+ self._checkpoint_no == t._checkpoint_no and \
+ self._exe_name == t._exe_name and \
+ self._program_name == t._program_name
+
+ def __ne__(self, t):
+ return not self == t
+
+ def serialize(self, path):
+ file_name = "{}/{}".format(path, self._file_name)
+ with open(file_name, 'w') as f:
+ s = self._serialize()
+ f.write(s)
+
+ def _serialize(self, pop_keys=["restored_from"]):
+ d = self._to_dict()
+ for k in pop_keys:
+ d.pop(k, None)
+ return json.dumps(d)
+
+ def deserialize(self, path):
+ d = None
+ file_name = "{}/{}".format(path, self._file_name)
+ with open(file_name, 'r') as f:
+ s = f.read()
+ self._deserialize(s)
+
+ def _deserialize(self, s):
+ d = json.loads(s)
+ self._epoch_no = d["epoch_no"]
+ self._key = d["key"]
+ self._hash_key = d["hash_key"]
+ self._checkpoint_path = d["checkpoint_path"]
+ self._checkpoint_no = d["checkpoint_no"]
+ self._exe_name = d["exe_name"]
+ self._program_name = d["program_name"]
+
+ def _to_dict(self):
+ return {
+ "epoch_no": self._epoch_no,
+ "key": self._key,
+ "hash_key": self._hash_key,
+ "checkpoint_path": self._checkpoint_path,
+ "restored_from": self._restored_from,
+ "exe_name": self._exe_name,
+ "program_name": self._program_name,
+ "checkpoint_no": self._checkpoint_no
+ }
+
+ def __str__(self):
+ return self._serialize([])
+
+
+class TrainEpochRange(SerializableBase):
+
+ def __init__(self,
+ max_epoch_num,
+ name,
+ checkpoint_inter=None,
+ restored=True):
+ self._max_epoch_num = max_epoch_num
+ self._epoch_no = -1 # current epoch_no
+ self._name = name
+ self._restored_from = None
+ self._exe_status = {}
+ self._flag_generated = False
+
+ self._checker = g_checker
+ if checkpoint_inter is not None:
+ self._save_checkpoint_inter = checkpoint_inter
+ else:
+ self._save_checkpoint_inter = self._checker.save_checkpoint_inter
+ assert self._save_checkpoint_inter >= 0, "checkpointer:{} must >=0".format(
+ self._save_checkpoint_inter)
+ self._last_checkpoint_time = time.time()
+
+ self._load_cp_nos = None
+ self._checkpoint_epoch_no = None
+
+ if not self._checker.valid():
+ return
+
+ self._file_name = "range_train_status"
+
+ if not restored:
+ return
+
+ self._checkpoint_path = self._checker.get_range_checkpoint_path(name)
+
+ config = {
+ "fs.default.name": self._checker.hdfs_name,
+ "hadoop.job.ugi": self._checker.hdfs_ugi
+ }
+
+ if self._checker.ce_test:
+ config = None
+
+ from paddle.distributed.fleet.utils.fs import HDFSClient
+ self._hdfs = HDFSClient(self._checker.hdfs_home, config)
+
+ self._cper = CheckpointSaver(self._hdfs)
+
+ _thread_checker()
+
+ self._get_last_valid_checkpoint()
+
+ def _look_for_valid(self, cp_nos):
+ cps = []
+ epoch_no = -1
+ for i in cp_nos[::-1]:
+ t = TrainEpochRange(self._max_epoch_num, self.name, restored=False)
+ self._cper.load_checkpoint(self._checkpoint_path, [t],
+ self._checker.trainer_id,
+ checkpoint_no=i,
+ local_cache_path=self._checker._fs_cache)
+ cps.append(t)
+ logger.debug("look for valid:{} t:{}".format(i, t._serialize()))
+ if epoch_no < 0:
+ epoch_no = t._epoch_no
+ else:
+ if epoch_no - t._epoch_no >= 1:
+ return t, i
+ return None, None
+
+ def _get_last_valid_checkpoint(self):
+ self._load_cp_nos = self._cper.get_checkpoint_no(self._checkpoint_path)
+ logger.info("find checkpoint nos:{}".format(self._load_cp_nos))
+
+ if len(self._load_cp_nos) < 1:
+ self._restored_from = CONST_MEMORYINIT
+ return
+
+ if g_acp_type == CONST_ACP_TYPE:
+ # get the last one
+ self._cper.load_checkpoint(self._checkpoint_path, [self],
+ self._checker.trainer_id,
+ local_cache_path=self._checker._fs_cache)
+ self._restored_from = CONST_CHECKPOINT
+ self._checkpoint_epoch_no = self._epoch_no
+
+ logger.info("load tain_epoch_range checkpoint:{}".format(
+ self._serialize()))
+
+ elif g_acp_type == CONST_DACP_TYPE:
+ t, i = self._look_for_valid(self._load_cp_nos)
+ if t is None:
+ self._restored_from = CONST_MEMORYINIT
+ return
+
+ self._cper.load_checkpoint(self._checkpoint_path, [self],
+ self._checker.trainer_id,
+ checkpoint_no=i,
+ local_cache_path=self._checker._fs_cache)
+
+ self._restored_from = CONST_CHECKPOINT
+ self._checkpoint_epoch_no = self._epoch_no
+ logger.info("load tain_epoch_range checkpoint:{}".format(
+ self._serialize()))
+ else:
+ assert False, "not supported acp_type:{}".format(g_acp_type)
+
+ def _to_dict(self):
+ d = {
+ "max_epoch_num": self._max_epoch_num,
+ "epoch_no": self._epoch_no,
+ "name": self._name,
+ "checkpoint_path": self._checkpoint_path,
+ "restored_from": self._restored_from,
+ "checkpoint_epoch_no": self._checkpoint_epoch_no
+ }
+ return d
+
+ def __str__(self):
+ return self._serialize([])
+
+ @property
+ def name(self):
+ return self._name
+
+ def serialize(self, path):
+ file_name = "{}/{}".format(path, self._file_name)
+ with open(file_name, 'w') as f:
+ s = self._serialize()
+ f.write(s)
+
+ def _serialize(self, pop_keys=["restored_from", "checkpoint_epoch_no"]):
+ # self
+ d = self._to_dict()
+ for k in pop_keys:
+ d.pop(k, None)
+
+ # registerd exes
+ d["exe_status"] = {}
+ e = d["exe_status"]
+ for k, t in six.iteritems(self._exe_status):
+ e[t._key] = t._serialize()
+ return json.dumps(d)
+
+ @property
+ def restored_from(self):
+ return self._restored_from
+
+ def deserialize(self, path):
+ d = None
+ file_name = "{}/{}".format(path, self._file_name)
+ with open(file_name, 'r') as f:
+ d = json.load(f)
+
+ # self
+ self._max_epoch_num = d["max_epoch_num"]
+ self._epoch_no = d["epoch_no"]
+ self._name = d["name"]
+ self._checkpoint_path = d["checkpoint_path"]
+
+ # exes status
+ e = d["exe_status"]
+ for k, v in six.iteritems(e):
+ t = ExeTrainStatus()
+ t._deserialize(v)
+ self._exe_status[k] = t
+
+ def next(self):
+ _thread_checker()
+
+ if self._max_epoch_num < 0:
+ self._max_epoch_num = sys.maxint
+
+ assert self._epoch_no >= -1, "self._epoch_no:{} must >=-1".format(
+ self._epoch_no)
+
+ self._last_checkpoint_time = time.time()
+ start = self._epoch_no + 1
+ logger.info("started epoch_no:{} max_epoch_num:{}".format(
+ start, self._max_epoch_num))
+
+ for i in range(start, self._max_epoch_num):
+ self._epoch_no = i
+ yield i
+
+ self.save_checkpoint()
+
+ def get(self):
+ return self._epoch_no
+
+ def save_checkpoint(self):
+ # not save last one because exe and program can't be restored.
+ if self._checker.trainer_id == 0:
+
+ if time.time() - self._last_checkpoint_time >= \
+ self._save_checkpoint_inter:
+ if g_acp_type == CONST_ACP_TYPE:
+ # not save the last one
+ if self._max_epoch_num > 0 and self._epoch_no != self._max_epoch_num - 1:
+ self._save_checkpoint()
+ elif g_acp_type == CONST_DACP_TYPE:
+ self._save_checkpoint()
+ else:
+ assert False, "not supported acp_type:{}".format(g_acp_type)
+ self._last_checkpoint_time = time.time()
+
+ def _save_checkpoint(self):
+ """
+ status => /jobid/xxx_range_xx/range/
+ model => /exe/
+ """
+ if not self._checker.valid():
+ return
+
+ e = self._exe_status
+ for k, t in six.iteritems(self._exe_status):
+ m = PaddleModel(t._exe, t._program)
+ p = self._checker.get_exe_checkpoint_path(t._hash_key)
+ t._epoch_no = self.get()
+ path, checkpoint_no = self._cper.save_checkpoint(
+ p, [m],
+ self._checker.trainer_id,
+ local_cache_path=self._checker._fs_cache)
+ # index info
+ t._checkpoint_path = path
+ t._checkpoint_no = checkpoint_no
+
+ e[t._key] = t
+
+ logger.debug("save executor checkpoint:{}".format(t._serialize()))
+
+ if len(self._exe_status) > 0:
+ self._cper.save_checkpoint(self._checkpoint_path, [self],
+ local_cache_path=self._checker._fs_cache)
+ logger.info("save train_epoch_range checkpoint:{}".format(
+ self._serialize()))
+
+ self._generate_flag()
+
+ def _generate_flag(self):
+ if self._flag_generated:
+ return
+
+ name = "can_be_auto_checkpoint.flag"
+ path = self._checker.get_job_path() + "/" + name
+ logger.info("this job can_be_auto_checkpoint")
+ self._hdfs.mkdirs(self._checker.get_job_path())
+ self._hdfs.touch(path, exist_ok=True)
+
+ self._flag_generated = True
+
+
+def _get_train_epoch_range():
+ return g_train_epoch_range
+
+
+def _check_program_oprole(program):
+ global_block = program.global_block()
+ has_backward = False
+ has_opt = False
+ for idx, op in enumerate(global_block.ops):
+ if op._is_backward_op():
+ has_backward = True
+
+ if op._is_optimize_op():
+ has_opt = True
+
+ if has_backward and has_opt:
+ return True
+
+ return False
+
+
+def _can_auto_checkpoint(prog):
+ if not isinstance(prog, compiler.CompiledProgram) and \
+ not isinstance(prog, Program):
+ return False
+
+ if isinstance(prog, compiler.CompiledProgram):
+ if prog._program is None or \
+ prog._program._is_distributed:
+ return False
+ else:
+ if prog._is_distributed:
+ return False
+
+ program = _get_valid_program(prog)
+
+ if program._auto_checkpoint_name in g_program_attr:
+ if not g_program_attr[program._auto_checkpoint_name]:
+ return False
+ else:
+ ret = False
+ if isinstance(program, compiler.CompiledProgram):
+ ret = _check_program_oprole(program._program)
+ else:
+ ret = _check_program_oprole(program)
+
+ g_program_attr[program._auto_checkpoint_name] = ret
+ if not ret:
+ logger.debug("program {} need't to auto checkpoint".format(
+ program._auto_checkpoint_name))
+ return False
+
+ return g_checker.valid() and g_train_epoch_range is not None
+
+
+def _get_running_key(exe_name, program_name):
+ return "{}_{}".format(exe_name, program_name)
+
+
+def _get_checker():
+ _get_logger(20)
+ global g_checker
+ if g_checker is None:
+ g_checker = AutoCheckpointChecker()
+
+ return g_checker
+
+
+def _normal_yield(max_epoch_num):
+ if max_epoch_num < 0:
+ max_epoch_num = sys.maxint
+ for i in range(0, max_epoch_num):
+ yield i
+
+ return
+
+
+def train_epoch_range(max_epoch_num, save_checkpoint_inter=None):
+ global g_acp_type
+ if not _get_checker().valid():
+ logger.warning(
+ "auto checkpoint will take effect automaticly on PaddleCloud")
+ for i in _normal_yield(max_epoch_num):
+ yield i
+
+ return
+
+ if g_acp_type == CONST_DACP_TYPE:
+ for i in _normal_yield(max_epoch_num):
+ yield i
+
+ return
+
+ g_acp_type = CONST_ACP_TYPE
+ logger.info("acp_type:{}".format(g_acp_type))
+
+ global g_train_epoch_range
+ try:
+ g_train_epoch_range = TrainEpochRange(
+ max_epoch_num,
+ g_checker.generate_range_name(),
+ checkpoint_inter=save_checkpoint_inter)
+
+ for i in g_train_epoch_range.next():
+ yield i
+ finally:
+ g_train_epoch_range = None
+
+
+def _get_valid_program(prog):
+ if isinstance(prog, compiler.CompiledProgram):
+ return prog._program
+
+ return prog
+
+
+def _auto_checkpoint(exe, prog):
+ _get_checker()
+
+ assert exe._auto_checkpoint_name != None
+ if not _can_auto_checkpoint(prog):
+ return
+
+ program = _get_valid_program(prog)
+ assert program._auto_checkpoint_name != None
+
+ exe_status = g_train_epoch_range._exe_status
+ key = _get_running_key(exe._auto_checkpoint_name,
+ program._auto_checkpoint_name)
+
+ if g_train_epoch_range.restored_from == CONST_CHECKPOINT:
+ assert key in exe_status, "when restored key:{} must be in train_epoch_range:{}".format(
+ key, g_train_epoch_range)
+
+ t = None
+ if key in exe_status:
+ t = exe_status[key]
+ if t._restored_from is None:
+ a = CheckpointSaver(g_train_epoch_range._hdfs)
+ m = PaddleModel(exe, program)
+ a.load_checkpoint(g_checker.get_exe_checkpoint_path(key), [m],
+ trainer_id=g_checker.trainer_id,
+ checkpoint_no=t._checkpoint_no,
+ local_cache_path=g_checker._fs_cache)
+ t._restored_from = CONST_CHECKPOINT
+ logger.info("load executor checkpoint {}".format(t))
+ t._exe = exe
+ t._program = program
+ t._epoch_no = g_train_epoch_range.get()
+ else:
+ t = ExeTrainStatus()
+ t._epoch_no = g_train_epoch_range.get()
+ t._hash_key = key
+ t._key = key
+ t._restored_from = CONST_MEMORYINIT
+ t._exe = exe
+ t._program = program
+ t._exe_name = exe._auto_checkpoint_name
+ t._program_name = program._auto_checkpoint_name
+
+ # register this
+ exe_status[key] = t
+
+ logger.info("not found checkpoint, so train from epoch 0")
+
+ _thread_checker()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/checkpoint_saver.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/checkpoint_saver.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8aeb50f157c0f66df920fef133cf5870cd57052
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/checkpoint/checkpoint_saver.py
@@ -0,0 +1,225 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ...compiler import CompiledProgram
+
+
+class SerializableBase(object):
+
+ def serialize(self, path):
+ raise NotImplementedError
+
+ def deserialize(self, path):
+ raise NotImplementedError
+
+
+class PaddleModel(SerializableBase):
+
+ def __init__(self, exe, program):
+ self._exe = exe
+ self._origin_program = program
+ self._program = program
+ if isinstance(program, CompiledProgram):
+ self._program = program._program
+
+ self._file_name = "_paddle_fleet_param__"
+
+ def serialize(self, path):
+ from ...io import save_persistables
+ save_persistables(executor=self._exe,
+ dirname=path,
+ main_program=self._program,
+ filename=self._file_name)
+
+ def deserialize(self, path):
+ from ...io import load_persistables
+ load_persistables(executor=self._exe,
+ dirname=path,
+ main_program=self._program,
+ filename=self._file_name)
+
+
+class CheckpointSaver(object):
+
+ def __init__(self, fs):
+ self._fs = fs
+ self._checkpoint_prefix = "__paddle_checkpoint__"
+
+ def save_checkpoint(self,
+ path,
+ slists,
+ trainer_id=None,
+ local_cache_path=".cache"):
+ """
+ Serialize objects in slists to path
+ Return really saved path and checkpoint_no
+ """
+ if not self._fs.is_exist(path):
+ self._fs.mkdirs(path)
+ else:
+ assert self._fs.is_dir(path), "path:{} must be a directory".format(
+ path)
+
+ max_no = self._get_last_checkpoint_no(path)
+ if max_no < 0:
+ max_no = -1
+ max_no += 1
+
+ real_path = "{}/{}.{}".format(path, self._checkpoint_prefix, max_no)
+ tmp_path = "{}.tmp".format(real_path)
+ saved_path = tmp_path
+
+ from paddle.distributed.fleet.utils.fs import LocalFS
+ local_fs = LocalFS()
+
+ cache_path = None
+ if self._fs.need_upload_download():
+ cache_path = "{}/{}.{}.saved_cache".format(local_cache_path,
+ self._checkpoint_prefix,
+ max_no)
+
+ if trainer_id is not None:
+ cache_path = "{}.{}".format(cache_path, trainer_id)
+
+ if not local_fs.is_exist(cache_path):
+ local_fs.mkdirs(cache_path)
+ else:
+ assert local_fs.is_dir(cache_path), \
+ "cache path:{} must be a directory".format(cache_path)
+
+ saved_path = cache_path
+
+ for s in slists:
+ s.serialize(saved_path)
+
+ if self._fs.need_upload_download():
+ self._fs.delete(tmp_path)
+ self._fs.upload(cache_path, tmp_path)
+ local_fs.delete(cache_path)
+ self._fs.mv(tmp_path, real_path)
+
+ return real_path, max_no
+
+ def load_checkpoint(self,
+ path,
+ slists,
+ trainer_id,
+ local_cache_path=".cache",
+ checkpoint_no=None,
+ ignore_empty=True):
+ """
+ Deserialize objects in slists from path
+ Return really load path
+ """
+ if checkpoint_no is None:
+ max_no = self._get_last_checkpoint_no(path)
+
+ if not ignore_empty:
+ assert max_no >= 0, "Can't find checkpoint"
+
+ if max_no < 0:
+ return None
+
+ checkpoint_no = max_no
+ else:
+ assert isinstance(checkpoint_no, int)
+ assert checkpoint_no >= 0
+
+ from paddle.distributed.fleet.utils.fs import LocalFS
+ local_fs = LocalFS()
+ if self._fs.need_upload_download():
+ cache_path = "{}/{}.{}.load_cache".format(local_cache_path,
+ self._checkpoint_prefix,
+ checkpoint_no)
+
+ if trainer_id is not None:
+ cache_path = "{}.{}".format(cache_path, trainer_id)
+
+ if not local_fs.is_exist(local_cache_path):
+ local_fs.mkdirs(local_cache_path)
+ if local_fs.is_exist(cache_path):
+ local_fs.delete(cache_path)
+
+ real_path = "{}/{}.{}".format(path, self._checkpoint_prefix,
+ checkpoint_no)
+ load_path = real_path
+ if self._fs.need_upload_download():
+ self._fs.download(real_path, cache_path)
+ load_path = cache_path
+
+ for s in slists:
+ s.deserialize(load_path)
+
+ if self._fs.need_upload_download() and cache_path:
+ local_fs.delete(cache_path)
+
+ return real_path
+
+ def get_checkpoint_no(self, root_path):
+ a = []
+ dirs = self._fs.list_dirs(root_path)
+ for d in dirs:
+ g = d.split(".")
+ if len(g) != 2:
+ continue
+
+ if g[0] != self._checkpoint_prefix:
+ continue
+
+ try:
+ n = int(g[1])
+ a.append(n)
+ except:
+ continue
+
+ a.sort()
+ return a
+
+ def _get_last_checkpoint_no(self, root_path):
+ """
+ only get the first depth
+ """
+ a = self.get_checkpoint_no(root_path)
+ if len(a) > 0:
+ return a[-1]
+
+ return -1
+
+ def clean_redundant_checkpoints(self, root_path, reserved=[]):
+ max_no = self._get_last_checkpoint_no(root_path)
+ if max_no < 0:
+ return
+
+ s = set(reserved)
+ if len(s) == 0:
+ s.add(max_no)
+
+ dirs = self._fs.list_dirs(root_path)
+ for d in dirs:
+ g = d.split(".")
+ if len(g) != 2:
+ continue
+
+ if g[0] != self._checkpoint_prefix:
+ continue
+
+ try:
+ n = int(g[1])
+ if n not in s:
+ path = "{}/{}.{}".format(root_path, self._checkpoint_prefix,
+ n)
+ self._fs.delete(path)
+ except Exception as e:
+ print(e)
+ continue
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/data_generator/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/data_generator/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ef851f52e7b8a61fc73d884b992b3fd2714f8d4
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/data_generator/__init__.py
@@ -0,0 +1,346 @@
+# Copyright (c) 2019 PaddlePaddle 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 os
+import sys
+
+__all__ = ['MultiSlotDataGenerator', 'MultiSlotStringDataGenerator']
+
+
+class DataGenerator(object):
+ """
+ DataGenerator is a general Base class for user to inherit
+ A user who wants to define his/her own python processing logic
+ with paddle.fluid.dataset should inherit this class
+ """
+
+ def __init__(self):
+ self._proto_info = None
+ self.batch_size_ = 32
+
+ def _set_line_limit(self, line_limit):
+ if not isinstance(line_limit, int):
+ raise ValueError("line_limit%s must be in int type" %
+ type(line_limit))
+ if line_limit < 1:
+ raise ValueError("line_limit can not less than 1")
+ self._line_limit = line_limit
+
+ def set_batch(self, batch_size):
+ '''
+ Set batch size of current DataGenerator
+ This is necessary only if a user wants to define generator_batch
+
+ Example:
+ .. code-block:: python
+ import paddle.fluid.incubate.data_generator as dg
+ class MyData(dg.DataGenerator):
+ def generate_sample(self, line):
+ def local_iter():
+ int_words = [int(x) for x in line.split()]
+ yield ("words", int_words)
+ return local_iter
+ def generate_batch(self, samples):
+ def local_iter():
+ for s in samples:
+ yield ("words", s[1].extend([s[1][0]]))
+ mydata = MyData()
+ mydata.set_batch(128)
+
+ '''
+ self.batch_size_ = batch_size
+
+ def run_from_memory(self):
+ '''
+ This function generator data from memory, it is usually used for
+ debug and benchmarking
+ Example:
+ .. code-block:: python
+ import paddle.fluid.incubate.data_generator as dg
+ class MyData(dg.DataGenerator):
+ def generate_sample(self, line):
+ def local_iter():
+ yield ("words", [1, 2, 3, 4])
+ return local_iter
+ mydata = MyData()
+ mydata.run_from_memory()
+ '''
+ batch_samples = []
+ line_iter = self.generate_sample(None)
+ for user_parsed_line in line_iter():
+ if user_parsed_line == None:
+ continue
+ batch_samples.append(user_parsed_line)
+ if len(batch_samples) == self.batch_size_:
+ batch_iter = self.generate_batch(batch_samples)
+ for sample in batch_iter():
+ sys.stdout.write(self._gen_str(sample))
+ batch_samples = []
+ if len(batch_samples) > 0:
+ batch_iter = self.generate_batch(batch_samples)
+ for sample in batch_iter():
+ sys.stdout.write(self._gen_str(sample))
+
+ def run_from_stdin(self):
+ '''
+ This function reads the data row from stdin, parses it with the
+ process function, and further parses the return value of the
+ process function with the _gen_str function. The parsed data will
+ be wrote to stdout and the corresponding protofile will be
+ generated.
+ Example:
+
+ .. code-block:: python
+ import paddle.fluid.incubate.data_generator as dg
+ class MyData(dg.DataGenerator):
+ def generate_sample(self, line):
+ def local_iter():
+ int_words = [int(x) for x in line.split()]
+ yield ("words", [int_words])
+ return local_iter
+ mydata = MyData()
+ mydata.run_from_stdin()
+ '''
+ batch_samples = []
+ for line in sys.stdin:
+ line_iter = self.generate_sample(line)
+ for user_parsed_line in line_iter():
+ if user_parsed_line == None:
+ continue
+ batch_samples.append(user_parsed_line)
+ if len(batch_samples) == self.batch_size_:
+ batch_iter = self.generate_batch(batch_samples)
+ for sample in batch_iter():
+ sys.stdout.write(self._gen_str(sample))
+ batch_samples = []
+ if len(batch_samples) > 0:
+ batch_iter = self.generate_batch(batch_samples)
+ for sample in batch_iter():
+ sys.stdout.write(self._gen_str(sample))
+
+ def _gen_str(self, line):
+ '''
+ Further processing the output of the process() function rewritten by
+ user, outputting data that can be directly read by the datafeed,and
+ updating proto_info information.
+ Args:
+ line(str): the output of the process() function rewritten by user.
+ Returns:
+ Return a string data that can be read directly by the datafeed.
+ '''
+ raise NotImplementedError(
+ "pls use MultiSlotDataGenerator or PairWiseDataGenerator")
+
+ def generate_sample(self, line):
+ '''
+ This function needs to be overridden by the user to process the
+ original data row into a list or tuple.
+ Args:
+ line(str): the original data row
+ Returns:
+ Returns the data processed by the user.
+ The data format is list or tuple:
+ [(name, [feasign, ...]), ...]
+ or ((name, [feasign, ...]), ...)
+
+ For example:
+ [("words", [1926, 08, 17]), ("label", [1])]
+ or (("words", [1926, 08, 17]), ("label", [1]))
+ Note:
+ The type of feasigns must be in int or float. Once the float
+ element appears in the feasign, the type of that slot will be
+ processed into a float.
+ Example:
+ .. code-block:: python
+ import paddle.fluid.incubate.data_generator as dg
+ class MyData(dg.DataGenerator):
+ def generate_sample(self, line):
+ def local_iter():
+ int_words = [int(x) for x in line.split()]
+ yield ("words", [int_words])
+ return local_iter
+ '''
+ raise NotImplementedError(
+ "Please rewrite this function to return a list or tuple: " +
+ "[(name, [feasign, ...]), ...] or ((name, [feasign, ...]), ...)")
+
+ def generate_batch(self, samples):
+ '''
+ This function needs to be overridden by the user to process the
+ generated samples from generate_sample(self, str) function
+ It is usually used as batch processing when a user wants to
+ do preprocessing on a batch of samples, e.g. padding according to
+ the max length of a sample in the batch
+ Args:
+ samples(list tuple): generated sample from generate_sample
+ Returns:
+ a python generator, the same format as return value of generate_sample
+ Example:
+ .. code-block:: python
+ import paddle.fluid.incubate.data_generator as dg
+ class MyData(dg.DataGenerator):
+ def generate_sample(self, line):
+ def local_iter():
+ int_words = [int(x) for x in line.split()]
+ yield ("words", int_words)
+ return local_iter
+ def generate_batch(self, samples):
+ def local_iter():
+ for s in samples:
+ yield ("words", s[1].extend([s[1][0]]))
+ mydata = MyData()
+ mydata.set_batch(128)
+ '''
+
+ def local_iter():
+ for sample in samples:
+ yield sample
+
+ return local_iter
+
+
+# TODO: guru4elephant
+# add more generalized DataGenerator that can adapt user-defined slot
+# for example, [(name, float_list), (name, str_list), (name, int_list)]
+class MultiSlotStringDataGenerator(DataGenerator):
+
+ def _gen_str(self, line):
+ '''
+ Further processing the output of the process() function rewritten by
+ user, outputting data that can be directly read by the MultiSlotDataFeed,
+ and updating proto_info information.
+ The input line will be in this format:
+ >>> [(name, [str(feasign), ...]), ...]
+ >>> or ((name, [str(feasign), ...]), ...)
+ The output will be in this format:
+ >>> [ids_num id1 id2 ...] ...
+ For example, if the input is like this:
+ >>> [("words", ["1926", "08", "17"]), ("label", ["1"])]
+ >>> or (("words", ["1926", "08", "17"]), ("label", ["1"]))
+ the output will be:
+ >>> 3 1234 2345 3456 1 1
+ Args:
+ line(str): the output of the process() function rewritten by user.
+ Returns:
+ Return a string data that can be read directly by the MultiSlotDataFeed.
+ '''
+ if not isinstance(line, list) and not isinstance(line, tuple):
+ raise ValueError(
+ "the output of process() must be in list or tuple type"
+ "Examples: [('words', ['1926', '08', '17']), ('label', ['1'])]")
+ output = ""
+ for index, item in enumerate(line):
+ name, elements = item
+ if output:
+ output += " "
+ out_str = []
+ out_str.append(str(len(elements)))
+ out_str.extend(elements)
+ output += " ".join(out_str)
+ return output + "\n"
+
+
+class MultiSlotDataGenerator(DataGenerator):
+
+ def _gen_str(self, line):
+ '''
+ Further processing the output of the process() function rewritten by
+ user, outputting data that can be directly read by the MultiSlotDataFeed,
+ and updating proto_info information.
+ The input line will be in this format:
+ >>> [(name, [feasign, ...]), ...]
+ >>> or ((name, [feasign, ...]), ...)
+ The output will be in this format:
+ >>> [ids_num id1 id2 ...] ...
+ The proto_info will be in this format:
+ >>> [(name, type), ...]
+
+ For example, if the input is like this:
+ >>> [("words", [1926, 08, 17]), ("label", [1])]
+ >>> or (("words", [1926, 08, 17]), ("label", [1]))
+ the output will be:
+ >>> 3 1234 2345 3456 1 1
+ the proto_info will be:
+ >>> [("words", "uint64"), ("label", "uint64")]
+ Args:
+ line(str): the output of the process() function rewritten by user.
+ Returns:
+ Return a string data that can be read directly by the MultiSlotDataFeed.
+ '''
+ if not isinstance(line, list) and not isinstance(line, tuple):
+ raise ValueError(
+ "the output of process() must be in list or tuple type"
+ "Example: [('words', [1926, 08, 17]), ('label', [1])]")
+ output = ""
+
+ if self._proto_info is None:
+ self._proto_info = []
+ for item in line:
+ name, elements = item
+ if not isinstance(name, str):
+ raise ValueError("name%s must be in str type" % type(name))
+ if not isinstance(elements, list):
+ raise ValueError("elements%s must be in list type" %
+ type(elements))
+ if not elements:
+ raise ValueError(
+ "the elements of each field can not be empty, you need padding it in process()."
+ )
+ self._proto_info.append((name, "uint64"))
+ if output:
+ output += " "
+ output += str(len(elements))
+ for elem in elements:
+ if isinstance(elem, float):
+ self._proto_info[-1] = (name, "float")
+ elif not isinstance(elem, int) and not isinstance(
+ elem, long):
+ raise ValueError(
+ "the type of element%s must be in int or float" %
+ type(elem))
+ output += " " + str(elem)
+ else:
+ if len(line) != len(self._proto_info):
+ raise ValueError(
+ "the complete field set of two given line are inconsistent."
+ )
+ for index, item in enumerate(line):
+ name, elements = item
+ if not isinstance(name, str):
+ raise ValueError("name%s must be in str type" % type(name))
+ if not isinstance(elements, list):
+ raise ValueError("elements%s must be in list type" %
+ type(elements))
+ if not elements:
+ raise ValueError(
+ "the elements of each field can not be empty, you need padding it in process()."
+ )
+ if name != self._proto_info[index][0]:
+ raise ValueError(
+ "the field name of two given line are not match: require<%s>, get<%s>."
+ % (self._proto_info[index][0], name))
+ if output:
+ output += " "
+ output += str(len(elements))
+ for elem in elements:
+ if self._proto_info[index][1] != "float":
+ if isinstance(elem, float):
+ self._proto_info[index] = (name, "float")
+ elif not isinstance(elem, int) and not isinstance(
+ elem, long):
+ raise ValueError(
+ "the type of element%s must be in int or float"
+ % type(elem))
+ output += " " + str(elem)
+ return output + "\n"
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a05baabca392b14a4cb09a3f395ae7687d8a5e62
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/__init__.py
@@ -0,0 +1,14 @@
+# Copyright (c) 2019 PaddlePaddle 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
+
+__version__ = '0.1.0'
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8647330f3290f3142cabca9a7e3fe162a9838dda
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) 2019 PaddlePaddle 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
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/fleet_base.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/fleet_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..6aa4fcf45c792614922ff1d1f917f2a5736fd9fe
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/fleet_base.py
@@ -0,0 +1,370 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import abc
+
+import paddle.fluid as fluid
+from paddle.fluid.executor import Executor
+from paddle.fluid.optimizer import SGD
+from paddle.optimizer import SGD as SGD_v2
+
+from paddle.fluid.incubate.fleet.base.mode import Mode
+from paddle.distributed.fleet.base.role_maker import RoleMakerBase
+from paddle.fluid.contrib.mixed_precision.decorator import OptimizerWithMixedPrecision
+from . import mode
+
+__all__ = ['Fleet', 'DistributedOptimizer']
+__all__ += mode.__all__
+
+
+class Fleet(object):
+ """
+ Fleet is the base class, transpiler and pslib are implementation of Fleet.
+
+ Args:
+ mode(Mode): the implementation of Fleet's mode.
+
+ Returns:
+ None
+ """
+ __metaclass__ = abc.ABCMeta
+
+ def __init__(self, mode):
+ self._is_initialized = False
+ self._mode = mode
+ self._optimizer = None
+ self._role_maker = None
+ self._executor = None
+
+ def is_first_worker(self):
+ """
+ Check whether the node is the first instance of worker.
+
+ Returns:
+ bool: True if this is the first node of worker,
+ False if not.
+ """
+ return self._role_maker.is_first_worker()
+
+ def worker_index(self):
+ """
+ Get current worker index.
+
+ Returns:
+ int: node id
+ """
+ return self._role_maker.worker_index()
+
+ def worker_num(self):
+ """
+ Get current total worker number.
+
+ Returns:
+ int: worker numbers
+ """
+ return self._role_maker.worker_num()
+
+ def is_worker(self):
+ """
+ Check whether the node is an instance of worker.
+
+ Returns:
+ bool: True if this is a node of worker,
+ False if not.
+ """
+ return self._role_maker.is_worker()
+
+ def worker_endpoints(self, to_string=False):
+ """
+ Get current server endpoints, such as ["127.0.0.1:1001", "127.0.0.1:1002"].
+
+ Returns:
+ list/string: server endpoints
+ """
+
+ if to_string:
+ return ",".join(self._role_maker.get_trainer_endpoints())
+ else:
+ return self._role_maker.get_trainer_endpoints()
+
+ def server_num(self):
+ """
+ Get current total worker number.
+
+ Returns:
+ int: server number
+ """
+ return len(self._role_maker.get_pserver_endpoints())
+
+ def server_index(self):
+ """
+ Get current server index.
+
+ Returns:
+ int: node id
+ """
+ return self._role_maker.server_index()
+
+ def server_endpoints(self, to_string=False):
+ """
+ Get current server endpoints, such as ["127.0.0.1:1001", "127.0.0.1:1002"].
+
+ Returns:
+ list/string: server endpoints
+ """
+
+ if to_string:
+ return ",".join(self._role_maker.get_pserver_endpoints())
+ else:
+ return self._role_maker.get_pserver_endpoints()
+
+ def is_server(self):
+ """
+ Check whether the node is an instance of server.
+
+ Returns:
+ bool: True if this is a node of server,
+ False if not
+ """
+ return self._role_maker.is_server()
+
+ def is_xpu(self):
+ """
+ Check whether the node is an instance of server.
+
+ Returns:
+ bool: True if this is a node of server,
+ False if not.
+ """
+ return self._role_maker.is_xpu()
+
+ def split_files(self, files):
+ """
+ split files before distributed training,
+ example 1: files is [a, b, c ,d, e] and trainer_num = 2, then trainer
+ 0 gets [a, b, c] and trainer 1 gets [d, e].
+ example 2: files is [a, b], and trainer_num = 3, then trainer 0 gets
+ [a], trainer 1 gets [b], trainer 2 gets []
+
+ Args:
+ files(list): file list need to be read.
+
+ Returns:
+ list: files belongs to this worker.
+ """
+ if not isinstance(files, list):
+ raise TypeError("files should be a list of file need to be read.")
+
+ trainer_id = self.worker_index()
+ trainers = self.worker_num()
+
+ remainder = len(files) % trainers
+ blocksize = len(files) // trainers
+
+ blocks = [blocksize] * trainers
+ for i in range(remainder):
+ blocks[i] += 1
+
+ trainer_files = [[]] * trainers
+ begin = 0
+ for i in range(trainers):
+ trainer_files[i] = files[begin:begin + blocks[i]]
+ begin += blocks[i]
+
+ return trainer_files[trainer_id]
+
+ def init(self, role_maker=None):
+ """
+ should be called only once in user's python scripts,
+ init() will initialize RoleMaker which is used for identifying
+ current node's role, e.g. worker, server, etc.
+
+ Args:
+ role_maker(RoleMakerBase): subclass of RoleMakerBase.
+
+ Returns:
+ None
+ """
+ self._executor = Executor(fluid.CPUPlace())
+
+ if role_maker and not isinstance(role_maker, RoleMakerBase):
+ from paddle.fluid.incubate.fleet.base.role_maker import RoleMakerBase as RoleMakerBaseIncubate
+ if role_maker and not isinstance(role_maker, RoleMakerBaseIncubate):
+ raise TypeError(
+ "role_maker must be an instance of RoleMakerBase")
+
+ self._role_maker = role_maker
+ self._role_maker.generate_role()
+ self._is_initialized = True
+
+ def all_reduce_worker(self, input, output):
+ """
+ all reduce between workers, only support array of one dim.
+
+ Args:
+ input(list|numpy.array): array of one dim
+ output(list|numpy.array): array of one dim
+ """
+ self._role_maker.all_reduce_worker(input, output)
+
+ def barrier_worker(self):
+ """
+ barrier between workers
+ """
+ self._role_maker.barrier_worker()
+
+ @abc.abstractmethod
+ def init_worker(self):
+ pass
+
+ @abc.abstractmethod
+ def init_server(self, model_dir=None, **kwargs):
+ pass
+
+ @abc.abstractmethod
+ def run_server(self):
+ pass
+
+ @abc.abstractmethod
+ def stop_worker(self):
+ pass
+
+ @abc.abstractmethod
+ def distributed_optimizer(self, optimizer, strategy=None):
+ pass
+
+ @abc.abstractmethod
+ def save_inference_model(self,
+ executor,
+ dirname,
+ feeded_var_names,
+ target_vars,
+ main_program=None,
+ export_for_deployment=True):
+ pass
+
+ @abc.abstractmethod
+ def save_persistables(self, executor, dirname, main_program=None):
+ pass
+
+
+class DistributedOptimizer(object):
+ """
+ DistributedOptimizer is a wrapper for paddle.fluid.optimizer
+ A user should pass a paddle.fluid.optimizer to DistributedOptimizer
+ minimize() function is implemented.
+ DistributedOptimizer is the starting point for a user who wants to
+ run distributed training. The optimized information will be stored in
+ Fleet() instance who holds the global information about current distributed
+ training.
+
+ Args:
+ optimizer(Optimizer): subclass of Optimizer.
+ strategy(any): the user define config for Optimizer.
+
+ Returns:
+ None
+
+ """
+ __metaclass__ = abc.ABCMeta
+
+ def __init__(self, optimizer, strategy=None):
+ if not isinstance(optimizer, SGD.__bases__) \
+ and not isinstance(optimizer, OptimizerWithMixedPrecision) \
+ and not isinstance(optimizer, SGD_v2.__base__):
+ raise TypeError("optimizer must be an instance of Optimizer")
+
+ self._optimizer = optimizer
+ self._strategy = strategy
+
+ @abc.abstractmethod
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ """
+ First part of `minimize`, do auto-diff to append backward ops for
+ the current program.
+
+ Args:
+ loss (Variable): loss variable to run optimizations.
+ startup_program (Program): startup_program for initializing parameters
+ in `parameter_list`.
+ parameter_list (list): list of Variables to update.
+ no_grad_set (set|None): set of Variables should be ignored.
+ callbacks (list|None): list of callables to run when appending backward
+ operator for one parameter.
+
+ Return:
+ list: list of (param, grad) pair, grad is the output of backward.
+
+ Examples:
+ See examples in `apply_gradients`.
+ """
+ pass
+
+ @abc.abstractmethod
+ def apply_gradients(self, params_grads):
+ """
+ Second part of `minimize`, appending optimization operators for
+ given `params_grads` pairs.
+
+ Args:
+ params_grads (list): list of (param, grad) pair to do optimization.
+
+ Returns:
+ list: A list of operators appended to the current program.
+
+ Examples:
+ .. code-block:: python
+
+ loss = network()
+ optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+ params_grads = optimizer.backward(loss)
+ # you may append operations for params_grads here
+ # ...
+ optimizer.apply_gradients(params_grads)
+ """
+ pass
+
+ @abc.abstractmethod
+ def minimize(self,
+ losses,
+ scopes=None,
+ startup_programs=None,
+ parameter_list=None,
+ no_grad_set=None):
+ """
+ Add operations to minimize `loss` by updating `parameter_list`.
+
+ This method combines interface `backward()` and
+ `apply_gradients()` into one.
+
+ Args:
+ losses (Variable|Variable List): loss variable to run optimizations.
+ scopes (Scope| Scope List): scope instance.
+ startup_programs (Program|Program List): startup_program for initializing parameters
+ in `parameter_list`.
+ parameter_list (list): list of Variables to update.
+ no_grad_set (set|None): set of Variables should be ignored.
+
+ Returns:
+ tuple: (optimize_ops, params_grads) which are, list of operators appended;
+ and list of (param, grad) Variables pair for optimization.
+ """
+ pass
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/mode.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/mode.py
new file mode 100644
index 0000000000000000000000000000000000000000..da6519d49e630111f5cb4d9305d05548a7147e30
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/mode.py
@@ -0,0 +1,26 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+__all__ = ['Mode']
+
+
+class Mode:
+ """
+ There are various mode for fleet, each of them is designed for different model.
+ """
+ TRANSPILER = 1
+ PSLIB = 2
+ COLLECTIVE = 3
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/role_maker.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/role_maker.py
new file mode 100644
index 0000000000000000000000000000000000000000..f97f46a7c49b3d9872479335d8e20cf1994c35cf
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/base/role_maker.py
@@ -0,0 +1,1305 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+"""Defination of Role Makers."""
+
+from __future__ import print_function
+from multiprocessing import Process, Manager
+import paddle.fluid as fluid
+import os
+import time
+
+__all__ = [
+ 'Role', 'RoleMakerBase', 'MPISymetricRoleMaker', 'UserDefinedRoleMaker',
+ 'UserDefinedCollectiveRoleMaker', 'PaddleCloudRoleMaker', 'GeneralRoleMaker'
+]
+
+
+class Role:
+ WORKER = 1
+ SERVER = 2
+ XPU = 3
+
+
+class MockBarrier(object):
+ """
+ MockBarrier is a empty impletation for barrier
+ mock as a real barrier for never-barrier in a specific scenario
+ """
+
+ def barrier(self):
+ """
+ dummy barrier, do nothing
+ """
+ pass
+
+ def barrier_all(self):
+ """
+ dummy all barrier, do nothing
+ """
+ pass
+
+ def all_reduce(self, obj):
+ """
+ dummy all reduce, do nothing
+ Args:
+ obj(any): obj to do all reduce
+ """
+ return obj
+
+ def all_gather(self, obj):
+ """
+ dummy all gather, do nothing
+ Args:
+ obj(any): obj to do all gather
+ """
+ return [obj]
+
+
+class RoleMakerBase(object):
+ """
+ RoleMakerBase is a base class for assigning a role to current process
+ in distributed training.
+ A paddle developer can implement RoleMakerBase to design a role maker
+ for worker or pserver assignment.
+ """
+
+ def __init__(self):
+ self._worker_endpoints = []
+ self._server_endpoints = []
+ self._role_is_generated = False
+ self._role = None
+ self._current_id = -1
+
+ def is_worker(self):
+ """
+ return is_worker() of current process
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def is_server(self):
+ """
+ return is_server() of current process
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def is_first_worker(self):
+ """
+ Check whether the node is the first instance of worker.
+ Returns:
+ bool: True if this is the first node of worker,
+ False if not.
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def worker_num(self):
+ """
+ Get current total worker number.
+
+ Returns:
+ int: worker number
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def role_id(self):
+ return self.worker_index() if self.is_worker() else self.server_index()
+
+ def worker_index(self):
+ """
+ Get current worker id.
+
+ Returns:
+ int: node id
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def server_index(self):
+ """
+ Get current server id.
+
+ Returns:
+ int: node id
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+ def get_trainer_endpoints(self):
+ """
+ return trainer endpoints
+ """
+ return self._worker_endpoints
+
+ def get_pserver_endpoints(self):
+ """
+ return pserver endpoints
+ """
+ return self._server_endpoints
+
+ def to_string(self):
+ return "role: {}, current_id: {}, worker_endpoints: {}, server_endpoints: {}".format(
+ self._role, self._current_id, self._worker_endpoints,
+ self._server_endpoints)
+
+ def all_gather(self, input):
+ """
+ all gather between trainers and pservers
+
+ Args:
+ input(int|float): input value
+
+ Returns:
+ return a list of values
+ """
+ print("warning: RoleMakerBase does not have all gather.")
+ return None
+
+ def all_reduce_worker(self, input, output, mode="sum"):
+ """
+ all reduce between trainers if current role is TRAINER,
+ only support array of one dim.
+
+ Args:
+ input(list/numpy.array): array of one dim
+ output(list/numpy.array): array of one dim
+ mode(str): "sum" or "min" or "max"
+ """
+ print("warning: RoleMakerBase does not have all reduce worker.")
+
+ def barrier_worker(self):
+ """
+ barrier between trainers if current role is TRAINER
+ """
+ print("warning: RoleMakerBase does not have barrier worker.")
+
+ def barrier_all(self):
+ """
+ barrier between trainers if current role is PSERVER
+ """
+ print("warning: RoleMakerBase does not have barrier all.")
+
+
+class MPIRoleMaker(RoleMakerBase):
+ """
+ MPIRoleMaker is a MPI-API based role maker which is a counter-part of K8SRoleMaker
+ mpi4py will be used if a developer inherits MPIRoleMaker
+ """
+
+ def __init__(self):
+ """Init."""
+ super(MPIRoleMaker, self).__init__()
+ from mpi4py import MPI
+ self.MPI = MPI
+ self._comm = MPI.COMM_WORLD
+ self._node_type_comm = None
+ self._ips = None
+ self._ip = None
+
+ def _get_rank(self):
+ """Return rank."""
+ self._rank = self._comm.Get_rank()
+ return self._rank
+
+ def _get_size(self):
+ """Return size."""
+ self._size = self._comm.Get_size()
+ return self._size
+
+ def _all_gather(self, obj):
+ """
+ all_gather(obj) will call MPI's allgather function
+ """
+ self._barrier_all()
+ return self._comm.allgather(obj)
+
+ def _worker_gather(self, obj):
+ """
+ worker_gather(obj) will call MPI's allgather function
+ """
+ if self.is_worker():
+ self._node_type_comm.barrier()
+ return self._node_type_comm.allgather(obj)
+ return None
+
+ def _barrier_all(self):
+ """
+ barrier_all() will call MPI's barrier_all function
+ """
+ self._comm.barrier()
+
+ def _finalize(self):
+ """
+ finalize the current MPI instance.
+ """
+ self.MPI.Finalize()
+
+ def _get_ips(self):
+ """
+ collect current distributed job's ip list
+ """
+ if not self._ips:
+ self._ips = self._comm.allgather(self.get_local_ip())
+ return self._ips
+
+ def get_local_ip(self):
+ """Return get local ip."""
+ import socket
+ self._ip = socket.gethostbyname(socket.gethostname())
+ return self._ip
+
+ def generate_role(self):
+ """
+ generate_role() should be called to identify current process's role
+ """
+ raise NotImplementedError("Please implement this method in child class")
+
+
+class MPISymetricRoleMaker(MPIRoleMaker):
+ """
+ MPISymetricRoleMaker is designed for worker and server assignment
+ under MPI. Typically, a worker and a server node will be appointed
+ on each physical node. This role maker can be only used under MPI.
+ """
+
+ def __init__(self):
+ """Init."""
+ super(MPISymetricRoleMaker, self).__init__()
+ self._node_type = None
+ self._proc_per_node = 2
+ self._pserver_rand_port = 0
+
+ def _check_role_generation(self):
+ """Check whether role has been generated."""
+ if not self._role_is_generated:
+ raise NameError("generate_role() should be called first")
+ return True
+
+ def all_gather(self, input):
+ """
+ all gather between trainers and pservers
+
+ Args:
+ input(int|float): input value
+
+ Returns:
+ return a list of values
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._all_gather(input)
+
+ def all_reduce_worker(self, input, output, mode="sum"):
+ """
+ all reduce between trainers if current role is TRAINER,
+ only support array of one dim.
+
+ Args:
+ input(list/numpy.array): array of one dim
+ output(list/numpy.array): array of one dim
+ mode(str): "sum" or "min" or "max"
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if not self.is_worker():
+ print("warning: current role is not worker in all_reduce_worker")
+ return
+ self._all_reduce(input, output, mode)
+
+ def barrier_worker(self):
+ """
+ barrier between trainers if current role is TRAINER
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if self.is_worker():
+ self._node_type_comm.barrier()
+ else:
+ print("warning: current role is not worker in barrier_worker")
+
+ def barrier_all(self):
+ """
+ barrier between trainers if current role is PSERVER
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ self._comm.barrier()
+
+ def is_first_worker(self):
+ """
+ return whether current process is the first worker assigned by role maker
+ """
+ if self._check_role_generation():
+ return self.is_worker() and 0 == self.worker_index()
+ return False
+
+ def get_pserver_endpoints(self):
+ """
+ get pserver endpoints
+ Returns:
+ endpoints(list): pserver endpoints
+ """
+ if self._pserver_rand_port <= 0:
+ import random
+ random.seed(self._server_num())
+ # port will be randomly generated from 60001 to 63999
+ # random seed is server num so that all nodes will get
+ # the same port
+ self._pserver_rand_port = random.randint(60001, 64000)
+ endpoints = [
+ x + ":" + str(self._pserver_rand_port)
+ for x in self._server_endpoints
+ ]
+ return endpoints
+
+ def worker_num(self):
+ return self._worker_num()
+
+ def is_worker(self):
+ """
+ return whether current process is worker assigned by role maker
+ """
+ if self._check_role_generation():
+ return self._node_type == 1
+ return False
+
+ def is_server(self):
+ """
+ return whether current process is server assigned by role maker
+ """
+ if self._check_role_generation():
+ return self._node_type == 0
+ return False
+
+ def _worker_num(self):
+ """
+ return the current number of worker
+ """
+ if self._check_role_generation():
+ return int(self._get_size() / self._proc_per_node)
+ return 0
+
+ def _server_num(self):
+ """
+ return the current number of server
+ """
+ if self._check_role_generation():
+ return int(self._get_size() / self._proc_per_node)
+ else:
+ self.generate_role()
+ return int(self._get_size() / self._proc_per_node)
+
+ def worker_index(self):
+ """
+ return the index of worker
+ """
+ if self._check_role_generation():
+ return int(self._rank / self._proc_per_node)
+ else:
+ self.generate_role()
+ return int(self._get_size() / 2)
+
+ def server_index(self):
+ """
+ return the index of server
+ """
+ if self._check_role_generation():
+ return int(self._rank / self._proc_per_node)
+ else:
+ self.generate_role()
+ return int(self._get_size() / self._proc_per_node)
+
+ def _all_reduce(self, input, output, mode="sum"):
+ """
+ all reduce between trainers if current role is TRAINER,
+ only support array of one dim.
+
+ Args:
+ input(list/numpy.array): array of one dim
+ output(list/numpy.array): array of one dim
+ mode(str): "sum" or "min" or "max"
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if mode == "sum":
+ mode = self.MPI.SUM
+ elif mode == "max":
+ mode = self.MPI.MAX
+ elif mode == "min":
+ mode = self.MPI.MIN
+ else:
+ raise ValueError("unknown mode: %s" % mode)
+ self._node_type_comm.Allreduce(input, output, op=mode)
+
+ def _barrier_worker(self):
+ """
+ barrier all workers in current distributed job
+ """
+ if self._check_role_generation():
+ if self.is_worker():
+ self._node_type_comm.barrier()
+ else:
+ raise Exception("You should check role generation first")
+
+ def _barrier_server(self):
+ """
+ barrier all servers in current distributed job
+ """
+ if self._check_role_generation():
+ if self.is_server():
+ self._node_type_comm.barrier()
+ else:
+ raise Exception("You should check role generation first")
+
+ def generate_role(self):
+ """
+ generate currently process's role
+ """
+ if not self._role_is_generated:
+ # TODO(guru4elephant): only allow to be called once
+ self._worker_endpoints = self._get_ips()[1::2]
+ self._server_endpoints = self._get_ips()[::2]
+
+ if 0 == self._get_rank() % self._proc_per_node % 2:
+ self._node_type = 0
+ else:
+ self._node_type = 1
+ self._node_type_comm = self._comm.Split(self._node_type)
+ self._role_is_generated = True
+ else:
+ raise Exception("You should check role generation first")
+
+
+class PaddleCloudRoleMaker(RoleMakerBase):
+ """
+ role maker for paddle cloud,
+ base class is RoleMakerBase
+ """
+
+ def __init__(self, is_collective=False):
+ super(PaddleCloudRoleMaker, self).__init__()
+ self._role_is_generated = False
+ self._is_collective = is_collective
+
+ def generate_role(self):
+ """Generate role."""
+ if not self._role_is_generated:
+ if not self._is_collective:
+ try:
+ # Environment variable PADDLE_PSERVERS_IP_PORT_LIST must be set
+ # format: string(ip:port), eg. 127.0.0.1:6001
+ eplist = os.environ["PADDLE_PSERVERS_IP_PORT_LIST"].split(
+ ",")
+ # note that, we usually assign the same port to different ips
+ # if we run parameter server training in local mode
+ # port should be different in environment variables
+
+ trainers_num = int(os.environ["PADDLE_TRAINERS_NUM"])
+ training_role = os.environ["TRAINING_ROLE"]
+
+ if training_role not in ["TRAINER", "PSERVER"]:
+ raise ValueError(
+ "TRAINING_ROLE must be PSERVER or TRAINER")
+
+ if training_role == "TRAINER":
+ role = Role.WORKER
+ current_id = int(os.environ["PADDLE_TRAINER_ID"])
+ elif training_role == "PSERVER":
+ role = Role.SERVER
+ cur_ip = os.environ["POD_IP"]
+ curr_port = os.environ["PADDLE_PORT"]
+ curr_endpoint = ":".join([cur_ip, curr_port])
+ current_id = eplist.index(curr_endpoint)
+ else:
+ raise ValueError(
+ "TRAINING_ROLE must be PSERVER or TRAINER")
+ except ValueError as ve:
+ raise ValueError(
+ "something wrong with PaddleCloud, please check environment"
+ )
+
+ self._trainers_num = trainers_num
+ self._server_endpoints = eplist
+ self._role = role
+ self._current_id = current_id
+ else:
+ self._current_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
+ self._training_role = os.getenv("PADDLE_TRAINING_ROLE",
+ "TRAINER")
+ assert (self._training_role == "TRAINER")
+ self._worker_endpoints = os.getenv("PADDLE_TRAINER_ENDPOINTS")
+ self._current_endpoint = os.getenv("PADDLE_CURRENT_ENDPOINT")
+ assert self._worker_endpoints is not None, "can't find PADDLE_TRAINER_ENDPOINTS"
+ self._worker_endpoints = self._worker_endpoints.split(",")
+ self._trainers_num = len(self._worker_endpoints)
+
+ self._role_is_generated = True
+
+ def get_pserver_endpoints(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._server_endpoints
+
+ def is_worker(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.WORKER
+
+ def is_server(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.SERVER
+
+ def is_first_worker(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.WORKER and self._current_id == 0
+
+ def worker_index(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._current_id
+
+ def server_index(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._current_id
+
+ def worker_num(self):
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._trainers_num
+
+
+class GeneralRoleMaker(RoleMakerBase):
+ """
+ This role maker is for general use, you can set os.environ to customize:
+ PADDLE_PSERVERS_IP_PORT_LIST : all pservers' ip:port, separated by ','
+ PADDLE_TRAINER_ENDPOINTS : all trainers' ip:port, separated by ','
+ TRAINING_ROLE : TRAINER or PSERVER
+ PADDLE_TRAINER_ID : current trainer id (only for trainer),
+ it is index in PADDLE_TRAINER_ENDPOINTS
+ PADDLE_PSERVER_ID : current pserver id (only for pserver)
+ it is index in PADDLE_PSERVERS_IP_PORT_LIST
+ """
+
+ def __init__(self, **kwargs):
+ super(GeneralRoleMaker, self).__init__()
+ self._role_is_generated = False
+ self._hdfs_name = kwargs.get("hdfs_name", "")
+ self._hdfs_ugi = kwargs.get("hdfs_ugi", "")
+ self._hdfs_path = kwargs.get("path", "").rstrip("/")
+ self._init_timeout_seconds = kwargs.get("init_timeout_seconds", 3600)
+ self._run_timeout_seconds = kwargs.get("run_timeout_seconds", 9999999)
+ self._use_metric = kwargs.get("use_metric", False)
+ ip_port = kwargs.get("http_ip_port", "")
+ self._use_ps_gpu = kwargs.get("use_ps_gpu", False)
+ self._http_ip_port = []
+ self._http_server = None
+ # if ip_port is not empty, it will use http instead of hdfs
+ if ip_port != "":
+ self._http_ip_port = ip_port.split(":")
+ # it's for communication between processes
+ self._manager = Manager()
+ # global dict to store status
+ self._http_server_d = self._manager.dict()
+ # set running status of http server
+ self._http_server_d["running"] = False
+ self._iface = self.__get_default_iface()
+ self._iface = "" if self._iface == "lo" else self._iface
+ # this environment variable can be empty
+ self._prefix = os.getenv("SYS_JOB_ID", "")
+
+ def generate_role(self):
+ """
+ generate role for general role maker
+ """
+ if not self._role_is_generated:
+ eplist = os.environ["PADDLE_PSERVERS_IP_PORT_LIST"].split(",")
+ training_role = os.environ["TRAINING_ROLE"]
+ worker_endpoints = os.environ["PADDLE_TRAINER_ENDPOINTS"].split(",")
+ trainers_num = len(worker_endpoints)
+ if training_role not in ["TRAINER", "PSERVER"]:
+ raise ValueError("TRAINING_ROLE must be PSERVER or TRAINER")
+ self._is_barrier_all = 1
+ if "PADDLE_IS_BARRIER_ALL_ROLE" in os.environ:
+ self._is_barrier_all = int(
+ os.environ["PADDLE_IS_BARRIER_ALL_ROLE"])
+ if training_role == "TRAINER":
+ role = Role.WORKER
+ current_id = int(os.environ["PADDLE_TRAINER_ID"])
+ if current_id == 0 and len(self._http_ip_port) != 0:
+ size_d = {
+ "trainer": len(worker_endpoints),
+ "pserver": len(eplist),
+ "all": len(worker_endpoints) + len(eplist)
+ }
+ # child process for http server
+ self._http_server = Process(target=self.__start_kv_server,
+ args=(self._http_server_d,
+ size_d))
+ self._http_server.daemon = True
+ # set running status to True
+ self._http_server_d["running"] = True
+ # start child process
+ self._http_server.start()
+ self._node_type = 1
+ self._cur_endpoint = worker_endpoints[current_id]
+ if self._is_barrier_all:
+ gloo = fluid.core.Gloo()
+ gloo.set_rank(current_id)
+ gloo.set_size(len(worker_endpoints))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ if len(self._http_ip_port) != 0:
+ gloo.set_http_store(self._http_ip_port[0],
+ int(self._http_ip_port[1]),
+ "trainer")
+ else:
+ gloo.set_hdfs_store(self._hdfs_path + "/trainer",
+ self._hdfs_name, self._hdfs_ugi)
+ gloo.init()
+ self._node_type_comm = gloo
+ if self._use_ps_gpu or self._use_metric:
+ Gloo_strategy = fluid.core.GlooParallelStrategy()
+ Gloo_strategy.rank = current_id
+ Gloo_strategy.rank_num = len(worker_endpoints)
+ Gloo_strategy.ip_address = self._http_ip_port[0]
+ Gloo_strategy.ip_port = int(self._http_ip_port[1])
+ Default_init_timeout_seconds = 3600
+ Default_run_timeout_seconds = 9999999
+ Gloo_strategy.init_seconds = Default_init_timeout_seconds
+ Gloo_strategy.run_seconds = Default_run_timeout_seconds
+ Gloo = fluid.core.GlooParallelContext(Gloo_strategy)
+ Gloo.init()
+ else:
+ self._all_comm = MockBarrier()
+ elif training_role == "PSERVER":
+ role = Role.SERVER
+ if os.environ.get("PADDLE_PSERVER_ID") is not None:
+ current_id = int(os.environ["PADDLE_PSERVER_ID"])
+ cur_endpoint = eplist[current_id]
+ else:
+ # this is for compatible with paddlecloud
+ cur_ip = os.environ["POD_IP"]
+ cur_port = os.environ["PADDLE_PORT"]
+ cur_endpoint = ":".join([cur_ip, cur_port])
+ current_id = eplist.index(cur_endpoint)
+ self._node_type = 0
+ self._cur_endpoint = cur_endpoint
+ gloo = fluid.core.Gloo()
+ gloo.set_rank(current_id)
+ gloo.set_size(len(eplist))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ if len(self._http_ip_port) != 0:
+ gloo.set_http_store(self._http_ip_port[0],
+ int(self._http_ip_port[1]), "pserver")
+ else:
+ gloo.set_hdfs_store(self._hdfs_path + "/pserver",
+ self._hdfs_name, self._hdfs_ugi)
+ gloo.init()
+ self._node_type_comm = gloo
+
+ gloo = fluid.core.Gloo()
+ all_list = worker_endpoints + eplist
+ gloo.set_rank(all_list.index(self._cur_endpoint))
+ gloo.set_size(len(all_list))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ if len(self._http_ip_port) != 0:
+ gloo.set_http_store(self._http_ip_port[0],
+ int(self._http_ip_port[1]), "all")
+ else:
+ gloo.set_hdfs_store(self._hdfs_path + "/all", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+ self._all_comm = gloo
+ self._trainers_num = trainers_num
+ self._server_endpoints = eplist
+ self._role = role
+ self._current_id = current_id
+ self._rank = all_list.index(self._cur_endpoint)
+ self._size = len(all_list)
+ self._worker_endpoints = worker_endpoints
+ self._role_is_generated = True
+
+ def all_gather(self, input):
+ """
+ all gather between trainers and pservers
+
+ Args:
+ input(int|float): input value
+
+ Returns:
+ return a list of values
+ """
+ return self._all_gather(input)
+
+ def all_reduce_worker(self, input, output, mode="sum"):
+ """
+ all reduce between trainers if current role is TRAINER,
+ only support array of one dim.
+
+ Args:
+ input(list/numpy.array): array of one dim
+ output(list/numpy.array): array of one dim
+ mode(str): "sum" or "min" or "max"
+ """
+ if not self.is_worker():
+ return
+ self._all_reduce(input, output, mode)
+
+ def barrier_worker(self):
+ """
+ barrier between trainers if current role is TRAINER
+ """
+ self._barrier_worker()
+
+ def barrier_all(self):
+ """
+ barrier between trainers if current role is PSERVER
+ """
+ self._barrier_all()
+
+ def get_local_endpoint(self):
+ """
+ get local endpoint of current process
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._cur_endpoint
+
+ def get_trainer_endpoints(self):
+ """
+ get endpoint of all trainers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._worker_endpoints
+
+ def get_pserver_endpoints(self):
+ """
+ get endpoint of all pservers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._server_endpoints
+
+ def is_worker(self):
+ """
+ whether current process is worker
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.WORKER
+
+ def is_server(self):
+ """
+ whether current process is server
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.SERVER
+
+ def is_first_worker(self):
+ """
+ whether current process is worker of rank 0
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.WORKER and self._current_id == 0
+
+ def worker_index(self):
+ """
+ get index of current worker
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._current_id
+
+ def server_index(self):
+ """
+ get index of current server
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._current_id
+
+ def worker_num(self):
+ """
+ retrun the current number of worker
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._worker_num()
+
+ def server_num(self):
+ """
+ return the current number of server
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._server_num()
+
+ def _barrier_worker(self):
+ """
+ barrier all workers in current distributed job
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if self.is_worker():
+ self._node_type_comm.barrier()
+
+ def _barrier_all(self):
+ """
+ barrier all workers and servers in current distributed job
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ self._all_comm.barrier()
+
+ def _barrier_server(self):
+ """
+ barrier all servers in current distributed job
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if self.is_server():
+ self._node_type_comm.barrier()
+
+ def _worker_num(self):
+ """
+ return the current number of worker
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._trainers_num
+
+ def _server_num(self):
+ """
+ return the current number of server
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return len(self._server_endpoints)
+
+ def _finalize(self):
+ """Default do nothing."""
+ pass
+
+ def _all_reduce(self, input, output, mode="sum"):
+ """
+ all reduce between all workers
+
+ Args:
+ input(list|numpy.array): array of one dim
+ output(list|numpy.array): array of one dim
+ mode(str): "sum" or "min" or "max"
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ input_list = [i for i in input]
+ ans = self._node_type_comm.all_reduce(input_list, mode)
+ for i in range(len(ans)):
+ output[i] = ans[i]
+
+ def _all_gather(self, obj):
+ """
+ gather between all workers and pservers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ self._barrier_all()
+ return self._all_comm.all_gather(obj)
+
+ def _worker_gather(self, obj):
+ """
+ gather between all workers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if not self.is_worker():
+ return None
+ self._barrier_worker()
+ return self._node_type_comm.all_gather(obj)
+
+ def _get_rank(self):
+ """
+ get current rank in all workers and pservers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._rank
+
+ def _get_size(self):
+ """
+ get total num of all workers and pservers
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._size
+
+ def __get_default_iface(self):
+ """
+ get default physical interface
+ """
+ default1 = self.__get_default_iface_from_gateway()
+ default2 = self.__get_default_iface_from_interfaces()
+ return default2 if default1 == "lo" else default1
+
+ def __get_default_iface_from_gateway(self):
+ """
+ get default physical interface
+ """
+ res = os.popen("route -A inet").read().strip().split("\n")
+
+ gateway_idx = None
+ iface_idx = None
+ for item in res:
+ item = item.split()
+ if "Gateway" in item and "Iface" in item:
+ gateway_idx = item.index("Gateway")
+ iface_idx = item.index("Iface")
+ elif gateway_idx != None and iface_idx != None:
+ gateway = None
+ if len(item) > gateway_idx:
+ gateway = item[gateway_idx]
+ if gateway and gateway != '*' and gateway != "0.0.0.0" and len(
+ item) > iface_idx:
+ return item[iface_idx]
+ return "lo"
+
+ def __get_default_iface_from_interfaces(self):
+ """
+ get default physical interface
+ """
+ res = os.popen("ip -f inet addr | awk NR%3==1").read().strip().split(
+ "\n")
+ for item in res:
+ if "BROADCAST" in item:
+ return item.split(":")[1].strip()
+ return "lo"
+
+ def __start_kv_server(self, http_server_d, size_d):
+ from paddle.fluid.incubate.fleet.utils.http_server import KVServer
+ http_server = KVServer(int(self._http_ip_port[1]), size_d)
+ http_server.start()
+ wait_seconds = 5
+ while http_server_d.get("running", False):
+ time.sleep(wait_seconds)
+ http_server.stop()
+
+
+class HeterRoleMaker(GeneralRoleMaker):
+ """
+ This role maker is for general use, you can set os.environ to customize:
+ PADDLE_PSERVERS_IP_PORT_LIST : all pservers' ip:port, separated by ','
+ PADDLE_TRAINER_ENDPOINTS : all trainers' ip:port, separated by ','
+ TRAINING_ROLE : TRAINER or PSERVER
+ PADDLE_TRAINER_ID : current trainer id (only for trainer),
+ it is index in PADDLE_TRAINER_ENDPOINTS
+ PADDLE_PSERVER_ID : current pserver id (only for pserver)
+ it is index in PADDLE_PSERVERS_IP_PORT_LIST
+ """
+
+ def generate_role(self):
+ """
+ generate role for general role maker
+ """
+ if not self._role_is_generated:
+ eplist = os.environ["PADDLE_PSERVERS_IP_PORT_LIST"].split(",")
+ training_role = os.environ["TRAINING_ROLE"]
+ worker_endpoints = os.environ["PADDLE_TRAINER_ENDPOINTS"].split(",")
+ trainers_num = len(worker_endpoints)
+ xpu_endpoints = os.environ["PADDLE_XPU_ENDPOINTS"].split(",")
+ xpu_num = len(xpu_endpoints)
+ if training_role not in ["TRAINER", "PSERVER", "XPU"]:
+ raise ValueError(
+ "TRAINING_ROLE must be PSERVER or TRAINER or XPU")
+ if training_role == "TRAINER":
+ role = Role.WORKER
+ current_id = int(os.environ["PADDLE_TRAINER_ID"])
+ self._node_type = 1
+ self._cur_endpoint = worker_endpoints[current_id]
+ gloo = fluid.core.Gloo()
+
+ gloo.set_rank(current_id)
+ gloo.set_size(len(worker_endpoints))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ gloo.set_hdfs_store(
+ self._hdfs_path.rstrip("/") + "/trainer", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+ self._node_type_comm = gloo
+ elif training_role == "XPU":
+ role = Role.XPU
+ current_id = int(os.environ["PADDLE_XPU_ID"])
+ self._node_type = 2
+ self._cur_endpoint = xpu_endpoints[current_id]
+ gloo = fluid.core.Gloo()
+
+ gloo.set_rank(current_id)
+ gloo.set_size(len(xpu_endpoints))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ gloo.set_hdfs_store(
+ self._hdfs_path.rstrip("/") + "/xpu", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+ self._node_type_comm = gloo
+ elif training_role == "PSERVER":
+ role = Role.SERVER
+ if os.environ.get("PADDLE_PSERVER_ID") is not None:
+ current_id = int(os.environ["PADDLE_PSERVER_ID"])
+ cur_endpoint = eplist[current_id]
+ else:
+ # this is for compatible with paddlecloud
+ cur_ip = os.environ["POD_IP"]
+ cur_port = os.environ["PADDLE_PORT"]
+ cur_endpoint = ":".join([cur_ip, cur_port])
+ current_id = eplist.index(cur_endpoint)
+ self._node_type = 0
+ self._cur_endpoint = cur_endpoint
+ gloo = fluid.core.Gloo()
+ gloo.set_rank(current_id)
+ gloo.set_size(len(eplist))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ gloo.set_hdfs_store(
+ self._hdfs_path.rstrip("/") + "/pserver", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+ self._node_type_comm = gloo
+
+ if training_role == "TRAINER" or training_role == "XPU":
+ gloo = fluid.core.Gloo()
+ heter_list = worker_endpoints + xpu_endpoints
+
+ gloo.set_rank(heter_list.index(self._cur_endpoint))
+ gloo.set_size(len(heter_list))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ gloo.set_hdfs_store(
+ self._hdfs_path.rstrip("/") + "/heter", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+ self._heter_comm = gloo
+
+ gloo = fluid.core.Gloo()
+ all_list = worker_endpoints + eplist + xpu_endpoints
+
+ gloo.set_rank(all_list.index(self._cur_endpoint))
+ gloo.set_size(len(all_list))
+ gloo.set_prefix(self._prefix)
+ gloo.set_iface(self._iface)
+ gloo.set_timeout_seconds(self._init_timeout_seconds,
+ self._run_timeout_seconds)
+ gloo.set_hdfs_store(
+ self._hdfs_path.rstrip("/") + "/all", self._hdfs_name,
+ self._hdfs_ugi)
+ gloo.init()
+
+ self._all_comm = gloo
+ self._trainers_num = trainers_num
+ self._server_endpoints = eplist
+ self._role = role
+ self._current_id = current_id
+ self._rank = all_list.index(self._cur_endpoint)
+ self._size = len(all_list)
+ self._worker_endpoints = worker_endpoints
+ self._xpu_endpoints = xpu_endpoints
+ self._role_is_generated = True
+
+ def is_xpu(self):
+ """
+ whether current process is server
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.XPU
+
+ def is_first_xpu(self):
+ """
+ whether current process is worker of rank 0
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return self._role == Role.XPU and self._current_id == 0
+
+ def _barrier_xpu(self):
+ """
+ barrier all workers in current distributed job
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if self.is_xpu():
+ self._node_type_comm.barrier()
+
+ def _barrier_heter(self):
+ """
+ barrier all workers in current distributed job
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ if self.is_xpu() or self.is_worker:
+ self._heter_comm.barrier()
+
+ def xpu_num(self):
+ """
+ """
+ if not self._role_is_generated:
+ self.generate_role()
+ return len(self._xpu_endpoints)
+
+
+class UserDefinedRoleMaker(RoleMakerBase):
+ """
+ UserDefinedRoleMaker is designed for worker and server assignment
+ under manual. Typically, a worker and a server node will be appointed
+ on each physical node, It can be assign by user.
+ """
+
+ def __init__(self,
+ current_id=0,
+ role=Role.WORKER,
+ worker_num=0,
+ server_endpoints=None):
+ super(UserDefinedRoleMaker, self).__init__()
+
+ if not isinstance(server_endpoints, list):
+ raise TypeError("server_endpoints must be as string list")
+ elif len(server_endpoints) <= 0:
+ raise ValueError(
+ "the length of server_endpoints list must be greater than 0")
+ elif len(server_endpoints) != len(set(server_endpoints)):
+ raise ValueError("server_endpoints can't have duplicate elements")
+ else:
+ for server_endpoint in server_endpoints:
+ if not isinstance(server_endpoint, str):
+ raise TypeError(
+ "every element in server_endpoints list must be as string"
+ )
+ self._server_endpoints = server_endpoints
+
+ if role != Role.WORKER and role != Role.SERVER:
+ raise TypeError("role must be as Role")
+ else:
+ self._role = role
+
+ if not isinstance(current_id, int):
+ raise TypeError("current_id must be as int")
+ else:
+ if current_id < 0:
+ raise ValueError(
+ "current_id must be greater than or equal to 0")
+ elif self._role == Role.SERVER and current_id >= len(
+ server_endpoints):
+ raise ValueError(
+ "if role is Role.SERVER, current_id must be less than or equal to len(server_endpoints) - 1"
+ )
+ self._current_id = current_id
+
+ if not isinstance(worker_num, int):
+ raise TypeError("worker_num must be as int")
+ else:
+ if worker_num <= 0:
+ raise ValueError("worker_num must be greater than 0")
+ self._worker_num = worker_num
+
+ def generate_role(self):
+ self._role_is_generated = True
+
+ def is_worker(self):
+ return self._role == Role.WORKER
+
+ def is_server(self):
+ return self._role == Role.SERVER
+
+ def is_first_worker(self):
+ return self._role == Role.WORKER and self._current_id == 0
+
+ def worker_index(self):
+ return self._current_id
+
+ def server_index(self):
+ return self._current_id
+
+ def worker_num(self):
+ return self._worker_num
+
+
+class UserDefinedCollectiveRoleMaker(RoleMakerBase):
+ """
+ UserDefinedCollectiveRoleMaker is designed for worker assignment
+ under manual for collective mode.
+ """
+
+ def __init__(self, current_id=0, worker_endpoints=None):
+ super(UserDefinedCollectiveRoleMaker, self).__init__()
+
+ if not isinstance(worker_endpoints, list):
+ raise TypeError("worker_endpoints must be as string list")
+ elif len(worker_endpoints) <= 0:
+ raise ValueError(
+ "the length of worker_endpoints list must be greater than 0")
+ elif len(worker_endpoints) != len(set(worker_endpoints)):
+ raise ValueError("worker_endpoints can't have duplicate elements")
+ else:
+ for worker_endpoint in worker_endpoints:
+ if not isinstance(worker_endpoint, str):
+ raise TypeError(
+ "every element in worker_endpoints list must be as string"
+ )
+ self._worker_endpoints = worker_endpoints
+
+ if not isinstance(current_id, int):
+ raise TypeError("current_id must be as int")
+ else:
+ if current_id < 0:
+ raise ValueError(
+ "current_id must be greater than or equal to 0")
+ elif current_id >= len(worker_endpoints):
+ raise ValueError(
+ "current_id must be less than or equal to len(worker_endpoints) - 1"
+ )
+ self._current_id = current_id
+
+ self._worker_num = len(self._worker_endpoints)
+
+ def generate_role(self):
+ self._role_is_generated = True
+
+ def is_worker(self):
+ return True
+
+ def is_first_worker(self):
+ return self._current_id == 0
+
+ def worker_index(self):
+ return self._current_id
+
+ def worker_num(self):
+ return self._worker_num
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/collective/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/collective/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..da4fe609ca3e65aed0737422367db54461b97d2e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/collective/__init__.py
@@ -0,0 +1,514 @@
+# Copyright (c) 2019 PaddlePaddle 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
+
+import logging
+
+import paddle.fluid as fluid
+import paddle.fluid.io as io
+import paddle.fluid.transpiler.distribute_transpiler as dist_transpiler
+from paddle.fluid.executor import Executor
+from paddle.fluid.parallel_executor import ParallelExecutor
+from paddle.fluid.compiler import CompiledProgram
+from paddle.fluid.framework import Program
+
+from paddle.fluid.incubate.fleet.base.fleet_base import Fleet
+from paddle.fluid.incubate.fleet.base.fleet_base import Mode
+from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer
+
+from paddle.fluid import compiler
+from paddle.fluid.incubate.checkpoint.checkpoint_saver import PaddleModel, CheckpointSaver
+
+import paddle
+
+import os
+import sys
+import six
+import json
+import re
+import shutil
+
+
+class LambConfig(object):
+
+ def __init__(self):
+ pass
+
+
+class DistFCConfig(object):
+
+ def __init__(self):
+ pass
+
+
+class Collective(Fleet):
+
+ def __init__(self):
+ super(Collective, self).__init__(Mode.COLLECTIVE)
+ self._local_ip = 0
+
+ self.startup_program = None
+ self._origin_program = None
+ self._transpiled_program = None
+ self.main_program = None
+ self._checkpoint_prefix = "__paddle_fleet_checkpoint__"
+ self._param_file_name = "_paddle_fleet_param__"
+
+ def init_worker(self):
+ logging.warn(
+ "You should not call 'init_worker' method for collective mode.")
+
+ def run_worker(self, main_programs=None, scopes=None):
+ logging.warn(
+ "You should not call 'run_worker' method for collective mode.")
+
+ def init_server(self, model_dir=None):
+ logging.warn(
+ "You should not call 'init_server' method for collective mode.")
+
+ def run_server(self):
+ logging.warn(
+ "You should not call 'run_server' method for collective mode.")
+
+ def stop_worker(self):
+ logging.warn(
+ "You should not call 'stop_worker' method for collective mode.")
+
+ def distributed_optimizer(self, optimizer, strategy=None):
+ self._optimizer = \
+ CollectiveOptimizer(optimizer, strategy)
+ return self._optimizer
+
+ def save_inference_model(self,
+ executor,
+ dirname,
+ feeded_var_names=None,
+ target_vars=None,
+ main_program=None,
+ export_for_deployment=True):
+ """
+ Prune the given `main_program` to build a new program especially for
+ inference, and then save it and all related parameters to given
+ `dirname` by the `executor`.
+ """
+ assert isinstance(executor, Executor), \
+ "In fleet.save_inference_model() function, executor must be as" \
+ " Executor type."
+
+ if main_program is None:
+ main_program = self._origin_program
+ assert isinstance(main_program, Program), \
+ "In fleet.save_inference_model() function, main_program " \
+ "must be as Program type."
+
+ io.save_inference_model(dirname, feeded_var_names, target_vars,
+ executor, main_program, None, None,
+ export_for_deployment)
+
+ def save_persistables(self,
+ executor,
+ dirname,
+ main_program=None,
+ filename=None):
+ """
+ This function filters out all variables with `persistable==True` from
+ the give `main_program` and then saves these variables to the folder
+ `dirname` or file `filename`.
+
+ The `dirname` is used to specify the folder where persistable variables
+ are going to be saved. If you would like to save variables in separate
+ files, set `filename` None; if you would like to save all variables in a
+ single file, use `filename` to specify the file name.
+ """
+ assert isinstance(executor, Executor), \
+ "In fleet.save_inference_model() function, executor must be as" \
+ " Executor type."
+
+ if main_program is None:
+ main_program = self._origin_program
+
+ assert isinstance(main_program, Program), \
+ "In fleet.save_inference_model() function, main_program " \
+ "must be as Program type."
+
+ io.save_persistables(executor, dirname, main_program, filename=filename)
+
+ def save_checkpoint(self,
+ executor,
+ path,
+ trainer_id,
+ train_status,
+ fs,
+ main_program=None,
+ local_cache_path=".cache",
+ remain_all_checkpoint=True):
+ """
+ This function save persistables and current epoch num to path.
+ """
+ if main_program == None:
+ main_program = self._transpiled_program
+
+ m = PaddleModel(executor, main_program)
+ t = train_status
+ c = CheckpointSaver(fs)
+ real_path, checkpoint_no = c.save_checkpoint(
+ path=path,
+ slists=[m, t],
+ trainer_id=trainer_id,
+ local_cache_path=local_cache_path)
+
+ if not remain_all_checkpoint:
+ c.clean_redundant_checkpoints(path)
+
+ return real_path, checkpoint_no
+
+ def load_checkpoint(self,
+ executor,
+ path,
+ trainer_id,
+ train_status,
+ fs,
+ main_program=None,
+ local_cache_path=".cache",
+ ignore_empty=True):
+ """
+ This function load persistables and current epoch num from path.
+ """
+
+ if main_program == None:
+ main_program = self._transpiled_program
+
+ m = PaddleModel(executor, main_program)
+ c = CheckpointSaver(fs)
+ return c.load_checkpoint(path, [m, train_status],
+ trainer_id=trainer_id,
+ ignore_empty=ignore_empty,
+ local_cache_path=local_cache_path)
+
+
+fleet = Collective()
+
+
+class DistributedStrategy(fluid.BuildStrategy):
+ """
+ Init function of DistributedStrategy
+ """
+
+ def __init__(self):
+ super(DistributedStrategy, self).__init__()
+ self.use_local_sgd = False
+ self.use_dist_fc = False
+
+ self.dist_fc_config = None # DistFCConfig
+ self.mode = "nccl2" # or collective
+ self.collective_mode = None # local_sgd or grad_allreduce
+ self.nccl_comm_num = 1
+ self.forward_recompute = False # use RecomputeOptimizer
+ self.recompute_checkpoints = []
+ self.use_amp = False # use mixed precision optimizer
+ self.amp_loss_scaling = 2**15
+
+ self.exec_strategy = fluid.ExecutionStrategy()
+
+ # configurations below are used for unit test
+ self._ut4grad_allreduce = False
+
+
+class CollectiveOpBasedOptimizer(DistributedOptimizer):
+ """
+ Collective Operator Base Class For Distributed Optimizer
+ The class is invisible to a user
+ """
+
+ def __init__(self, optimizer, strategy=None):
+ assert isinstance(
+ strategy,
+ DistributedStrategy), "strategy must be DistributedStrategy"
+ super(CollectiveOpBasedOptimizer, self).__init__(optimizer, strategy)
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ return self._optimizer.backward(loss, startup_program, parameter_list,
+ no_grad_set, callbacks)
+
+ def apply_gradients(self, params_grads):
+ return self._optimizer.apply_gradients(params_grads)
+
+
+class CollectiveOptimizer(DistributedOptimizer):
+ """
+ DistributedOptimizer is a wrapper for paddle.fluid.optimizer
+ A user should pass a paddle.fluid.optimizer to DistributedOptimizer
+ minimize() function is implemented.
+ DistributedOptimizer is the starting point for a user who wants to
+ run distributed training. The optimized information will be stored in
+ Fleet() instance who holds the global information about current distributed
+ training.
+ """
+
+ def __init__(self, optimizer, strategy=DistributedStrategy()):
+ if strategy is None:
+ strategy = DistributedStrategy()
+ super(CollectiveOptimizer, self).__init__(optimizer, strategy)
+ self._forward_recompute = strategy.forward_recompute
+ if (not isinstance(strategy.recompute_checkpoints, list)):
+ raise ValueError("DistStrategy.recompute_checkpoints should"
+ "be a List")
+ self._recompute_checkpoints = strategy.recompute_checkpoints
+ self._use_amp = strategy.use_amp
+ self._amp_loss_scaling = strategy.amp_loss_scaling
+ self.print_config = False
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ return self._optimizer.backward(loss, startup_program, parameter_list,
+ no_grad_set, callbacks)
+
+ def apply_gradients(self, params_grads):
+ return self._optimizer.apply_gradients(params_grads)
+
+ def _check_condition(self, name, **kwargs):
+ for k, v in six.iteritems(kwargs):
+ if v is True:
+ assert False, "you can't use %s and %s together" % (name, k)
+
+ def _check_collective_mode(self, main_program, optimizer, strategy):
+ """
+ Check the conflict conditions.
+ """
+ if strategy.use_local_sgd:
+ strategy.mode = "collective"
+ strategy.collective_mode = "local_sgd"
+ self._check_condition("use_local_sgd",
+ use_dgc=main_program._enable_dgc,
+ use_dist_fc=strategy.use_dist_fc,
+ use_lamb=main_program._use_lamb)
+
+ if strategy.use_dist_fc:
+ self._check_condition("use_dist_fc",
+ use_dgc=main_program._enable_dgc,
+ use_local_sgd=strategy.use_local_sgd,
+ use_lamb=main_program._use_lamb)
+ assert strategy.dist_fc_config is not None, "DistributedStrategy.dist_fc_config should be set"
+
+ if strategy._ut4grad_allreduce:
+ strategy.mode = "collective"
+ strategy.collective_mode = "grad_allreduce"
+ self._check_condition("_ut4grad_allreduce",
+ use_dgc=main_program._enable_dgc,
+ use_lamb=main_program._use_lamb)
+
+ if self._strategy.collective_mode=="local_sgd" \
+ or self._strategy.collective_mode == "grad_allreduce":
+ assert self._strategy.mode == "collective", \
+ "local_sgd and grad_allreduce can be used under collective mode"
+
+ def _transpile(self, startup_program, main_program):
+ """
+ Transpile the programs to distributed programs. And add the variables.
+ """
+ worker_endpoints = fleet.worker_endpoints()
+ trainer_id = fleet.worker_index()
+ current_endpoint = fleet.worker_endpoints()[trainer_id]
+ worker_endpoints_env = ','.join(worker_endpoints)
+ trainers_num = fleet.worker_num()
+
+ if self.print_config:
+ print("worker_endpoints:{} trainers_num:{} current_endpoint:{} \
+ trainer_id:{}".format(worker_endpoints, trainers_num,
+ current_endpoint, trainer_id))
+
+ # call transpiler
+ config = dist_transpiler.DistributeTranspilerConfig()
+ config.mode = self._strategy.mode
+ config.collective_mode = self._strategy.collective_mode
+
+ config.nccl_comm_num = self._strategy.nccl_comm_num
+ config.use_hierarchical_allreduce = self._strategy.use_hierarchical_allreduce
+ config.hierarchical_allreduce_inter_nranks = self._strategy.hierarchical_allreduce_inter_nranks
+
+ t = dist_transpiler.DistributeTranspiler(config=config)
+ t.transpile(trainer_id=trainer_id,
+ trainers=worker_endpoints_env,
+ startup_program=startup_program,
+ program=main_program,
+ current_endpoint=current_endpoint)
+
+ def _get_node_ips_from_endpoints(self, endpoints):
+ ss = set()
+ ips = []
+ for ep in endpoints:
+ ip = ep.split(":")[0].strip()
+ if ip not in ss:
+ ss.add(ip)
+ ips.append(ip)
+ else:
+ continue
+
+ return ips
+
+ def _node_num(self):
+ worker_endpoints = fleet.worker_endpoints()
+ current_endpoint = fleet.worker_endpoints()[fleet.worker_index()]
+ worker_endpoints_env = ','.join(worker_endpoints)
+
+ node_ips = self._get_node_ips_from_endpoints(worker_endpoints)
+ node_ip = current_endpoint.split(":")[0].strip()
+
+ node_num = len(node_ips)
+
+ return node_num
+
+ def _try_to_compile(self, startup_program, main_program):
+ node_num = self._node_num()
+ assert node_num >= 1, "nccl2 node_num must >= 1, now:{}" % node_num
+
+ exec_strategy = self._strategy.exec_strategy
+
+ if node_num <= 1:
+ if self._strategy.nccl_comm_num > 1:
+ logging.warn("set nccl_comm_num=1 since you only have 1 node.")
+ self._strategy.nccl_comm_num = 1
+
+ if self._strategy.use_hierarchical_allreduce:
+ logging.warn(
+ "set use_hierarchical_allreduce=False since you only have 1 node."
+ )
+ self._strategy.use_hierarchical_allreduce = False
+
+ sync_allreduce = os.getenv("FLAGS_sync_nccl_allreduce")
+ if sync_allreduce is None or sync_allreduce == "1":
+ exec_strategy.num_threads = self._strategy.nccl_comm_num + 1
+ if self._strategy.use_hierarchical_allreduce:
+ exec_strategy.num_threads = 2 * self._strategy.nccl_comm_num + 1
+ if exec_strategy.num_threads > 4:
+ logging.warn(
+ "if you use use_hierarchical_allreduce or "
+ "with multi nccl comm, please export FLAGS_sync_nccl_allreduce = 0"
+ )
+
+ # NOTE. open sync_batch_norm will hang when use multi num_threads
+ sync_batch_norm = self._strategy.sync_batch_norm
+ if sync_batch_norm is not None and sync_batch_norm is True:
+ self._strategy.nccl_comm_num = 1
+ self._strategy.use_hierarchical_allreduce = False
+ exec_strategy.num_threads = 1
+ logging.warn(
+ "use sync_batch_norm will hang when set num_threads > 1, so "
+ "set num_threads=1, nccl_comm_num=1, use_hierarchical_allreduce=False."
+ )
+
+ if self.print_config:
+ print("node_num:", node_num, "num_threads:",
+ exec_strategy.num_threads, "use_hierarchical_allreduce:",
+ self._strategy.use_hierarchical_allreduce, "nccl_comm_num:",
+ self._strategy.nccl_comm_num, "FLAGS_sync_nccl_allreduce:",
+ sync_allreduce)
+
+ self._transpile(startup_program, main_program)
+
+ if self._strategy.mode == "collective":
+ return main_program
+
+ self._strategy.num_trainers = fleet.worker_num()
+ self._strategy.trainer_id = fleet.worker_index()
+ self._strategy.trainers_endpoints = fleet.worker_endpoints()
+ self._strategy.enable_backward_optimizer_op_deps = True
+
+ self._compiled_program = compiler.CompiledProgram(main_program)
+
+ self._compiled_program.with_data_parallel(
+ loss_name=self._loss.name,
+ build_strategy=self._strategy,
+ exec_strategy=self._strategy.exec_strategy,
+ share_vars_from=None)
+
+ return self._compiled_program
+
+ def raiseOptimizeError(self, strategy_name, optimize_name):
+ raise ValueError("can not use {0} when you set DistStrategy.{1} "
+ "as True".format(optimize_name, strategy_name))
+
+ def minimize(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ """
+ minimize a program through loss
+ Args:
+ loss (Variable|Variable List): loss variable or loss variable list to run optimization.
+ startup_program (Program): startup_program for initializing parameters
+ in `parameter_list`.
+ parameter_list (list): list of Variables to update.
+ no_grad_set (set|None): set of Variables should be ignored.
+ Returns:
+ tuple: (optimize_ops, params_grads) which are, list of operators appended;
+ and list of (param, grad) Variables pair for optimization.
+ Note that in parameter server mode, a worker will not get anything about optimize_os
+ Because optimizer algorithms run on pserver side. We will make this usable in pserver
+ process, but currently the optimization part is written into Fleet(). A user does not
+ need to care about how to startup a pserver node.
+ """
+
+ # check optimizer conflicts
+ if self._forward_recompute:
+ if self._recompute_checkpoints == []:
+ raise ValueError("please set strategy.recompute_checkpoints"
+ "when set strategy.forward_recompute as True")
+ if self._optimizer.__class__.__name__ in [
+ "RecomputeOptimizer", "OptimizerWithMixedPrecision"
+ ]:
+ self.raiseOptimizeError("forward_recompute",
+ self._optimizer.__class__.__name__)
+
+ self._optimizer = \
+ fluid.optimizer.RecomputeOptimizer(self._optimizer)
+ self._optimizer._set_checkpoints(self._recompute_checkpoints)
+
+ if self._use_amp:
+ if self._optimizer.__class__.__name__ in [
+ "OptimizerWithMixedPrecision", "DGCMomentumOptimizer"
+ ]:
+ self.raiseOptimizeError("mixed_precision",
+ self._optimizer.__class__.__name__)
+ self._optimizer = fluid.contrib.mixed_precision.decorate(
+ self._optimizer,
+ init_loss_scaling=self._amp_loss_scaling,
+ use_dynamic_loss_scaling=True)
+
+ main_program = loss.block.program
+ if startup_program is None:
+ startup_program = fluid.default_startup_program()
+ fleet.startup_program = startup_program
+
+ self._loss = loss
+
+ self._check_collective_mode(main_program, self._optimizer,
+ self._strategy)
+
+ optimize_ops, param_grads = self._optimizer.minimize(
+ loss, startup_program, parameter_list, no_grad_set=no_grad_set)
+
+ fleet._origin_program = main_program.clone(for_test=False)
+ fleet._transpiled_program = main_program
+ fleet.main_program = self._try_to_compile(startup_program, main_program)
+
+ return optimize_ops, param_grads
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..33ed0ecf10ec4cad807ebb6df1590de65eeeab1e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..67c1a0f0f8b47470973fab7c6ea071be01a4ca69
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/__init__.py
@@ -0,0 +1,870 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+"""
+Convert the fluid program to distributed data-parallelism programs.
+"""
+
+import os
+import sys
+import warnings
+
+from paddle import fluid
+from paddle.fluid import core
+from paddle.fluid.framework import default_main_program
+from paddle.fluid.framework import default_startup_program
+from paddle.fluid.framework import Program
+from paddle.fluid.compiler import CompiledProgram
+from paddle.fluid.executor import Executor
+from paddle.fluid.parallel_executor import ParallelExecutor
+from paddle.fluid.optimizer import Optimizer
+
+from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig
+
+from paddle.fluid.incubate.fleet.base.fleet_base import Fleet
+from paddle.fluid.incubate.fleet.base.mode import Mode
+from paddle.fluid.incubate.fleet.base.role_maker import MPISymetricRoleMaker
+
+from paddle.fluid.incubate.fleet.parameter_server import version
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _has_global_step
+from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler.distributed_strategy import TrainerRuntimeConfig, DistributedStrategy, \
+ SyncStrategy, AsyncStrategy, HalfAsyncStrategy, GeoStrategy, StrategyFactory
+
+from paddle.fluid.transpiler.details.checkport import wait_server_ready
+
+from paddle.fluid.incubate.fleet.parameter_server.mode import PSMode
+from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer
+
+from paddle.fluid.incubate.fleet.parameter_server.ir import trainer_pass as worker
+from paddle.fluid.incubate.fleet.parameter_server.ir import pserver_pass as server
+from paddle.fluid.incubate.fleet.parameter_server.ir import public as public
+
+
+class FleetTranspiler(Fleet):
+ """
+ A subclass for compatibility with fluid.transpiler.DistributeTranspiler.
+ """
+
+ def __init__(self):
+ super(FleetTranspiler, self).__init__(Mode.TRANSPILER)
+
+ self._inner_mode = None
+
+ if version.is_transpiler():
+ self._inner_mode = PSMode.TRANSPILER
+ else:
+ self._inner_mode = PSMode.PSLIB
+
+ self._strategy = None
+ self._transpiler = None
+ self._origin_main_program = None
+ self._origin_startup_program = None
+ self._communicator = None
+ self.startup_program = None
+ self.main_program = None
+
+ self._opt_info = None
+ self._local_ip = 0
+ self._fleet_ptr = None
+ self._main_programs = []
+ self._scopes = []
+ self._client2client_request_timeout_ms = 500000
+ self._client2client_connect_timeout_ms = 10000
+ self._client2client_max_retry = 3
+
+ def init(self, role_maker=None):
+ if role_maker is None:
+ role_maker = MPISymetricRoleMaker()
+ super(FleetTranspiler, self).init(role_maker)
+ if self._fleet_ptr is None:
+ self._fleet_ptr = core.Fleet()
+
+ def _init_transpiler_worker(self):
+ """
+ `init_worker` has many many functions to do before training,
+ first, wait for all parameter servers launch completely.
+ second, run executor to initialize startup program
+ third, wait for all worker initialize completely.
+
+ Returns:
+ None
+ """
+
+ def sync_strategy_envs():
+ kwargs = {}
+ kwargs[
+ "pserver_endpoints"] = self._role_maker.get_pserver_endpoints()
+ kwargs["trainer_id"] = self._role_maker.worker_index()
+ return kwargs
+
+ def geo_strategy_envs():
+
+ def get_sparse_attrs():
+ opt_init_map = {}
+ opt_init_map["gaussian_random"] = ["seed", "mean", "std"]
+ opt_init_map["fill_constant"] = ["value"]
+ opt_init_map["uniform_random"] = ["seed", "min", "max"]
+ opt_init_map["truncated_gaussian_random"] = [
+ "seed", "mean", "std"
+ ]
+
+ dist_varnames = get_sparse_tablenames(self._origin_main_program,
+ True)
+ sparse_varnames = get_sparse_tablenames(
+ self._origin_main_program, False)
+
+ if len(dist_varnames) != 0:
+ raise ValueError(
+ "GeoStrategy can not support large scale embeding now, please use fluid.layers.embedding"
+ )
+
+ init_attrs = []
+ for value_name in sparse_varnames:
+ value_var = self._origin_main_program.global_block(
+ ).vars[value_name]
+ value_attr = [
+ value_name,
+ ",".join([str(dim) for dim in value_var.shape])
+ ]
+ for op in self._origin_startup_program.global_block().ops:
+ if op.type in opt_init_map.keys(
+ ) and value_name == op.output("Out")[0]:
+ init_attr = [op.type]
+ for attr in opt_init_map[op.type]:
+ init_attr.append(str(op.attr(attr)))
+ value_attr.append("&".join(init_attr))
+ init_attrs.append(":".join(value_attr))
+ break
+ return "#".join(init_attrs)
+
+ kwargs = {}
+ kwargs["trainers"] = self.worker_num()
+ kwargs["sparse_attrs"] = get_sparse_attrs()
+ return kwargs
+
+ # if MPISymetricRoleMaker is defined
+ # we suppose a user wants to submit job on mpi cluster
+
+ if isinstance(self._role_maker, MPISymetricRoleMaker):
+ # check whether server has been initialized
+ wait_server_ready(self.server_endpoints(to_string=False))
+
+ trainer_config = self._strategy.get_trainer_runtime_config()
+
+ print(trainer_config)
+
+ lrs = _has_global_step(_get_lr_ops(self._origin_main_program))
+
+ if lrs > 0:
+ kwargs = {"need_global_step": "1"}
+ else:
+ kwargs = {"need_global_step": "0"}
+
+ if isinstance(self._strategy, GeoStrategy):
+ geo_kwargs = geo_strategy_envs()
+ kwargs.update(geo_kwargs)
+ if isinstance(self._strategy, SyncStrategy):
+ sync_kwargs = sync_strategy_envs()
+ kwargs.update(sync_kwargs)
+
+ kwargs = kwargs if kwargs else None
+
+ send_ctx = fleet.compiled_config.get_communicator_send_context()
+
+ if self.compiled_config.is_geo_mode():
+ recv_ctx = fleet.compiled_config.get_communicator_recv_context(
+ recv_type=4)
+ else:
+ recv_ctx = fleet.compiled_config.get_communicator_recv_context(
+ recv_type=1)
+
+ from paddle.fluid.communicator import Communicator
+ self._communicator = Communicator(
+ trainer_config.mode, kwargs,
+ trainer_config.get_communicator_flags())
+
+ self._communicator.init_with_ctx(send_ctx, recv_ctx)
+
+ if not self._communicator.is_running():
+ self._communicator.start()
+ else:
+ raise ValueError(
+ "Communicator can only be inited once, please check")
+
+ def init_worker(self):
+ """
+ `init_worker` has many many functions to do before training,
+ first, wait for all parameter servers launch completely.
+ second, run executor to initialize startup program
+ third, wait for all worker initialize completely.
+
+ Returns:
+ None
+ """
+ if self._inner_mode == PSMode.TRANSPILER:
+ self._init_transpiler_worker()
+ else:
+ raise NotImplementedError("add implement later")
+
+ def _init_transpiler_server(self, model_dir=None):
+ if not self.startup_program:
+ raise ValueError(
+ "startup_program is None, need invoke DistributedOptimizer.minimize first"
+ )
+
+ self._executor.run(self.startup_program)
+
+ if model_dir:
+ if not os.path.isdir(model_dir):
+ raise ValueError("There is no directory named '%s'", model_dir)
+
+ sparse_varnames = self.compiled_config.get_sparse_varname_on_ps(
+ True)
+ distribtued_varnames = self.compiled_config.get_sparse_varname_on_ps(
+ False)
+
+ remaining_vars = list(
+ filter(
+ FleetTranspiler.__exclude_vars(sparse_varnames +
+ distribtued_varnames),
+ self.main_program.list_vars()))
+
+ fluid.io.load_vars(self._executor,
+ main_program=self.main_program,
+ dirname=model_dir,
+ vars=remaining_vars)
+
+ self._load_sparse_params(dirname=model_dir,
+ varnames=sparse_varnames)
+
+ # todo(tangwei12) load distributed vars
+ # self._load_sparse_params(dirname=model_dir, varnames=distribtued_varnames)
+
+ def init_server(self, model_dir=None, **kwargs):
+ """
+ `init_server` has many many functions to do before start pserver,
+ first, run executor to initialize startup program,
+ second, if the `model_dir` is not empty, it will load parameters from it for increment training.
+
+ Args:
+ model_dir(str): The directory path.
+
+ Returns:
+ None
+ """
+
+ if self._inner_mode == PSMode.TRANSPILER:
+ self._init_transpiler_server(model_dir)
+ else:
+ raise NotImplementedError("add implement later")
+
+ def run_server(self):
+ """
+ `run_server` execute executor to start pserver main program.
+
+ Returns:
+ None
+ """
+
+ if self._inner_mode == PSMode.TRANSPILER:
+ if not self.main_program:
+ raise ValueError(
+ "main_program is None, need invoke DistributedOptimizer.minimize first"
+ )
+
+ self._executor.run(self.main_program)
+ else:
+ raise NotImplementedError("add implement later")
+
+ def stop_worker(self):
+ """
+ Close this executor.
+
+ For the distributed training, this method would free the resource on PServers related to
+ the current Trainer.
+
+ Returns:
+ None
+ """
+
+ if self._inner_mode == PSMode.TRANSPILER:
+ self._communicator.stop()
+ if isinstance(self._role_maker, MPISymetricRoleMaker):
+ self._role_maker._finalize()
+ self._executor.close()
+ else:
+ raise NotImplementedError("add implement later")
+
+ def distributed_optimizer(self, optimizer, strategy=None):
+ """
+ Optimizer for distributed training.
+
+ For the distributed training, this method would rebuild a new instance of DistributedOptimizer.
+ Which has basic Optimizer function and special features for distributed training.
+
+ Args:
+ optimizer(Optimizer): The executor to run for init server.
+ strategy(DistributeTranspilerConfig): Extra properties for distributed optimizer.
+
+ Returns:
+ TranspilerOptimizer: subclass of DistributedOptimizer.
+ """
+
+ if not isinstance(optimizer, Optimizer):
+ raise ValueError("optimizer must be an instance of Optimizer")
+ if not self._is_initialized:
+ raise ValueError(
+ "fleet.init(role) to initialize before optimizer.minimize(loss)"
+ )
+
+ if not strategy:
+ _strategy = StrategyFactory.create_async_strategy()
+
+ if isinstance(strategy, DistributedStrategy):
+ _strategy = strategy
+ elif isinstance(strategy, DistributeTranspilerConfig):
+ if strategy.sync_mode:
+ _strategy = SyncStrategy()
+ else:
+ if strategy.runtime_split_send_recv:
+ if strategy.geo_sgd_mode:
+ _strategy = GeoStrategy(strategy.geo_sgd_need_push_nums)
+ elif strategy.half_async:
+ _strategy = HalfAsyncStrategy()
+ else:
+ _strategy = AsyncStrategy()
+ else:
+ _strategy = HalfAsyncStrategy()
+ # for half_async compatibility
+ strategy.half_async = True
+ strategy.runtime_split_send_recv = True
+ _strategy.set_program_config(strategy)
+ elif isinstance(strategy, dict):
+ if self._inner_mode != PSMode.PSLIB:
+ raise TypeError("Dict strategy can only be used at PSLIB Mode")
+
+ _strategy = StrategyFactory.create_async_strategy()
+ _strategy.set_pslib_runtime_config(strategy)
+ else:
+ raise TypeError(
+ "strategy must be an instance of DistributeTranspilerConfig, DistributedStrategy"
+ )
+
+ self._strategy = _strategy
+ self._optimizer = ParameterServerOptimizer(optimizer, _strategy)
+ return self._optimizer
+
+ def save_inference_model(self,
+ executor,
+ dirname,
+ feeded_var_names,
+ target_vars,
+ main_program=None,
+ export_for_deployment=True):
+ """
+ Prune the given `main_program` to build a new program especially for inference,
+ and then save it and all related parameters to given `dirname` by the `executor`.
+ """
+
+ if self._inner_mode == PSMode.PSLIB:
+ raise NotImplementedError("add implement later")
+
+ if isinstance(executor, ParallelExecutor):
+ raise TypeError(
+ "in fleet.save_inference_model() function, executor must be as Executor type, ParallelExecutor is not allowed"
+ )
+
+ if not isinstance(executor, Executor):
+ raise TypeError(
+ "in fleet.save_inference_model() function, executor must be as Executor type"
+ )
+
+ # Todo(MrChengmo): support recv&save GPU-Kernel for ps-gpu model save
+ if not isinstance(executor.place, fluid.CPUPlace):
+ save_executor = Executor(fluid.CPUPlace())
+ else:
+ save_executor = executor
+
+ if main_program is not None:
+ if isinstance(main_program, CompiledProgram):
+ raise TypeError(
+ "in fleet.save_inference_model() function, main_program must be as Program type, CompiledProgram is not allowed"
+ )
+ fluid.io.save_inference_model(dirname, feeded_var_names,
+ target_vars, executor, main_program,
+ None, None, export_for_deployment)
+ else:
+ fluid.io.save_inference_model(dirname, feeded_var_names,
+ target_vars, executor,
+ self._origin_main_program, None, None,
+ export_for_deployment, True)
+
+ model_basename = "__model__"
+ model_filename = os.path.join(dirname, model_basename)
+
+ with open(model_filename, "rb") as f:
+ program_desc_str = f.read()
+
+ program = Program.parse_from_string(program_desc_str)
+ program._copy_dist_param_info_from(self.main_program)
+ self.save_persistables(executor, dirname, program)
+
+ def _load_sparse_params(self, dirname, varnames):
+ from paddle.fluid.communicator import LargeScaleKV
+ scale_kv = LargeScaleKV()
+ for varname in varnames:
+ origin_varname, _, _ = public._get_varname_parts(varname)
+ sparse_dir = os.path.join(dirname, origin_varname, varname)
+ scale_kv.load(varname, sparse_dir)
+
+ def _get_optimizer_status(self, op, param_name):
+ supported_opts = [
+ "sgd", "adam", "adagrad", "adamax", "momentum", "lars_momentum",
+ "rmsprop", "decayed_adagrad", "ftrl"
+ ]
+
+ reshaped_val_map = {}
+ reshaped_val_map["sgd"] = []
+ reshaped_val_map["adam"] = ["moment1_0", "moment2_0"]
+ reshaped_val_map["adagrad"] = ["moment_0"]
+ reshaped_val_map["adamax"] = ["moment_0", "inf_norm_0"]
+ reshaped_val_map["momentum"] = ["velocity_0"]
+ reshaped_val_map["lars_momentum"] = ["velocity_0"]
+ reshaped_val_map["rmsprop"] = [
+ "momentum_0", "mean_square_0", "mean_grad_0"
+ ]
+ reshaped_val_map["decayed_adagrad"] = ["moment_0"]
+ reshaped_val_map["ftrl"] = ["squared_0", "linear_0"]
+
+ orishaped_val_map = {}
+ orishaped_val_map["adam"] = ["beta1_pow_acc_0", "beta2_pow_acc_0"]
+ orishaped_val_map["adamax"] = ["beta1_pow_acc_0"]
+
+ if op not in supported_opts:
+ raise ValueError(
+ "fleet can not support optimizer: {}, only this can be supported: {}"
+ .format(op, supported_opts))
+
+ reshaped_names = [
+ param_name + "_" + val for val in reshaped_val_map[op]
+ ]
+
+ if op not in orishaped_val_map:
+ origin_names = []
+ else:
+ origin_names = [
+ param_name + "_" + val for val in orishaped_val_map[op]
+ ]
+ return reshaped_names, origin_names
+
+ def _get_optimizer_op(self, param_name):
+ opts = public._get_optimize_ops(self._origin_main_program)
+ for op in opts:
+ if "Param" in op.input_names and \
+ "LearningRate" in op.input_names and op.input("Param")[0] == param_name:
+ return op
+
+ def _save_dense_params(self, executor, dirname, context, main_program):
+ self._communicator.recv()
+
+ prog = Program()
+ block = prog.global_block()
+ local_vars = []
+
+ for name, var_ctx in context.items():
+ if len(var_ctx.origin_varnames()) != 1:
+ raise ValueError("Dense can not support split now.")
+
+ varname = var_ctx.origin_varnames()[0]
+ local_vars.append(varname)
+
+ optimizer = self._get_optimizer_op(varname)
+ reshaped_varnames, origin_varnames = self._get_optimizer_status(
+ optimizer.type, varname)
+
+ for var_name in [varname] + reshaped_varnames + origin_varnames:
+ var = self._origin_main_program.global_block().vars[var_name]
+ block.append_op(type='recv_save',
+ attrs={
+ "trainer_id":
+ self._role_maker.worker_index(),
+ "shape":
+ var.shape,
+ "slice_shapes":
+ [",".join([str(i) for i in var.shape])],
+ "slice_varnames": [var.name],
+ "remote_varnames": [var.name],
+ "is_sparse":
+ False,
+ "endpoints":
+ var_ctx.split_endpoints(),
+ "file_path":
+ os.path.join(dirname, var.name)
+ })
+
+ executor.run(prog)
+ return local_vars
+
+ def _save_sparse_params(self, executor, dirname, context, main_program):
+ prog = Program()
+ block = prog.global_block()
+ local_vars = []
+
+ for name, var_ctx in context.items():
+ if len(var_ctx.origin_varnames()) != 1:
+ raise ValueError("Dense can not support split now.")
+
+ varname = var_ctx.origin_varnames()[0]
+ local_vars.append(varname)
+
+ optimizer = self._get_optimizer_op(varname)
+ reshaped_varnames, origin_varnames = self._get_optimizer_status(
+ optimizer.type, varname)
+
+ var = self._origin_main_program.global_block().vars[varname]
+ slice_shapes = []
+ dims1 = ",".join([str(i) for i in var.shape[1:]])
+
+ for section in var_ctx.sections():
+ slice_shapes.append(str(section) + dims1)
+
+ block.append_op(type='recv_save',
+ attrs={
+ "trainer_id":
+ self._role_maker.worker_index(),
+ "shape":
+ var.shape,
+ "slice_shapes":
+ slice_shapes,
+ "slice_varnames":
+ var_ctx.split_varnames(),
+ "remote_varnames":
+ var_ctx.split_varnames(),
+ "is_sparse":
+ True,
+ "endpoints":
+ var_ctx.split_endpoints(),
+ "pserver_num":
+ len(self._role_maker.get_pserver_endpoints()),
+ "file_path":
+ os.path.join(dirname, var.name)
+ })
+
+ for reshaped_varname in reshaped_varnames:
+ var = self._origin_main_program.global_block(
+ ).vars[reshaped_varname]
+
+ slice_varnames = []
+ remote_varnames = []
+ for i in range(len(var_ctx.split_varnames())):
+ slice_varnames.append("{}.block{}".format(
+ reshaped_varname, i))
+ remote_varnames.append(reshaped_varname)
+
+ block.append_op(
+ type='recv_save',
+ attrs={
+ "trainer_id": self._role_maker.worker_index(),
+ "shape": var.shape,
+ "slice_shapes": slice_shapes,
+ "slice_varnames": slice_varnames,
+ "remote_varnames": remote_varnames,
+ "is_sparse": True,
+ "endpoints": var_ctx.split_endpoints(),
+ "pserver_num":
+ len(self._role_maker.get_pserver_endpoints()),
+ "file_path": os.path.join(dirname, var.name)
+ })
+
+ for origin_varname in origin_varnames:
+ var = self._origin_main_program.global_block(
+ ).vars[origin_varname]
+
+ block.append_op(type='recv_save',
+ attrs={
+ "trainer_id":
+ self._role_maker.worker_index(),
+ "shape":
+ var.shape,
+ "slice_shapes":
+ [",".join([str(i) for i in var.shape])],
+ "slice_varnames": [origin_varname],
+ "remote_varnames": [origin_varname],
+ "is_sparse":
+ False,
+ "endpoints":
+ var_ctx.split_endpoints()[:1],
+ "file_path":
+ os.path.join(dirname, var.name)
+ })
+ executor.run(prog)
+ return context.keys()
+
+ def _save_distributed_params(self, executor, dirname, context,
+ main_program):
+ prog = Program()
+ block = prog.global_block()
+
+ for name, var_ctx in context.items():
+ block.append_op(type='checkpoint_notify',
+ attrs={
+ "varname": name,
+ "is_slice": True,
+ "slice_varnames": var_ctx.split_varnames(),
+ "remote_varnames": var_ctx.split_varnames(),
+ "endpoints": var_ctx.split_endpoints(),
+ "dirname": dirname
+ })
+
+ executor.run(prog)
+ return context.keys()
+
+ def _save_distributed_persistables(self, executor, dirname, main_program):
+ dense_ctx = fleet.compiled_config.get_communicator_recv_context(
+ recv_type=1)
+
+ sparse_ctx = fleet.compiled_config.get_communicator_recv_context(
+ recv_type=2)
+
+ distributed_ctx = fleet.compiled_config.get_communicator_recv_context(
+ recv_type=3)
+
+ recv_dense_varnames = self._save_dense_params(executor, dirname,
+ dense_ctx, main_program)
+
+ recv_sparse_varnames = self._save_sparse_params(executor, dirname,
+ sparse_ctx,
+ main_program)
+
+ recv_distributed_varnames = self._save_distributed_params(
+ executor, dirname, distributed_ctx, main_program)
+
+ saved_varnames = recv_dense_varnames + list(
+ recv_sparse_varnames) + list(recv_distributed_varnames)
+
+ remaining_vars = list(
+ filter(FleetTranspiler.__exclude_vars(saved_varnames),
+ main_program.list_vars()))
+
+ fluid.io.save_vars(executor,
+ main_program=main_program,
+ dirname=dirname,
+ vars=remaining_vars)
+
+ def save_persistables(self, executor, dirname, main_program=None, **kwargs):
+ """
+ This function filters out all variables with `persistable==True` from the
+ give `main_program` and then saves these variables to the folder `dirname`
+ or file `filename`.
+
+ The `dirname` is used to specify the folder where persistable variables
+ are going to be saved. If you would like to save variables in separate
+ files, set `filename` None;
+if you would like to save all variables in a
+ single file, use `filename` to specify the file name.
+ """
+
+ if self._inner_mode == PSMode.PSLIB:
+ raise NotImplementedError("add implement later")
+
+ if isinstance(executor, ParallelExecutor):
+ raise TypeError(
+ "in fleet.save_persistables() function, executor must be as Executor type, ParallelExecutor is not allowed"
+ )
+
+ if not isinstance(executor, Executor):
+ raise TypeError(
+ "in fleet.save_persistables() function, executor must be as Executor type"
+ )
+ # Todo(MrChengmo): support recv&save GPU-Kernel for ps-gpu model save
+ if not isinstance(executor.place, fluid.CPUPlace):
+ save_executor = Executor(fluid.CPUPlace())
+ else:
+ save_executor = executor
+
+ if main_program is None:
+ main_program = self.main_program
+
+ if isinstance(main_program, CompiledProgram):
+ raise TypeError(
+ "in fleet.save_persistables() function, main_program must be as Program type, CompiledProgram is not allowed"
+ )
+
+ self._save_distributed_persistables(save_executor, dirname,
+ main_program)
+
+ @staticmethod
+ def __exclude_vars(exclude_var_names=[]):
+
+ def is_valid(var):
+ if var.name in exclude_var_names:
+ return False
+
+ origin_varname, _, _ = public._get_varname_parts(var.name)
+ if origin_varname.endswith("@GRAD"):
+ return False
+
+ if origin_varname == "learning_rate_0":
+ return False
+
+ if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
+ var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
+ var.desc.type() == core.VarDesc.VarType.READER:
+ return False
+ return var.persistable
+
+ return is_valid
+
+
+# fleet is a global instance for parameter server.
+fleet = FleetTranspiler()
+
+
+class ParameterServerOptimizer(DistributedOptimizer):
+ """
+ DistributedOptimizer is a wrapper for paddle.fluid.optimizer
+ A user should pass a paddle.fluid.optimizer to DistributedOptimizer
+ minimize() function is implemented.
+ DistributedOptimizer is the starting point for a user who wants to
+ run distributed training. The optimized information will be stored in
+ Fleet() instance who holds the global information about current distributed
+ training.
+
+ Args:
+ optimizer(Optimizer): subclass of Optimizer.
+ strategy(DistributeTranspilerConfig): instance of DistributeTranspilerConfig.
+
+ Returns:
+ None
+ """
+
+ def __init__(self, optimizer, strategy, mode=PSMode.TRANSPILER):
+ super(ParameterServerOptimizer, self).__init__(optimizer, strategy)
+ self._mode = mode
+ if self._mode == PSMode.PSLIB:
+ self._optimizer_name = "Distributed%s" % optimizer.type.capitalize()
+ if optimizer.type != "adam":
+ print(
+ "Currently, distributed optimizer only support Adam"
+ "Will config built-in adam for you."
+ "We will support more functions in DistributedOptimizer",
+ sys.stderr)
+ self._optimizer_name = "DistributedAdam"
+
+ self._optimizer = globals()[self._optimizer_name](optimizer)
+ else:
+ self._optimizer = optimizer
+
+ self._window = 1
+ self.type = "downpour"
+ self.data_norm_name = [
+ ".batch_size", ".batch_square_sum", ".batch_sum",
+ ".batch_size@GRAD", ".batch_square_sum@GRAD", ".batch_sum@GRAD"
+ ]
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ raise NotImplementedError()
+
+ def apply_gradients(self, params_grads):
+ raise NotImplementedError()
+
+ def _build_trainer_programs(self, compiled_config):
+ _main = fleet._origin_main_program.clone()
+ _startup = fleet._origin_startup_program.clone()
+
+ if not compiled_config.is_geo_mode():
+ # for main program
+ _main = worker.delete_optimizer_pass(_main, compiled_config)
+ _main = worker.distributed_ops_pass(_main, compiled_config)
+ _main = worker.append_send_ops_pass(_main, compiled_config)
+
+ # for startup program
+ _startup = worker.fake_init_ops_pass(_startup, compiled_config)
+ _startup = worker.init_from_server_pass(_startup, compiled_config)
+ _startup = worker.delet_extra_optimizes_pass(
+ _startup, compiled_config)
+ else:
+ _main = worker.append_send_ops_pass(_main, compiled_config)
+ _startup = _startup
+
+ return _main, _startup
+
+ def _build_pserver_programs(self, compiled_config):
+ _main = fluid.Program()
+ _startup = fluid.Program()
+
+ if not compiled_config.is_geo_mode():
+ _main = server.add_listen_and_serv_pass(_main, compiled_config)
+ _main = server.add_rpc_global_flags_pass(_main, compiled_config)
+ _main = server.add_optimizer_pass(_main, compiled_config)
+ _main = server.large_scale_sparse_pass(_main, _main,
+ compiled_config, False)
+ _startup = server.build_pserver_startup_program_pass(
+ _startup, _main, compiled_config)
+ _startup = server.large_scale_sparse_pass(_startup, _main,
+ compiled_config, True)
+
+ if not compiled_config.is_sync_mode():
+ _main = server.delete_unused_in_main_pass(
+ _main, compiled_config)
+
+ _startup = server.delete_unused_in_startup_pass(
+ _startup, _main, compiled_config)
+ else:
+ _main = server.add_listen_and_serv_pass(_main, compiled_config)
+ _main = server.add_rpc_global_flags_pass(_main, compiled_config)
+ _main = server.add_geo_optimizer_pass(_main, compiled_config)
+ _main = server.large_scale_sparse_pass(_main, _main,
+ compiled_config, False)
+ _startup = server.build_pserver_startup_program_pass(
+ _startup, _main, compiled_config)
+ _startup = server.large_scale_sparse_pass(_startup, _main,
+ compiled_config, True)
+ _startup = server.delete_unused_in_startup_pass(
+ _startup, _main, compiled_config)
+
+ return _main, _startup
+
+ def minimize(self,
+ losses,
+ scopes=None,
+ startup_programs=None,
+ parameter_list=None,
+ no_grad_set=None):
+
+ if isinstance(losses, list):
+ raise ValueError("need implement later")
+
+ self._optimizer.minimize(losses, startup_programs, parameter_list,
+ no_grad_set)
+
+ fleet._origin_main_program = default_main_program().clone(
+ for_test=False)
+ fleet._origin_startup_program = default_startup_program().clone(
+ for_test=False)
+
+ compiled_config = public.CompileTimeStrategy(
+ fleet._origin_main_program, fleet._origin_startup_program,
+ self._strategy, fleet._role_maker)
+
+ fleet.compiled_config = compiled_config
+ fleet.main_program, fleet.startup_program = \
+ self._build_trainer_programs(compiled_config) if fleet.is_worker() \
+ else self._build_pserver_programs(compiled_config)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e40fa81ebbc4d4c6bf89f5fcce92364a054d1d5
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/distribute_transpiler/distributed_strategy.py
@@ -0,0 +1,438 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+
+__all__ = [
+ "TrainerRuntimeConfig", "DistributedStrategy", "SyncStrategy",
+ "AsyncStrategy", "HalfAsyncStrategy", "GeoStrategy", "StrategyFactory"
+]
+
+import os
+import paddle.fluid as fluid
+from paddle.fluid.transpiler.distribute_transpiler import DistributeTranspilerConfig, ServerRuntimeConfig
+from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode
+
+
+class TrainerRuntimeConfig(object):
+
+ def __init__(self):
+ self.mode = None
+ num_threads = os.getenv("CPU_NUM", "1")
+
+ self.runtime_configs = {}
+ self.runtime_configs['communicator_max_merge_var_num'] = os.getenv(
+ "FLAGS_communicator_max_merge_var_num", num_threads)
+ self.runtime_configs['communicator_send_queue_size'] = os.getenv(
+ "FLAGS_communicator_send_queue_size", num_threads)
+ self.runtime_configs[
+ 'communicator_independent_recv_thread'] = os.getenv(
+ "FLAGS_communicator_independent_recv_thread", "1")
+ self.runtime_configs[
+ 'communicator_min_send_grad_num_before_recv'] = os.getenv(
+ "FLAGS_communicator_min_send_grad_num_before_recv", num_threads)
+ self.runtime_configs['communicator_thread_pool_size'] = os.getenv(
+ "FLAGS_communicator_thread_pool_size", "5")
+ self.runtime_configs['communicator_send_wait_times'] = os.getenv(
+ "FLAGS_communicator_send_wait_times", "5")
+ self.runtime_configs['communicator_is_sgd_optimizer'] = os.getenv(
+ "FLAGS_communicator_is_sgd_optimizer", "1")
+
+ # not used
+ self.runtime_configs['rpc_deadline'] = os.getenv(
+ "FLAGS_rpc_deadline", "180000")
+ self.runtime_configs['rpc_retry_times'] = os.getenv(
+ "FLAGS_rpc_retry_times", "3")
+
+ def get_communicator_flags(self):
+ need_keys = []
+ num_threads = os.getenv("CPU_NUM", "1")
+ mode_str = ""
+ if self.mode is None or self.mode == DistributedMode.ASYNC:
+ need_keys = self.runtime_configs.keys()
+ mode_str = "async"
+ elif self.mode == DistributedMode.SYNC or self.mode == DistributedMode.HALF_ASYNC:
+ mode_str = "sync or half_async"
+ need_keys = [
+ 'communicator_max_merge_var_num',
+ 'communicator_send_wait_times', 'communicator_thread_pool_size',
+ 'communicator_send_queue_size'
+ ]
+ elif self.mode == DistributedMode.GEO:
+ mode_str = "GEO"
+ need_keys = [
+ 'communicator_thread_pool_size', 'communicator_send_wait_times',
+ 'communicator_max_merge_var_num', 'communicator_send_queue_size'
+ ]
+ else:
+ raise ValueError("Unsupported Mode")
+
+ if self.mode == DistributedMode.SYNC or self.mode == DistributedMode.HALF_ASYNC:
+ max_merge_var_num = self.runtime_configs[
+ 'communicator_max_merge_var_num']
+ send_queue_size = self.runtime_configs[
+ 'communicator_send_queue_size']
+ if max_merge_var_num != num_threads:
+ print('WARNING: In {} mode, communicator_max_merge_var_num '
+ 'must be equal to CPU_NUM. But received, '
+ 'communicator_max_merge_var_num = {}, CPU_NUM = '
+ '{}. communicator_max_merge_var_num will be fored to {}.'.
+ format(mode_str, max_merge_var_num, num_threads,
+ num_threads))
+ self.runtime_configs[
+ 'communicator_max_merge_var_num'] = num_threads
+ if send_queue_size != num_threads:
+ print('WARNING: In {} mode, communicator_send_queue_size '
+ 'must be equal to CPU_NUM. But received, '
+ 'communicator_send_queue_size = {}, CPU_NUM = '
+ '{}. communicator_send_queue_size will be fored to {}.'.
+ format(mode_str, send_queue_size, num_threads,
+ num_threads))
+ self.runtime_configs[
+ 'communicator_send_queue_size'] = num_threads
+
+ return dict((key, str(self.runtime_configs[key])) for key in need_keys)
+
+ def display(self, configs):
+ raw0, raw1, length = 45, 5, 50
+ h_format = "{:^45s}{:<5s}\n"
+ l_format = "{:<45s}{:<5s}\n"
+
+ border = "".join(["="] * length)
+ line = "".join(["-"] * length)
+
+ draws = ""
+ draws += border + "\n"
+ draws += h_format.format("TrainerRuntimeConfig Overview", "Value")
+ draws += line + "\n"
+
+ for k, v in configs.items():
+ draws += l_format.format(k, v)
+
+ draws += border
+
+ _str = "\n{}\n".format(draws)
+ return _str
+
+ def __repr__(self):
+ return self.display(self.get_communicator_flags())
+
+
+class PSLibRuntimeConfig(object):
+
+ def __init__(self):
+ self.runtime_configs = {}
+
+ def get_runtime_configs(self):
+ return self.runtime_configs
+
+
+class DistributedStrategy(object):
+
+ def __init__(self):
+ self._program_config = DistributeTranspilerConfig()
+ self._trainer_runtime_config = TrainerRuntimeConfig()
+ self._pslib_runtime_config = PSLibRuntimeConfig()
+ self._server_runtime_config = ServerRuntimeConfig()
+ num_threads = int(os.getenv("CPU_NUM", "1"))
+
+ self._execute_strategy = fluid.ExecutionStrategy()
+ self._build_strategy = fluid.BuildStrategy()
+
+ self._execute_strategy.num_threads = num_threads
+ if num_threads > 1:
+ self._build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
+ self.debug_opt = None
+ self.use_ps_gpu = False
+
+ def set_debug_opt(self, opt_info):
+ self.debug_opt = opt_info
+
+ def get_debug_opt(self):
+ opt_info = dict()
+ if self.debug_opt is not None and isinstance(self.debug_opt, dict):
+ opt_info["dump_slot"] = bool(self.debug_opt.get("dump_slot", 0))
+ opt_info["dump_converter"] = str(
+ self.debug_opt.get("dump_converter", ""))
+ opt_info["dump_fields"] = self.debug_opt.get("dump_fields", [])
+ opt_info["dump_file_num"] = self.debug_opt.get("dump_file_num", 16)
+ opt_info["dump_fields_path"] = self.debug_opt.get(
+ "dump_fields_path", "")
+ opt_info["dump_param"] = self.debug_opt.get("dump_param", [])
+ return opt_info
+
+ def get_program_config(self):
+ return self._program_config
+
+ def set_program_config(self, config):
+ if isinstance(config, DistributeTranspilerConfig):
+ self._program_config = config
+ elif isinstance(config, dict):
+ for key in config:
+ if hasattr(self._program_config, key):
+ setattr(self._program_config, key, config[key])
+ else:
+ raise ValueError(
+ "DistributeTranspilerConfig doesn't have key: {}".
+ format(key))
+ else:
+ raise TypeError(
+ "program_config only accept input type: dict or DistributeTranspilerConfig"
+ )
+ self.check_program_config()
+
+ def check_program_config(self):
+ raise NotImplementedError(
+ "check_program_config must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy."
+ )
+
+ def get_trainer_runtime_config(self):
+ return self._trainer_runtime_config
+
+ def set_trainer_runtime_config(self, config):
+ if isinstance(config, TrainerRuntimeConfig):
+ self._trainer_runtime_config = config
+ elif isinstance(config, dict):
+ for key, Value in config.items():
+ if key in self._trainer_runtime_config.runtime_configs:
+ self._trainer_runtime_config.runtime_configs[key] = Value
+ else:
+ raise ValueError(
+ "TrainerRuntimeConfig doesn't have key: {}".format(key))
+ else:
+ raise TypeError(
+ "trainer_runtime_config only accept input type: dict or TrainerRuntimeConfig"
+ )
+ self.check_trainer_runtime_config()
+
+ def check_trainer_runtime_config(self):
+ raise NotImplementedError(
+ "check_trainer_runtime_config must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy."
+ )
+
+ def get_pslib_runtime_config(self):
+ return self._pslib_runtime_config
+
+ def set_pslib_runtime_config(self, config):
+ self._pslib_runtime_config.runtime_configs = config
+
+ def get_server_runtime_config(self):
+ return self._server_runtime_config
+
+ def set_server_runtime_config(self, config):
+ if isinstance(config, ServerRuntimeConfig):
+ self._server_runtime_config = config
+ elif isinstance(config, dict):
+ for key in config:
+ if hasattr(self._server_runtime_config, key):
+ setattr(self._server_runtime_config, key, config[key])
+ else:
+ raise ValueError(
+ "ServerRuntimeConfig doesn't have key: {}".format(key))
+ else:
+ raise TypeError(
+ "server_runtime_config only accept input type: dict or ServerRuntimeConfig"
+ )
+ self.check_server_runtime_config()
+
+ def check_server_runtime_config(self):
+ raise NotImplementedError(
+ "check_server_runtime_config must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy."
+ )
+
+ def get_execute_strategy(self):
+ return self._execute_strategy
+
+ def set_execute_strategy(self, config):
+ if isinstance(config, fluid.ExecutionStrategy):
+ self._execute_strategy = config
+ elif isinstance(config, dict):
+ for key in config:
+ if hasattr(self._execute_strategy, key):
+ setattr(self._execute_strategy, key, config[key])
+ else:
+ raise ValueError(
+ "ExecutionStrategy doesn't have key: {}".format(key))
+ else:
+ raise TypeError(
+ "execute_strategy only accept input type: dict or ExecutionStrategy"
+ )
+ self.check_execute_strategy()
+
+ def check_execute_strategy(self):
+ raise NotImplementedError(
+ "check_execute_strategy must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy."
+ )
+
+ def get_build_strategy(self):
+ return self._build_strategy
+
+ def set_build_strategy(self, config):
+ if isinstance(config, fluid.BuildStrategy):
+ self._build_strategy = config
+ elif isinstance(config, dict):
+ for key in config:
+ if hasattr(self._build_strategy, key):
+ setattr(self._build_strategy, key, config[key])
+ else:
+ raise ValueError(
+ "BuildStrategy doesn't have key: {}".format(key))
+ else:
+ raise TypeError(
+ "build_strategy only accept input type: dict or BuildStrategy")
+ self.check_build_strategy()
+
+ def check_build_strategy(self):
+ raise NotImplementedError(
+ "check_build_strategy must be implemented by derived class. You should use StrategyFactory to create DistributedStrategy."
+ )
+
+
+class SyncStrategy(DistributedStrategy):
+
+ def __init__(self):
+ super(SyncStrategy, self).__init__()
+ self.check_program_config()
+ self.check_trainer_runtime_config()
+ self.check_server_runtime_config()
+ self.check_build_strategy()
+ self.check_execute_strategy()
+
+ def check_trainer_runtime_config(self):
+ self._trainer_runtime_config.mode = DistributedMode.SYNC
+
+ def check_program_config(self):
+ self._program_config.sync_mode = False
+ self._program_config.runtime_split_send_recv = True
+ self._program_config.half_async = True
+ self._program_config.completely_not_async = True
+
+ def check_server_runtime_config(self):
+ pass
+
+ def check_execute_strategy(self):
+ self._execute_strategy.use_thread_barrier = True
+
+ def check_build_strategy(self):
+ self._build_strategy.async_mode = True
+
+
+class AsyncStrategy(DistributedStrategy):
+
+ def __init__(self):
+ super(AsyncStrategy, self).__init__()
+ self.check_program_config()
+ self.check_trainer_runtime_config()
+ self.check_server_runtime_config()
+ self.check_build_strategy()
+ self.check_execute_strategy()
+
+ def check_trainer_runtime_config(self):
+ self._trainer_runtime_config.mode = DistributedMode.ASYNC
+
+ def check_program_config(self):
+ self._program_config.sync_mode = False
+ self._program_config.runtime_split_send_recv = True
+
+ def check_server_runtime_config(self):
+ pass
+
+ def check_execute_strategy(self):
+ pass
+
+ def check_build_strategy(self):
+ self._build_strategy.async_mode = True
+
+
+class HalfAsyncStrategy(DistributedStrategy):
+
+ def __init__(self):
+ super(HalfAsyncStrategy, self).__init__()
+ self.check_program_config()
+ self.check_trainer_runtime_config()
+ self.check_server_runtime_config()
+ self.check_build_strategy()
+ self.check_execute_strategy()
+
+ def check_trainer_runtime_config(self):
+ self._trainer_runtime_config.mode = DistributedMode.HALF_ASYNC
+
+ def check_program_config(self):
+ self._program_config.sync_mode = False
+ self._program_config.runtime_split_send_recv = True
+ self._program_config.half_async = True
+
+ def check_server_runtime_config(self):
+ pass
+
+ def check_execute_strategy(self):
+ self._execute_strategy.use_thread_barrier = True
+
+ def check_build_strategy(self):
+ self._build_strategy.async_mode = True
+
+
+class GeoStrategy(DistributedStrategy):
+
+ def __init__(self, update_frequency=100):
+ super(GeoStrategy, self).__init__()
+ self._program_config.geo_sgd_need_push_nums = update_frequency
+ self.check_program_config()
+ self.check_trainer_runtime_config()
+ self.check_server_runtime_config()
+ self.check_build_strategy()
+ self.check_execute_strategy()
+
+ def check_program_config(self):
+ self._program_config.sync_mode = False
+ self._program_config.runtime_split_send_recv = True
+ self._program_config.geo_sgd_mode = True
+
+ def check_trainer_runtime_config(self):
+ self._trainer_runtime_config.mode = DistributedMode.GEO
+
+ self._trainer_runtime_config.runtime_configs[
+ 'communicator_send_queue_size'] = self._program_config.geo_sgd_need_push_nums
+
+ self._trainer_runtime_config.runtime_configs[
+ 'communicator_max_merge_var_num'] = self._program_config.geo_sgd_need_push_nums
+
+ def check_server_runtime_config(self):
+ pass
+
+ def check_execute_strategy(self):
+ pass
+
+ def check_build_strategy(self):
+ self._build_strategy.async_mode = True
+
+
+class StrategyFactory(object):
+
+ def __init_(self):
+ pass
+
+ @staticmethod
+ def create_sync_strategy():
+ return SyncStrategy()
+
+ @staticmethod
+ def create_half_async_strategy():
+ return HalfAsyncStrategy()
+
+ @staticmethod
+ def create_async_strategy():
+ return AsyncStrategy()
+
+ @staticmethod
+ def create_geo_strategy(update_frequency=100):
+ return GeoStrategy(update_frequency)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..abf198b97e6e818e1fbe59006f98492640bcee54
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/heter_trainer_pass.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/heter_trainer_pass.py
new file mode 100644
index 0000000000000000000000000000000000000000..0018b73e264798dd21450564812dfca5ec992038
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/heter_trainer_pass.py
@@ -0,0 +1,72 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import warnings
+
+import paddle.fluid.core as core
+import paddle.fluid.framework as framework
+
+from paddle.fluid.transpiler.details.program_utils import delete_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import find_heter_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import union_forward_gradient_op
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import create_heter_program
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import create_trainer_program
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import find_block_joints
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import find_op_input_output
+from paddle.fluid.incubate.fleet.parameter_server.ir.trainer_pass import get_vars_name_in_block
+
+
+def split_heter_worker_ops_pass(program, config, stage_id, device):
+ """
+ split heter worker program from origin-program
+ 1. find heter op (located on different device)
+ 2. find input&output of every heter-block
+ 3. create heter worker program, add listen&serv op
+ """
+ default_deveice = "cpu"
+ program, heter_ops, _, program_block_ops = find_heter_ops(
+ program, default_deveice)
+ if len(heter_ops) == 0:
+ warnings.warn(
+ "Currently running in Heter Parameter Server mode, but no OP running on heterogeneous devices, Please check your code."
+ )
+ return program
+
+ program_block_ops = union_forward_gradient_op(program_block_ops)
+ block_vars_detail = find_block_joints(program, program_block_ops, heter_ops)
+ heter_program = framework.Program()
+ create_heter_program(program, config, heter_program, program_block_ops,
+ heter_ops, block_vars_detail, device, stage_id)
+ return heter_program
+
+
+def split_trainer_ops_pass(program, config, default_device="cpu"):
+ """
+ split cpu-trainer program from origin-program
+ 1. find heter op (located on different device)
+ 2. find input&output of every heter-block
+ 3. create cpu-trainer program, add send&recv op
+ """
+ # Todo: support user define default_device (MrChengmo)
+ default_device_ = default_device
+ program, heter_ops, default_ops, program_block_ops = find_heter_ops(
+ program, default_device_)
+ program_block_ops = union_forward_gradient_op(program_block_ops)
+
+ block_vars_detail = find_block_joints(program, program_block_ops, heter_ops)
+ trainer_program = program.clone()
+ create_trainer_program(trainer_program, program, config, program_block_ops,
+ block_vars_detail)
+ return trainer_program
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..74ded7c09967fce5c8cd5cc6551f875074ea4279
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ps_dispatcher.py
@@ -0,0 +1,125 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+
+class PSDispatcher(object):
+ """
+ PSDispatcher is the base class for dispatching vars
+ into different pserver instance.
+ You need to implement the `dispatch` interface.
+ """
+
+ def __init__(self, pserver_endpoints):
+ self._eps = pserver_endpoints
+ self._step = 0
+
+ @property
+ def eps(self):
+ return self._eps
+
+ def reset(self):
+ """
+ reset the step counter, set it zero.
+ """
+ self._step = 0
+
+ def dispatch(self, varlist):
+ """
+ Args:
+ varlist(list): a list of Variables
+ Returns:
+ a map of pserver endpoint -> varname
+ """
+ raise NotImplementedError("Interface has not been implemented.")
+
+
+class HashName(PSDispatcher):
+ """
+ Hash variable names to several endpoints using python
+ "hash()" function.
+
+ Args:
+ pserver_endpoints (list): list of endpoint(ip:port).
+
+ Examples:
+ .. code-block:: python
+
+ pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"]
+ vars = ["var1","var2","var3","var4","var5"]
+
+ rr = RoundRobin(pserver_endpoints)
+ rr.dispatch(vars)
+
+ """
+
+ def __init__(self, pserver_endpoints):
+ super(HashName, self).__init__(pserver_endpoints)
+
+ def _hash_block(self, block_str, total):
+ return hash(block_str) % total
+
+ def dispatch(self, varlist):
+ """
+ use `HashName` method to dispatch variables with each parameter server.
+ Args:
+ varlist (list): a list of Variables
+
+ """
+ eplist = []
+ for var in varlist:
+ server_id = self._hash_block(var.name(), len(self._eps))
+ server_for_param = self._eps[server_id]
+ eplist.append(server_for_param)
+ return eplist
+
+
+class RoundRobin(PSDispatcher):
+ """
+ Distribute variables to several endpoints using
+ RondRobin method.
+
+ Args:
+ pserver_endpoints (list): list of endpoint(ip:port).
+
+ Examples:
+ .. code-block:: python
+
+ pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"]
+ vars = ["var1","var2","var3","var4","var5"]
+
+ rr = RoundRobin(pserver_endpoints)
+ rr.dispatch(vars)
+
+ """
+
+ def __init__(self, pserver_endpoints):
+ super(RoundRobin, self).__init__(pserver_endpoints)
+
+ def dispatch(self, varlist):
+ """
+ use `RoundRobin` method to dispatch variables with each parameter server.
+ Args:
+ varlist (list): a list of Variables
+
+ """
+ eplist = []
+ for var in varlist:
+ server_for_param = self._eps[self._step]
+ eplist.append(server_for_param)
+ self._step += 1
+ if self._step >= len(self._eps):
+ self._step = 0
+ return eplist
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py
new file mode 100644
index 0000000000000000000000000000000000000000..38a4a14b02f38256d7e2d459d69438d86a4a73b0
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/pserver_pass.py
@@ -0,0 +1,1001 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import collections
+import six
+
+from paddle.fluid import core
+from paddle.fluid.framework import Block
+
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_optimize_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _orig_varname
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_varname_parts
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import is_distributed_sparse_op
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablename
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops
+
+LEARNING_RATE_DECAY_COUNTER = "@LR_DECAY_COUNTER@"
+OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName()
+RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName()
+OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize
+LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched
+
+
+def _is_optimizer_op(op):
+ if "Param" in op.input_names and \
+ "LearningRate" in op.input_names:
+ return True
+ return False
+
+
+def _same_or_split_var(p_name, var_name):
+ return p_name == var_name or p_name.startswith(var_name + ".block")
+
+
+def _get_optimizer_input_shape(op_type, varkey, orig_shape, param_shape):
+ """
+ Returns the shape for optimizer inputs that need to be reshaped when
+ Param and Grad is split to multiple servers.
+ """
+ # HACK(typhoonzero) : Should use functions of corresponding optimizer in
+ # optimizer.py to get the shape, do not bind this in the transpiler.
+ if op_type == "adam":
+ if varkey in ["Moment1", "Moment2"]:
+ return param_shape
+ elif op_type == "adagrad":
+ if varkey == "Moment":
+ return param_shape
+ elif op_type == "adamax":
+ if varkey in ["Moment", "InfNorm"]:
+ return param_shape
+ elif op_type in ["momentum", "lars_momentum"]:
+ if varkey == "Velocity":
+ return param_shape
+ elif op_type == "rmsprop":
+ if varkey in ["Moment", "MeanSquare"]:
+ return param_shape
+ elif op_type == "decayed_adagrad":
+ if varkey == "Moment":
+ return param_shape
+ elif op_type == "ftrl":
+ if varkey in ["SquaredAccumulator", "LinearAccumulator"]:
+ return param_shape
+ elif op_type == "sgd":
+ pass
+ else:
+ raise ValueError(
+ "Not supported optimizer for distributed training: %s" % op_type)
+ return orig_shape
+
+
+def _append_pserver_non_opt_ops(optimize_block, opt_op, origin_program, config):
+
+ def _get_pserver_grad_param_var(var, var_dict):
+ """
+ Return pserver side grad/param variable, return None
+ if the variable is not grad/param, e.g.
+
+ a@GRAD -> a@GRAD.block0
+ a@GRAD -> a@GRAD (a is not split)
+ fc_0.w_0 -> fc_0.w_0.block_0
+ fc_0.w_0 -> fc_0.w_0 (weight is not split)
+ _generated_var_123 -> None
+ """
+
+ grad_block = None
+ for _, g in six.iteritems(var_dict):
+ if _orig_varname(g.name) == _orig_varname(var.name):
+ # skip per trainer vars
+ if g.name.find(".trainer_") == -1:
+ # only param or grads have split blocks
+ ovar_name = _orig_varname(g.name)
+ if ovar_name in config.param_grad_ep_mapping:
+ grad_block = g
+ break
+ elif ovar_name in config.grad_param_mapping:
+ grad_block = g
+ break
+
+ return grad_block
+
+ program = optimize_block.program
+ # Append the ops for parameters that do not need to be optimized / updated
+ inputs = _get_input_map_from_op(origin_program.global_block().vars, opt_op)
+ for key, varlist in six.iteritems(inputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for i in range(len(varlist)):
+ var = varlist[i]
+ # for ops like clipping and weight decay, get the split var(xxx.block0)
+ # for inputs / outputs
+ grad_block = _get_pserver_grad_param_var(
+ var,
+ program.global_block().vars)
+ if grad_block:
+ varlist[i] = grad_block
+ elif var.name not in program.global_block().vars:
+ tmpvar = program.global_block()._clone_variable(var)
+ varlist[i] = tmpvar
+ else:
+ varlist[i] = program.global_block().vars[var.name]
+ inputs[key] = varlist
+
+ outputs = _get_output_map_from_op(origin_program.global_block().vars,
+ opt_op)
+ for key, varlist in six.iteritems(outputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for i in range(len(varlist)):
+ var = varlist[i]
+ grad_block = _get_pserver_grad_param_var(
+ var,
+ program.global_block().vars)
+ if grad_block:
+ varlist[i] = grad_block
+ elif var.name not in program.global_block().vars:
+ tmpvar = program.global_block()._clone_variable(var)
+ varlist[i] = tmpvar
+ else:
+ varlist[i] = program.global_block().vars[var.name]
+ outputs[key] = varlist
+
+ return optimize_block.append_op(type=opt_op.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=opt_op.all_attrs())
+
+
+def _append_pserver_ops(optimize_block, opt_op, endpoint, grad_to_block_id,
+ origin_program, merged_var, sparse_grad_to_param,
+ config):
+ program = optimize_block.program
+ pserver_block = program.global_block()
+ new_inputs = collections.OrderedDict()
+
+ def _get_param_block(opt_op):
+ # param is already created on global program
+ unmerged_vars = []
+ merged_vars = []
+ merged_ordervars = []
+
+ param_vars = [
+ p for p in config.param_grad_ep_mapping[endpoint]["params"]
+ ]
+
+ for var in param_vars:
+ name = var.name
+ orig_varname = _orig_varname(name)
+
+ for pairs in config.merged_variables_pairs:
+ merged_p = pairs[0]
+ if merged_p.merged_var.name == orig_varname:
+ if merged_p.merged_var.name == merged_p.ordered_vars[
+ 0].name:
+ unmerged_vars.append(merged_p.ordered_vars[0])
+ else:
+ merged_vars.append(merged_p.merged_var)
+ merged_ordervars.append(merged_p.ordered_vars[0])
+ break
+
+ param_name = opt_op.input("Param")[0]
+
+ for i in range(len(unmerged_vars)):
+ if _same_or_split_var(param_name, unmerged_vars[i].name):
+ for var in param_vars:
+ if _same_or_split_var(var.name, unmerged_vars[i].name):
+ return var
+
+ for i in range(len(merged_ordervars)):
+ if _same_or_split_var(param_name, merged_ordervars[i].name):
+ for var in param_vars:
+ if _same_or_split_var(var.name, merged_vars[i].name):
+ return var
+ return None
+
+ for key in opt_op.input_names:
+ if key == "Grad":
+ # Note !!This is for l2decay on sparse gradient, \
+ # because it will create a new tensor for
+ # decayed gradient but not inplace modify the origin one
+ origin_grad_name = opt_op.input(key)[0]
+ if core.kNewGradSuffix(
+ ) in origin_grad_name and pserver_block.has_var(origin_grad_name):
+ new_grad = pserver_block.var(origin_grad_name)
+ new_inputs[key] = new_grad
+ else:
+ new_inputs[key] = merged_var
+ elif key == "Param":
+ param_block = _get_param_block(opt_op)
+
+ if not param_block:
+ return
+ tmpvar = pserver_block.create_var(name=param_block.name,
+ persistable=True,
+ dtype=param_block.dtype,
+ shape=param_block.shape)
+ new_inputs[key] = tmpvar
+
+ elif key == "LearningRate":
+ # learning rate variable has already be created by non - optimize op,
+ # don't create it once again.
+ lr_varname = opt_op.input(key)[0]
+ if lr_varname in pserver_block.vars:
+ new_inputs[key] = pserver_block.vars[opt_op.input(key)[0]]
+ else:
+ origin_var = origin_program.global_block().vars[lr_varname]
+ tmpvar = pserver_block.create_var(
+ name=origin_var.name,
+ persistable=origin_var.persistable,
+ dtype=origin_var.dtype,
+ shape=origin_var.shape)
+ new_inputs[key] = tmpvar
+
+ for key in opt_op.input_names:
+ new_shape = None
+ if key in [
+ "Param", "Grad", "LearningRate", "MasterParam", "Beta1Tensor",
+ "Beta2Tensor"
+ ]:
+ continue
+ var = origin_program.global_block().vars[opt_op.input(key)[0]]
+ param_var = new_inputs["Param"]
+ # update accumulator variable shape
+ new_shape = _get_optimizer_input_shape(opt_op.type, key, var.shape,
+ param_var.shape)
+ tmpvar = pserver_block.create_var(name=var.name,
+ persistable=var.persistable,
+ dtype=var.dtype,
+ shape=new_shape)
+ new_inputs[key] = tmpvar
+
+ # change output's ParamOut variable
+ outputs = _get_output_map_from_op(origin_program.global_block().vars,
+ opt_op)
+ outputs["ParamOut"] = new_inputs["Param"]
+ optimize_block.append_op(type=opt_op.type,
+ inputs=new_inputs,
+ outputs=outputs,
+ attrs=opt_op.all_attrs())
+
+ # record sparse grad to param name
+ if new_inputs["Grad"].type == core.VarDesc.VarType.SELECTED_ROWS:
+ sparse_grad_to_param.append(
+ str(new_inputs["Grad"].name) + ":" + str(new_inputs["Param"].name))
+
+
+def _get_input_map_from_op(varmap, op):
+ """Returns a dict from op input name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.input_names:
+ vars = []
+ for varname in op.input(key):
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+
+def _get_output_map_from_op(varmap, op):
+ """Returns a dict from op output name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.output_names:
+ vars = []
+ for varname in op.output(key):
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+
+def get_op_by_type(block, op_type):
+ for op in block.ops:
+ if op.type == op_type:
+ return op
+ raise ValueError("add_listen_and_serv_pass must at first")
+
+
+def add_listen_and_serv_pass(program, config):
+ attrs = {
+ "grad_to_block_id": None,
+ "sparse_grad_to_param": None,
+ "lr_decay_block_id": None,
+ "dense_optimize_blocks": None,
+ "sparse_optimize_blocks": None,
+
+ # runtime attribute
+ "endpoint": config.get_ps_endpoint(),
+ "pserver_id": config.get_role_id(),
+ "Fanin": config.get_trainers(),
+ "distributed_mode": config.get_distributed_mode(),
+ "rpc_get_thread_num": -1,
+ "rpc_send_thread_num": -1,
+ "rpc_prefetch_thread_num": -1
+ }
+
+ # step5 append the listen_and_serv op
+ program.global_block().append_op(type="listen_and_serv",
+ inputs={'X': []},
+ outputs={},
+ attrs=attrs)
+
+ return program
+
+
+def add_rpc_global_flags_pass(program, config):
+ server_runtime = config.get_server_runtime_config()
+ send_threads = server_runtime._rpc_send_thread_num
+ get_threads = server_runtime._rpc_get_thread_num
+ pull_threads = server_runtime._rpc_prefetch_thread_num
+
+ op = get_op_by_type(program.global_block(), "listen_and_serv")
+
+ if get_threads < 1 or send_threads < 1 or pull_threads < 1:
+ raise ValueError(
+ "error arguments in get_threads/send_threads/pull_threads")
+
+ op._set_attr("rpc_get_thread_num", get_threads)
+ op._set_attr("rpc_send_thread_num", send_threads)
+ op._set_attr("rpc_prefetch_thread_num", pull_threads)
+
+ return program
+
+
+def _clone_var(block, var, persistable=True):
+ return block.create_var(name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ lod_level=var.lod_level,
+ persistable=persistable)
+
+
+def add_optimizer_pass(program, config):
+
+ def _append_pserver_grad_merge_ops(optimize_block, grad_varname_for_block,
+ endpoint, grad_to_block_id):
+ trainers = config.get_trainers()
+
+ program = optimize_block.program
+ pserver_block = program.global_block()
+ grad_block = None
+
+ for g in config.param_grad_ep_mapping[endpoint]["grads"]:
+ if _orig_varname(g.name) == \
+ _orig_varname(grad_varname_for_block):
+ grad_block = g
+ break
+
+ if not grad_block:
+ # do not append this op if current endpoint
+ # is not dealing with this grad block
+ return None
+
+ orig_varname, block_name, trainer_name = _get_varname_parts(
+ grad_block.name)
+
+ if block_name:
+ merged_var_name = '.'.join([orig_varname, block_name])
+ else:
+ merged_var_name = orig_varname
+
+ merged_var = pserver_block.create_var(name=grad_block.name,
+ persistable=True,
+ type=grad_block.type,
+ dtype=grad_block.dtype,
+ shape=grad_block.shape)
+
+ grad_to_block_id.append(merged_var.name + ":" + str(optimize_block.idx))
+ if config.is_sync_mode() and trainers > 1:
+ vars2merge = []
+ for i in range(trainers):
+ per_trainer_name = "%s.trainer_%d" % \
+ (merged_var_name, i)
+ per_trainer_var = pserver_block.create_var(
+ name=per_trainer_name,
+ persistable=False,
+ type=grad_block.type,
+ dtype=grad_block.dtype,
+ shape=grad_block.shape)
+ vars2merge.append(per_trainer_var)
+
+ optimize_block.append_op(type="sum",
+ inputs={"X": vars2merge},
+ outputs={"Out": merged_var},
+ attrs={"use_mkldnn": False})
+ optimize_block.append_op(type="scale",
+ inputs={"X": merged_var},
+ outputs={"Out": merged_var},
+ attrs={"scale": 1.0 / float(trainers)})
+ return merged_var
+
+ origin_program = config.get_origin_main_program()
+ origin_program = origin_program.clone()
+ ps_endpoint = config.get_ps_endpoint()
+
+ opt_op_on_pserver = []
+ # Iterate through the ops, and if an op and the optimize ops
+ # which located on current pserver are in one set, then
+ # append it into the sub program.
+ global_ops = []
+ # sparse grad name to param name
+ sparse_grad_to_param = []
+
+ def _is_opt_op_on_pserver(endpoint, op):
+ param_names = [
+ p.name for p in config.param_grad_ep_mapping[endpoint]["params"]
+ ]
+
+ unmerged_varnames = []
+ merged_varnames = []
+ merged_ordernames = []
+
+ for name in param_names:
+ orig_varname = _orig_varname(name)
+
+ for pairs in config.merged_variables_pairs:
+ merged_p = pairs[0]
+ if merged_p.merged_var.name == orig_varname:
+ if merged_p.merged_var.name == merged_p.ordered_vars[
+ 0].name:
+ unmerged_varnames.append(merged_p.ordered_vars[0].name)
+ else:
+ merged_varnames.append(merged_p.merged_var.name)
+ merged_ordernames.append(merged_p.ordered_vars[0].name)
+ break
+
+ param = op.input("Param")[0]
+
+ if param in unmerged_varnames:
+ return True
+
+ for i in range(len(merged_ordernames)):
+ if param == merged_ordernames[i]:
+ merged_p = merged_varnames[i]
+ merged_g = "{}@GRAD".format(merged_varnames[i])
+ op._set_attr(OP_ROLE_VAR_ATTR_NAME, [merged_p, merged_g])
+ return True
+ return False
+
+ def __append_optimize_op__(op, block, grad_to_block_id, merged_var, lr_ops):
+ if _is_optimizer_op(op):
+ _append_pserver_ops(block, op, ps_endpoint, grad_to_block_id,
+ origin_program, merged_var,
+ sparse_grad_to_param, config)
+ elif op not in lr_ops:
+ _append_pserver_non_opt_ops(block, op, origin_program, config)
+
+ optimize_ops = _get_optimize_ops(origin_program)
+ for _, op in enumerate(optimize_ops):
+ if _is_optimizer_op(op) and _is_opt_op_on_pserver(ps_endpoint, op):
+ opt_op_on_pserver.append(op)
+
+ # append lr decay ops to the child block if exists
+ lr_ops = _get_lr_ops(origin_program)
+ has_lr_decay = True if len(lr_ops) > 0 else False
+ lr_decay_block_id = -1
+ optimize_blocks = []
+
+ if has_lr_decay > 0:
+ counter_increment_idx = -1
+ for idx, op in enumerate(lr_ops):
+ if op.type != 'increment':
+ continue
+ counter = op.input("X")[0]
+ if counter == LEARNING_RATE_DECAY_COUNTER:
+ counter_increment_idx = idx
+ break
+
+ if counter_increment_idx != -1:
+ lr_ops.pop(counter_increment_idx)
+
+ lr_decay_block = program._create_block(program.num_blocks - 1)
+ optimize_blocks.append(lr_decay_block)
+ for op in lr_ops:
+ cloned_op = _append_pserver_non_opt_ops(lr_decay_block, op,
+ origin_program, config)
+ # append sub blocks to pserver_program in lr_decay_op
+ # todo(tangwei12): __clone_lr_op_sub_block__
+ lr_decay_block_id = lr_decay_block.idx
+
+ # append op to the current block
+ grad_to_block_id = []
+ pre_block_idx = program.num_blocks - 1
+
+ for idx, opt_op in enumerate(opt_op_on_pserver):
+ per_opt_block = program._create_block(pre_block_idx)
+ optimize_blocks.append(per_opt_block)
+ optimize_target_param_name = opt_op.attr(OP_ROLE_VAR_ATTR_NAME)[0]
+ # append grad merging ops before clip and weight decay
+ # e.g.merge grad->L2Decay op->clip op->optimize
+ merged_var = None
+ for _, op in enumerate(optimize_ops):
+ # find the origin grad var before clipping / L2Decay,
+ # merged_var should be the input var name of L2Decay
+ grad_varname_for_block = op.attr(OP_ROLE_VAR_ATTR_NAME)[1]
+ if op.attr(OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name:
+ merged_var = _append_pserver_grad_merge_ops(
+ per_opt_block, grad_varname_for_block, ps_endpoint,
+ grad_to_block_id)
+ if merged_var:
+ break # append optimize op once then append other ops.
+
+ if merged_var:
+ for _, op in enumerate(optimize_ops):
+ # optimizer is connected to itself
+ if op.attr(OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name and \
+ op not in global_ops:
+ __append_optimize_op__(op, per_opt_block, grad_to_block_id,
+ merged_var, lr_ops)
+
+ # dedup grad to ids list
+ grad_to_block_id = list(set(grad_to_block_id))
+ # append global ops
+ if global_ops:
+ opt_state_block = program._create_block(program.num_blocks - 1)
+ optimize_blocks.append(opt_state_block)
+ for glb_op in global_ops:
+ __append_optimize_op__(glb_op, opt_state_block, grad_to_block_id,
+ None, lr_ops)
+
+ if len(optimize_blocks) == 0:
+ pre_block_idx = program.num_blocks - 1
+ empty_block = program._create_block(pre_block_idx)
+ optimize_blocks.append(empty_block)
+
+ op = get_op_by_type(program.global_block(), "listen_and_serv")
+ op._set_attr("optimize_blocks", optimize_blocks)
+ op._set_attr("grad_to_block_id", grad_to_block_id)
+ op._set_attr("sparse_grad_to_param", sparse_grad_to_param)
+ op._set_attr("lr_decay_block_id", lr_decay_block_id)
+ return program
+
+
+def large_scale_sparse_pass(program, main_program, config, is_startup=False):
+ opt_value_map = {}
+ opt_value_map["sgd"] = ["Param"]
+ opt_value_map["adam"] = ["Param", "Moment1", "Moment2"]
+ opt_value_map["adagrad"] = ["Param", "Moment"]
+ opt_value_map["adamax"] = ["Param", "Moment", "InfNorm"]
+ opt_value_map["momentum"] = ["Param", "Velocity"]
+ opt_value_map["lars_momentum"] = ["Param", "Velocity"]
+ opt_value_map["rmsprop"] = ["Param", "Moment", "MeanSquare"]
+ opt_value_map["decayed_adagrad"] = ["Param", "Moment"]
+ opt_value_map["ftrl"] = ["Param", "SquaredAccumulator", "LinearAccumulator"]
+
+ geo_value_map = {}
+ geo_value_map["sum"] = "Param"
+
+ opt_init_map = {}
+ opt_init_map["gaussian_random"] = ["seed", "mean", "std"]
+ opt_init_map["fill_constant"] = ["value"]
+ opt_init_map["uniform_random"] = ["seed", "min", "max"]
+ opt_init_map["truncated_gaussian_random"] = ["seed", "mean", "std"]
+
+ def get_entry_attr(param_name):
+ origin_name = _orig_varname(param_name)
+ o_main_program = config.get_origin_main_program()
+ for op in o_main_program.global_block().ops:
+ if is_distributed_sparse_op(op) and get_sparse_tablename(
+ op) == origin_name:
+ entry = op.attr("entry")
+ return entry
+
+ def get_initializer_attrs(acture_value_names):
+ l_sep = ","
+ l_in = "&"
+ init_attrs = []
+ o_startup_program = config.get_origin_startup_program()
+
+ for value_name in acture_value_names:
+ origin_var_name = _orig_varname(value_name)
+ for op in o_startup_program.global_block().ops:
+ if op.type in opt_init_map.keys(
+ ) and origin_var_name == op.output("Out")[0]:
+ init_attr = [op.type]
+ for attr in opt_init_map[op.type]:
+ init_attr.append(str(op.attr(attr)))
+ init_attrs.append(l_in.join(init_attr))
+ break
+
+ return l_sep.join(init_attrs)
+
+ def get_optimizer_values(block):
+ value_names = []
+ acture_names = []
+ value_dims = []
+ grad = None
+ opt_idx = -1
+ fuse = False
+
+ for op in block.ops:
+ opt_idx += 1
+
+ if op.type not in opt_value_map.keys():
+ continue
+
+ if op.type in ["sgd", "adam"]:
+ fuse = True
+
+ grad = main_program.global_block().vars[op.input("Grad")[0]]
+
+ for value in opt_value_map[op.type]:
+ var = main_program.global_block().vars[op.input(value)[0]]
+ if len(var.shape) != 2:
+ raise ValueError("sparse param's dimension must be 2")
+
+ value_names.append(value)
+ value_dims.append(var.shape[1])
+ acture_names.append(var.name)
+
+ if value_names:
+ break
+ return grad, opt_idx, value_names, value_dims, acture_names, fuse
+
+ def add_fuse_large_scale_op(block, global_block, table_name, value_names,
+ acture_names, grad, is_entry, opt_idx):
+
+ op = block.ops[opt_idx]
+
+ if op.type == "sgd":
+ grad = main_program.global_block().vars[op.input("Grad")[0]]
+ lr = main_program.global_block().vars[op.input("LearningRate")[0]]
+
+ block._insert_op(opt_idx,
+ type="lookup_sparse_table_fuse_sgd",
+ inputs={
+ "Grad": grad,
+ "LearningRate": lr
+ },
+ attrs={
+ "is_entry": is_entry,
+ "tablename": table_name,
+ "value_names": value_names
+ })
+
+ elif op.type == "adam":
+ grad = main_program.global_block().vars[op.input("Grad")[0]]
+ lr = main_program.global_block().vars[op.input("LearningRate")[0]]
+ beta1_pow = main_program.global_block().vars[op.input("Beta1Pow")
+ [0]]
+ beta2_pow = main_program.global_block().vars[op.input("Beta2Pow")
+ [0]]
+ beta1_pow_o = main_program.global_block().vars[op.output(
+ "Beta1PowOut")[0]]
+ beta2_pow_o = main_program.global_block().vars[op.output(
+ "Beta2PowOut")[0]]
+
+ beta1 = op.attr('beta1')
+ beta2 = op.attr('beta2')
+ epsilon = op.attr('epsilon')
+
+ block._insert_op(opt_idx,
+ type="lookup_sparse_table_fuse_adam",
+ inputs={
+ "Grad": grad,
+ "LearningRate": lr,
+ "Beta1Pow": beta1_pow,
+ "Beta2Pow": beta2_pow
+ },
+ outputs={
+ "Beta1PowOut": beta1_pow_o,
+ "Beta2PowOut": beta2_pow_o
+ },
+ attrs={
+ "beta1": beta1,
+ "beta2": beta2,
+ "epsilon": epsilon,
+ "is_entry": is_entry,
+ "tablename": table_name,
+ "value_names": value_names
+ })
+ else:
+ raise ValueError("only support sgd/adam optimizer now")
+
+ def add_large_scale_op(block, global_block, table_name, value_names,
+ acture_names, grad, is_entry, opt_idx):
+ ids = global_block.create_var(name="kSparseIDs@{}".format(table_name),
+ persistable=False,
+ dtype="int64",
+ shape=[1, 1],
+ lod_level=0)
+
+ # insert grad split to ids and tensor op
+ block._insert_op(opt_idx,
+ type="lookup_sparse_table_grad_split",
+ inputs={"Grad": grad},
+ outputs={
+ "Row": ids,
+ "Value": grad
+ },
+ attrs={
+ "tablename": table_name,
+ "is_entry": is_entry
+ })
+
+ # insert read at first
+ vars = [global_block.vars[acture_name] for acture_name in acture_names]
+ block._insert_op(opt_idx + 1,
+ type="lookup_sparse_table_read",
+ inputs={"Ids": ids},
+ outputs={"Out": vars},
+ attrs={
+ "tablename": table_name,
+ "value_names": value_names
+ })
+
+ # append write at last
+ inputs = {"Ids": ids, "In": vars}
+
+ block.append_op(type="lookup_sparse_table_write",
+ inputs=inputs,
+ outputs={},
+ attrs={
+ "tablename": table_name,
+ "value_names": value_names
+ })
+
+ op = get_op_by_type(main_program.global_block(), "listen_and_serv")
+
+ param_blockid_map = {}
+ grad_blockid_map = {}
+ grad_to_params = op.attr('sparse_grad_to_param')
+ grad_to_block_ids = op.attr('grad_to_block_id')
+
+ origin_program = config.get_origin_main_program()
+ sparse_varnames = get_sparse_tablenames(origin_program, False)
+
+ for grad_to_block_id in grad_to_block_ids:
+ grad, blockid = grad_to_block_id.split(":")
+ grad_blockid_map[grad] = int(blockid)
+
+ for grad_to_param in grad_to_params:
+ grad, param = grad_to_param.split(":")
+
+ if _orig_varname(param) in sparse_varnames:
+ continue
+
+ param_blockid_map[param] = grad_blockid_map[grad]
+
+ if not is_startup:
+ for param, blockid in param_blockid_map.items():
+ opt_block = program.block(blockid)
+
+ grad, opt_idx, value_names, value_dims, acture_names, fuse = \
+ get_optimizer_values(opt_block)
+
+ entry_attr = get_entry_attr(param)
+ is_entry = False if entry_attr == "none" else True
+
+ if fuse:
+ add_fuse_large_scale_op(opt_block, program.global_block(),
+ param, value_names, acture_names, grad,
+ is_entry, opt_idx)
+ else:
+ add_large_scale_op(opt_block, program.global_block(), param,
+ value_names, acture_names, grad, is_entry,
+ opt_idx)
+ else:
+ large_scale_kv_metas = []
+ for param, blockid in param_blockid_map.items():
+ opt_block = main_program.block(blockid)
+
+ grad, opt_idx, value_names, value_dims, acture_names, fuse = \
+ get_optimizer_values(opt_block)
+
+ entry_attr = get_entry_attr(param)
+
+ if fuse:
+ # remove origin optimzier op
+ opt_block._remove_op(opt_idx)
+
+ # training/infer
+ mode = "0"
+ names_str = ",".join(value_names)
+ dims_str = ",".join([str(dim) for dim in value_dims])
+ ids_name = "kSparseIDs@{}".format(param)
+ cached_str = ",".join(acture_names + [ids_name])
+ init_attr_str = get_initializer_attrs(acture_names)
+
+ meta_str = ":".join([
+ param, names_str, dims_str, mode, grad.name, cached_str,
+ init_attr_str, entry_attr
+ ])
+ print("large_scale_metas: {}".format(meta_str))
+ large_scale_kv_metas.append(meta_str)
+
+ program.global_block().append_op(
+ type="lookup_sparse_table_init",
+ inputs=None,
+ outputs=None,
+ attrs={"large_scale_metas": large_scale_kv_metas})
+
+ # todo: need delete unused var.
+ return program
+
+
+def get_distributed_from_listen_and_serv(program, origin_program):
+ op = get_op_by_type(program.global_block(), "listen_and_serv")
+ sparse_varnames = get_sparse_tablenames(origin_program, True)
+ sparse_params = []
+ grad_to_params = op.attr('sparse_grad_to_param')
+ for grad_to_param in grad_to_params:
+ _, param = grad_to_param.split(":")
+ if _orig_varname(param) in sparse_varnames:
+ sparse_params.append(param)
+ return sparse_params
+
+
+def delete_unused_in_main_pass(program, config):
+ origin_program = config.get_origin_main_program()
+ sparse_params = get_distributed_from_listen_and_serv(
+ program, origin_program)
+
+ for var in sparse_params:
+ if program.global_block().has_var(var):
+ program.global_block()._remove_var(var)
+ return program
+
+
+def delete_unused_in_startup_pass(program, main_program, config):
+ origin_program = config.get_origin_main_program()
+ sparse_params = get_distributed_from_listen_and_serv(
+ main_program, origin_program)
+ remove_ops = []
+
+ for op in program.global_block().ops:
+ if op.type in ["recv", "fetch_barrier", "concat"]:
+ continue
+
+ for key in op.output_names:
+ if op.output(key)[0] in sparse_params:
+ remove_ops.append(op)
+
+ all_ops = program.global_block().ops
+ op_idxs = [all_ops.index(op) for op in remove_ops]
+
+ for idx in op_idxs[::-1]:
+ program.global_block()._remove_op(idx)
+
+ for var in sparse_params:
+ if program.global_block().has_var(var):
+ program.global_block()._remove_var(var)
+
+ return program
+
+
+def build_pserver_startup_program_pass(program, p_main_program, config):
+ ps_endpoint = config.get_ps_endpoint()
+ o_startup_program = config.get_origin_startup_program()
+ program.random_seed = o_startup_program.random_seed
+ params = config.param_grad_ep_mapping[ps_endpoint]["params"]
+ merged_ordervars = []
+
+ for var in params:
+ name = var.name
+ orig_varname = _orig_varname(name)
+
+ for pairs in config.merged_variables_pairs:
+ merged_p = pairs[0]
+ if merged_p.merged_var.name == orig_varname:
+ if merged_p.merged_var.name != merged_p.ordered_vars[0].name:
+ merged_ordervars.append(merged_p.ordered_vars[0])
+ break
+
+ def _get_splited_name_and_shape(varname):
+ for splited_param in params:
+ pname = splited_param.name
+ if _same_or_split_var(pname, varname) and varname != pname:
+ return pname, splited_param.shape
+
+ for idx, ordered in enumerate(merged_ordervars):
+ if _same_or_split_var(varname, ordered.name):
+ return pname, splited_param.shape
+
+ return "", []
+
+ # 1. create vars in pserver program to startup program
+ pserver_vars = p_main_program.global_block().vars
+
+ created_var_map = collections.OrderedDict()
+ for _, var in six.iteritems(pserver_vars):
+ tmpvar = program.global_block()._clone_variable(var)
+ created_var_map[var.name] = tmpvar
+
+ # 2. rename op outputs
+ for op in o_startup_program.global_block().ops:
+ new_outputs = collections.OrderedDict()
+ # do not append startup op if var is not on this pserver
+ op_on_pserver = False
+ # TODO(gongwb) : remove this line.
+ if op.type not in ["recv", "fetch_barrier", "concat"]:
+ for key in op.output_names:
+ newname, _ = _get_splited_name_and_shape(op.output(key)[0])
+ if newname:
+ op_on_pserver = True
+ new_outputs[key] = created_var_map[newname]
+ elif op.output(key)[0] in pserver_vars:
+ op_on_pserver = True
+ new_outputs[key] = pserver_vars[op.output(key)[0]]
+
+ if op_on_pserver:
+ # most startup program ops have no inputs
+ new_inputs = _get_input_map_from_op(pserver_vars, op)
+
+ if op.type in [
+ "gaussian_random", "fill_constant", "uniform_random",
+ "truncated_gaussian_random"
+ ]:
+ op._set_attr("shape", list(new_outputs["Out"].shape))
+
+ program.global_block().append_op(type=op.type,
+ inputs=new_inputs,
+ outputs=new_outputs,
+ attrs=op.all_attrs())
+
+ return program
+
+
+def add_geo_optimizer_pass(program, config):
+ endpoint = config.get_ps_endpoint()
+ params = [p for p in config.param_grad_ep_mapping[endpoint]["params"]]
+
+ sparse_tablenames = get_sparse_tablenames(config.get_origin_main_program(),
+ False)
+
+ for param in params:
+ _clone_var(program.global_block(), param)
+
+ optimize_block = []
+ sparse_grad_to_param = []
+ param_to_block_id = []
+ pre_block_idx = program.num_blocks - 1
+
+ for param in params:
+ per_opt_block = program._create_block(pre_block_idx)
+ optimize_block.append(per_opt_block)
+ var_name = param.name
+ pserver_block = per_opt_block.program.global_block()
+ param = pserver_block.vars[var_name]
+
+ delta_var_name = "%s.delta" % (param.name)
+ origin_varname = _orig_varname(param.name)
+
+ if origin_varname in sparse_tablenames:
+ sparse_grad_to_param.append(":".join([delta_var_name, param.name]))
+
+ delta_var = pserver_block.create_var(name=delta_var_name,
+ persistable=False,
+ type=param.type,
+ dtype=param.dtype,
+ shape=param.shape)
+
+ per_opt_block.append_op(type="sum",
+ inputs={"X": [param, delta_var]},
+ outputs={"Out": param})
+
+ param_to_block_id.append(delta_var_name + ":" + str(per_opt_block.idx))
+
+ op = get_op_by_type(program.global_block(), "listen_and_serv")
+ op._set_attr("optimize_blocks", optimize_block)
+ op._set_attr("grad_to_block_id", param_to_block_id)
+ op._set_attr("sparse_grad_to_param", sparse_grad_to_param)
+
+ return program
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/public.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/public.py
new file mode 100644
index 0000000000000000000000000000000000000000..5567fe309ec5e1e8afbed0d4edabae9b2bdd4430
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/public.py
@@ -0,0 +1,1291 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+from functools import reduce
+
+import collections
+import math
+import os
+import warnings
+import logging
+import six
+import paddle.fluid as fluid
+from paddle.fluid import core
+from paddle.fluid.core import CommContext
+import paddle.fluid.framework as framework
+from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode
+from paddle.fluid.incubate.fleet.parameter_server.ir import vars_metatools
+from paddle.fluid.incubate.fleet.parameter_server.ir.ps_dispatcher import RoundRobin, PSDispatcher
+from paddle.fluid.transpiler.details.program_utils import delete_ops
+
+OP_NAME_SCOPE = "op_namescope"
+CLIP_OP_NAME_SCOPE = "gradient_clip"
+STEP_COUNTER = "@PS_STEP_COUNTER@"
+LEARNING_RATE_DECAY_COUNTER = "@LR_DECAY_COUNTER@"
+
+OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName()
+RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName()
+RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC
+op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched
+OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize
+
+SPARSE_OP_LIST = ["lookup_table", "lookup_table_v2"]
+SPARSE_OP_TYPE_DICT = {"lookup_table": "W", "lookup_table_v2": "W"}
+
+
+def _get_lr_ops(program):
+ lr_ops = []
+ for index, op in enumerate(program.global_block().ops):
+ role_id = int(op.attr(RPC_OP_ROLE_ATTR_NAME))
+ if role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) or \
+ role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) | \
+ int(OPT_OP_ROLE_ATTR_VALUE):
+ lr_ops.append(op)
+ return lr_ops
+
+
+def _has_global_step(lr_ops):
+ if len(lr_ops) > 0:
+ for idx, op in enumerate(lr_ops):
+ if op.type != 'increment':
+ continue
+ counter = op.input("X")[0]
+ if counter == LEARNING_RATE_DECAY_COUNTER:
+ return True
+ return False
+
+
+def is_sparse_op(op):
+ if op.type in SPARSE_OP_LIST and op.attr('is_sparse') is True and op.attr(
+ 'is_distributed') is False:
+ return True
+
+ if op.type == "distributed_lookup_table" and op.attr(
+ 'is_distributed') is False:
+ return True
+
+ return False
+
+
+def is_distributed_sparse_op(op):
+ if op.type in SPARSE_OP_LIST and op.attr('is_distributed') is True:
+ return True
+
+ if op.type == "distributed_lookup_table" and op.attr(
+ 'is_distributed') is True:
+ return True
+
+ return False
+
+
+def get_sparse_tablename(op):
+ return op.input("W")[0]
+
+
+def get_sparse_tablenames(program, is_distributed):
+ tablenames = set()
+ if is_distributed:
+ for op in program.global_block().ops:
+ if is_distributed_sparse_op(op):
+ tablenames.add(get_sparse_tablename(op))
+ else:
+ for op in program.global_block().ops:
+ if is_sparse_op(op):
+ tablenames.add(get_sparse_tablename(op))
+ return list(tablenames)
+
+
+class MergedVariable:
+
+ def __init__(self, merged, ordered, offsets):
+ self.merged_var = merged
+ self.ordered_vars = ordered
+ self.offsets = offsets
+
+
+def Singleton(cls):
+ _instance = {}
+
+ def _singleton(*args, **kargs):
+ if cls not in _instance:
+ _instance[cls] = cls(*args, **kargs)
+ return _instance[cls]
+
+ return _singleton
+
+
+@Singleton
+class CompileTimeStrategy(object):
+
+ def __init__(self, main_program, startup_program, strategy, role_maker):
+ self.min_block_size = 81920
+
+ self.origin_main_program = main_program
+ self.origin_startup_program = startup_program
+ self.origin_ps_main_program = main_program
+ self.origin_ps_startup_program = startup_program
+
+ self.strategy = strategy
+ self.role_maker = role_maker
+ self.use_ps_gpu = False
+ try:
+ self.is_heter_ps_mode = role_maker._is_heter_parameter_server_mode
+ except:
+ warnings.warn(
+ "Using paddle.distributed.fleet instead of paddle.fluid.incubate.fleet"
+ )
+ self.is_heter_ps_mode = False
+
+ self.origin_sparse_pairs = []
+ self.origin_dense_pairs = []
+
+ self.merged_variables_pairs = []
+ self.merged_dense_pairs = []
+ self.merged_sparse_pairs = []
+
+ self.merged_variable_map = {}
+ self.param_name_to_grad_name = {}
+ self.grad_name_to_param_name = {}
+
+ self.param_grad_ep_mapping = collections.OrderedDict()
+ self.grad_param_mapping = collections.OrderedDict()
+
+ self._build_var_distributed()
+
+ self.tensor_table_dict = {}
+
+ # for heter-ps save variables
+ self.origin_merged_variables_pairs = list(self.merged_variables_pairs)
+ self.origin_merged_dense_pairs = list(self.merged_dense_pairs)
+ self.origin_merged_sparse_pairs = list(self.merged_sparse_pairs)
+
+ def get_distributed_mode(self):
+ trainer = self.strategy.get_trainer_runtime_config()
+ return trainer.mode
+
+ def is_sync_mode(self):
+ trainer = self.strategy.get_trainer_runtime_config()
+ return trainer.mode == DistributedMode.SYNC
+
+ def is_geo_mode(self):
+ trainer = self.strategy.get_trainer_runtime_config()
+ return trainer.mode == DistributedMode.GEO
+
+ def is_async_mode(self):
+ trainer = self.strategy.get_trainer_runtime_config()
+ return trainer.mode == DistributedMode.ASYNC
+
+ def get_role_id(self):
+ try:
+ return self.role_maker._role_id()
+ except Exception:
+ return self.role_maker.role_id()
+
+ def get_trainers(self):
+ try:
+ return self.role_maker._worker_num()
+ except Exception:
+ return self.role_maker.worker_num()
+
+ def get_ps_endpoint(self):
+ try:
+ return self.role_maker._get_pserver_endpoints()[self.get_role_id()]
+ except Exception:
+ return self.role_maker.get_pserver_endpoints()[self.get_role_id()]
+
+ def get_ps_endpoints(self):
+ try:
+ return self.role_maker._get_pserver_endpoints()
+ except Exception:
+ return self.role_maker.get_pserver_endpoints()
+
+ def get_heter_worker_endpoints(self):
+ try:
+ return self.role_maker._get_heter_worker_endpoints()
+ except Exception:
+ return self.role_maker.get_heter_worker_endpoints()
+
+ def get_next_stage_trainers(self):
+ try:
+ return self.role_maker._get_next_trainers()
+ except Exception:
+ return self.role_maker.get_next_trainers()
+
+ def get_heter_worker_endpoint(self):
+ try:
+ return self.role_maker._get_heter_worker_endpoint()
+ except Exception:
+ return self.role_maker.get_heter_worker_endpoint()
+
+ def get_trainer_endpoints(self):
+ try:
+ return self.role_maker._get_trainer_endpoints()
+ except Exception:
+ return self.role_maker.get_trainer_endpoints()
+
+ def get_trainer_endpoint(self):
+ try:
+ return self.role_maker._get_trainer_endpoint()
+ except Exception:
+ return self.role_maker.get_trainer_endpoint()
+
+ def get_previous_stage_trainers(self):
+ try:
+ return self.role_maker._get_previous_trainers()
+ except Exception:
+ return self.role_maker.get_previous_trainers()
+
+ def get_origin_programs(self):
+ return self.origin_main_program, self.origin_startup_program
+
+ def get_origin_main_program(self):
+ return self.origin_main_program
+
+ def get_origin_startup_program(self):
+ return self.origin_startup_program
+
+ def set_origin_ps_main_program(self, program):
+ self.origin_ps_main_program = program
+
+ def set_origin_ps_startup_program(self, program):
+ self.origin_ps_startup_program = program
+
+ def get_origin_ps_main_program(self):
+ return self.origin_ps_main_program
+
+ def get_origin_ps_startup_program(self):
+ return self.origin_ps_startup_program
+
+ def add_tensor_table(self,
+ feed_var_name,
+ fetch_var_name="",
+ startup_program=None,
+ main_program=None,
+ tensor_table_class=""):
+ self.tensor_table_dict[feed_var_name] = {}
+ self.tensor_table_dict[feed_var_name]["feed_var_name"] = feed_var_name
+ self.tensor_table_dict[feed_var_name]["fetch_var_name"] = fetch_var_name
+ self.tensor_table_dict[feed_var_name][
+ "startup_program"] = startup_program
+ self.tensor_table_dict[feed_var_name]["main_program"] = main_program
+ self.tensor_table_dict[feed_var_name][
+ "tensor_table_class"] = tensor_table_class
+
+ def get_tensor_table_dict(self):
+ return self.tensor_table_dict
+
+ def get_sparse_varname_on_ps(self, is_distributed, endpoint=None):
+ if not endpoint:
+ endpoint = self.get_ps_endpoint()
+ varnames = get_sparse_tablenames(self.get_origin_main_program(),
+ is_distributed)
+
+ ps_sparse_varnames = []
+ for varname in varnames:
+ tables = self.get_var_distributed(varname, True)
+ for i in range(len(tables)):
+ table, ep, _ = tables[i]
+ if ep == endpoint:
+ ps_sparse_varnames.append(table)
+ return ps_sparse_varnames
+
+ def get_optimize_varname_on_ps(self, param_name):
+ origin_param_name, _, _ = _get_varname_parts(param_name)
+ optimize_var_names = []
+ for op in self.get_origin_main_program().global_block().ops:
+ # check all optimizer op
+ if int(op.all_attrs()["op_role"]) == 2:
+ # check param name
+ if op.input("Param")[0] != origin_param_name:
+ continue
+ # check all input
+ for key in op.input_names:
+ if key in [
+ "Param", "Grad", "LearningRate", "Beta1Tensor",
+ "Beta2Tensor"
+ ]:
+ continue
+ # check varibale shape related param, e.g: Moment1
+ optimize_var_names += self._get_optimizer_param_related_var_name(
+ op, op.type, key)
+ return optimize_var_names
+
+ def _get_optimizer_param_related_var_name(self, op, op_type, varkey):
+ """
+ Returns the names for optimizer inputs that need to be load
+ """
+ related_var_names = []
+ if op_type == "adam":
+ if varkey in ["Moment1", "Moment2"]:
+ related_var_names.append(op.input(varkey)[0])
+ elif op_type == "adagrad":
+ if varkey == "Moment":
+ related_var_names.append(op.input(varkey)[0])
+ elif op_type in ["momentum", "lars_momentum"]:
+ if varkey == "Velocity":
+ related_var_names.append(op.input(varkey)[0])
+ elif op_type == "rmsprop":
+ if varkey in ["Moment", "MeanSquare"]:
+ related_var_names.append(op.input(varkey)[0])
+ elif op_type == "ftrl":
+ if varkey in ["SquaredAccumulator", "LinearAccumulator"]:
+ related_var_names.append(op.input(varkey)[0])
+ elif op_type == "sgd":
+ pass
+ else:
+ raise ValueError(
+ "Not supported optimizer for distributed training: %s" %
+ op_type)
+ return related_var_names
+
+ def build_ctx(self,
+ vars,
+ mapping,
+ is_grad,
+ is_sparse,
+ is_send,
+ is_distributed=False):
+
+ def get_grad_var_ep(slices):
+ names = []
+ eps = []
+ sections = []
+
+ for slice in slices:
+ if self.is_geo_mode():
+ if is_send:
+ names.append("{}.delta".format(slice.name))
+ else:
+ names.append(slice.name)
+ elif is_grad and self.is_sync_mode(
+ ) and self.get_trainers() > 1:
+ names.append("{}.trainer_{}".format(slice.name,
+ self.get_role_id()))
+ else:
+ names.append(slice.name)
+
+ sections.append(slice.shape[0])
+
+ for ep, pairs in self.param_grad_ep_mapping.items():
+ params, grads = pairs["params"], pairs["grads"]
+
+ for var in params + grads:
+ if slice.name == var.name:
+ eps.append(ep)
+ break
+ return names, eps, sections
+
+ if isinstance(vars, MergedVariable):
+ name = vars.merged_var.name
+ slices = mapping[name]
+ names, eps, sections = get_grad_var_ep(slices)
+ origin_varnames = [var.name for var in vars.ordered_vars]
+ else:
+ name = vars.name
+ slices = mapping[name]
+ names, eps, sections = get_grad_var_ep(slices)
+ origin_varnames = [vars.name]
+
+ trainer_id = self.get_role_id()
+ aggregate = True
+ ctx = CommContext(name, names, eps, sections, origin_varnames,
+ trainer_id, aggregate, is_sparse, is_distributed, [])
+ return ctx
+
+ def get_trainer_send_context(self):
+ send_ctx = {}
+ distibuted_varnames = get_sparse_tablenames(self.origin_main_program,
+ True)
+ idx = 0
+
+ if not self.is_geo_mode():
+ for merged in self.merged_dense_pairs:
+ grad = merged[1]
+ ctx = self.build_ctx(grad, self.grad_var_mapping, True, False,
+ True)
+ send_ctx[ctx.var_name()] = ctx
+
+ for merged in self.merged_sparse_pairs:
+ param = merged[0]
+ grad = merged[1]
+
+ param_name = param.merged_var.name
+
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ ctx = self.build_ctx(grad, self.grad_var_mapping, True, True,
+ True, is_distributed)
+ send_ctx[ctx.var_name()] = ctx
+ idx += 1
+
+ if self.is_async_mode():
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+ else:
+ for pairs in self.origin_sparse_pairs:
+ param, grad = pairs
+ param_name = param.name
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ param_ctx = self.build_ctx(param, self.param_var_mapping, False,
+ True, True, is_distributed)
+ grad_ctx = self.build_ctx(grad, self.grad_var_mapping, True,
+ True, True, is_distributed)
+
+ ctx = CommContext(param_ctx.var_name(),
+ param_ctx.split_varnames(),
+ param_ctx.split_endpoints(),
+ param_ctx.sections(),
+ grad_ctx.origin_varnames(),
+ param_ctx.trainer_id(), param_ctx.aggregate(),
+ param_ctx.is_sparse(),
+ param_ctx.is_distributed(), [])
+
+ send_ctx[ctx.var_name()] = ctx
+ idx += 1
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+ return send_ctx
+
+ def get_communicator_send_context(self):
+ send_ctx = {}
+ distibuted_varnames = get_sparse_tablenames(self.origin_main_program,
+ True)
+ idx = 0
+
+ if self.is_geo_mode():
+ for pairs in self.merged_dense_pairs:
+ param = pairs[0]
+ ctx = self.build_ctx(param, self.param_var_mapping, False,
+ False, True)
+ send_ctx[ctx.var_name()] = ctx
+
+ for pairs in self.merged_sparse_pairs:
+ param = pairs[0]
+ param_name = param.merged_var.name
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ ctx = self.build_ctx(param, self.param_var_mapping, False, True,
+ True, is_distributed)
+ send_ctx[ctx.var_name()] = ctx
+ idx += 1
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+ else:
+ for merged in self.merged_dense_pairs:
+ grad = merged[1]
+ ctx = self.build_ctx(grad, self.grad_var_mapping, True, False,
+ True)
+ send_ctx[ctx.var_name()] = ctx
+
+ for merged in self.merged_sparse_pairs:
+ param, grad = merged
+ param_name = param.merged_var.name
+
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ ctx = self.build_ctx(grad, self.grad_var_mapping, True, True,
+ True, is_distributed)
+ send_ctx[ctx.var_name()] = ctx
+ idx += 1
+
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+ return send_ctx
+
+ def get_communicator_recv_context(self,
+ recv_type=1,
+ use_origin_program=False):
+ # recv_type
+ # 1 : DENSE 2. SPARSE 3. DISTRIBUTED 4. ALL
+ distibuted_varnames = get_sparse_tablenames(self.origin_main_program,
+ True)
+ sparse_varnames = []
+ for pairs in self.origin_sparse_pairs:
+ param, grad = pairs
+ sparse_varnames.append(param.name)
+
+ dense_recv_ctx = {}
+ sparse_recv_ctx = {}
+ distributed_recv_ctx = {}
+
+ variables_pairs = self.merged_variables_pairs if not use_origin_program else self.origin_merged_variables_pairs
+ for merged in variables_pairs:
+ params = merged[0]
+ if params.merged_var.name in sparse_varnames:
+ continue
+
+ ctx = self.build_ctx(params, self.param_var_mapping, False, False,
+ False, False)
+ dense_recv_ctx[ctx.var_name()] = ctx
+
+ for pairs in self.origin_sparse_pairs:
+ param, grad = pairs
+
+ if param.name in distibuted_varnames:
+ ctx = self.build_ctx(param, self.param_var_mapping, False, True,
+ False, True)
+ distributed_recv_ctx[ctx.var_name()] = ctx
+ else:
+ ctx = self.build_ctx(param, self.param_var_mapping, False, True,
+ False, False)
+ sparse_recv_ctx[ctx.var_name()] = ctx
+
+ if recv_type == 1:
+ return dense_recv_ctx
+ if recv_type == 2:
+ return sparse_recv_ctx
+ if recv_type == 3:
+ return distributed_recv_ctx
+ if recv_type == 4:
+ dense_recv_ctx.update(sparse_recv_ctx)
+ dense_recv_ctx.update(distributed_recv_ctx)
+ return dense_recv_ctx
+ assert ValueError(
+ "recv_type can only be 1/2/3/4, 1 : DENSE 2. SPARSE 3. DISTRIBUTED 4. ALL"
+ )
+
+ def get_the_one_trainer_send_context(self, split_dense_table):
+ if self.is_geo_mode():
+ send_ctx = {}
+ trainer_id = self.get_role_id()
+ idx = 0
+
+ distibuted_varnames = get_sparse_tablenames(
+ self.origin_main_program, True)
+ for merged in self.merged_sparse_pairs:
+ param, grad = merged
+ grad_name = grad.merged_var.name
+ param_name = param.merged_var.name
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ var = self.origin_main_program.global_block().vars[
+ grad.merged_var.name]
+ var_numel = reduce(lambda x, y: x * y, var.shape[1:])
+
+ sparse_ctx = CommContext(grad_name, [grad_name],
+ ["127.0.0.1:6071"], [var_numel],
+ [grad_name], trainer_id, True, True,
+ is_distributed, idx, False, False, -1,
+ [])
+ idx += 1
+ send_ctx[sparse_ctx.var_name()] = sparse_ctx
+
+ if len(send_ctx) == 0:
+ raise ValueError(
+ "GeoSGD require sparse parameters in your net.")
+
+ if len(self.tensor_table_dict) > 0 and self.role_maker._is_worker():
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+
+ return send_ctx
+ else:
+ return self.get_the_one_send_context(split_dense_table)
+
+ def get_dense_send_context(self,
+ send_ctx,
+ idx,
+ merged_dense_pairs,
+ trainer_id,
+ split_dense_table=False):
+ if len(merged_dense_pairs) < 1:
+ return idx
+ if not split_dense_table:
+ origin_varnames = []
+ var_numel = 0
+ for merged in merged_dense_pairs:
+ grad = merged[1]
+ origin_varnames.append(grad.merged_var.name)
+ var = self.origin_main_program.global_block().vars[
+ grad.merged_var.name]
+ var_numel += reduce(lambda x, y: x * y, var.shape)
+ grad_name = "Dense@Grad"
+ trainer_id = self.get_role_id()
+ aggregate = True
+ dense_ctx = CommContext(grad_name, [grad_name], ["127.0.0.1:6071"],
+ [var_numel], origin_varnames, trainer_id,
+ aggregate, False, False, idx, False, False,
+ -1, [])
+ send_ctx[grad_name] = dense_ctx
+ idx += 1
+ else:
+ for merged in merged_dense_pairs:
+ grad = merged[1]
+ origin_varname = grad.merged_var.name
+ var = self.origin_main_program.global_block(
+ ).vars[origin_varname]
+ var_numel = reduce(lambda x, y: x * y, var.shape)
+ grad_name = origin_varname
+ aggregate = True
+ dense_ctx = CommContext(grad_name, [grad_name],
+ ["127.0.0.1:6071"], [var_numel],
+ [origin_varname], trainer_id, aggregate,
+ False, False, idx, False, False, -1, [])
+ send_ctx[grad_name] = dense_ctx
+ idx += 1
+ return idx
+
+ def get_the_one_send_context(self,
+ split_dense_table=False,
+ use_origin_program=False,
+ ep_list=None):
+ if ep_list is None:
+ ep_list = ["127.0.0.1:6071"]
+ send_ctx = {}
+ trainer_id = self.get_role_id()
+ idx = 0
+
+ merged_dense_pairs = self.origin_merged_dense_pairs if use_origin_program else self.merged_dense_pairs
+ merged_sparse_pairs = self.origin_merged_sparse_pairs if use_origin_program else self.merged_sparse_pairs
+
+ idx += self.get_dense_send_context(send_ctx, idx, merged_dense_pairs,
+ trainer_id, split_dense_table)
+
+ distibuted_varnames = get_sparse_tablenames(self.origin_main_program,
+ True)
+ for merged in merged_sparse_pairs:
+ param, grad = merged
+ grad_name = grad.merged_var.name
+ param_name = param.merged_var.name
+ splited_varname = []
+
+ for i in range(len(ep_list)):
+ splited_varname.append("{}.block{}".format(param_name, i))
+
+ is_distributed = True if param_name in distibuted_varnames else False
+
+ var = self.origin_main_program.global_block().vars[
+ grad.merged_var.name]
+
+ shape = list(var.shape)
+ shape[0] = 0 if is_distributed else shape[0]
+
+ sparse_ctx = CommContext(grad_name, splited_varname, ep_list, shape,
+ [grad_name], trainer_id, True, True,
+ is_distributed, idx, False, False, -1, [])
+
+ idx += 1
+ send_ctx[sparse_ctx.var_name()] = sparse_ctx
+
+ if len(self.tensor_table_dict) > 0 and self.role_maker._is_worker():
+ name, ctx = self._step_ctx(idx)
+ send_ctx[name] = ctx
+
+ return send_ctx
+
+ def get_the_one_recv_context(self,
+ is_dense=True,
+ split_dense_table=False,
+ use_origin_program=False):
+ recv_id_maps = {}
+ if is_dense:
+ send_ctx = self.get_the_one_send_context(
+ split_dense_table=split_dense_table,
+ use_origin_program=use_origin_program)
+ for idx, (name, ctx) in enumerate(send_ctx.items()):
+ if ctx.is_sparse():
+ continue
+ if ctx.is_tensor_table():
+ continue
+
+ origin_grad_varnames = ctx.origin_varnames()
+
+ param_names = []
+ for grad_varname in origin_grad_varnames:
+ param_name = self.grad_name_to_param_name[grad_varname]
+ param_names.append(param_name)
+ recv_id_maps[ctx.table_id()] = param_names
+ else:
+ send_ctx = self.get_the_one_send_context()
+ for idx, (name, ctx) in enumerate(send_ctx.items()):
+ if not ctx.is_sparse():
+ continue
+
+ origin_grad_varnames = ctx.origin_varnames()
+
+ param_names = []
+ for grad_varname in origin_grad_varnames:
+ param_name = self.grad_name_to_param_name[grad_varname]
+ param_names.append(param_name)
+ recv_id_maps[ctx.table_id()] = param_names
+ return recv_id_maps
+
+ def get_server_runtime_config(self):
+ return self.strategy.get_server_runtime_config()
+
+ def get_var_distributed(self, varname, is_param):
+ var_distributed = []
+ offset = 0
+ if is_param:
+ params = self.param_var_mapping[varname]
+ param_varnames = [var.name for var in params]
+ for ep, pairs in self.param_grad_ep_mapping.items():
+ for p in pairs["params"]:
+ if p.name in param_varnames:
+ offset += p.shape[0]
+ var_distributed.append((p.name, ep, p.shape[0]))
+ else:
+ grads = self.grad_var_mapping[varname]
+ grad_varnames = [var.name for var in grads]
+ for ep, pairs in self.param_grad_ep_mapping.items():
+ for g in pairs["grads"]:
+ if g.name in grad_varnames:
+ var_distributed.append((g.name, ep, g.shape[0]))
+ return var_distributed
+
+ def _step_ctx(self, idx):
+ name = STEP_COUNTER
+ trainer_id = self.get_role_id()
+ endpoints = self.get_ps_endpoints()
+ sections = [1] * len(endpoints)
+ names = [name] * len(endpoints)
+ ctx = CommContext(name, names, endpoints, sections, [name], trainer_id,
+ True, False, False, idx, True, False, -1, [])
+ return name, ctx
+
+ def _create_vars_from_blocklist(self, block_list):
+ """
+ Create vars for each split.
+ NOTE: only grads need to be named for different trainers, use
+ add_trainer_suffix to rename the grad vars.
+ Args:
+ block_list (list[(varname, block_id, block_size)]): List of gradient blocks.
+ add_trainer_suffix (Bool): Add trainer suffix to new variable's name if set True.
+ Returns:
+ var_mapping (collections.OrderedDict(varname->[new_varname_variable])):A dict mapping
+ from original var name to each var split.
+ """
+
+ # varname->[(block_id, current_block_size)]
+ block_map = collections.OrderedDict()
+ var_mapping = collections.OrderedDict()
+
+ for block_str in block_list:
+ varname, offset, size = block_str.split(":")
+ if varname not in block_map:
+ block_map[varname] = []
+ block_map[varname].append((int(offset), int(size)))
+
+ for varname, split in six.iteritems(block_map):
+ orig_var = self.merged_variable_map[varname]
+
+ if len(split) == 1:
+ var_mapping[varname] = [orig_var]
+ self.var_distributed.add_distributed_var(origin_var=orig_var,
+ slice_var=orig_var,
+ block_id=0,
+ offset=0,
+ is_slice=False,
+ vtype="Param")
+ else:
+ var_mapping[varname] = []
+ orig_shape = orig_var.shape
+ orig_dim1_flatten = 1
+
+ if len(orig_shape) >= 2:
+ orig_dim1_flatten = reduce(lambda x, y: x * y,
+ orig_shape[1:])
+
+ for i, block in enumerate(split):
+ size = block[1]
+ rows = size // orig_dim1_flatten
+ splited_shape = [rows]
+ if len(orig_shape) >= 2:
+ splited_shape.extend(orig_shape[1:])
+
+ new_var_name = "%s.block%d" % (varname, i)
+ slice_var = vars_metatools.VarStruct(
+ name=new_var_name,
+ shape=splited_shape,
+ dtype=orig_var.dtype,
+ type=orig_var.type,
+ lod_level=orig_var.lod_level,
+ persistable=False)
+ var_mapping[varname].append(slice_var)
+
+ self.var_distributed.add_distributed_var(
+ origin_var=orig_var,
+ slice_var=slice_var,
+ block_id=i,
+ offset=-1,
+ is_slice=False,
+ vtype="Param")
+
+ return var_mapping
+
+ def _dispatcher(self):
+ ps_dispatcher = RoundRobin(self.get_ps_endpoints())
+ ps_dispatcher.reset()
+ grad_var_mapping_items = list(six.iteritems(self.grad_var_mapping))
+
+ sparse_gradnames = [grad.name for _, grad in self.origin_sparse_pairs]
+
+ for grad_varname, splited_vars in grad_var_mapping_items:
+ if grad_varname in sparse_gradnames:
+ continue
+
+ send_vars = []
+ for _, var in enumerate(splited_vars):
+ send_vars.append(var)
+
+ recv_vars = []
+ for _, var in enumerate(send_vars):
+ recv_vars.append(self.grad_param_mapping[var])
+
+ eps = ps_dispatcher.dispatch(recv_vars)
+
+ for i, ep in enumerate(eps):
+ self.param_grad_ep_mapping[ep]["params"].append(recv_vars[i])
+ self.param_grad_ep_mapping[ep]["grads"].append(send_vars[i])
+
+ for grad_varname, splited_vars in grad_var_mapping_items:
+ if grad_varname not in sparse_gradnames:
+ continue
+
+ ps_dispatcher.reset()
+
+ send_vars = []
+ for _, var in enumerate(splited_vars):
+ send_vars.append(var)
+
+ recv_vars = []
+ for _, var in enumerate(send_vars):
+ recv_vars.append(self.grad_param_mapping[var])
+
+ eps = ps_dispatcher.dispatch(recv_vars)
+
+ for i, ep in enumerate(eps):
+ self.param_grad_ep_mapping[ep]["params"].append(recv_vars[i])
+ self.param_grad_ep_mapping[ep]["grads"].append(send_vars[i])
+
+ def _slice_variable(self,
+ var_list,
+ slice_count,
+ min_block_size,
+ uniform=False):
+ """
+ We may need to split dense tensor to one or more blocks and put
+ them equally onto parameter server. One block is a sub-tensor
+ aligned by dim[0] of the tensor.
+
+ We need to have a minimal block size so that the calculations in
+ the parameter server side can gain better performance. By default
+ minimum block size 8K elements (maybe 16bit or 32bit or 64bit).
+
+ Args:
+ var_list (list): List of variables.
+ slice_count (int): Numel of count that variables will be sliced, which
+ could be the pserver services' count.
+ min_block_size (int): Minimum split block size.
+ Returns:
+ blocks (list[(varname, block_id, current_block_size)]): A list
+ of VarBlocks. Each VarBlock specifies a shard of the var.
+ """
+ blocks = []
+ for var in var_list:
+ if not uniform:
+ var_numel = reduce(lambda x, y: x * y, var.shape)
+
+ split_count = 1
+
+ if min_block_size == -1:
+ split_count = 1
+ else:
+ split_count = slice_count
+ max_pserver_count = int(
+ math.floor(var_numel / float(min_block_size)))
+ if max_pserver_count == 0:
+ max_pserver_count = 1
+ if max_pserver_count < slice_count:
+ split_count = max_pserver_count
+ block_size = int(math.ceil(var_numel / float(split_count)))
+
+ if len(var.shape) >= 2:
+ # align by dim1(width)
+ dim1 = reduce(lambda x, y: x * y, var.shape[1:])
+ remains = block_size % dim1
+ if remains != 0:
+ block_size += dim1 - remains
+ # update split_count after aligning
+ split_count = int(math.ceil(var_numel / float(block_size)))
+ for block_id in range(split_count):
+ curr_block_size = min(block_size,
+ var_numel - ((block_id) * block_size))
+ block = vars_metatools.VarBlock(var.name, block_id,
+ curr_block_size)
+ blocks.append(str(block))
+ else:
+ block_size = var.shape[0] / slice_count
+ remainder = var.shape[0] % slice_count
+
+ if block_size == 0:
+ dim0s = [block_size] * remainder
+ else:
+ dim0s = [block_size] * slice_count
+ for i in range(remainder):
+ dim0s[i] = dim0s[i] + 1
+
+ dim1 = reduce(lambda x, y: x * y, var.shape[1:])
+
+ for block_id in range(len(dim0s)):
+ numel = dim0s[block_id] * dim1
+ block = vars_metatools.VarBlock(var.name, block_id, numel)
+ blocks.append(str(block))
+ return blocks
+
+ def _get_param_grad_blocks(self, pairs, min_block_size, uniform=False):
+ param_list = []
+ grad_list = []
+ param_grad_set = set()
+ for p, g in pairs:
+ # todo(tangwei12) skip parameter marked not trainable
+ # if type(p) == Parameter and p.trainable == False:
+ # continue
+ p = p.merged_var
+ g = g.merged_var
+
+ if p.name not in param_grad_set:
+ param_list.append(p)
+ param_grad_set.add(p.name)
+ if g.name not in param_grad_set:
+ grad_list.append(g)
+ param_grad_set.add(g.name)
+
+ # when we slice var up into blocks, we will slice the var according to
+ # pserver services' count. A pserver may have two or more listening ports.
+ grad_blocks = self._slice_variable(grad_list,
+ len(self.get_ps_endpoints()),
+ min_block_size, uniform)
+
+ param_blocks = self._slice_variable(param_list,
+ len(self.get_ps_endpoints()),
+ min_block_size, uniform)
+ return param_blocks, grad_blocks
+
+ def _var_slice_and_distribute(self):
+ # update these mappings for further transpile:
+ # 1. param_var_mapping : param var name->[split params vars]
+ # 2. grad_var_mapping : grad var name->[split grads vars]
+ # 3. grad_param_mapping : grad.blockx->param.blockx
+ # 4. param_grad_ep_mapping : ep->{"params" : [], "grads" : [] }
+
+ dps, dgs = self._get_param_grad_blocks(self.merged_dense_pairs,
+ self.min_block_size, False)
+ sps, sgs = self._get_param_grad_blocks(self.merged_sparse_pairs,
+ self.min_block_size, True)
+
+ param_blocks = dps + sps
+ grad_blocks = dgs + sgs
+
+ assert (len(grad_blocks) == len(param_blocks))
+
+ # origin_param_name->[splited_param_vars]
+ self.param_var_mapping = self._create_vars_from_blocklist(param_blocks)
+ self.grad_var_mapping = self._create_vars_from_blocklist(grad_blocks)
+
+ # dict(grad_splited_var->param_splited_var)
+ self.grad_param_mapping = collections.OrderedDict()
+ for g, p in zip(grad_blocks, param_blocks):
+ g_name, g_bid, _ = g.split(":")
+ p_name, p_bid, _ = p.split(":")
+ self.grad_param_mapping[self.grad_var_mapping[g_name][int(g_bid)]] = \
+ self.param_var_mapping[p_name][int(p_bid)]
+
+ print_maps = {}
+ for k, v in self.grad_param_mapping.items():
+ print_maps[str(k)] = str(v)
+
+ # create mapping of endpoint->split var to create pserver side program
+ self.param_grad_ep_mapping = collections.OrderedDict()
+ [
+ self.param_grad_ep_mapping.update({ep: {
+ "params": [],
+ "grads": []
+ }}) for ep in self.get_ps_endpoints()
+ ]
+
+ def _build_var_distributed(self):
+ self.var_distributed = vars_metatools.VarsDistributed()
+
+ sparse_pairs, dense_pairs = self.get_param_grads()
+ origin_for_sparse = []
+ origin_for_dense = []
+ param_name_grad_name = dict()
+ grad_name_to_param_name = dict()
+
+ for param, grad in sparse_pairs:
+ param = vars_metatools.create_var_struct(param)
+ grad = vars_metatools.create_var_struct(grad)
+ origin_for_sparse.append((param, grad))
+
+ for param, grad in dense_pairs:
+ param = vars_metatools.create_var_struct(param)
+ grad = vars_metatools.create_var_struct(grad)
+ origin_for_dense.append((param, grad))
+
+ for dense_pair in origin_for_dense:
+ param, grad = dense_pair
+
+ m_param = MergedVariable(param, [param], [0])
+ m_grad = MergedVariable(grad, [grad], [0])
+ self.merged_variables_pairs.append((m_param, m_grad))
+ self.merged_dense_pairs.append((m_param, m_grad))
+
+ for sparse_pair in origin_for_sparse:
+ param, grad = sparse_pair
+
+ m_param = MergedVariable(param, [param], [0])
+ m_grad = MergedVariable(grad, [grad], [0])
+ self.merged_variables_pairs.append((m_param, m_grad))
+ self.merged_sparse_pairs.append((m_param, m_grad))
+
+ for merged in self.merged_variables_pairs:
+ m_param, m_grad = merged
+ self.merged_variable_map[
+ m_param.merged_var.name] = m_param.merged_var
+ self.merged_variable_map[m_grad.merged_var.name] = m_grad.merged_var
+
+ param_merges = []
+ param_merges.extend(origin_for_sparse)
+ param_merges.extend(origin_for_dense)
+
+ for param, grad in param_merges:
+ param_name_grad_name[param.name] = grad.name
+ grad_name_to_param_name[grad.name] = param.name
+
+ self.origin_sparse_pairs = origin_for_sparse
+ self.origin_dense_pairs = origin_for_dense
+ self.param_name_to_grad_name = param_name_grad_name
+ self.grad_name_to_param_name = grad_name_to_param_name
+
+ sparse_pair_map = collections.OrderedDict()
+
+ for pair in self.origin_sparse_pairs + self.origin_dense_pairs:
+ param, grad = pair
+ sparse_pair_map[param.name] = str(param)
+ sparse_pair_map[grad.name] = str(grad)
+
+ self._var_slice_and_distribute()
+ self._dispatcher()
+
+ def get_param_grads(self):
+ origin_program = self.origin_main_program
+
+ def _get_params_grads(sparse_varnames):
+ block = origin_program.global_block()
+
+ dense_param_grads = []
+ sparse_param_grads = []
+
+ optimize_params = set()
+ origin_var_dict = origin_program.global_block().vars
+ role_id = int(core.op_proto_and_checker_maker.OpRole.Backward)
+ for op in block.ops:
+ if _is_opt_role_op(op):
+ # delete clip op from opt_ops when run in Parameter Server mode
+ if OP_NAME_SCOPE in op.all_attrs() \
+ and CLIP_OP_NAME_SCOPE in op.attr(OP_NAME_SCOPE):
+ op._set_attr("op_role", role_id)
+ continue
+ if op.attr(OP_ROLE_VAR_ATTR_NAME):
+ param_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[0]
+ grad_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[1]
+ if param_name not in optimize_params:
+ optimize_params.add(param_name)
+ param_grad = (origin_var_dict[param_name],
+ origin_var_dict[grad_name])
+
+ if param_name in sparse_varnames:
+ sparse_param_grads.append(param_grad)
+ else:
+ dense_param_grads.append(param_grad)
+ return sparse_param_grads, dense_param_grads
+
+ def _get_sparse_varnames():
+ varnames = []
+ for op in origin_program.global_block().ops:
+ if op.type in SPARSE_OP_TYPE_DICT.keys() \
+ and op.attr('remote_prefetch') is True:
+ param_name = op.input(SPARSE_OP_TYPE_DICT[op.type])[0]
+ varnames.append(param_name)
+
+ return list(set(varnames))
+
+ sparse_varnames = _get_sparse_varnames()
+ sparse_param_grads, dense_param_grads = _get_params_grads(
+ sparse_varnames)
+
+ return sparse_param_grads, dense_param_grads
+
+ def remove_var_pair_by_grad(self, var_name):
+
+ for index, pair in enumerate(self.merged_variables_pairs):
+ var = pair[0]
+ var_grad = pair[1]
+ if var_grad.merged_var.name == var_name:
+ del self.merged_variables_pairs[index]
+
+ for index, pair in enumerate(self.merged_dense_pairs):
+ var = pair[0]
+ var_grad = pair[1]
+ if var_grad.merged_var.name == var_name:
+ del self.merged_dense_pairs[index]
+ return
+
+ for index, pair in enumerate(self.merged_sparse_pairs):
+ var = pair[0]
+ var_grad = pair[1]
+ if var_grad.merged_var.name == var_name:
+ del self.merged_sparse_pairs[index]
+ return
+
+ print("Not find {} in self.merge_pairs".format(var_name))
+
+
+def _is_opt_role_op(op):
+ # NOTE : depend on oprole to find out whether this op is for
+ # optimize
+ op_maker = core.op_proto_and_checker_maker
+ optimize_role = core.op_proto_and_checker_maker.OpRole.Optimize
+ if op_maker.kOpRoleAttrName() in op.attr_names and \
+ int(op.all_attrs()[op_maker.kOpRoleAttrName()]) == int(optimize_role):
+ return True
+ return False
+
+
+def _get_optimize_ops(_program):
+ block = _program.global_block()
+ opt_ops = []
+ for op in block.ops:
+ if _is_opt_role_op(op):
+ # delete clip op from opt_ops when run in Parameter Server mode
+ if OP_NAME_SCOPE in op.all_attrs() \
+ and CLIP_OP_NAME_SCOPE in op.attr(OP_NAME_SCOPE):
+ op._set_attr(
+ "op_role",
+ int(core.op_proto_and_checker_maker.OpRole.Backward))
+ continue
+ opt_ops.append(op)
+ return opt_ops
+
+
+def _add_lr_decay_table_pass(main_program, compiled_config, lr_decay_steps):
+ if hasattr(compiled_config.origin_main_program, 'lr_sheduler'):
+ from paddle.optimizer.lr import LRScheduler
+ assert isinstance(compiled_config.origin_main_program.lr_sheduler,
+ LRScheduler), "must be LRScheduler"
+ ops = _get_optimize_ops(compiled_config.origin_main_program)
+ lr_param_dict = _get_lr_param_dict(ops)
+ lr_decay_main_program, lr_decay_startup_program, lr_name = _get_lr_sheduler_program(
+ compiled_config.origin_main_program.lr_sheduler, lr_param_dict,
+ lr_decay_steps)
+ compiled_config.add_tensor_table("@LR_DECAY_COUNTER@", lr_name,
+ lr_decay_startup_program,
+ lr_decay_main_program,
+ "GlobalStepTable")
+
+
+def _get_lr_param_dict(opt_ops):
+ lr_param_dict = {}
+ for op in opt_ops:
+ lr_name = op.input("LearningRate")[0]
+ param_name = op.input("Param")[0]
+ if lr_name not in lr_param_dict:
+ lr_param_dict[lr_name] = []
+ lr_param_dict[lr_name].append(param_name)
+ return lr_param_dict
+
+
+def _get_lr_sheduler_program(lr_sheduler, lr_param_dict, lr_decay_steps):
+ schedler_decay = [
+ 'NoamDecay', 'NaturalExpDecay', 'InverseTimeDecay', 'ExponentialDecay'
+ ]
+
+ from paddle.optimizer.lr import ExponentialDecay, NoamDecay, PiecewiseDecay, NaturalExpDecay, InverseTimeDecay
+ from paddle.fluid.layers.learning_rate_scheduler import exponential_decay, noam_decay, piecewise_decay, natural_exp_decay, inverse_time_decay
+
+ decay_main_program = fluid.framework.Program()
+ decay_startup_program = fluid.framework.Program()
+ lr_name = ""
+
+ if isinstance(lr_sheduler, ExponentialDecay):
+ with fluid.program_guard(decay_main_program, decay_startup_program):
+ lr = exponential_decay(1.0, lr_decay_steps, lr_sheduler.gamma, True)
+ lr_name = lr.name
+ logging.warn(
+ "ExponentialDecay is set, staircase = True, global learning rate decay step is [ %d ], Change decay steps as follow: \n"
+ "\t strategy = paddle.distributed.fleet.DistributedStrategy() \n "
+ "\t strategy.a_sync = True \n"
+ "\t strategy.a_sync_configs= { 'lr_decay_steps' : YOUR_DECAY_STEP } \n"
+ % lr_decay_steps)
+ elif isinstance(lr_sheduler, NoamDecay):
+ with fluid.program_guard(decay_main_program, decay_startup_program):
+ lr = noam_decay(lr_sheduler.d_model, lr_sheduler.warmup_steps, 1.0)
+ lr_name = lr.name
+ logging.warn("NoamDecay is set, warmup steps is [ %d ]" %
+ lr_sheduler.warmup_steps)
+ elif isinstance(lr_sheduler, NaturalExpDecay):
+ with fluid.program_guard(decay_main_program, decay_startup_program):
+ lr = natural_exp_decay(1.0, lr_decay_steps, lr_sheduler.gamma, True)
+ lr_name = lr.name
+ logging.warn(
+ "NaturalExpDecay is set, staircase = True, global learning rate decay step is [ %d ], Change decay steps as follow: \n"
+ "\t strategy = paddle.distributed.fleet.DistributedStrategy() \n "
+ "\t strategy.a_sync = True \n"
+ "\t strategy.a_sync_configs= { 'lr_decay_steps' : YOUR_DECAY_STEP } \n"
+ % lr_decay_steps)
+ elif isinstance(lr_sheduler, InverseTimeDecay):
+ with fluid.program_guard(decay_main_program, decay_startup_program):
+ lr = inverse_time_decay(1.0, lr_decay_steps, lr_sheduler.gamma,
+ True)
+ lr_name = lr.name
+ logging.warn(
+ "InverseTimeDecay is set, staircase = True, global learning rate decay step is [ %d ], Change decay steps as follow: \n"
+ "\t strategy = paddle.distributed.fleet.DistributedStrategy() \n "
+ "\t strategy.a_sync = True \n"
+ "\t strategy.a_sync_configs= { 'lr_decay_steps' : YOUR_DECAY_STEP } \n"
+ % lr_decay_steps)
+ else:
+ raise ValueError(
+ "Not supported current LearningRate strategy, please use follow decay strategy: {}"
+ .format(schedler_decay))
+
+ return decay_main_program, decay_startup_program, lr_name
+
+
+def _get_varname_parts(varname):
+ # returns origin, blockid, trainerid
+ orig_var_name = ""
+ trainer_part = ""
+ block_part = ""
+ trainer_idx = varname.find(".trainer_")
+ if trainer_idx >= 0:
+ trainer_part = varname[trainer_idx + 1:]
+ else:
+ trainer_idx = len(varname)
+ block_index = varname.find(".block")
+ if block_index >= 0:
+ block_part = varname[block_index + 1:trainer_idx]
+ else:
+ block_index = len(varname)
+ orig_var_name = varname[0:min(block_index, trainer_idx)]
+ return orig_var_name, block_part, trainer_part
+
+
+def _orig_varname(varname):
+ orig, _, _ = _get_varname_parts(varname)
+ return orig
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py
new file mode 100644
index 0000000000000000000000000000000000000000..18755212cc16bc5537b77805c875ba54f9bde51e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/trainer_pass.py
@@ -0,0 +1,1995 @@
+# -*- coding: UTF-8 -*-
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import os
+import six
+import collections
+import warnings
+import math
+
+from functools import reduce
+import paddle.fluid as fluid
+import paddle.fluid.core as core
+import paddle.fluid.framework as framework
+import paddle.compat as cpt
+
+from paddle.fluid.transpiler.details.program_utils import delete_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_optimize_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import _get_lr_ops
+from paddle.fluid.incubate.fleet.parameter_server.ir.public import get_sparse_tablenames
+from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode
+
+OP_NAME_SCOPE = "op_namescope"
+CLIP_OP_NAME_SCOPE = "gradient_clip"
+STEP_COUNTER = "@PS_STEP_COUNTER@"
+OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName()
+RPC_OP_ROLE_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleAttrName()
+RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC
+LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched
+OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize
+op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+
+SPARSE_OP_TYPE_DICT = {"lookup_table": "W", "lookup_table_v2": "W"}
+SPARSE_GRAD_OP_TYPE_DICT = {
+ "lookup_table_grad": "W",
+ "lookup_table_v2_grad": "W"
+}
+DEVICE_LIST = ["cpu", "gpu", "xpu"]
+COMMUNICATE_OPS_TYPE = ["send", "recv", "fetch_barrier", "send_barrier"]
+DEFAULT_DEVICE = 'cpu'
+
+
+def delete_optimizer_pass(program, config):
+
+ def _delete_optimizer_op_and_vars(_program, optimize_ops):
+ optimize_vars = []
+ optimize_op_role_vars = []
+ optimize_need_delete_vars = []
+
+ for op in optimize_ops:
+ optimize_vars.extend(op.input_arg_names)
+ optimize_op_role_vars.extend(op.attr("op_role_var"))
+
+ optimize_vars = list(set(optimize_vars))
+ optimize_op_role_vars = list(set(optimize_op_role_vars))
+
+ for var in optimize_vars:
+ if var not in optimize_op_role_vars:
+ optimize_need_delete_vars.append(var)
+ need_delete_optimize_vars = list(set(optimize_need_delete_vars))
+
+ delete_ops(_program.global_block(), optimize_ops)
+ for var in need_delete_optimize_vars:
+ if _program.global_block().has_var(var):
+ _program.global_block()._remove_var(var)
+
+ def _add_lr_var(main_program, compiled_config):
+ # Todo: hard code for pe
+ lr_var = compiled_config.origin_main_program.global_block(
+ ).vars["learning_rate_0"]
+ main_program.global_block().create_var(name=lr_var.name,
+ shape=lr_var.shape,
+ dtype=lr_var.dtype,
+ type=lr_var.type,
+ lod_level=lr_var.lod_level,
+ persistable=True)
+
+ optimizer_ops = _get_optimize_ops(program)
+ lr_ops = _get_lr_ops(program)
+ optimizer_ops.extend(lr_ops)
+ _delete_optimizer_op_and_vars(program, optimizer_ops)
+
+ if hasattr(config.origin_main_program, 'lr_sheduler'):
+ _add_lr_var(program, config)
+
+ return program
+
+
+def distributed_ops_pass(program, config, use_ps_gpu=False):
+ trainer_id = config.get_role_id()
+ send_ctx = config.get_the_one_send_context(
+ split_dense_table=config.is_heter_ps_mode)
+ w_2_table_id = {}
+ emb_size = {}
+
+ def _get_pull_sparse_ops(_program):
+ pull_sparse_ops = {}
+ pull_sparse_ids = {}
+ push_sparse_ops = {}
+ ops = {}
+ for op in _program.global_block().ops:
+ if op.type in SPARSE_OP_TYPE_DICT.keys() \
+ and op.attr('remote_prefetch') is True:
+ param_name = op.input(SPARSE_OP_TYPE_DICT[op.type])[0]
+ if config.is_heter_ps_mode:
+ # trick for matchnet, need to modify
+ param_name += op.input("Ids")[0][0]
+ ops = pull_sparse_ops.get(param_name, [])
+ ops.append(op)
+ pull_sparse_ops[param_name] = ops
+ ids = pull_sparse_ids.get(param_name, [])
+ ids.append(op.input("Ids")[0])
+ pull_sparse_ids[param_name] = ids
+ for op in _program.global_block().ops:
+ if op.type in SPARSE_GRAD_OP_TYPE_DICT.keys():
+ param_name = op.input(SPARSE_GRAD_OP_TYPE_DICT[op.type])[0]
+ if param_name in pull_sparse_ids and op.input(
+ "Ids")[0] in pull_sparse_ids[param_name]:
+ ops = push_sparse_ops.get(param_name, [])
+ ops.append(op)
+ push_sparse_ops[param_name] = ops
+ return pull_sparse_ops, push_sparse_ops
+
+ def _pull_sparse_fuse(_program, pull_sparse_ops, use_ps_gpu):
+
+ def dag_check_up_and_reorder(program, inputs, outputs):
+ global_block = program.global_block()
+ min_output_index = len(global_block.ops)
+ max_input_index = -1
+ input_indexes = [0] * len(global_block.ops)
+ output_indexes = [0] * len(global_block.ops)
+ for idx, op in enumerate(global_block.ops):
+ for i in range(0, len(op.output_names)):
+ if input_indexes[idx] == 1:
+ break
+ outs = op.output(op.output_names[i])
+ for in_id, in_var in enumerate(inputs):
+ if in_var.name in outs:
+ input_indexes[idx] = 1
+ max_input_index = max(max_input_index, idx)
+ break
+
+ for i in range(0, len(op.input_names)):
+ if output_indexes[idx] == 1:
+ break
+ ins = op.input(op.input_names[i])
+ for out_id, out_var in enumerate(outputs):
+ if out_var.name in ins:
+ output_indexes[idx] = 1
+ min_output_index = min(min_output_index, idx)
+
+ for i in range(len(global_block.ops)):
+ if input_indexes[i] == 1 and output_indexes[i] == 1:
+ warnings.warn(
+ "unable to re-arrange dags order to combine distributed embedding ops because a op both needs embedding table's output as input and produces ids as the same embedding table's input"
+ )
+ return
+
+ if min_output_index < max_input_index:
+ move_ops = []
+ for i in range(min_output_index + 1, len(input_indexes)):
+ if input_indexes[i] == 1:
+ move_ops.append((global_block.ops[i], i))
+ for i, op in enumerate(move_ops):
+ queue = list()
+ visited = set()
+ queue.append(op[1])
+ visited.add(op[0])
+ start = 0
+ while start < len(queue):
+ pos = queue[start]
+ op = global_block.ops[pos]
+ op_inputs = []
+ for k in range(0, len(op.input_names)):
+ ins = op.input(op.input_names[k])
+ op_inputs.append(ins)
+ for j in range(pos - 1, min_output_index - 1, -1):
+ op1 = global_block.ops[j]
+ if op1 in visited:
+ continue
+ found = False
+ for k in range(0, len(op1.output_names)):
+ outs = op1.output(op1.output_names[k])
+ for t in range(len(op_inputs)):
+ for y in op_inputs[t]:
+ if y in outs:
+ found = True
+ break
+ if found:
+ break
+ if found:
+ break
+ if found:
+ if output_indexes[j] == True:
+ warnings.warn(
+ "unable to re-arrange dags order to combine distributed embedding ops"
+ )
+ return
+ queue.append(j)
+ visited.add(global_block.ops[j])
+ start = start + 1
+
+ queue.sort()
+ for index in queue:
+ desc = global_block.desc._insert_op(min_output_index)
+ desc.copy_from(global_block.ops[index].desc)
+ global_block.desc._remove_op(index + 1, index + 2)
+ global_block.ops[index].desc = desc
+ insert_op = global_block.ops.pop(index)
+ input_state = input_indexes.pop(index)
+ output_state = output_indexes.pop(index)
+ global_block.ops.insert(min_output_index, insert_op)
+ input_indexes.insert(min_output_index, input_state)
+ output_indexes.insert(min_output_index, output_state)
+ min_output_index = min_output_index + 1
+
+ assert global_block.desc.op_size() == len(global_block.ops)
+ for i in range(len(global_block.ops)):
+ assert global_block.desc.op(i) == global_block.ops[i].desc
+
+ for param, ops in pull_sparse_ops.items():
+ all_ops = program.global_block().ops
+ op_device = ""
+ if config.is_heter_ps_mode:
+ op_device = ops[0].attr("op_device")
+ inputs = [
+ program.global_block().vars[op.input("Ids")[0]] for op in ops
+ ]
+ w = program.global_block().vars[ops[0].input("W")[0]]
+ emb_size[param] = w.shape[1]
+
+ grad_name = config.param_name_to_grad_name[w.name]
+
+ table_id = -1
+
+ for name, ctx in send_ctx.items():
+ if grad_name in ctx.origin_varnames():
+ table_id = ctx.table_id()
+
+ if table_id == -1:
+ raise ValueError(
+ "can not find suitable sparse table, please check")
+
+ w_2_table_id[param] = table_id
+ padding_idx = ops[0].attr("padding_idx")
+ is_distributed = ops[0].attr("is_distributed")
+ op_type = ops[0].type
+
+ outputs = [
+ program.global_block().vars[op.output("Out")[0]] for op in ops
+ ]
+
+ dag_check_up_and_reorder(program, inputs, outputs)
+
+ op_idxs = [all_ops.index(op) for op in ops]
+
+ for idx in op_idxs[::-1]:
+ program.global_block()._remove_op(idx)
+
+ inputs_idxs = [-1] * len(inputs)
+ outputs_idxs = [len(program.global_block().ops) + 1] * len(outputs)
+
+ for idx, op in enumerate(program.global_block().ops):
+ for i in range(0, len(op.output_names)):
+ outs = op.output(op.output_names[i])
+ for in_id, in_var in enumerate(inputs):
+ if in_var.name in outs:
+ inputs_idxs[in_id] = max(idx, inputs_idxs[in_id])
+ for i in range(0, len(op.input_names)):
+ ins = op.input(op.input_names[i])
+ for out_id, out_var in enumerate(outputs):
+ if out_var.name in ins:
+ outputs_idxs[out_id] = min(idx,
+ outputs_idxs[out_id])
+
+ if min(outputs_idxs) - max(inputs_idxs) >= 1:
+ if max(inputs_idxs) == -1:
+ distributed_idx = min(op_idxs)
+ else:
+ distributed_idx = max(inputs_idxs) + 1
+
+ if use_ps_gpu:
+ program.global_block()._insert_op(
+ index=distributed_idx,
+ type="pull_gpups_sparse",
+ inputs={
+ "Ids": inputs,
+ 'W': w
+ },
+ outputs={"Out": outputs},
+ attrs={
+ "size": [w.shape[1] for i in inputs],
+ "is_distributed": True,
+ "is_sparse": True
+ })
+ else:
+ program.global_block()._insert_op(
+ index=distributed_idx,
+ type="distributed_lookup_table",
+ inputs={
+ "Ids": inputs,
+ 'W': w
+ },
+ outputs={"Outputs": outputs},
+ attrs={
+ "is_distributed": is_distributed,
+ "padding_idx": padding_idx,
+ "table_id": table_id,
+ "lookup_table_version": op_type,
+ "op_device": op_device
+ })
+ else:
+ for i in range(len(inputs_idxs)):
+ distributed_idx = op_idxs[i]
+
+ program.global_block()._insert_op(
+ index=distributed_idx,
+ type="distributed_lookup_table",
+ inputs={
+ "Ids": [inputs[i]],
+ 'W': w
+ },
+ outputs={"Outputs": [outputs[i]]},
+ attrs={
+ "is_distributed": is_distributed,
+ "padding_idx": padding_idx,
+ "table_id": table_id,
+ "lookup_table_version": op_type,
+ "op_device": op_device
+ })
+
+ def _push_sparse_fuse(_program, push_sparse_ops, use_ps_gpu):
+ if use_ps_gpu:
+ # in ps_gpu_pass
+ return
+ if len(push_sparse_ops) == 0:
+ return
+ show = None
+ clk = None
+ use_entry = False
+ for param, ops in push_sparse_ops.items():
+ op_first = ops[0]
+ break
+ print(op_first)
+ if op_first.has_attr("entry"):
+ entry = op_first.attr("entry")
+ entry = entry.split(':')
+ if len(entry) == 3 and entry[0] == 'show_click_entry':
+ show_var_name = entry[1]
+ click_var_name = entry[2]
+ if show_var_name in program.global_block(
+ ).vars and click_var_name in program.global_block().vars:
+ show = program.global_block().vars[show_var_name]
+ clk = program.global_block().vars[click_var_name]
+ use_entry = True
+ else:
+ warnings.warn(
+ 'ShowClickEntry configured, but cannot find show/click var, will not use'
+ )
+
+ if not use_entry:
+ print('ShowClickEntry not configured, will not use')
+ show = program.global_block().create_var(
+ name="show",
+ dtype=core.VarDesc.VarType.INT64,
+ persistable=False,
+ stop_gradient=True)
+ program.global_block()._insert_op(
+ index=0,
+ type='fill_constant',
+ inputs={},
+ outputs={'Out': show},
+ attrs={
+ 'shape': [1],
+ 'dtype': show.dtype,
+ 'value': 1,
+ #OP_ROLE_KEY: OpRole.Forward
+ })
+
+ clk = program.global_block().create_var(
+ name="clk",
+ dtype=core.VarDesc.VarType.INT64,
+ persistable=False,
+ stop_gradient=True)
+ program.global_block()._insert_op(
+ index=0,
+ type='fill_constant',
+ inputs={},
+ outputs={'Out': clk},
+ attrs={
+ 'shape': [1],
+ 'dtype': clk.dtype,
+ 'value': 0,
+ #OP_ROLE_KEY: OpRole.Forward
+ })
+
+ for param, ops in push_sparse_ops.items():
+ all_ops = program.global_block().ops
+ op_idxs = [all_ops.index(op) for op in ops]
+ inputs = [
+ program.global_block().vars[op.input("Ids")[0]] for op in ops
+ ]
+ w = program.global_block().vars[ops[0].output("W@GRAD")[0]]
+ table_id = w_2_table_id[param]
+
+ padding_idx = ops[0].attr("padding_idx")
+ is_distributed = ops[0].attr("is_distributed")
+ op_type = ops[0].type
+ outputs = [
+ program.global_block().vars[op.input("Out@GRAD")[0]]
+ for op in ops
+ ]
+
+ for idx in op_idxs[::-1]:
+ program.global_block()._remove_op(idx)
+
+
+# if use_ps_gpu:
+# program.global_block().append_op(
+# type="push_box_sparse",
+# inputs={"Ids": inputs,
+# 'Out': outputs},
+# outputs={"Out": outputs},
+# attrs={
+# "size": w.shape[1],
+# "is_distributed": True,
+# "is_sparse": True
+# })
+# else:
+ program.global_block().append_op(type="distributed_push_sparse",
+ inputs={
+ "Ids": inputs,
+ 'W': w,
+ "Outputs": outputs,
+ "Shows": show,
+ "Clicks": clk
+ },
+ outputs={"Outputs": outputs},
+ attrs={
+ "is_distributed":
+ is_distributed,
+ "padding_idx": padding_idx,
+ "table_id": table_id,
+ "size": emb_size[param]
+ })
+
+ pull_sparse_ops, push_sparse_ops = _get_pull_sparse_ops(program)
+ _pull_sparse_fuse(program, pull_sparse_ops, use_ps_gpu)
+ _push_sparse_fuse(program, push_sparse_ops, use_ps_gpu)
+ return program
+
+
+def append_send_ops_pass(program, config):
+ mode = config.get_distributed_mode()
+ trainer_id = config.get_role_id()
+
+ def _append_send_op(union_vars, queue, is_sparse, table_id):
+
+ if queue == STEP_COUNTER:
+ send_input_vars = []
+ else:
+ send_input_vars = [
+ program.global_block().vars[union_var]
+ for union_var in union_vars
+ ]
+
+ dummy_output = []
+ if mode in [DistributedMode.SYNC, DistributedMode.HALF_ASYNC]:
+ dummy_output = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+
+ program.global_block().append_op(type="send",
+ inputs={"X": send_input_vars},
+ outputs={"Out": dummy_output},
+ attrs={
+ "send_varnames": [queue],
+ "is_sparse":
+ is_sparse,
+ "table_id":
+ table_id,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ return dummy_output
+
+ def _append_barrier_op(dummys):
+ program.global_block().append_op(type="send_barrier",
+ inputs={"X": dummys},
+ outputs={"Out": []},
+ attrs={
+ "trainer_id":
+ trainer_id,
+ "half_async":
+ True,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ dummys = []
+
+ sends = config.get_the_one_trainer_send_context(
+ split_dense_table=config.is_heter_ps_mode)
+
+ for merged_name, send in sends.items():
+ if send.is_sparse() and not config.is_geo_mode():
+ continue
+ is_sparse = 1 if send.is_sparse() else 0
+ is_sparse = 2 if send.is_distributed() else is_sparse
+ dummys.append(
+ _append_send_op(send.origin_varnames(), merged_name, is_sparse,
+ send.table_id()))
+
+ if mode in [DistributedMode.SYNC, DistributedMode.HALF_ASYNC]:
+ _append_barrier_op(dummys)
+
+ return program
+
+
+def init_from_server_pass(program, config):
+ # 0' trainer do not need barrier, it will call barrier at the end init_worker
+ if config.role_maker._is_first_worker():
+ return program
+
+ fetch_barrier_out = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+
+ program.global_block().append_op(type="fetch_barrier",
+ inputs={},
+ outputs={"Out": fetch_barrier_out},
+ attrs={
+ "endpoints":
+ config.get_ps_endpoints(),
+ "trainer_id":
+ config.get_role_id(),
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE
+ })
+ return program
+
+
+def fake_init_ops_pass(program, config):
+ origin_program = config.get_origin_main_program()
+
+ def _get_sparse_table_names():
+ dist_varnames = get_sparse_tablenames(origin_program, True)
+ sparse_varnames = get_sparse_tablenames(origin_program, False)
+ return list(set(dist_varnames + sparse_varnames))
+
+ def _fake_init_sparsetable(sparse_table_names):
+ # delete table init op
+ for table_name in sparse_table_names:
+ table_var = program.global_block().vars[table_name]
+ table_param_init_op = []
+ for op in program.global_block().ops:
+ if table_name in op.output_arg_names:
+ table_param_init_op.append(op)
+ init_op_num = len(table_param_init_op)
+ if init_op_num != 1:
+ raise ValueError("table init op num should be 1, now is " +
+ str(init_op_num))
+ table_init_op = table_param_init_op[0]
+ program.global_block().append_op(
+ type="fake_init",
+ inputs={},
+ outputs={"Out": table_var},
+ attrs={"shape": table_init_op.attr('shape')})
+ delete_ops(program.global_block(), table_param_init_op)
+
+ sparse_tables = _get_sparse_table_names()
+ _fake_init_sparsetable(sparse_tables)
+
+ return program
+
+
+def ps_gpu_pass(program):
+
+ def _add_push_box_sparse_op(program):
+ op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ for op in program.global_block().ops:
+ if op.type != "pull_box_sparse" and op.type != "pull_gpups_sparse":
+ continue
+ grad_op_desc, op_grad_to_var = core.get_grad_op_desc(
+ op.desc, cpt.to_text(set()), [])
+ for op_desc in grad_op_desc:
+ new_op_desc = program.global_block().desc.append_op()
+ new_op_desc.copy_from(op_desc)
+ new_op_desc._set_attr(op_role_attr_name, backward)
+
+ def _remove_lookup_table_grad_op_and_var(program):
+ lookup_table_grad_var = {}
+ remove_op_index = []
+ remove_var = []
+ for idx, op in list(enumerate(program.global_block().ops)):
+ if op.type == "lookup_table_grad":
+ for name in op.output("W@GRAD"):
+ lookup_table_grad_var[name] = 1
+ remove_op_index.append(idx)
+ remove_var.append(name)
+ for name in op.input("W"):
+ lookup_table_grad_var[name] = 1
+
+ for idx, op in list(enumerate(program.global_block().ops)):
+ if op.type == "pull_box_sparse" or op.type == "pull_gpups_sparse":
+ continue
+ for key_name in op.input_names:
+ for var in op.input(key_name):
+ if var in lookup_table_grad_var:
+ remove_op_index.append(idx)
+ break
+
+ remove_op_index = list(set(remove_op_index))
+ remove_op_index.sort(reverse=True)
+ for idx in remove_op_index:
+ program.global_block()._remove_op(idx)
+ for name in remove_var:
+ program.global_block()._remove_var(name)
+
+ def _remove_optimizer_var(program):
+
+ embedding_w = {}
+ for idx, op in list(enumerate(program.global_block().ops)):
+ if op.type == "lookup_table_grad":
+ for name in op.input("W"):
+ embedding_w[name] = 1
+
+ optimize_vars = []
+ optimize_op_role_vars = []
+ optimize_need_delete_vars = []
+ for op in _get_optimize_ops(program):
+ for name in op.input("Param"):
+ if name in embedding_w:
+ optimize_op_role_vars.extend(op.attr("op_role_var"))
+ for key_name in op.input_names:
+ if key_name == "LearningRate":
+ continue
+ for var in op.input(key_name):
+ optimize_vars.append(var)
+
+ optimize_vars = list(set(optimize_vars))
+ optimize_op_role_vars = list(set(optimize_op_role_vars))
+
+ for var in optimize_vars:
+ if var not in optimize_op_role_vars:
+ optimize_need_delete_vars.append(var)
+ need_delete_optimize_vars = list(set(optimize_need_delete_vars))
+
+ for name in need_delete_optimize_vars:
+ if program.global_block().has_var(name):
+ program.global_block()._remove_var(name)
+
+ _add_push_box_sparse_op(program)
+ _remove_optimizer_var(program)
+ _remove_lookup_table_grad_op_and_var(program)
+ return program
+
+
+def delete_extra_optimizes_pass(program, config):
+ optimize_vars = []
+ optimize_op_role_vars = []
+ optimize_need_delete_vars = []
+
+ origin_program = config.get_origin_main_program()
+ for op in _get_optimize_ops(origin_program):
+ optimize_vars.extend(op.input_arg_names)
+ optimize_op_role_vars.extend(op.attr("op_role_var"))
+
+ optimize_vars = list(set(optimize_vars))
+ optimize_op_role_vars = list(set(optimize_op_role_vars))
+ for var in optimize_vars:
+ if var not in optimize_op_role_vars:
+ optimize_need_delete_vars.append(var)
+ need_delete_optimize_vars = list(set(optimize_need_delete_vars))
+
+ init_ops = []
+ for var in need_delete_optimize_vars:
+ param_init_op = []
+ for op in program.global_block().ops:
+ if var in op.output_arg_names:
+ param_init_op.append(op)
+ init_ops.extend(param_init_op)
+ delete_ops(program.global_block(), init_ops)
+
+ for var in need_delete_optimize_vars:
+ if program.global_block().has_var(var):
+ program.global_block()._remove_var(var)
+
+ return program
+
+
+def find_heter_ops(program, default_device="cpu"):
+ if default_device not in DEVICE_LIST:
+ raise ValueError("Given device {} is not in device list {}".format(
+ default_device, DEVICE_LIST))
+
+ def _is_heter_op(op, current_heter_device, default_device="cpu"):
+ heter_devices = list(DEVICE_LIST)
+ heter_devices.remove(default_device)
+ op_device = op.attr("op_device")
+ op_type = op.type
+ if op_device in heter_devices:
+ return True
+ elif op_type in COMMUNICATE_OPS_TYPE and current_heter_device != default_device:
+ # for distributed communciate ops: send & recv & barrier etc.
+ # Todo: need update this method
+ #op._set_attr('op_device', current_heter_device)
+ return True
+ elif op_device == None or op_device == default_device:
+ op._set_attr('op_device', default_device)
+ return False
+ return False
+
+ def _is_same_device(op, pre_device, default_device="cpu"):
+ op_device = op.attr("op_device")
+ if op_device == pre_device:
+ return True
+ if pre_device == default_device:
+ return True
+ return False
+
+ def _append_heter_op(op, current_heter_block_ops, heter_ops):
+ op_device = op.attr("op_device")
+ if op_device not in heter_ops:
+ heter_ops[op_device] = {}
+ current_heter_block_ops.append(op)
+
+ origin_porgram = program.clone()
+ block = program.global_block()
+ '''
+ re-place sum op to fix bug for union forward backward op
+ '''
+ var2idx = {}
+ op_list = list(block.ops)
+ op_size = len(op_list)
+
+ for i in range(op_size - 1, -1, -1):
+ op_list = list(block.ops)
+ op = op_list[i]
+ if "_grad" in op.type:
+ forward_op_type = op.type.split("_grad")[0]
+ if forward_op_type in SPARSE_OP_TYPE_DICT.keys() \
+ and op.attr('remote_prefetch') is True:
+ param_name = op.input(SPARSE_OP_TYPE_DICT[forward_op_type])[0]
+ if param_name in var2idx:
+ ## insert sum op & remove sum op from var2idx and origin place
+ op_list = list(block.ops)
+ sum_op = op_list[var2idx[param_name]]
+ sum_op_inputs = {
+ sum_op.input_names[0]:
+ [block.vars[input] for input in sum_op.input_arg_names]
+ }
+ sum_op_outputs = {
+ sum_op.output_names[0]: [
+ block.vars[output]
+ for output in sum_op.output_arg_names
+ ]
+ }
+ block._insert_op(index=i + 1,
+ type=sum_op.type,
+ inputs=sum_op_inputs,
+ outputs=sum_op_outputs,
+ attrs=sum_op.all_attrs())
+ block._remove_op(var2idx[param_name] + 1)
+ var2idx.pop(param_name)
+ for var_ in var2idx:
+ var2idx[var_] += 1
+ elif forward_op_type == "elementwise_mul":
+ """
+ get output varname of pre op
+
+ """
+ output_vars_no_grad = []
+ for key in op.output_names:
+ for varname in op.output(key):
+ if varname == "@EMPTY@":
+ continue
+ if "lod_tensor_blocking_queue" in varname:
+ continue
+ output_vars_no_grad.append(varname.split("@GRAD")[0])
+ for no_grad_var in output_vars_no_grad:
+ if no_grad_var in var2idx:
+ """
+ insert sum op & remove sum op from var2idx and origin place
+
+ """
+ op_list = list(block.ops)
+ sum_op = op_list[var2idx[no_grad_var]]
+ sum_op_inputs = {
+ sum_op.input_names[0]: [
+ block.vars[input]
+ for input in sum_op.input_arg_names
+ ]
+ }
+ sum_op_outputs = {
+ sum_op.output_names[0]: [
+ block.vars[output]
+ for output in sum_op.output_arg_names
+ ]
+ }
+ block._insert_op(index=i + 1,
+ type=sum_op.type,
+ inputs=sum_op_inputs,
+ outputs=sum_op_outputs,
+ attrs=sum_op.all_attrs())
+ block._remove_op(var2idx[no_grad_var] + 1)
+ var2idx.pop(no_grad_var)
+ for var_ in var2idx:
+ var2idx[var_] += 1
+ else:
+ if op.type == "sum":
+ var = op.output("Out")[0]
+ if "@GRAD" in var:
+ origin_var = var.split("@GRAD")[0]
+ pre_op = op_list[i - 1]
+ if "_grad" in pre_op.type:
+ forward_op_type = pre_op.type.split("_grad")[0]
+ if forward_op_type in SPARSE_OP_TYPE_DICT.keys() \
+ and pre_op.attr('remote_prefetch') is True:
+ param_name = pre_op.input(
+ SPARSE_OP_TYPE_DICT[forward_op_type])[0]
+ if param_name == origin_var and op.attr(
+ "op_device") == pre_op.attr("op_device"):
+ continue
+ else:
+ var2idx[origin_var] = i
+ elif forward_op_type == "elementwise_mul":
+ output_vars = []
+ for key in pre_op.output_names:
+ for varname in pre_op.output(key):
+ if varname == "@EMPTY@":
+ continue
+ if "lod_tensor_blocking_queue" in varname:
+ continue
+ output_vars.append(varname)
+ input_vars = []
+ for key in op.input_names:
+ for varname in op.input(key):
+ if varname == "@EMPTY@":
+ continue
+ if "lod_tensor_blocking_queue" in varname:
+ continue
+ input_vars.append(varname)
+ is_match = False
+ for varname in output_vars:
+ if varname in input_vars:
+ is_match = True
+ break
+ if is_match:
+ continue
+ else:
+ var2idx[origin_var] = i
+ else:
+ var2idx[origin_var] = i
+
+ origin_porgram = program.clone()
+ block = program.global_block()
+
+ program_block_ops = []
+ default_ops = {default_device: {}}
+ heter_ops = {}
+ block_index = 0
+
+ current_heter_block_ops = []
+ current_default_block_ops = []
+ current_heter_device = default_device
+ is_heter = False
+ for op in block.ops:
+ if _is_heter_op(op, current_heter_device, default_device):
+ # for gpu/xpu-op
+ is_heter = True
+
+ # for cpu-op block append
+ if len(current_default_block_ops) > 1:
+ default_ops[default_device][
+ block_index] = current_default_block_ops
+ program_block_ops.append(current_default_block_ops)
+ current_default_block_ops = []
+ block_index += 1
+
+ if _is_same_device(op, current_heter_device, default_device):
+ # for gpu-op, gpu-op -> gpu-op,...
+ current_heter_device = op.attr("op_device")
+ _append_heter_op(op, current_heter_block_ops, heter_ops)
+ else:
+ # for gpu-op -> xpu-op, ...
+ op_device = current_heter_block_ops[0].attr("op_device")
+ heter_ops[op_device][block_index] = current_heter_block_ops
+ program_block_ops.append(current_heter_block_ops)
+ block_index += 1
+ current_heter_block_ops = []
+ current_heter_device = op.attr("op_device")
+ _append_heter_op(op, current_heter_block_ops, heter_ops)
+
+ elif is_heter:
+ # for gpu/xpu-op -> cpu-op
+ op_device = current_heter_block_ops[0].attr("op_device")
+ heter_ops[op_device][block_index] = current_heter_block_ops
+ program_block_ops.append(current_heter_block_ops)
+ block_index += 1
+ current_heter_block_ops = []
+ current_heter_device = default_device
+ is_heter = False
+ current_default_block_ops.append(op)
+ else:
+ # for cpu-op
+ current_default_block_ops.append(op)
+
+ if current_default_block_ops != []:
+ default_ops[default_device][block_index] = current_default_block_ops
+ program_block_ops.append(current_default_block_ops)
+
+ if current_heter_block_ops != []:
+ op_device = current_heter_block_ops[0].attr("op_device")
+ heter_ops[op_device][block_index] = current_heter_block_ops
+ program_block_ops.append(current_heter_block_ops)
+
+ if len(heter_ops) == 0:
+ warnings.warn(
+ "No heterogeneous OP was found in your program , "
+ " please using fluid.device_guard() to run OPs on different device."
+ )
+
+ total_heter_ops = 0
+ heter_blocks = 0
+ for device in heter_ops.keys():
+ heter_block_dict = heter_ops[device]
+ heter_blocks += len(heter_block_dict)
+ for _, heter_block in heter_block_dict.items():
+ total_heter_ops += len(heter_block)
+ print(
+ "There are {} OPs in your main_program, and contains {} heter-OPs which is made up of {} heter-blocks."
+ .format(len(block.ops), total_heter_ops, heter_blocks))
+
+ return origin_porgram, heter_ops, default_ops, program_block_ops
+
+
+def create_heter_program(program, config, heter_program, program_block_ops_list,
+ heter_ops, block_var_detail, current_device, stage_id):
+ # This function mainly includes the following contents:
+ # 1. For every heter block:
+ # a) copy heter device op from origin program
+ # b) create variables which belong to heter op:
+ # -> if variable is persistable, clone it in global_scope
+ # -> if variable is temp, create it in heter block
+ # c) create communicate related op as follow:
+ # joint_var.0_1 -> slice -> reshape -> origin_var
+ # origin_var -> origin_program
+ # reshape -> concat -> joint_var.1_2
+ # d) copy send op from origin program for var@grad which loacted in current heter block
+ # e) re-check every op in current blcok if its device is not current heter devie
+ # 2. Create send op for step counter in last heter-block
+ # 3. Create Listen&Serv OP and Send&Recv OP for distributed training
+ # 4. update CompileTimeStrategy for heter_program
+
+ optimizer_block = []
+ grad_to_block_id = []
+ send_grad_var_list = []
+
+ pre_block_idx = heter_program.num_blocks - 1
+ stage_id = int(stage_id)
+ print("stage id", stage_id)
+ heter_block_ops_forward = program_block_ops_list[stage_id - 1]["forward"]
+
+ heter_block_ops_backward = program_block_ops_list[stage_id - 1]["backward"]
+
+ heter_block = heter_program._create_block(pre_block_idx)
+ optimizer_block.append(heter_block)
+ for _, op in enumerate(heter_block_ops_forward):
+ block_append_op(heter_program, program, heter_block, op)
+
+ entrance_vars = block_var_detail[stage_id - 1]["forward"]["entrance"]
+ add_vars_by_var_list(entrance_vars, program, heter_program, heter_block)
+ exit_vars = block_var_detail[stage_id - 1]["forward"]["exit"]
+ add_vars_by_var_list(exit_vars, program, heter_program, heter_block)
+
+ first_op_index_fp = len(heter_block.ops)
+
+ if stage_id < len(program_block_ops_list):
+
+ heter_block_bp = heter_program._create_block(pre_block_idx)
+ optimizer_block.append(heter_block_bp)
+
+ for _, op in enumerate(heter_block_ops_backward):
+ block_append_op(heter_program, program, heter_block_bp, op)
+
+ bp_entrance_vars = block_var_detail[stage_id -
+ 1]["backward"]["entrance"]
+ add_vars_by_var_list(bp_entrance_vars, program, heter_program,
+ heter_block_bp)
+ bp_exit_vars = block_var_detail[stage_id - 1]["backward"]["exit"]
+ add_vars_by_var_list(bp_exit_vars, program, heter_program,
+ heter_block_bp)
+ backward_comm_info = get_communicate_var_info(program,
+ stage_id,
+ bp_entrance_vars,
+ type="backward")
+
+ grad_to_block_id.append(backward_comm_info["block_input_var_name"] +
+ ":" + str(heter_block_bp.idx))
+
+ else:
+ for _, op in enumerate(heter_block_ops_backward):
+ block_append_op(heter_program, program, heter_block, op)
+
+ bp_entrance_vars = block_var_detail[stage_id -
+ 1]["backward"]["entrance"]
+ add_vars_by_var_list(bp_entrance_vars, program, heter_program,
+ heter_block)
+ bp_exit_vars = block_var_detail[stage_id - 1]["backward"]["exit"]
+ add_vars_by_var_list(bp_exit_vars, program, heter_program, heter_block)
+
+ heter_block_bp = heter_block
+
+ forward_comm_info = get_communicate_var_info(program,
+ stage_id,
+ entrance_vars,
+ type="forward")
+
+ grad_to_block_id.append(forward_comm_info["block_input_var_name"] + ":" +
+ str(heter_block.idx))
+
+ first_op_index_bp = len(heter_block_bp.ops)
+
+ if stage_id <= len(block_var_detail) - 1:
+ static_var = insert_communicate_op(program, config, heter_block,
+ stage_id, first_op_index_fp,
+ block_var_detail, current_device)
+ static_var_bp = insert_communicate_op(program, config, heter_block_bp,
+ stage_id, first_op_index_bp,
+ block_var_detail, current_device,
+ False)
+
+ # add send op
+ send_grad_var_list = add_heter_send_op(program, heter_program,
+ heter_block_bp,
+ block_var_detail[stage_id - 1])
+
+ # ---------------
+ # add step conter
+ send_input_vars = []
+ dummy_output = []
+ pserver_endpoints = config.get_ps_endpoints()
+
+ # optimizer_block[-1].append_op(
+ # type="send",
+ # inputs={"X": send_input_vars},
+ # outputs={"Out": dummy_output},
+ # attrs={
+ # "send_varnames": [STEP_COUNTER],
+ # "merge_add": True,
+ # "use_send_handler": False,
+ # "endpoints": pserver_endpoints
+ # })
+
+ # add info in listen&serv
+ attrs = {
+ #"mode": "sync",
+ #"trainers": config.get_trainers(),
+ #"trainer_id": config.get_role_id() + config.get_trainers(),
+ "message_to_block_id": grad_to_block_id,
+ "optimize_blocks": optimizer_block,
+ # runtime attribute
+ "endpoint": config.get_heter_worker_endpoint(),
+ "fanin": len(config.get_previous_stage_trainers()),
+ "pserver_id": config.get_role_id(),
+ "distributed_mode": config.get_distributed_mode(),
+ "rpc_exec_thread_num": int(os.getenv("CPU_NUM", 32)),
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ }
+ # append the listen_and_serv op
+ heter_program.global_block().append_op(type="heter_listen_and_serv",
+ inputs={'X': []},
+ outputs={},
+ attrs=attrs)
+ check_heter_compile_time_strategy(program, config, send_grad_var_list)
+
+
+def check_heter_compile_time_strategy(program, config, send_grad_var_list):
+ origin_grad_var_list = []
+ for _, var_grad in config.merged_variables_pairs:
+ origin_grad_var_list.append(var_grad.merged_var.name)
+
+ origin_grad_var_list = list(set(origin_grad_var_list))
+ send_grad_var_list = list(set(send_grad_var_list))
+ useless_grad_var_list = list(
+ set(origin_grad_var_list) - set(send_grad_var_list))
+
+ for useless_grad_var in useless_grad_var_list:
+ config.remove_var_pair_by_grad(useless_grad_var)
+
+
+def create_trainer_program(program, origin_program, config,
+ program_block_ops_list, block_var_detail):
+ # This function mainly includes the following contents:
+ # 1. For every heter block in origin program
+ # a) delete heter op and related variables
+ # b) add send&recv op
+ # c) add communicate ops as follows:
+ # origin_var -> reshape -> concat -> joint_var.0_1
+ # send&recv op(send joint_var.0_1; recv joint_var.1_2)
+ # joint_var.1_2 -> slice -> reshape -> origin_var
+ # d) remove send op which related var@grad is not in trainer program
+ # 2. check every op's device
+ static_var = []
+ for heter_block_index in range(1, len(program_block_ops_list)):
+ ops_list = program_block_ops_list[heter_block_index][
+ "forward"] + program_block_ops_list[heter_block_index]["backward"]
+ static_var += replace_ops_by_communicate_op(program, config,
+ heter_block_index, ops_list,
+ block_var_detail)
+ remove_trainer_send_op(program, config, heter_block_index,
+ block_var_detail)
+
+ optimizer_block = []
+ grad_to_block_id = []
+
+ bp_ops_list = program_block_ops_list[0]["backward"]
+ delete_same_ops(program.global_block(), bp_ops_list)
+ delete_trainer_useless_var(config, program, static_var)
+ backward_block = create_backward_block(program, origin_program, config,
+ bp_ops_list, block_var_detail)
+
+ bp_entrance_vars = block_var_detail[0]["backward"]["entrance"]
+ backward_comm_info = get_communicate_var_info(origin_program,
+ 1,
+ bp_entrance_vars,
+ type="backward")
+
+ grad_to_block_id.append(backward_comm_info["block_input_var_name"] + ":" +
+ str(backward_block.idx))
+ optimizer_block.append(backward_block)
+
+ attrs = {
+ #"mode": "sync",
+ #"trainers": config.get_trainers(),
+ #"trainer_id": config.get_role_id(),
+ "message_to_block_id": grad_to_block_id,
+ "optimize_blocks": optimizer_block,
+ # runtime attribute
+ "endpoint": config.get_trainer_endpoint(), ## get trainer endpoint
+ "fanin": 0, ## get heter worker
+ "pserver_id": config.get_role_id(),
+ "distributed_mode": config.get_distributed_mode(),
+ "rpc_exec_thread_num": int(os.getenv("CPU_NUM", 32)),
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ }
+ # append the listen_and_serv op
+ program.global_block()._insert_op(index=0,
+ type="heter_listen_and_serv",
+ inputs={'X': []},
+ outputs={},
+ attrs=attrs)
+
+ ## TODO add check for bp block
+ check_op_device(program.global_block(), DEFAULT_DEVICE)
+
+
+def insert_communicate_op(orign_program,
+ config,
+ heter_block,
+ stage_id,
+ first_op_index,
+ block_var_detail,
+ device,
+ is_forward=True):
+
+ if is_forward:
+ next_heter_worker_endpoints = config.get_next_stage_trainers()
+ previous_heter_worker_endpoints = config.get_previous_stage_trainers()
+ entrance_var = block_var_detail[stage_id]["forward"]["entrance"]
+ comm_info = get_communicate_var_info(orign_program, stage_id + 1,
+ entrance_var)
+
+ else:
+ next_heter_worker_endpoints = config.get_next_stage_trainers()
+ #if next_heter_worker_endpoints == "":
+ # next_heter_worker_endpoints = []
+ previous_heter_worker_endpoints = config.get_previous_stage_trainers()
+ entrance_var = block_var_detail[stage_id - 1]["backward"]["exit"]
+ comm_info = get_communicate_var_info(orign_program, stage_id - 1,
+ entrance_var, "backward")
+
+ heter_block._insert_op(index=first_op_index,
+ type="send_and_recv",
+ inputs={"X": heter_block.vars[entrance_var[0]]},
+ outputs={"Out": []},
+ attrs={
+ "mode": "forward" if is_forward else "backward",
+ "send_var_name":
+ entrance_var + ["microbatch_id"],
+ "recv_var_name": [],
+ "message_name":
+ comm_info["block_input_var_name"],
+ "next_endpoints": next_heter_worker_endpoints,
+ "previous_endpoints":
+ previous_heter_worker_endpoints,
+ "trainer_id": config.get_role_id(),
+ "op_device": device,
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ return entrance_var
+
+
+def create_backward_block(program, origin_program, config, bp_ops_list,
+ block_var_detail):
+ pre_block_idx = program.num_blocks - 1
+ heter_block = program._create_block(pre_block_idx)
+
+ for _, op in enumerate(bp_ops_list):
+ if op.type == "send":
+ send_varnames = op.attr('send_varnames')
+ is_skip = False
+ for varname in send_varnames:
+ if varname not in program.global_block(
+ ).vars and varname not in heter_block.vars:
+ is_skip = True
+ break
+ if is_skip == True:
+ continue
+ block_append_op(program, origin_program, heter_block, op)
+
+ entrance_vars = block_var_detail[0]["backward"]["entrance"]
+ add_vars_by_var_list(entrance_vars, origin_program, program, heter_block)
+ exit_vars = block_var_detail[0]["backward"]["exit"]
+ add_vars_by_var_list(exit_vars, origin_program, program, heter_block)
+ return heter_block
+
+
+def replace_ops_by_communicate_op(program, config, heter_block_index, ops_list,
+ block_var_detail):
+ all_op = program.global_block().ops
+ start_op = ops_list[0]
+ first_op_idx = -1
+ for op in all_op:
+ if is_same_op(op, start_op):
+ first_op_idx = all_op.index(op)
+ break
+ assert first_op_idx != -1
+ delete_same_ops(program.global_block(), ops_list)
+
+ entrance_var = []
+
+ if heter_block_index == 1:
+ mode = config.get_distributed_mode()
+ next_heter_worker_endpoints = config.get_next_stage_trainers()
+
+ entrance_var = block_var_detail[heter_block_index]["forward"][
+ "entrance"]
+
+ comm_info = get_communicate_var_info(program, heter_block_index + 1,
+ entrance_var)
+ program.global_block()._insert_op(
+ index=first_op_idx,
+ type="send_and_recv",
+ inputs={"X": program.global_block().vars[entrance_var[0]]},
+ outputs={"Out": []},
+ attrs={
+ "mode": "forward",
+ "send_var_name": entrance_var + ["microbatch_id"],
+ "recv_var_name": [],
+ "message_name": comm_info["block_input_var_name"],
+ "next_endpoints": next_heter_worker_endpoints,
+ "previous_endpoints": [],
+ "trainer_id": config.get_role_id(),
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ return entrance_var
+
+
+def remove_trainer_send_op(program, config, heter_block_index,
+ block_var_detail):
+
+ # if trainer do FF->BP->SEND, it has follow vars: var, var@GRAD
+ # if trainer only do SEND, it has one var: var@GRAD
+ # Delete Send op ,if trainer doesn't has pair var (var<->var@GRAD)
+ persistables = block_var_detail[heter_block_index]["forward"]["persistables"] + \
+ block_var_detail[heter_block_index]["backward"]["persistables"]
+ need_remove_send_op = []
+ need_remove_grad_var = []
+ for op in find_send_op(program):
+ input_list, _ = find_op_input_output(program, program.global_block(),
+ op)
+ for var_name in input_list:
+ origin_var_name = var_name.split("@GRAD")[0]
+ if origin_var_name in persistables:
+ need_remove_send_op.append(op)
+ need_remove_grad_var.append(var_name)
+ need_remove_send_op = list(set(need_remove_send_op))
+ delete_ops(program.global_block(), need_remove_send_op)
+ for grad_var_name in need_remove_grad_var:
+ config.remove_var_pair_by_grad(grad_var_name)
+
+
+def add_heter_send_op(program, heter_program, block, block_var_detail):
+
+ def _get_send_op_dict():
+ send_op_dict = {}
+ send_op_list = find_send_op(program)
+ for op in send_op_list:
+ input_list, _ = find_op_input_output(program,
+ program.global_block(), op)
+ for var in input_list:
+ send_op_dict[var] = op
+ return send_op_dict
+
+ # send_Op = { inputs{'X':[]},
+ # outputs{'Out':dummy_output},
+ # attrs{'send_varnames'"[]",
+ # 'is_sparse':int,
+ # 'table_id':int } }
+ send_grad_var_list = []
+ send_op_dict = _get_send_op_dict()
+ table_dict = {}
+ for persistable_var in block_var_detail["backward"]["persistables"]:
+ # check var_name == var@GRAD
+ if "@GRAD" not in persistable_var:
+ continue
+ if "GRAD" != persistable_var.split("@")[-1]:
+ continue
+ if persistable_var not in send_op_dict:
+ continue
+ send_op = send_op_dict[persistable_var]
+ is_sparse = send_op.attr('is_sparse')
+ table_id = send_op.attr('table_id')
+ send_varnames = send_op.attr('send_varnames')
+ send_grad_var_list.append(persistable_var)
+ if table_id not in table_dict:
+ table_dict[table_id] = {}
+ table_dict[table_id]['var_list'] = []
+ table_dict[table_id]['is_sparse'] = is_sparse
+ table_dict[table_id]['send_varnames'] = send_varnames
+ table_dict[table_id]['var_list'].append(persistable_var)
+
+ for table_id in table_dict:
+ dummy_output = block.create_var(
+ name=framework.generate_control_dev_var_name())
+ send_input_vars = [
+ block.vars[union_var]
+ for union_var in table_dict[table_id]['var_list']
+ ]
+ block.append_op(type="send",
+ inputs={"X": send_input_vars},
+ outputs={"Out": dummy_output},
+ attrs={
+ "send_varnames":
+ table_dict[table_id]['send_varnames'],
+ "is_sparse": is_sparse,
+ "table_id": table_id,
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ return send_grad_var_list
+
+
+def find_send_op(program):
+ send_op_list = []
+ for op in program.global_block().ops:
+ if op.type == "send":
+ send_op_list.append(op)
+ return send_op_list
+
+
+def get_communicate_var_info(program,
+ block_index,
+ entrance_var_list,
+ type="forward"):
+ input_var_reshape_dim = []
+ input_var_reshape_name = []
+
+ if type == "forward":
+ block_input_var_name = "forward_joint_{}_{}@Heter".format(
+ block_index - 1, block_index)
+ else:
+ block_input_var_name = "backward_joint_{}_{}@Heter".format(
+ block_index + 1, block_index)
+
+ entrance_var_list.sort()
+ # input
+ # Heter_SERVER_BLOCK_index@JOINT_VAR -> slice -> var@Heter_SERVER_BLOCK@INPUT_RESHAPE_VAR -> reshape -> var
+ for name in entrance_var_list:
+ var = program.global_block().vars[name]
+ shape = var.shape
+ # if len(shape) < 2 or shape[0] != -1:
+ # raise ValueError(
+ # "Variable {} not support heter training. its shape is {}".
+ # format(name, shape))
+ recv_var_dim = -1 * reduce(lambda x, y: x * y, shape)
+ input_var_reshape_dim.append(recv_var_dim)
+ input_var_reshape_name.append("{}.input_reshape@Heter".format(name))
+
+ # output
+ # var -> reshape -> var@Heter_SERVER_BLOCK@INPUT_RESHAPE_VAR -> concat -> Heter_SERVER_BLOCK_index@JOINT_VAR
+ #for var_name in exit_var_list:
+ # var = program.global_block().vars[var_name]
+ # shape = var.shape
+ # # if len(shape) < 2 or shape[0] != -1:
+ # # raise ValueError(
+ # # "Variable {} not support heter training. its shape is {}".
+ # # format(var_name, shape))
+ # send_reshape_dim = -1 * reduce(lambda x, y: x * y, shape)
+ # output_var_reshape_dim.append(send_reshape_dim)
+ # output_var_reshape_name.append("{}.output_reshape@Heter".format(
+ # var_name))
+
+ info = {
+ "input_var_reshape_dim": input_var_reshape_dim,
+ "input_var_reshape_name": input_var_reshape_name,
+ "block_input_var_name": block_input_var_name,
+ # "output_var_reshape_dim": output_var_reshape_dim,
+ # "output_var_reshape_name": output_var_reshape_name,
+ # "block_output_var_name": block_output_var_name
+ }
+
+ return info
+
+
+def union_forward_gradient_op(program_block_ops_list):
+ """
+ before analyzing the input & output of each block in program_block_list, we should
+ union the forward op and corresponding gradient op to elimincate the unnecessary variable
+ transmit
+ """
+ """
+ fix for 2emb model, re-place sum op
+
+ """
+ block_length = len(program_block_ops_list)
+ '''
+ ## get the final part
+ final_part_idx = -1
+ for i in range(block_length):
+ op_list = program_block_ops_list[i]
+ for op in op_list:
+ if "_grad" in op.type:
+ final_part_idx = i
+ break
+ if final_part_idx != -1:
+ break
+
+ ## eliminate wrong partition because of sum op
+ ## lookup_table_v2_grad
+ ## every looup_table_v2_grad op block should follow a sum op
+ var2idx = {}
+
+ for i in range(final_part_idx, block_length):
+ op_list = program_block_ops_list[i]
+ for j in range(len(op_list) - 1, -1, -1):
+ op = op_list[j]
+ #if op.type == "lookup_table_v2_grad":
+ # if j < len(op_list) - 1):
+ # else:
+ # ## get var and record place
+ if _grad in op.type:
+ forward_op_type = op.type.split("_grad")[0]
+ if forward_op_type in SPARSE_OP_TYPE_DICT.keys() \
+ and op.attr('remote_prefetch') is True:
+ param_name = op.input(SPARSE_OP_TYPE_DICT[forward_op_type])[0]
+
+ var2idx[] = [i,j] ##
+
+ '''
+
+ union_program_block_ops_list = []
+ assert block_length % 2 != 0, "the length of program_block_ops_list should be odd"
+ for i in range(0, block_length // 2):
+ block_op_list = {"forward": program_block_ops_list[i]}
+ block_op_list.update(
+ {"backward": program_block_ops_list[block_length - 1 - i]})
+ union_program_block_ops_list.append(block_op_list)
+
+ block_op_list = {"forward": [], "backward": []}
+ for op in program_block_ops_list[block_length // 2]:
+ if not "_grad" in op.type and not (op.type == "sum"):
+ block_op_list["forward"].append(op)
+ else:
+ block_op_list["backward"].append(op)
+ union_program_block_ops_list.append(block_op_list)
+ return union_program_block_ops_list
+
+
+def find_block_joints(program, program_block_ops_list, heter_ops):
+ block_var_detail = find_entrance_exit_private(program,
+ program_block_ops_list)
+ block_var_detail = entrance_exit_check(program, program_block_ops_list,
+ block_var_detail, heter_ops)
+ block_var_detail = delete_block_useless_exit(program,
+ program_block_ops_list,
+ block_var_detail)
+
+ return block_var_detail
+
+
+def find_entrance_exit_private(program, program_block_ops_list):
+ block_var_detail = []
+ persistables = []
+ for index, block_op_list in enumerate(program_block_ops_list):
+ ## forward
+ block_input, block_output = find_ops_list_input_output(
+ program, block_op_list["forward"])
+ persistables = screen_persistables(
+ program, block_input) + screen_persistables(program, block_output)
+ # find entrance & exit
+ block_private_vars = list(set(block_input) & set(block_output))
+ block_entrance = list(set(block_input) - set(block_private_vars))
+ block_exit = list(set(block_output) - set(block_private_vars))
+ detail = {
+ "forward": {
+ "entrance": block_entrance,
+ "exit": block_exit,
+ "private": block_private_vars,
+ "persistables": persistables
+ }
+ }
+
+ ## backward
+ bp_block_input, bp_block_output = find_ops_list_input_output(
+ program, block_op_list["backward"])
+ bp_persistables = screen_persistables(
+ program, bp_block_input) + screen_persistables(
+ program, bp_block_output)
+ # find entrance & exit
+ bp_block_private_vars = list(set(bp_block_input) & set(bp_block_output))
+ bp_block_entrance = list(
+ set(bp_block_input) - set(bp_block_private_vars))
+ bp_block_exit = list(set(bp_block_output) - set(bp_block_private_vars))
+ detail.update({
+ "backward": {
+ "entrance": bp_block_entrance,
+ "exit": bp_block_exit,
+ "private": bp_block_private_vars,
+ "persistables": bp_persistables
+ }
+ })
+ block_var_detail.append(detail)
+ return block_var_detail
+
+
+def entrance_exit_check(program, program_block_ops_list, block_var_detail,
+ heter_ops):
+ for index in range(len(block_var_detail) - 1, -1, -1):
+ if index - 1 < 0:
+ break
+ previous_block_exit = block_var_detail[index - 1]["forward"]["exit"]
+ previous_block_exit.sort()
+ current_block_entrance = block_var_detail[index]["forward"]["entrance"]
+
+ backward_entrance = block_var_detail[index]["backward"]["entrance"]
+
+ forward_all = block_var_detail[index]["forward"][
+ "entrance"] + block_var_detail[index]["forward"][
+ "private"] + block_var_detail[index]["forward"]["exit"]
+
+ for var in backward_entrance:
+ if not ("@GRAD" in var) and not (var in forward_all):
+ current_block_entrance.append(var)
+
+ current_block_entrance.sort()
+
+ if previous_block_exit == current_block_entrance:
+ continue
+ exist_vars = list(
+ set(previous_block_exit) & set(current_block_entrance))
+ need_add_vars = list(set(current_block_entrance) - set(exist_vars))
+ # var in different stage should not be ignored, since they are not placed in the same program & device
+ #need_add_vars = find_need_var_from_previous_block(
+ # need_add_vars, block_var_detail, index, heter_ops)
+
+ previous_block_private = block_var_detail[index -
+ 1]["forward"]["private"]
+ previous_block_entrance = block_var_detail[index -
+ 1]["forward"]["entrance"]
+ for var in need_add_vars:
+ if var not in previous_block_private and var not in previous_block_entrance:
+ previous_block_entrance.append(var)
+ previous_block_exit.append(var)
+ if not var in current_block_entrance:
+ current_block_entrance.append(var)
+
+ for index in range(0, len(block_var_detail) - 1, 1):
+ previous_block_exit = block_var_detail[index + 1]["backward"]["exit"]
+ previous_block_exit.sort()
+ current_block_entrance = block_var_detail[index]["backward"]["entrance"]
+
+ current_block_entrance.sort()
+
+ if previous_block_exit == current_block_entrance:
+ continue
+ exist_vars = list(
+ set(previous_block_exit) & set(current_block_entrance))
+ need_add_vars = list(set(current_block_entrance) - set(exist_vars))
+ need_ignore_vars = []
+ for var in need_add_vars:
+ if not "@GRAD" in var:
+ need_ignore_vars.append(var)
+ need_add_vars = list(
+ set(need_add_vars).difference(set(need_ignore_vars)))
+ previous_block_private = block_var_detail[index +
+ 1]["backward"]["private"]
+ previous_block_entrance = block_var_detail[index +
+ 1]["backward"]["entrance"]
+ for var in need_add_vars:
+ if var not in previous_block_private and var not in previous_block_entrance:
+ previous_block_entrance.append(var)
+ previous_block_exit.append(var)
+ return block_var_detail
+
+
+def find_need_var_from_previous_block(need_add_vars, block_var_detail,
+ current_index, heter_ops):
+ # create index_device_map
+ index_device_map = {}
+ for index in range(len(block_var_detail)):
+ index_device_map[index] = DEFAULT_DEVICE
+ for device in heter_ops:
+ for index in heter_ops[device].keys():
+ if index < len(block_var_detail):
+ index_device_map[index] = device
+
+ pre_index = current_index - 1
+ need_ignore_var = []
+
+ # if need_add_var in current device, no need communicate
+ for var in need_add_vars:
+ while (pre_index >= 0):
+ previous_block_private = block_var_detail[pre_index]["private"]
+ previous_block_exit = block_var_detail[pre_index]["exit"]
+ previous_block_entrance = block_var_detail[pre_index]["entrance"]
+ total_var = previous_block_private + previous_block_exit + previous_block_entrance
+ if var in total_var:
+ if index_device_map[current_index] == index_device_map[
+ pre_index] and index_device_map[
+ current_index] == DEFAULT_DEVICE:
+ need_ignore_var.append(var)
+ break
+ pre_index -= 1
+
+ need_add_vars = list(set(need_add_vars).difference(set(need_ignore_var)))
+ return need_add_vars
+
+
+def delete_block_useless_exit(program, program_block_ops_list,
+ block_var_detail):
+ ## forward
+ for index in range(len(block_var_detail)):
+ if index == len(block_var_detail) - 1:
+ break
+ current_block_exit = block_var_detail[index]["forward"]["exit"]
+ next_block_entrance = block_var_detail[index + 1]["forward"]["entrance"]
+ need_delete_var = []
+ for var in current_block_exit:
+ if var not in next_block_entrance:
+ need_delete_var.append(var)
+
+ for var in need_delete_var:
+ current_block_exit.remove(var)
+ ## backward
+ for index in range(len(block_var_detail) - 1, -1, -1):
+ if index - 1 < 0:
+ break
+ current_block_exit = block_var_detail[index]["backward"]["exit"]
+ next_block_entrance = block_var_detail[index -
+ 1]["backward"]["entrance"]
+ need_delete_var = []
+ for var in current_block_exit:
+ if var not in next_block_entrance:
+ need_delete_var.append(var)
+ for var in need_delete_var:
+ current_block_exit.remove(var)
+
+ return block_var_detail
+
+
+def check_op_device(block, device):
+ for op in block.ops:
+ op._set_attr('op_device', device)
+
+
+def screen_persistables(program, var_list):
+ need_remove = []
+ for var_name in var_list:
+ if "@GRAD" in var_name:
+ if "GRAD" != var_name.split("@")[-1]:
+ continue
+ origin_var_name = var_name.split("@GRAD")[0]
+ var = program.global_block().vars[origin_var_name]
+ else:
+ var = program.global_block().vars[var_name]
+
+ if fluid.io.is_persistable(var):
+ need_remove.append(var_name)
+
+ for var_name in need_remove:
+ var_list.remove(var_name)
+ return need_remove
+
+
+def insert_reshape_op(program,
+ block,
+ index,
+ var_name,
+ new_var_name,
+ new_var_shape=None):
+ input_var = block.vars[var_name]
+
+ if new_var_name not in block.vars:
+ out = block.create_var(name=new_var_name,
+ shape=new_var_shape,
+ dtype=input_var.dtype,
+ type=input_var.type)
+ else:
+ out = block.vars[new_var_name]
+ new_var_shape = out.shape
+
+ x_shape = block.create_var(name="{}.xshape@Heter".format(var_name),
+ dtype=input_var.dtype)
+ block._insert_op(index=index,
+ type="reshape2",
+ inputs={"X": input_var},
+ attrs={'shape': new_var_shape},
+ outputs={
+ "Out": out,
+ "XShape": x_shape
+ })
+
+
+def insert_send_concat_op(program, block, index, var_name_list, new_var_name,
+ new_var_shape):
+ input_var_list = [block.vars[var_name] for var_name in var_name_list]
+
+ out = program.global_block().create_var(name=new_var_name,
+ shape=new_var_shape,
+ dtype=input_var_list[0].dtype,
+ type=input_var_list[0].type)
+
+ block._insert_op(index=index,
+ type='concat',
+ inputs={"X": input_var_list},
+ outputs={'Out': [out]},
+ attrs={
+ 'axis': -1,
+ 'use_stack': False
+ })
+
+
+def insert_recv_slice_op(program, block, index, var_name, var_shape, dtype,
+ type, new_var_name_list, new_var_shape_list):
+ if var_name not in program.global_block().vars:
+ input_var = program.global_block().create_var(name=var_name,
+ shape=var_shape,
+ dtype=dtype,
+ type=type)
+ else:
+ input_var = program.global_block().vars[var_name]
+
+ out_list = []
+ for i in range(len(new_var_name_list)):
+ if new_var_name_list[i] not in block.vars:
+ out = block.create_var(name=new_var_name_list[i],
+ shape=new_var_shape_list[i],
+ dtype=input_var.dtype,
+ type=input_var.type)
+ else:
+ out = block.vars[new_var_name_list[i]]
+ out_list.append(out)
+
+ start_index = 0
+ end_index = 0
+ for i in range(len(new_var_name_list)):
+ starts = []
+ ends = []
+ attrs = {'axes': [1]}
+ end_index += new_var_shape_list[i][1]
+ starts.append(start_index)
+ ends.append(end_index)
+ attrs['starts'] = starts
+ attrs['ends'] = ends
+
+ block._insert_op(index=index,
+ type='slice',
+ inputs={'Input': input_var},
+ attrs=attrs,
+ outputs={'Out': out_list[i]})
+ start_index = end_index
+ index += 1
+
+
+def add_heter_trainer_useful_vars(config, program, heter_program, heter_block,
+ static_var):
+ static_var = list(set(static_var))
+ for var_name in static_var:
+ if var_name not in heter_program.global_block(
+ ).vars and var_name not in heter_block.vars:
+ var = program.global_block().vars[var_name]
+ if var.persistable:
+ heter_program.global_block()._clone_variable(
+ var, force_persistable=False)
+ else:
+ heter_block._clone_variable(var, force_persistable=False)
+
+
+def delete_trainer_useless_var(config, program, static_var):
+ static_var = list(set(static_var))
+ program_useful_var_list = []
+ for op in program.global_block().ops:
+ input_var_list, output_var_list = find_op_input_output(
+ program, program.global_block(), op)
+ op_var_list = list(set(input_var_list).union(set(output_var_list)))
+ program_useful_var_list = list(
+ set(program_useful_var_list).union(set(op_var_list)))
+ program_useful_var_list += static_var
+ program_useless_var_list = list(
+ set(get_vars_name_in_block(program.global_block())).difference(
+ set(program_useful_var_list)))
+ for var in program_useless_var_list:
+ program.global_block()._remove_var(var)
+ return program_useless_var_list
+
+
+def block_append_op(program, origin_program, block, op):
+
+ merge_ordereddict = origin_program.global_block().vars.copy()
+ merge_ordereddict.update(block.vars)
+ inputs = _get_input_map_from_op(merge_ordereddict, op)
+ for key, varlist in six.iteritems(inputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for var in varlist:
+ if var.name not in program.global_block(
+ ).vars and var.name not in block.vars:
+ if var.persistable:
+ program.global_block()._clone_variable(
+ var, force_persistable=False)
+ else:
+ block._clone_variable(var, force_persistable=False)
+
+ outputs = _get_output_map_from_op(origin_program.global_block().vars, op)
+ for key, varlist in six.iteritems(outputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for var in varlist:
+ if var.name not in program.global_block(
+ ).vars and var.name not in block.vars:
+ if var.persistable:
+ program.global_block()._clone_variable(
+ var, force_persistable=False)
+ else:
+ block._clone_variable(var, force_persistable=False)
+
+ if "_grad" not in op.type:
+ # for forward op
+ return block.append_op(type=op.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=op.all_attrs())
+ else:
+ # for grad op
+ op_desc = op.desc
+ op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ device_attr_name = core.op_proto_and_checker_maker.kOpDeviceAttrName()
+
+ # append grad op
+ new_op_desc = block.desc.append_op()
+ new_op_desc.copy_from(op_desc)
+ new_op_desc._set_attr(op_role_attr_name, backward)
+
+ # set device gard
+ if op.desc.has_attr(device_attr_name):
+ op_device = op_desc.attr(device_attr_name)
+ new_op_desc._set_attr(device_attr_name, op_device)
+ block._sync_with_cpp()
+
+
+def add_vars_by_var_list(var_name_list, origin_program, program, block):
+ for var_name in var_name_list:
+ if var_name not in program.global_block(
+ ).vars and var_name not in block.vars:
+ var = origin_program.global_block().vars[var_name]
+ if var.persistable:
+ program.global_block()._clone_variable(var,
+ force_persistable=False)
+ else:
+ block._clone_variable(var, force_persistable=False)
+
+
+def get_varlist_from_op_map(var_map):
+ var_list = []
+ for key, varlist in six.iteritems(var_map):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for i in range(len(varlist)):
+ var = varlist[i]
+ var_list.append(var.name)
+ return var_list
+
+
+def find_ops_list_input_output(program, ops_list):
+ input_var_list = []
+ output_var_list = []
+ for op in ops_list:
+ inputs = _get_input_map_from_op(program.global_block().vars, op)
+ input_var_list += get_varlist_from_op_map(inputs)
+ outputs = _get_output_map_from_op(program.global_block().vars, op)
+ output_var_list += get_varlist_from_op_map(outputs)
+
+ input_var_list = list(set(input_var_list))
+ output_var_list = list(set(output_var_list))
+ return input_var_list, output_var_list
+
+
+def find_op_input_output(program, block, op):
+ input_var_list = []
+ output_var_list = []
+ inputs = _get_input_map_from_op(block.vars, op)
+ input_var_list += get_varlist_from_op_map(inputs)
+ outputs = _get_output_map_from_op(block.vars, op)
+ output_var_list += get_varlist_from_op_map(outputs)
+ input_var_list = list(set(input_var_list))
+ output_var_list = list(set(output_var_list))
+ return input_var_list, output_var_list
+
+
+def get_vars_name_in_block(block):
+ vars_list = block.vars.keys()
+ vars_name_list = [var_name for var_name in vars_list]
+ return vars_name_list
+
+
+def is_same_op(op1, op2):
+ if str(op1) != str(op2):
+ return False
+ return True
+
+
+def _get_input_map_from_op(varmap, op):
+ """Returns a dict from op input name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.input_names:
+ vars = []
+ for varname in op.input(key):
+ if varname == "@EMPTY@":
+ continue
+ if "lod_tensor_blocking_queue" in varname:
+ continue
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+
+def _get_output_map_from_op(varmap, op):
+ """Returns a dict from op output name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.output_names:
+ vars = []
+ for varname in op.output(key):
+ if varname == "@EMPTY@":
+ continue
+ if "lod_tensor_blocking_queue" in varname:
+ continue
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+
+def delete_same_ops(block, ops):
+ for op in ops:
+ try:
+ for origin_op in block.ops:
+ if is_same_op(origin_op, op):
+ idx = list(block.ops).index(origin_op)
+ block._remove_op(idx)
+ break
+ except Exception as e:
+ print(e)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa63af7dcf7ac85031fb00ca4c39fb36d7e588b8
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/ufind.py
@@ -0,0 +1,66 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+
+class UnionFind(object):
+ """ Union-find data structure.
+
+ Union-find is a data structure that keeps track of a set of elements partitioned
+ into a number of disjoint (non-overlapping) subsets.
+
+ Reference:
+ https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+
+ Args:
+ elements(list): The initialize element list.
+ """
+
+ def __init__(self, elementes=None):
+ self._parents = [] # index -> parent index
+ self._index = {} # element -> index
+ self._curr_idx = 0
+ if not elementes:
+ elementes = []
+ for ele in elementes:
+ self._parents.append(self._curr_idx)
+ self._index.update({ele: self._curr_idx})
+ self._curr_idx += 1
+
+ def find(self, x):
+ # Find the root index of given element x,
+ # execute the path compress while findind the root index
+ if not x in self._index:
+ return -1
+ idx = self._index[x]
+ while idx != self._parents[idx]:
+ t = self._parents[idx]
+ self._parents[idx] = self._parents[t]
+ idx = t
+ return idx
+
+ def union(self, x, y):
+ # Union two given element
+ x_root = self.find(x)
+ y_root = self.find(y)
+
+ if x_root == y_root:
+ return
+ self._parents[x_root] = y_root
+
+ def is_connected(self, x, y):
+ # If two given elements have the same root index,
+ # then they are connected.
+ return self.find(x) == self.find(y)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py
new file mode 100644
index 0000000000000000000000000000000000000000..f852c1a0311d4cf2b94d4587f8c4b818d2427553
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/ir/vars_metatools.py
@@ -0,0 +1,199 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import print_function
+from functools import reduce
+
+from paddle.fluid.framework import Variable
+from paddle.fluid import core
+
+dtype_to_size = {
+ core.VarDesc.VarType.FP16: 2,
+ core.VarDesc.VarType.FP32: 4,
+ core.VarDesc.VarType.FP64: 8,
+ core.VarDesc.VarType.INT16: 2,
+ core.VarDesc.VarType.INT32: 4,
+ core.VarDesc.VarType.INT64: 8,
+ core.VarDesc.VarType.BOOL: 1,
+ core.VarDesc.VarType.UINT8: 1,
+}
+
+
+class VarBlock:
+
+ def __init__(self, varname, offset, size):
+ self.varname = varname
+ # NOTE: real offset is offset * size
+ self.offset = offset
+ self.size = size
+
+ def __str__(self):
+ return "%s:%d:%d" % (self.varname, self.offset, self.size)
+
+
+def create_var_struct(var):
+ if var.type == core.VarDesc.VarType.SELECTED_ROWS:
+ lod_level = None
+ elif var.type == core.VarDesc.VarType.LOD_TENSOR:
+ lod_level = var.lod_level
+ else:
+ raise ValueError("can only support SELECTED_ROWS/LOD_TENSOR now")
+
+ return VarStruct(var.name, var.shape, var.dtype, var.type, lod_level,
+ var.persistable)
+
+
+class VarStruct(object):
+ """
+ record part properties of a Variable in python.
+ """
+
+ def __init__(self, name, shape, dtype, type, lod_level, persistable):
+ self.name = name
+ self.shape = shape
+ self.dtype = dtype
+ self.type = type
+ self.lod_level = lod_level
+ self.persistable = persistable
+ self.m_size = 1
+ self.m_size = reduce(lambda x, y: x * y, shape)
+ self.m_size *= dtype_to_size[dtype]
+
+ def __str__(self):
+ return "N: {}, S: {}, D: {}, T: {}, LL: {}, P: {}, M: {}".format(
+ self.name, self.shape, self.dtype, self.type, self.lod_level,
+ self.persistable, self.m_size)
+
+
+class VarDistributed(object):
+ """
+ a class to record the var distributed on parameter servers.
+ the class will record the relationship between origin var and slice var.
+ the slice var's properties, such as type/shape/offset/endpoint.
+ """
+
+ def __init__(self,
+ origin_var,
+ slice_var,
+ is_slice=None,
+ block_id=None,
+ offset=None,
+ vtype=None,
+ endpoint=None):
+ """
+ Args:
+ origin_var(Variable|VarStruct): origin var properties
+ slice_var(Variable|VarStruct): slice var properties
+ is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard.
+ block_id(int|None): the number about the slice var.
+ offset(int|None): if the slice var is sliced, offset is the numel before the var.
+ vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch.
+ endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001"
+ """
+
+ if isinstance(origin_var, Variable):
+ self.origin = create_var_struct(origin_var)
+ else:
+ self.origin = origin_var
+
+ if isinstance(slice_var, Variable):
+ self.slice = create_var_struct(slice_var)
+ else:
+ self.slice = slice_var
+
+ if self.equal(self.origin, self.slice):
+ self.is_slice = False
+ self.block_id = 0
+ self.offset = 0
+ else:
+ self.is_slice = True
+ self.block_id = 0
+ self.offset = 0
+
+ if is_slice is not None:
+ self.is_slice = is_slice
+ if block_id is not None:
+ self.block_id = block_id
+ if offset is not None:
+ self.offset = offset
+
+ self.vtype = vtype
+ self.endpoint = endpoint
+
+ @staticmethod
+ def equal(var1, var2):
+ """
+ the two var is equal or not.
+ Returns:
+ bool: equal will return True else False
+ """
+ assert isinstance(var1, VarStruct) and isinstance(var2, VarStruct)
+
+ return var1.name == var2.name and \
+ var1.type == var2.type and \
+ var1.shape == var2.shape and \
+ var1.dtype == var2.dtype and \
+ var1.lod_level == var2.lod_level and \
+ var1.persistable == var2.persistable
+
+ def __str__(self):
+ origin_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})". \
+ format(i="{", e="}", name=self.origin.name, type=self.origin.type,
+ shape=self.origin.shape, dtype=self.origin.dtype)
+
+ slice_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})" \
+ ".slice({is_slice}).block({block_id}).offset({offset})". \
+ format(i="{", e="}", name=self.slice.name, type=self.slice.type,
+ shape=self.slice.shape, dtype=self.slice.dtype,
+ is_slice=self.is_slice, block_id=self.block_id, offset=self.offset)
+
+ return "var owned: {}, origin var: ( {} ), slice var: ( {} ), endpoint: {} ".format(
+ self.vtype, origin_var_str, slice_var_str, self.endpoint)
+
+
+class VarsDistributed(object):
+ """
+ a gather about VarDistributed with many methods to find distributed vars.
+ through the class, we can get overview about the distributed parameters on parameter servers.
+ this class may centralized and convenient for developer to manage and get variable's distribute.
+ other module can also use this to find variables such io.py.
+ """
+
+ def __init__(self):
+ self.distributed_vars = []
+
+ def add_distributed_var(self,
+ origin_var,
+ slice_var,
+ is_slice=None,
+ block_id=None,
+ offset=None,
+ vtype=None,
+ endpoint=None):
+ """
+ add distributed var in this.
+
+ Args:
+ origin_var(Variable|VarStruct): origin var properties
+ slice_var(Variable|VarStruct): slice var properties
+ is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard.
+ block_id(int|None): the number about the slice var.
+ offset(int|None): if the slice var is sliced, offset is the numel before the var.
+ vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch.
+ endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001"
+ Returns:
+ None
+ """
+ self.distributed_vars.append(
+ VarDistributed(origin_var, slice_var, is_slice, block_id, offset,
+ vtype, endpoint))
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/mode.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/mode.py
new file mode 100644
index 0000000000000000000000000000000000000000..0733f9b8a23e42f14817b603f0ca3a3d02b132bf
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/mode.py
@@ -0,0 +1,28 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+
+
+class PSMode:
+ """
+ There are various mode for fleet, each of them is designed for different model.
+ """
+ TRANSPILER = 1
+ PSLIB = 2
+
+
+class DistributedMode:
+ SYNC = 0
+ ASYNC = 1
+ HALF_ASYNC = 2
+ GEO = 3
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d625d47f30901527d34e9138ab0b42981fb7d8f
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/__init__.py
@@ -0,0 +1,1173 @@
+# Copyright (c) 2019 PaddlePaddle 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
+"""Defination of PSLib."""
+
+import os
+import sys
+from .optimizer_factory import *
+from google.protobuf import text_format
+import paddle.fluid as fluid
+from paddle.fluid.framework import Program
+
+from paddle.fluid.incubate.fleet.base.fleet_base import Fleet
+from paddle.fluid.incubate.fleet.base.mode import Mode
+from paddle.fluid.incubate.fleet.base.fleet_base import DistributedOptimizer
+from paddle.fluid.incubate.fleet.base.role_maker import MPISymetricRoleMaker
+from paddle.fluid.incubate.fleet.base.role_maker import HeterRoleMaker
+
+
+class PSLib(Fleet):
+ """PSLib class."""
+
+ def __init__(self):
+ super(PSLib, self).__init__(Mode.PSLIB)
+ self._opt_info = None
+ self._local_ip = 0
+ self._fleet_ptr = None
+ self._main_programs = []
+ self._scopes = []
+ self._client2client_request_timeout_ms = 500000
+ self._client2client_connect_timeout_ms = 10000
+ self._client2client_max_retry = 3
+
+ def init(self, role_maker=None):
+ if role_maker is None:
+ role_maker = MPISymetricRoleMaker()
+ super(PSLib, self).init(role_maker)
+ self._fleet_ptr = fluid.core.Fleet()
+ self._heter_ptr = None
+ if isinstance(role_maker, HeterRoleMaker):
+ self._heter_ptr = fluid.core.Heter()
+
+ def _set_client_communication_config(self, request_timeout_ms,
+ connect_timeout_ms, max_retry):
+ self._client2client_request_timeout_ms = request_timeout_ms
+ self._client2client_connect_timeout_ms = connect_timeout_ms
+ self._client2client_max_retry = max_retry
+
+ def set_pull_local_thread_num(self, thread_num):
+ self._fleet_ptr.set_pull_local_thread_num(thread_num)
+
+ def init_worker(self):
+ """
+ init_worker(): will be called by user. When a user knows current process is_server(), he/she
+ should call init_worker() to initialize global information about worker and connect
+ worker with pserver. You should run startup program before init_worker.
+ Args:
+ executor(Executor): The executor to run for init server.
+ programs(Program|None): The program that need to run.
+ """
+
+ if len(self._main_programs) == 0:
+ raise ValueError(
+ "You should run DistributedOptimizer.minimize() first")
+
+ if self._opt_info:
+ if "fleet_desc" in self._opt_info:
+ self._dist_desc_str = text_format.MessageToString(
+ self._opt_info["fleet_desc"])
+ self._dist_desc = self._opt_info["fleet_desc"]
+ else:
+ raise Exception(
+ "You should run DistributedOptimizer.minimize() first")
+ # barrier_all for init_server, wait for server starts
+ if isinstance(self._role_maker, HeterRoleMaker):
+ if self._role_maker.is_xpu():
+ local_endpoint = self._role_maker.get_local_endpoint()
+ local_endpoint = local_endpoint.split(":")
+ self._heter_ptr.start_xpu_service(str(local_endpoint[0]),
+ int(local_endpoint[1]))
+ self._role_maker._barrier_all()
+ self.all_ips_ = self._role_maker._all_gather(self._local_ip)
+ # worker_index * 2 is for compatible with older versions of pslib
+ self._fleet_ptr.init_worker(self._dist_desc_str, self.all_ips_,
+ self._role_maker._get_size(),
+ self._role_maker.worker_index() * 2)
+ if isinstance(self._role_maker, HeterRoleMaker):
+ if self._role_maker.is_worker():
+ self._heter_ptr.set_xpu_list(
+ self._role_maker._xpu_endpoints)
+ self._heter_ptr.create_client2xpu_connection()
+ # barrier_all for init_worker
+ self._role_maker._barrier_all()
+ # prepare for client to client communication
+ if self._role_maker.is_worker():
+ info = self._fleet_ptr.get_clients_info()
+ print("Client Info: {}".format(info))
+ all_info = self._role_maker._worker_gather(info[0])
+ print("All Client Info: {}".format(all_info))
+ self._fleet_ptr.gather_clients(all_info)
+ self._fleet_ptr.set_client2client_config(
+ self._client2client_request_timeout_ms,
+ self._client2client_connect_timeout_ms,
+ self._client2client_max_retry)
+ self._fleet_ptr.create_client2client_connection()
+ # barrier for init model
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ tables = []
+ for tp in self._dist_desc.trainer_param:
+ for i in tp.dense_table:
+ tables.append(i)
+ for prog, scope in zip(self._main_programs, self._scopes):
+ prog_id = str(id(prog))
+ prog_conf = self._opt_info['program_configs'][prog_id]
+ prog_tables = {}
+ for key in prog_conf:
+ if "dense" not in key:
+ continue
+ for table_id in prog_conf[key]:
+ prog_tables[int(table_id)] = 0
+ for table in tables:
+ if int(table.table_id) not in prog_tables:
+ continue
+ var_name_list = []
+ for i in range(0, len(table.dense_variable_name)):
+ var_name = table.dense_variable_name[i]
+ if scope.find_var(var_name) is None:
+ raise ValueError(
+ "var " + var_name +
+ " not found in scope, " +
+ "you should run startup program first")
+ var_name_list.append(var_name)
+ if not self._opt_info["use_ps_gpu"]:
+ self._fleet_ptr.init_model(scope,
+ int(table.table_id),
+ var_name_list)
+ # barrier for init model done
+ self._role_maker._barrier_worker()
+ else:
+ raise NameError(
+ "You should run DistributedOptimizer.minimize() first")
+
+ def init_server(self, model_dir=None, **kwargs):
+ """
+ init_server() will be called by user. It will load model from model_dir.
+ Args:
+ model_dir(str): load model path, can be local or hdfs/afs path.
+ kwargs: user-defined attributes, currently support following:
+ model(int): load model mode.
+ 0 is for load whole model,
+ 1 is for load delta model (load diff),
+ default is 0.
+ Example:
+ >>> fleet.init_server("/you/path/to/model", mode = 0)
+ """
+ mode = kwargs.get("mode", 0)
+ if isinstance(self._role_maker, HeterRoleMaker):
+ self._role_maker._barrier_xpu()
+ if self._role_maker.is_first_xpu():
+ self._fleet_ptr.load_model(model_dir, mode)
+ self._role_maker._barrier_xpu()
+ else:
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.load_model(model_dir, mode)
+ self._role_maker._barrier_worker()
+
+ def run_server(self):
+ """
+ init_pserver(): will be called by user. When a user knows current process is_worker(), he/she
+ should call init_pserver() to initialize global information about parameter server
+ """
+ if self._opt_info:
+ if "fleet_desc" in self._opt_info:
+ self._dist_desc_str = text_format.MessageToString(
+ self._opt_info["fleet_desc"])
+ self._dist_desc = self._opt_info["fleet_desc"]
+ else:
+ raise Exception(
+ "You should run DistributedOptimizer.minimize() first")
+ # server_index * 2 is for compatible with older versions of pslib
+ self._fleet_ptr.init_server(self._dist_desc_str,
+ self._role_maker.server_index() * 2)
+ if isinstance(self._role_maker, MPISymetricRoleMaker):
+ self._local_ip = self._fleet_ptr.run_server()
+ else:
+ local_endpoint = self._role_maker.get_local_endpoint()
+ local_endpoint = local_endpoint.split(":")
+ self._local_ip = self._fleet_ptr.run_server(
+ str(local_endpoint[0]), int(local_endpoint[1]))
+
+ # barrier_all for init_server
+ self._role_maker._barrier_all()
+ self.all_ips_ = self._role_maker._all_gather(self._local_ip)
+
+ self._fleet_ptr.gather_servers(self.all_ips_,
+ self._role_maker._get_size())
+ # barrier_all for init_worker, wait all workers start
+ self._role_maker._barrier_all()
+ else:
+ raise Exception(
+ "You should run DistributedOptimizer.minimize() first")
+
+ def end_pass(self, scope):
+ if self._role_maker.worker_index() < self._role_maker.xpu_num():
+ self._heter_ptr.end_pass(scope, self._role_maker.worker_index())
+ self._heter_ptr.stop_xpu_service(self._role_maker.worker_index())
+
+ def train_from_dataset(self,
+ executor,
+ program=None,
+ dataset=None,
+ scope=None,
+ thread=0,
+ debug=False,
+ fetch_list=None,
+ fetch_info=None,
+ print_period=100,
+ fetch_handler=None):
+ """
+
+ """
+
+ if self._role_maker.is_worker():
+ self._role_maker._barrier_heter()
+ executor.train_from_dataset(program, dataset, scope, thread, debug,
+ fetch_list, fetch_info, print_period,
+ fetch_handler)
+
+ def start_heter_trainer(self,
+ executor,
+ program=None,
+ scope=None,
+ debug=False,
+ fetch_list=None,
+ fetch_info=None,
+ print_period=100,
+ fetch_handler=None):
+ """
+
+ """
+
+ trainer_instance = executor.start_heter_trainer(program, scope, debug,
+ fetch_list, fetch_info,
+ print_period,
+ fetch_handler)
+ if self._role_maker.is_xpu():
+ print("barrier heter")
+ self._role_maker._barrier_heter()
+ print("barrier heter")
+ executor._default_executor.release_trainer(trainer_instance)
+
+ def stop_worker(self):
+ """
+ stop(): will be called after a user finishes his/her training task. Fleet instance will be
+ destroyed when stop() is called.
+ """
+ self._role_maker._barrier_worker()
+ # all worker should be finalize first
+ if self._role_maker.is_worker():
+ self._fleet_ptr.finalize_worker()
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.stop_server()
+ if self._heter_ptr:
+ self._heter_ptr.stop_xpu_service()
+ self._role_maker._barrier_worker()
+ self._role_maker._barrier_all()
+ self._role_maker._finalize()
+
+ def distributed_optimizer(self, optimizer, strategy={}):
+ """
+ distributed_optimizer
+ Args:
+ optimizer(Optimizer): optimizer
+ strategy(dict): strategy
+ Examples:
+ .. code-block:: python
+ fleet.distributed_optimizer(optimizer)
+ Returns:
+ optimizer(DownpourOptimizer): downpour optimizer
+ """
+ self._optimizer = DownpourOptimizer(optimizer, strategy)
+ return self._optimizer
+
+ def save_inference_model(self,
+ executor,
+ dirname,
+ feeded_var_names=None,
+ target_vars=None,
+ main_program=None,
+ export_for_deployment=True):
+ """
+ save pserver model called from a worker
+ Args:
+ executor(Executor): fluid executor
+ dirname(str): save model path
+ feeded_var_names(list): default None
+ target_vars(list): default None
+ main_program(Program): default None
+ export_for_deployment(bool): default None
+ Examples:
+ .. code-block:: python
+ fleet.save_inference_model(dirname="hdfs:/my/path")
+ """
+ self._fleet_ptr.save_model(dirname, 0)
+
+ def print_table_stat(self, table_id):
+ """
+ print stat info of table_id,
+ format: tableid, feasign size, mf size
+ Args:
+ table_id(int): the id of table
+ Example:
+ .. code-block:: python
+ fleet.print_table_stat(0)
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.print_table_stat(table_id)
+ self._role_maker._barrier_worker()
+
+ def set_file_num_one_shard(self, table_id, file_num):
+ """
+ set file_num in one shard
+ Args:
+ table_id(int): the id of table
+ file_num(int): file num in one shard
+ Example:
+ .. code-block:: python
+ fleet.set_file_num_one_shard(0, 5)
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.set_file_num_one_shard(table_id, file_num)
+ self._role_maker._barrier_worker()
+
+ def save_persistables(self, executor, dirname, main_program=None, **kwargs):
+ """
+ save presistable parameters,
+ when using fleet, it will save sparse and dense feature
+ Args:
+ executor(Executor): fluid executor
+ dirname(str): save path. It can be hdfs/afs path or local path
+ main_program(Program): fluid program, default None
+ kwargs: use define property, current support following
+ mode(int): 0 means save all pserver model,
+ 1 means save delta pserver model (save diff),
+ 2 means save xbox base,
+ 3 means save batch model.
+ Example:
+ .. code-block:: python
+ fleet.save_persistables(dirname="/you/path/to/model", mode = 0)
+ """
+ mode = kwargs.get("mode", 0)
+ self._fleet_ptr.client_flush()
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.save_model(dirname, mode)
+ self._role_maker._barrier_worker()
+
+ def save_model_with_whitelist(self,
+ executor,
+ dirname,
+ whitelist_path,
+ main_program=None,
+ **kwargs):
+ """
+ save whitelist, mode is consistent with fleet.save_persistables,
+ when using fleet, it will save sparse and dense feature
+
+ Args:
+ executor(Executor): fluid executor
+ dirname(str): save path. It can be hdfs/afs path or local path
+ main_program(Program): fluid program, default None
+ kwargs: use define property, current support following
+ mode(int): 0 means save all pserver model,
+ 1 means save delta pserver model (save diff),
+ 2 means save xbox base,
+ 3 means save batch model.
+
+ Example:
+ .. code-block:: python
+
+ fleet.save_persistables(dirname="/you/path/to/model", mode = 0)
+
+ """
+ mode = kwargs.get("mode", 0)
+ table_id = kwargs.get("table_id", 0)
+ self._fleet_ptr.client_flush()
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.save_model_with_whitelist(table_id, dirname, mode,
+ whitelist_path)
+ self._role_maker._barrier_worker()
+
+ def save_multi_table_one_path(self, table_ids, model_dir, **kwargs):
+ """
+ save pslib multi sparse table in one path.
+ Args:
+ table_ids(list): table ids
+ model_dir(str): if you use hdfs, model_dir should starts with
+ 'hdfs:', otherwise means local dir
+ kwargs(dict): user-defined properties.
+ mode(int): the modes illustrated above, default 0
+ prefix(str): the parts to save can have prefix,
+ for example, part-prefix-000-00000
+ Examples:
+ .. code-block:: python
+ fleet.save_multi_table_one_path("[0, 1]", "afs:/user/path/")
+ """
+ mode = kwargs.get("mode", 0)
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.save_multi_table_one_path(table_ids, model_dir,
+ mode)
+ self._role_maker._barrier_worker()
+
+ def save_cache_model(self, executor, dirname, main_program=None, **kwargs):
+ """
+ save sparse cache table,
+ when using fleet, it will save sparse cache table
+ Args:
+ executor(Executor): fluid executor
+ dirname(str): save path. It can be hdfs/afs path or local path
+ main_program(Program): fluid program, default None
+ kwargs: use define property, current support following
+ mode(int): define for feature extension in the future,
+ currently no use, will pass a default value 0
+ table_id(int): which table to save cache, default is 0
+ Returns:
+ feasign_num(int): cache feasign num
+ Example:
+ .. code-block:: python
+ fleet.save_cache_model(None, dirname="/you/path/to/model", mode = 0)
+ """
+ mode = kwargs.get("mode", 0)
+ table_id = kwargs.get("table_id", 0)
+ self._fleet_ptr.client_flush()
+ self._role_maker._barrier_worker()
+ cache_threshold = 0.0
+
+ if self._role_maker.is_first_worker():
+ cache_threshold = self._fleet_ptr.get_cache_threshold(table_id)
+ #check cache threshold right or not
+ self._role_maker._barrier_worker()
+
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.cache_shuffle(table_id, dirname, mode,
+ cache_threshold)
+
+ self._role_maker._barrier_worker()
+
+ feasign_num = -1
+ if self._role_maker.is_first_worker():
+ feasign_num = self._fleet_ptr.save_cache(table_id, dirname, mode)
+
+ self._role_maker._barrier_worker()
+ return feasign_num
+
+ def shrink_sparse_table(self):
+ """
+ shrink cvm of all sparse embedding in pserver, the decay rate
+ is defined as "show_click_decay_rate" in fleet_desc.prototxt
+ Example:
+ >>> fleet.shrink_sparse_table()
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ tables = []
+ for tp in self._opt_info["fleet_desc"].trainer_param:
+ for i in tp.sparse_table:
+ tables.append(i.table_id)
+ for i in list(set(tables)):
+ self._fleet_ptr.shrink_sparse_table(i)
+ self._role_maker._barrier_worker()
+
+ def shrink_dense_table(self, decay, emb_dim=11, scope=None, table_id=None):
+ """
+ shrink batch_sum in pserver by multiplying by decay
+ Args:
+ decay(float): the decay rate, usually range in (0, 1)
+ emb_dim(int): one element's length in datanorm layer
+ scope(Scope): Scope object, default is fluid.global_scope()
+ table_id(int): table id of shrinking dense table. None means shrink all,
+ you should specify it when using multiple scopes,
+ default is None.
+ Example:
+ >>> fleet.shrink_dense_table(0.98, 11, myscope1, 1)
+ >>> fleet.shrink_dense_table(0.98, 11, myscope1, 2)
+ >>> fleet.shrink_dense_table(0.98, 11, myscope2, 3)
+ """
+ if scope is None:
+ scope = fluid.global_scope()
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ for tp in self._opt_info["fleet_desc"].trainer_param:
+ for i in tp.dense_table:
+ if table_id is not None and table_id != i.table_id:
+ continue
+ var_list = [var for var in i.dense_variable_name]
+ skip = False
+ for var in var_list:
+ if scope.find_var(var) is None:
+ skip = True
+ break
+ if skip:
+ continue
+ self._fleet_ptr.shrink_dense_table(i.table_id, scope,
+ var_list, decay, emb_dim)
+ self._role_maker._barrier_worker()
+
+ def clear_one_table(self, table_id):
+ """
+ clear_one_table() will be called by user. It will clear one table.
+ Args:
+ table_id(int): table id
+ Examples:
+ .. code-block:: python
+ fleet.clear_one_table(0)
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.clear_one_table(table_id)
+ self._role_maker._barrier_worker()
+
+ def clear_model(self):
+ """
+ clear_model() will be called by user. It will clear sparse model.
+ Examples:
+ .. code-block:: python
+ fleet.clear_model()
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.clear_model()
+ self._role_maker._barrier_worker()
+
+ def load_pslib_whitelist(self, table_id, model_path, **kwargs):
+ """
+ load pslib model for one table with whitelist
+
+ Args:
+ table_id(int): load table id
+ model_path(str): load model path, can be local or hdfs/afs path
+ kwargs(dict): user defined params, currently support following:
+ only for load pslib model for one table:
+ mode(int): load model mode. 0 is for load whole model, 1 is
+ for load delta model (load diff), default is 0.
+ only for load params from paddle model:
+ scope(Scope): Scope object
+ model_proto_file(str): path of program desc proto binary
+ file, can be local or hdfs/afs file
+ var_names(list): var name list
+ load_combine(bool): load from a file or split param files
+ default False.
+
+ Examples:
+ .. code-block:: python
+
+ # load pslib model for one table
+ fleet.load_one_table(0, "hdfs:/my_fleet_model/20190714/0/")
+ fleet.load_one_table(1, "hdfs:/xx/xxx", mode = 0)
+
+ # load params from paddle model
+ fleet.load_one_table(2, "hdfs:/my_paddle_model/",
+ scope = my_scope,
+ model_proto_file = "./my_program.bin",
+ load_combine = False)
+
+ # below is how to save proto binary file
+ with open("my_program.bin", "wb") as fout:
+ my_program = fluid.default_main_program()
+ fout.write(my_program.desc.serialize_to_string())
+
+ """
+ self._role_maker._barrier_worker()
+ mode = kwargs.get("mode", 0)
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.load_table_with_whitelist(table_id, model_path,
+ mode)
+ self._role_maker._barrier_worker()
+
+ def load_one_table(self, table_id, model_path, **kwargs):
+ """
+ load pslib model for one table or load params from paddle model
+ Args:
+ table_id(int): load table id
+ model_path(str): load model path, can be local or hdfs/afs path
+ kwargs(dict): user defined params, currently support following:
+ only for load pslib model for one table:
+ mode(int): load model mode. 0 is for load whole model, 1 is
+ for load delta model (load diff), default is 0.
+ only for load params from paddle model:
+ scope(Scope): Scope object
+ model_proto_file(str): path of program desc proto binary
+ file, can be local or hdfs/afs file
+ var_names(list): var name list
+ load_combine(bool): load from a file or split param files
+ default False.
+ Examples:
+ .. code-block:: python
+ # load pslib model for one table
+ fleet.load_one_table(0, "hdfs:/my_fleet_model/20190714/0/")
+ fleet.load_one_table(1, "hdfs:/xx/xxx", mode = 0)
+ # load params from paddle model
+ fleet.load_one_table(2, "hdfs:/my_paddle_model/",
+ scope = my_scope,
+ model_proto_file = "./my_program.bin",
+ load_combine = False)
+ # below is how to save proto binary file
+ with open("my_program.bin", "wb") as fout:
+ my_program = fluid.default_main_program()
+ fout.write(my_program.desc.serialize_to_string())
+ """
+ self._role_maker._barrier_worker()
+ mode = kwargs.get("mode", 0)
+ scope = kwargs.get("scope", None)
+ model_proto_file = kwargs.get("model_proto_file", None)
+ var_names = kwargs.get("var_names", None)
+ load_combine = kwargs.get("load_combine", False)
+ self._role_maker._barrier_worker()
+ if scope is not None and model_proto_file is not None:
+ self._load_one_table_from_paddle_model(scope, table_id, model_path,
+ model_proto_file, var_names,
+ load_combine)
+ elif self._role_maker.is_first_worker():
+ self._fleet_ptr.load_model_one_table(table_id, model_path, mode)
+ self._role_maker._barrier_worker()
+
+ def _load_one_table_from_paddle_model(self,
+ scope,
+ table_id,
+ model_path,
+ model_proto_file,
+ var_names=None,
+ load_combine=False):
+ """
+ load params from paddle model, and push params to pserver
+ Args:
+ scope(Scope): Scope object
+ table_id(int): the id of table to load
+ model_path(str): path of paddle model, can be local or hdfs/afs file
+ model_proto_file(str): path of program desc proto binary file,
+ can be local or hdfs/afs file
+ var_names(list): load var names
+ load_combine(bool): load from a file or split param files
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ # get fs config from fleet_desc
+ fs_name = self._opt_info["fleet_desc"].fs_client_param.uri
+ fs_ugi = self._opt_info["fleet_desc"].fs_client_param.user + "," + \
+ self._opt_info["fleet_desc"].fs_client_param.passwd
+ hadoop_bin = self._opt_info["fleet_desc"].fs_client_param.hadoop_bin
+ # download model_path if it's hdfs/afs
+ if model_path.startswith("hdfs:") or model_path.startswith("afs:"):
+ dest = "./model_for_load_table_%s" % table_id
+ cmd = hadoop_bin + " fs -D fs.default.name=" + fs_name + \
+ " -D hadoop.job.ugi=" + fs_ugi + " -get " + model_path + \
+ " " + dest
+ ret = os.system(cmd)
+ if ret != 0:
+ raise RuntimeError("download model failed")
+ model_path = dest
+ # download model_proto_file if it's hdfs/afs
+ if model_proto_file.startswith("hdfs:") or \
+ model_proto_file.startswith("afs:"):
+ dest = "./model_proto_file_for_load_table_%s" % table_id
+ cmd = hadoop_bin + " fs -D fs.default.name=" + fs_name + \
+ " -D hadoop.job.ugi=" + fs_ugi + " -get " + \
+ model_proto_file + " " + dest
+ ret = os.system(cmd)
+ if ret != 0:
+ raise RuntimeError("download model proto file failed")
+ model_proto_file = dest
+ for tp in self._opt_info["fleet_desc"].trainer_param:
+ for i in tp.dense_table:
+ if table_id is not None and table_id != i.table_id:
+ continue
+ table_var_names = [var for var in i.dense_variable_name]
+ skip = False
+ for var in table_var_names:
+ if scope.find_var(var) is None:
+ skip = True
+ break
+ if skip:
+ continue
+ self._fleet_ptr.load_from_paddle_model(
+ scope, table_id, var_names, model_path,
+ model_proto_file, table_var_names, load_combine)
+ self._role_maker._barrier_worker()
+
+ def confirm(self):
+ """
+ confirm all the updated params in current pass
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.confirm()
+ self._role_maker._barrier_worker()
+
+ def revert(self):
+ """
+ revert all the updated params in current pass
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.revert()
+ self._role_maker._barrier_worker()
+
+ def load_model(self, model_dir=None, **kwargs):
+ """
+ load pslib model, there are at least 4 modes, these modes are the same
+ in load one table/save model/save one table:
+ 0: load checkpoint model
+ 1: load delta model (delta means diff, it's usually for online predict)
+ 2: load base model (base model filters some feasigns in checkpoint, it's
+ usually for online predict)
+ 3: load batch model (do some statistic works in checkpoint, such as
+ calculate unseen days of each feasign)
+ Args:
+ model_dir(str): if you use hdfs, model_dir should starts with
+ 'hdfs:', otherwise means local dir
+ kwargs(dict): user-defined properties.
+ mode(int): the modes illustrated above, default 0
+ Examples:
+ .. code-block:: python
+ fleet.load_model("afs:/user/path/")
+ """
+ mode = kwargs.get("mode", 0)
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.load_model(model_dir, mode)
+ self._role_maker._barrier_worker()
+
+ def save_model(self, model_dir=None, **kwargs):
+ """
+ save pslib model, the modes are same with load model.
+ Args:
+ model_dir(str): if you use hdfs, model_dir should starts with
+ 'hdfs:', otherwise means local dir
+ kwargs(dict): user-defined properties.
+ mode(int): the modes illustrated above, default 0
+ Examples:
+ .. code-block:: python
+ fleet.save_model("afs:/user/path/")
+ """
+ mode = kwargs.get("mode", 0)
+ prefix = kwargs.get("prefix", None)
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.save_model(model_dir, mode)
+ self._role_maker._barrier_worker()
+
+ def save_one_table(self, table_id, model_dir, **kwargs):
+ """
+ save pslib model's one table, the modes are same with load model.
+ Args:
+ table_id(int): table id
+ model_dir(str): if you use hdfs, model_dir should starts with
+ 'hdfs:', otherwise means local dir
+ kwargs(dict): user-defined properties.
+ mode(int): the modes illustrated above, default 0
+ prefix(str): the parts to save can have prefix,
+ for example, part-prefix-000-00000
+ Examples:
+ .. code-block:: python
+ fleet.save_one_table("afs:/user/path/")
+ """
+ mode = kwargs.get("mode", 0)
+ prefix = kwargs.get("prefix", None)
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ if prefix is not None:
+ self._fleet_ptr.save_model_one_table_with_prefix(
+ table_id, model_dir, mode, prefix)
+ else:
+ self._fleet_ptr.save_model_one_table(table_id, model_dir, mode)
+ self._role_maker._barrier_worker()
+
+ def set_date(self, table_id, date):
+ """
+ set_date, eg, 20210918
+ """
+ self._role_maker._barrier_worker()
+ if self._role_maker.is_first_worker():
+ self._fleet_ptr.set_date(table_id, str(date))
+ self._role_maker._barrier_worker()
+
+ def _set_opt_info(self, opt_info):
+ """
+ this function saves the result from DistributedOptimizer.minimize()
+ """
+ self._opt_info = opt_info
+
+
+fleet = PSLib()
+
+
+def _prepare_params(input,
+ size,
+ is_sparse=False,
+ is_distributed=False,
+ padding_idx=None,
+ param_attr=None,
+ dtype='float32'):
+ """
+ preprocess params, this interface is not for users.
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable
+ size(list of int): the embedding dim
+ is_sparse(bool): whether input is sparse ids
+ is_distributed(bool): whether in distributed mode
+ padding_idx(int): padding idx of input
+ param_attr(ParamAttr): To specify the weight parameter property
+ dtype(str): data type of output
+ """
+ if param_attr is None:
+ raise ValueError("param_attr must be set")
+ name = param_attr.name
+ if name is None:
+ raise ValueError("embedding name must be set")
+ if not isinstance(size, list) and not isinstance(size, tuple):
+ raise ValueError("embedding size must be list or tuple")
+ size = size[-1]
+ global FLEET_GLOBAL_DICT
+ FLEET_GLOBAL_DICT["enable"] = True
+ d_table = FLEET_GLOBAL_DICT["emb_to_table"]
+ d_accessor = FLEET_GLOBAL_DICT["emb_to_accessor"]
+ d_size = FLEET_GLOBAL_DICT["emb_to_size"]
+
+ # check embedding size
+ if d_size.get(name) is None:
+ d_size[name] = size
+ elif d_size[name] != size:
+ raise ValueError("embedding size error: %s vs %s" %
+ (size, d_size[name]))
+
+ # check embedding accessor
+ accessor = FLEET_GLOBAL_DICT["cur_accessor"]
+ if d_accessor.get(name) is None:
+ d_accessor[name] = accessor
+ elif d_accessor[name] != accessor:
+ raise ValueError("embedding size error: %s vs %s" %
+ (d_accessor[name], accessor))
+
+ # check embedding table id
+ if d_table.get(name) is None:
+ d_table[name] = FLEET_GLOBAL_DICT["cur_sparse_id"]
+ FLEET_GLOBAL_DICT["cur_sparse_id"] += 1
+
+ # check other params
+ if not is_sparse:
+ raise ValueError("is_sparse must be True")
+ elif not is_distributed:
+ raise ValueError("is_distributed must be True")
+ elif dtype != "float32":
+ raise ValueError("dtype must be float32")
+
+
+def _fleet_embedding(input,
+ size,
+ is_sparse=False,
+ is_distributed=False,
+ padding_idx=None,
+ param_attr=None,
+ dtype='float32'):
+ """
+ add fleet embedding, this interface is not for users.
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable
+ size(list of int): the embedding dim
+ is_sparse(bool): whether input is sparse ids
+ is_distributed(bool): whether in distributed mode
+ padding_idx(int): padding idx of input
+ param_attr(ParamAttr): To specify the weight parameter property
+ dtype(str): data type of output
+ """
+ # check and set params
+ _prepare_params(input, size, is_sparse, is_distributed, padding_idx,
+ param_attr, dtype)
+ name = param_attr.name
+ size = size[-1]
+ if padding_idx is None:
+ padding_idx = 0
+ global FLEET_GLOBAL_DICT
+ return fluid.layers.nn._pull_sparse(
+ input=input,
+ size=size,
+ table_id=FLEET_GLOBAL_DICT["emb_to_table"][name],
+ accessor_class=FLEET_GLOBAL_DICT["emb_to_accessor"][name],
+ name=name,
+ ctr_label_name=FLEET_GLOBAL_DICT["click_name"],
+ padding_id=padding_idx,
+ dtype=dtype,
+ scale_sparse_grad=FLEET_GLOBAL_DICT["scale_sparse_grad"])
+
+
+def _fleet_embedding_v2(input,
+ size,
+ is_sparse=False,
+ is_distributed=False,
+ padding_idx=None,
+ param_attr=None,
+ dtype='float32'):
+ """
+ add fleet embedding v2, this interface is not for users.
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable
+ size(list of int): the embedding dim
+ is_sparse(bool): whether input is sparse ids
+ is_distributed(bool): whether in distributed mode
+ padding_idx(int): padding idx of input
+ param_attr(ParamAttr): To specify the weight parameter property
+ dtype(str): data type of output
+ """
+ # check and set params
+ _prepare_params(input, size, is_sparse, is_distributed, padding_idx,
+ param_attr, dtype)
+ name = param_attr.name
+ size = size[-1]
+ if padding_idx is None:
+ padding_idx = 0
+
+ return fluid.layers.nn._pull_sparse_v2(
+ input=input,
+ size=size,
+ table_id=FLEET_GLOBAL_DICT["emb_to_table"][name],
+ accessor_class=FLEET_GLOBAL_DICT["emb_to_accessor"][name],
+ name=name,
+ ctr_label_name=FLEET_GLOBAL_DICT["click_name"],
+ padding_id=padding_idx,
+ dtype=dtype,
+ scale_sparse_grad=FLEET_GLOBAL_DICT["scale_sparse_grad"])
+
+
+class fleet_embedding(object):
+ """
+ fleet embedding class, it is used as a wrapper
+ Example:
+ .. code-block:: python
+ with fleet_embedding(click_name=label.name):
+ emb = fluid.layers.embedding(
+ input=var,
+ size=[-1, 11],
+ is_sparse=True,
+ is_distributed=True,
+ param_attr=fluid.ParamAttr(name="embedding"))
+ """
+
+ def __init__(self, click_name, scale_sparse_grad=True):
+ """Init."""
+ self.origin_emb = fluid.layers.embedding
+ self.origin_emb_v2 = fluid.embedding
+ # if user uses cvm layer after embedding, click_name can be None
+ self.click_name = "" if click_name is None else click_name
+ self.scale_sparse_grad = scale_sparse_grad
+ # it's default value, will be modified in minimize
+ self.accessor = "DownpourCtrAccessor"
+
+ def __enter__(self):
+ """Enter."""
+ fluid.layers.embedding = _fleet_embedding
+ fluid.embedding = _fleet_embedding_v2
+ FLEET_GLOBAL_DICT["cur_accessor"] = self.accessor
+ FLEET_GLOBAL_DICT["click_name"] = self.click_name
+ FLEET_GLOBAL_DICT["scale_sparse_grad"] = self.scale_sparse_grad
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ """Exit."""
+ fluid.layers.embedding = self.origin_emb
+ fluid.embedding = self.origin_emb_v2
+ FLEET_GLOBAL_DICT["cur_accessor"] = ""
+ FLEET_GLOBAL_DICT["click_name"] = ""
+ FLEET_GLOBAL_DICT["scale_sparse_grad"] = None
+
+
+class DownpourOptimizer(DistributedOptimizer):
+ """
+ DistributedOptimizer is a wrapper for paddle.fluid.optimizer
+ A user should pass a paddle.fluid.optimizer to DistributedOptimizer
+ minimize() function is implemented.
+ DistributedOptimizer is the starting point for a user who wants to
+ run distributed training. The optimized information will be stored in
+ Fleet() instance who holds the global information about current distributed
+ training.
+ Args:
+ optimizer(Optimizer): subclass of Optimizer.
+ strategy(any): config for DownpourOptimizer.
+ Returns:
+ None
+ """
+
+ def __init__(self, optimizer, strategy=None):
+ super(DownpourOptimizer, self).__init__(optimizer, strategy)
+
+ self._optimizer = optimizer
+ self._optimizer_name = "Distributed%s" % optimizer.type.capitalize()
+ if optimizer.type != "adam":
+ print(
+ "Currently, distributed optimizer only support Adam"
+ "Will config built-in adam for you."
+ "We will support more functions in DistributedOptimizer",
+ sys.stderr)
+ self._optimizer_name = "DistributedAdam"
+
+ self._distributed_optimizer = globals()[self._optimizer_name](optimizer)
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ """
+ Currently, backward function can not be called through DistributedOptimizer
+ """
+ raise NotImplementedError()
+
+ def _remove_collective_ops(self, program, name):
+ """
+ colective init op should call once, so remove other call.
+ """
+ block = program.global_block()
+ for ids, op in list(enumerate(block.ops)):
+ if op.type == name:
+ block._remove_op(ids)
+ return
+
+ def apply_gradients(self, params_grads):
+ """
+ Currently, apply_gradients function can not be called through DistributedOptimizer
+ """
+ raise NotImplementedError()
+
+ def get_dist_env(self):
+ trainer_id = int(os.getenv('PADDLE_TRAINER_ID', '0'))
+ trainer_endpoints = ''
+ current_endpoint = ''
+ num_trainers = 0
+ if os.getenv('PADDLE_TRAINER_ENDPOINTS') and os.getenv(
+ 'PADDLE_CURRENT_ENDPOINT'):
+ trainer_endpoints = os.getenv('PADDLE_TRAINER_ENDPOINTS')
+ current_endpoint = os.getenv('PADDLE_CURRENT_ENDPOINT')
+ num_trainers = len(trainer_endpoints.split(','))
+
+ return {
+ 'trainer_id': trainer_id,
+ 'num_trainers': num_trainers,
+ 'current_endpoint': current_endpoint,
+ 'trainer_endpoints': trainer_endpoints
+ }
+
+ def _remove_collective_op_for_embedding(self, loss, table_name):
+ """
+ find multi-sparse-table
+ """
+ table_name = [name + "@GRAD" for name in table_name]
+ need_remove_op_index = []
+ block = loss.block.program.global_block()
+ collective_ops = ["c_sync_calc_stream", "c_allreduce_sum"]
+ for ids, op in list(enumerate(block.ops)):
+ if op.type in collective_ops:
+ if op.input("X")[0] in table_name:
+ need_remove_op_index.append(ids)
+ if op.type == "lookup_table_grad":
+ need_remove_op_index.append(ids)
+ try:
+ if op.output("Out")[0] in table_name:
+ need_remove_op_index.append(ids)
+ except:
+ pass
+
+ need_remove_op_index.sort(reverse=True)
+ for index in need_remove_op_index:
+ block._remove_op(index)
+
+ def minimize(self,
+ losses,
+ scopes=None,
+ startup_programs=None,
+ parameter_list=None,
+ no_grad_set=None,
+ program_mode="all_reduce"):
+ """
+ minimize a program through loss, loss can be a list in DistributedOptimizer.
+ Note that in parameter server mode, a worker will not get anything about optimize_os
+ Because optimizer algorithms run on pserver side. We will make this usable in pserver
+ process, but currently the optimization part is written into Fleet(). A user does not
+ need to care about how to startup a pserver node.
+ Args:
+ losses (Variable|Variable List): loss variable or loss variable list to run optimization.
+ scopes (Scope| Scope List): scope instance.
+ startup_programs (Program|Program List): startup_program for initializing parameters
+ in `parameter_list`.
+ parameter_list (list): list of Variables to update.
+ no_grad_set (set|None): set of Variables should be ignored.
+ program_mode (str|"all_reduce"): grad action for grogram when use_ps_gpu.
+ Returns:
+ tuple: (optimize_ops, params_grads) which are, list of operators appended;
+ and list of (param, grad) Variables pair for optimization.
+ """
+
+ if not isinstance(losses, list):
+ losses = [losses]
+
+ optimize_ops, param_grads, opt_info = \
+ self._distributed_optimizer._minimize(
+ losses,
+ startup_programs,
+ parameter_list,
+ no_grad_set,
+ self._strategy)
+ opt_info["mpi_rank"] = fleet.worker_index()
+ opt_info["mpi_size"] = fleet.worker_num()
+ fleet._set_opt_info(opt_info)
+
+ programs = [loss.block.program for loss in losses]
+
+ if scopes is None:
+ scopes = [fluid.global_scope()] * len(programs)
+
+ if len(scopes) != len(programs):
+ raise ValueError(
+ "You should make sure len(scopes) == len(programs) or set scopes None"
+ )
+
+ fleet._main_programs = programs
+ fleet._scopes = scopes
+ if opt_info["use_ps_gpu"]:
+ from paddle.fluid.transpiler.collective import MultiThread
+ # check start program
+ if program_mode not in [
+ "all_reduce", "fuse_all_reduce", "all_gather",
+ "all_reduce_xpu"
+ ]:
+ raise ValueError("You should set program_mode in [ all_reduce, \
+ fuse_all_reduce, all_gather, all_reduce_xpu ]")
+ env = self.get_dist_env()
+ if not isinstance(losses, list):
+ startup_programs = [startup_programs]
+ for i in range(0, len(startup_programs)):
+
+ t = MultiThread(trans_mode=program_mode)
+ start_program = startup_programs[i]
+ main_program = programs[i]
+ t.transpile(startup_program=start_program,
+ main_program=main_program,
+ rank=env["trainer_id"],
+ endpoints=env["trainer_endpoints"],
+ current_endpoint=env['current_endpoint'],
+ wait_port=False)
+ if i > 0:
+ self._remove_collective_ops(start_program,
+ "c_comm_init_all")
+ for i in range(0, len(losses)):
+ loss = losses[i]
+ embedding_table = self._distributed_optimizer._find_multi_distributed_lookup_table(
+ [loss])
+ self._remove_collective_op_for_embedding(loss, embedding_table)
+
+ return [optimize_ops, param_grads]
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py
new file mode 100644
index 0000000000000000000000000000000000000000..308261cea0676d7efc621397bfbe54b645cbe638
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/node.py
@@ -0,0 +1,629 @@
+# Copyright (c) 2018 PaddlePaddle 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
+"""Defination of Server and Worker."""
+
+from . import ps_pb2 as pslib
+# NOTE: reduce removed in fuctools in python3
+from functools import reduce
+
+
+class Server(object):
+ """
+ A Server basic class
+ it's a base class, does not have implementation
+ """
+
+ def __init__(self):
+ pass
+
+
+class Worker(object):
+ """
+ A Worker basic class.
+ it's a base class, does not have implementation
+ """
+
+ def __init__(self):
+ pass
+
+
+class DownpourServer(Server):
+ """
+ DownpourServer class is used to generate server program_desc
+ Args:
+ server: it is pslib.ServerParameter()
+ Examples:
+ server = DownpourServer()
+ """
+
+ def __init__(self):
+ self._server = pslib.ServerParameter()
+ self._server.downpour_server_param.service_param.server_class = "DownpourBrpcPsServer"
+ self._server.downpour_server_param.service_param.client_class = "DownpourBrpcPsClient"
+ self._server.downpour_server_param.service_param.service_class = "DownpourPsService"
+ self._server.downpour_server_param.service_param.start_server_port = 0
+ self._server.downpour_server_param.service_param.server_thread_num = 12
+
+ def add_sparse_table(self, table_id, strategy):
+ """
+ Args:
+ table_id(int): id of sparse params table
+ strategy(dict): the config dict.
+ Returns:
+ return None
+ """
+
+ for table in self._server.downpour_server_param.downpour_table_param:
+ if table.table_id == table_id:
+ if table.type == pslib.PS_SPARSE_TABLE:
+ return
+ else:
+ raise ValueError("expect table %s type=%s, but actual type=%s" \
+ %(table_id, pslib.PS_SPARSE_TABLE, table.type))
+ if strategy is None:
+ strategy = dict()
+ table = self._server.downpour_server_param.downpour_table_param.add()
+ table.table_id = table_id
+ table.type = pslib.PS_SPARSE_TABLE
+
+ support_sparse_key_list = ['sparse_table_class', 'sparse_compress_in_save', 'sparse_shard_num', \
+ 'sparse_accessor_class', 'sparse_learning_rate', 'sparse_initial_g2sum', 'sparse_initial_range', \
+ 'sparse_weight_bounds', 'sparse_embedx_dim', 'sparse_embedx_threshold', 'sparse_nonclk_coeff', \
+ 'sparse_click_coeff', 'sparse_base_threshold', 'sparse_delta_threshold', 'sparse_delta_keep_days', \
+ 'sparse_delete_after_unseen_days', 'sparse_show_click_decay_rate', 'sparse_delete_threshold', \
+ 'sparse_converter', 'sparse_deconverter', 'sparse_enable_cache', 'sparse_cache_rate', \
+ 'sparse_cache_file_num', 'sparse_beta1_decay_rate', 'sparse_beta2_decay_rate', \
+ 'sparse_ada_epsilon', 'sparse_optimizer', 'sparse_ssd_unseenday_threshold', \
+ 'embed_sparse_optimizer', 'embed_sparse_learning_rate', 'embed_sparse_weight_bounds', \
+ 'embed_sparse_initial_range', 'embed_sparse_initial_g2sum', 'embed_sparse_beta1_decay_rate', \
+ 'embed_sparse_beta2_decay_rate', 'embedx_sparse_optimizer', 'embedx_sparse_learning_rate', \
+ 'embedx_sparse_weight_bounds', 'embedx_sparse_initial_range', 'embedx_sparse_initial_g2sum', \
+ 'embedx_sparse_beta1_decay_rate', 'embedx_sparse_beta2_decay_rate']
+
+ for key in strategy:
+ if key not in support_sparse_key_list:
+ raise ValueError("strategy key '%s' not support" % (key))
+
+ support_table_calss = ['DownpourSparseTable', 'DownpourSparseSSDTable']
+ if strategy.get('sparse_table_class') is not None:
+ table_class = strategy.get('sparse_table_class')
+ if table_class not in support_table_calss:
+ raise ValueError(
+ "support sparse_table_class: [ 'DownpourSparseTable', 'DownpourSparseSSDTable'], \
+ but actual %s" % (table_class))
+ else:
+ table_class = 'DownpourSparseTable'
+
+ table.table_class = table_class
+
+ if table_class == 'DownpourSparseTable' or table_class == 'DownpourSparseSSDTable':
+ table.enable_sparse_table_cache = strategy.get(
+ 'sparse_enable_cache', True)
+ table.sparse_table_cache_rate = strategy.get(
+ 'sparse_cache_rate', 0.00055)
+ table.sparse_table_cache_file_num = strategy.get(
+ 'sparse_cache_file_num', 16)
+ table.compress_in_save = strategy.get('sparse_compress_in_save',
+ True)
+ table.shard_num = strategy.get('sparse_shard_num', 1000)
+ # DownpourFeatureValueAccessor: for ctr task, has cvm, embedding and sgd info
+ # DownpourCtrAccessor : for ctr task, has cvm, slot, embedding and sgd info
+ # DownpourSparseValueAccessor : for general task, has embedding and sgd info
+ # DownpourCtrDoubleAccessor : for ctr task, which show clk are in double
+ # DownpourUnitAccessor : for ctr task, has cvm, slot, embedding and sgd info
+
+ support_accessor_class = [
+ 'DownpourFeatureValueAccessor', 'DownpourCtrAccessor',
+ 'DownpourCtrDymfAccessor', 'DownpourSparseValueAccessor',
+ 'DownpourCtrDoubleAccessor', 'DownpourUnitAccessor',
+ 'DownpourDoubleUnitAccessor'
+ ]
+ if strategy.get('sparse_accessor_class') is not None:
+ accessor_class = strategy.get('sparse_accessor_class')
+ if accessor_class not in support_accessor_class:
+ raise ValueError(
+ "support sparse_accessor_class: ['DownpourFeatureValueAccessor', 'DownpourCtrAccessor', 'DownpourCtrDymfAccessor', \
+ 'DownpourSparseValueAccessor', 'DownpourCtrDoubleAccessor'], \
+ but actual %s" % (accessor_class))
+ else:
+ accessor_class = 'DownpourCtrAccessor'
+
+ table.accessor.accessor_class = accessor_class
+
+ if accessor_class == 'DownpourFeatureValueAccessor' \
+ or accessor_class == 'DownpourCtrAccessor' \
+ or accessor_class == 'DownpourCtrDymfAccessor' \
+ or accessor_class == 'DownpourCtrDoubleAccessor':
+ table.accessor.sparse_sgd_param.learning_rate = strategy.get(
+ 'sparse_learning_rate', 0.05)
+ table.accessor.sparse_sgd_param.initial_g2sum = strategy.get(
+ 'sparse_initial_g2sum', 3)
+ table.accessor.sparse_sgd_param.initial_range = strategy.get(
+ 'sparse_initial_range', 1e-4)
+ if strategy.get('sparse_weight_bounds') is None:
+ table.accessor.sparse_sgd_param.weight_bounds.extend(
+ [-10, 10])
+ else:
+ table.accessor.sparse_sgd_param.weight_bounds.extend(
+ strategy.get('sparse_weight_bounds'))
+ table.accessor.embedx_dim = strategy.get('sparse_embedx_dim', 8)
+ table.accessor.embedx_threshold = strategy.get(
+ 'sparse_embedx_threshold', 10)
+ table.accessor.fea_dim = int(table.accessor.embedx_dim) + 3
+ table.accessor.downpour_accessor_param.nonclk_coeff = strategy.get(
+ 'sparse_nonclk_coeff', 0.1)
+ table.accessor.downpour_accessor_param.click_coeff = strategy.get(
+ 'sparse_click_coeff', 1)
+ table.accessor.downpour_accessor_param.base_threshold = strategy.get(
+ 'sparse_base_threshold', 1.5)
+ table.accessor.downpour_accessor_param.delta_threshold = strategy.get(
+ 'sparse_delta_threshold', 0.25)
+ table.accessor.downpour_accessor_param.delta_keep_days = strategy.get(
+ 'sparse_delta_keep_days', 16)
+ table.accessor.downpour_accessor_param.delete_after_unseen_days = strategy.get(
+ 'sparse_delete_after_unseen_days', 30)
+ table.accessor.downpour_accessor_param.ssd_unseenday_threshold = strategy.get(
+ 'sparse_ssd_unseenday_threshold', 1)
+ table.accessor.downpour_accessor_param.show_click_decay_rate = strategy.get(
+ 'sparse_show_click_decay_rate', 0.98)
+ table.accessor.downpour_accessor_param.delete_threshold = strategy.get(
+ 'sparse_delete_threshold', 0.8)
+ converter = strategy.get(
+ 'sparse_converter',
+ "(scripts/xbox_compressor_mf.py | bin/xbox_pb_converter)")
+ deconverter = strategy.get(
+ 'sparse_deconverter',
+ "(bin/xbox_pb_deconverter | scripts/xbox_decompressor_mf.awk)"
+ )
+
+ table1 = table.accessor.table_accessor_save_param.add()
+ table1.param = 1
+ table1.converter = converter
+ table1.deconverter = deconverter
+
+ table2 = table.accessor.table_accessor_save_param.add()
+ table2.param = 2
+ table2.converter = converter
+ table2.deconverter = deconverter
+ elif accessor_class == 'DownpourSparseValueAccessor':
+ optimizer_name = strategy.get("sparse_optimizer", "adam")
+ table.accessor.sparse_commonsgd_param.name = optimizer_name
+ table.accessor.embedx_dim = strategy.get('sparse_embedx_dim', 8)
+ table.accessor.fea_dim = int(table.accessor.embedx_dim)
+ if optimizer_name == "naive":
+ table.accessor.sparse_commonsgd_param.naive.learning_rate = \
+ strategy.get('sparse_learning_rate', 0.05)
+ table.accessor.sparse_commonsgd_param.naive.initial_range = \
+ strategy.get('sparse_initial_range', 1e-4)
+ if strategy.get('sparse_weight_bounds') is None:
+ table.accessor.sparse_commonsgd_param.naive.weight_bounds.extend(
+ [-10, 10])
+ else:
+ table.accessor.sparse_commonsgd_param.naive.weight_bounds.extend(
+ strategy.get('sparse_weight_bounds'))
+ elif optimizer_name == "adagrad":
+ table.accessor.sparse_commonsgd_param.adagrad.learning_rate = \
+ strategy.get('sparse_learning_rate', 0.05)
+ table.accessor.sparse_commonsgd_param.adagrad.initial_range = \
+ strategy.get('sparse_initial_range', 1e-4)
+ table.accessor.sparse_commonsgd_param.adagrad.initial_g2sum = strategy.get(
+ 'sparse_initial_g2sum', 3)
+ if strategy.get('sparse_weight_bounds') is None:
+ table.accessor.sparse_commonsgd_param.adagrad.weight_bounds.extend(
+ [-10, 10])
+ else:
+ table.accessor.sparse_commonsgd_param.adagrad.weight_bounds.extend(
+ strategy.get('sparse_weight_bounds'))
+ elif optimizer_name == "adam":
+ table.accessor.sparse_commonsgd_param.adam.learning_rate = \
+ strategy.get('sparse_learning_rate', 0.001)
+ table.accessor.sparse_commonsgd_param.adam.initial_range = \
+ strategy.get('sparse_initial_range', 1e-4)
+ table.accessor.sparse_commonsgd_param.adam.beta1_decay_rate = strategy.get(
+ 'sparse_beta1_decay_rate', 0.9)
+ table.accessor.sparse_commonsgd_param.adam.beta2_decay_rate = strategy.get(
+ 'sparse_beta2_decay_rate', 0.999)
+ table.accessor.sparse_commonsgd_param.adam.ada_epsilon = strategy.get(
+ 'sparse_ada_epsilon', 1e-8)
+ if strategy.get('sparse_weight_bounds') is None:
+ table.accessor.sparse_commonsgd_param.adam.weight_bounds.extend(
+ [-10, 10])
+ else:
+ table.accessor.sparse_commonsgd_param.adam.weight_bounds.extend(
+ strategy.get('sparse_weight_bounds'))
+ converter = strategy.get(
+ 'sparse_converter',
+ "(scripts/xbox_compressor_mf.py | bin/xbox_pb_converter)")
+ deconverter = strategy.get(
+ 'sparse_deconverter',
+ "(bin/xbox_pb_deconverter | scripts/xbox_decompressor_mf.awk)"
+ )
+
+ table1 = table.accessor.table_accessor_save_param.add()
+ table1.param = 1
+ table1.converter = converter
+ table1.deconverter = deconverter
+
+ table2 = table.accessor.table_accessor_save_param.add()
+ table2.param = 2
+ table2.converter = converter
+ table2.deconverter = deconverter
+ elif accessor_class == 'DownpourUnitAccessor' or accessor_class == 'DownpourDoubleUnitAccessor':
+ self.add_sparse_table_common_config(table, strategy)
+ self.add_sparse_optimizer(table.accessor.embed_sgd_param,
+ strategy, "embed_")
+ self.add_sparse_optimizer(table.accessor.embedx_sgd_param,
+ strategy, "embedx_")
+
+ def add_dense_table(self, table_id, param_var, grad_var, strategy,
+ sparse_table_names):
+ """
+ Args:
+ table_id(int): id of sparse params table
+ param_var(list): param vars
+ grad_var(list): param grad vars
+ strategy(dict): the dense config dict
+ sparse_table_names(list): sparse table names
+ Returns:
+ return None
+ """
+ fea_dim = 0
+ dense_param_vars = []
+ for p in param_var:
+ if p.name not in sparse_table_names:
+ dense_param_vars.append(p)
+
+ for param in dense_param_vars:
+ fea_dim += reduce(lambda x, y: x * y, param.shape, 1)
+
+ for table in self._server.downpour_server_param.downpour_table_param:
+ if table.table_id == table_id:
+ if table.type == pslib.PS_DENSE_TABLE:
+ table.accessor.fea_dim = fea_dim
+ return
+ else:
+ raise ValueError("expect table %s type=%s, but actual type=%s" \
+ %(table_id, pslib.PS_DENSE_TABLE, table.type))
+
+ if strategy is None:
+ strategy = dict()
+ table = self._server.downpour_server_param.downpour_table_param.add()
+ table.table_id = table_id
+ support_dense_key_list = ['dense_table_class', 'dense_compress_in_save', 'dense_accessor_class', \
+ 'dense_optimizer', 'dense_learning_rate', 'dense_avg_decay', 'dense_ada_decay', \
+ 'dense_ada_epsilon', 'dense_mom_decay', 'dense_naive_lr']
+
+ for key in strategy:
+ if key not in support_dense_key_list:
+ raise ValueError("strategy key '%s' not support" % (key))
+
+ table.table_class = strategy.get('dense_table_class',
+ "DownpourDenseTable")
+ table.type = pslib.PS_DENSE_TABLE
+ table.compress_in_save = strategy.get('dense_compress_in_save', True)
+ table.accessor.accessor_class = strategy.get(
+ 'dense_accessor_class', "DownpourDenseValueAccessor")
+ table.accessor.dense_sgd_param.name = strategy.get(
+ 'dense_optimizer', "adam")
+ table.accessor.dense_sgd_param.adam.learning_rate = strategy.get(
+ 'dense_learning_rate', 5e-06)
+ table.accessor.dense_sgd_param.adam.avg_decay_rate = strategy.get(
+ 'dense_avg_decay', 0.999993)
+ table.accessor.dense_sgd_param.adam.ada_decay_rate = strategy.get(
+ 'dense_ada_decay', 0.9999)
+ table.accessor.dense_sgd_param.adam.ada_epsilon = strategy.get(
+ 'dense_ada_epsilon', 1e-8)
+ table.accessor.dense_sgd_param.adam.mom_decay_rate = strategy.get(
+ 'dense_mom_decay', 0.99)
+ table.accessor.dense_sgd_param.naive.learning_rate = strategy.get(
+ 'dense_naive_lr', 0.0002)
+ table.accessor.fea_dim = fea_dim
+
+ def add_data_norm_table(self, table_id, learning_rate, param_var, grad_var,
+ strategy, sparse_table_names):
+ """
+ Args:
+ table_id(int): id of datanorm table
+ learning_rate(float): the learning rate used to update parameters
+ param_var(list): param vars
+ grad_var(list): param grad vars
+ strategy(dict): the datanorm config dict
+ sparse_table_names(list): sparse table names
+ Returns:
+ return None
+ """
+ fea_dim = 0
+ dense_param_vars = []
+ for p in param_var:
+ if p.name not in sparse_table_names:
+ dense_param_vars.append(p)
+
+ for param in dense_param_vars:
+ fea_dim += reduce(lambda x, y: x * y, param.shape, 1)
+
+ for table in self._server.downpour_server_param.downpour_table_param:
+ if table.table_id == table_id:
+ if table.type == pslib.PS_DENSE_TABLE:
+ table.accessor.fea_dim = fea_dim
+ return
+ else:
+ raise ValueError("expect table %s type=%s, but actual type=%s" \
+ %(table_id, pslib.PS_DENSE_TABLE, table.type))
+ if strategy is None:
+ strategy = dict()
+
+ support_datanorm_key_list = ['datanorm_table_class', 'datanorm_compress_in_save', \
+ 'datanorm_accessor_class', 'datanorm_operation', 'datanorm_decay_rate']
+
+ for key in strategy:
+ if key not in support_datanorm_key_list:
+ raise ValueError("strategy key '%s' not support" % (key))
+
+ table = self._server.downpour_server_param.downpour_table_param.add()
+ table.table_id = table_id
+ table.table_class = strategy.get('datanorm_table_class',
+ 'DownpourDenseTable')
+ table.type = pslib.PS_DENSE_TABLE
+ table.compress_in_save = strategy.get('datanorm_compress_in_save', True)
+ table.accessor.accessor_class = strategy.get(
+ 'datanorm_accessor_class', 'DownpourDenseValueAccessor')
+ table.accessor.dense_sgd_param.name = strategy.get(
+ 'datanorm_operation', 'summary')
+ table.accessor.dense_sgd_param.summary.summary_decay_rate = strategy.get(
+ 'datanorm_decay_rate', 0.999999)
+ table.accessor.fea_dim = fea_dim
+
+ def add_sparse_optimizer(self, sgd, strategy, prefix):
+ optimizer_name = strategy.get(prefix + "sparse_optimizer", "adagrad")
+ sgd.name = optimizer_name
+ if optimizer_name == "naive":
+ sgd.naive.learning_rate = \
+ strategy.get(prefix + 'sparse_learning_rate', 0.05)
+ sgd.naive.initial_range = \
+ strategy.get(prefix + 'sparse_initial_range', 1e-4)
+ bounds = strategy.get(prefix + 'sparse_weight_bounds', [-10, 10])
+ sgd.naive.weight_bounds.extend(bounds)
+ elif optimizer_name == "adagrad":
+ sgd.adagrad.learning_rate = \
+ strategy.get(prefix + 'sparse_learning_rate', 0.05)
+ sgd.adagrad.initial_range = \
+ strategy.get(prefix + 'sparse_initial_range', 1e-4)
+ if prefix == "embed_":
+ sgd.adagrad.initial_range = 0
+ sgd.adagrad.initial_g2sum = strategy.get(
+ prefix + 'sparse_initial_g2sum', 3)
+ bounds = strategy.get(prefix + 'sparse_weight_bounds', [-10, 10])
+ sgd.adagrad.weight_bounds.extend(bounds)
+ elif optimizer_name == "std_adagrad":
+ sgd.adagrad.learning_rate = \
+ strategy.get(prefix + 'sparse_learning_rate', 0.05)
+ sgd.adagrad.initial_range = \
+ strategy.get(prefix + 'sparse_initial_range', 1e-4)
+ if prefix == "embed_":
+ sgd.adagrad.initial_range = 0
+ sgd.adagrad.initial_g2sum = strategy.get(
+ prefix + 'sparse_initial_g2sum', 3)
+ bounds = strategy.get(prefix + 'sparse_weight_bounds', [-10, 10])
+ sgd.adagrad.weight_bounds.extend(bounds)
+ elif optimizer_name == "adam":
+ sgd.adam.learning_rate = \
+ strategy.get(prefix + 'sparse_learning_rate', 0.001)
+ sgd.adam.initial_range = \
+ strategy.get(prefix + 'sparse_initial_range', 1e-4)
+ sgd.adam.beta1_decay_rate = strategy.get(
+ prefix + 'sparse_beta1_decay_rate', 0.9)
+ sgd.adam.beta2_decay_rate = strategy.get(
+ prefix + 'sparse_beta2_decay_rate', 0.999)
+ sgd.adam.ada_epsilon = strategy.get(prefix + 'sparse_ada_epsilon',
+ 1e-8)
+ bounds = strategy.get(prefix + 'sparse_weight_bounds', [-10, 10])
+ sgd.adam.weight_bounds.extend(bounds)
+
+ def add_sparse_table_common_config(self, table, strategy):
+ table.accessor.embedx_dim = strategy.get('sparse_embedx_dim', 8)
+ table.accessor.embedx_threshold = strategy.get(
+ 'sparse_embedx_threshold', 10)
+ table.accessor.fea_dim = int(table.accessor.embedx_dim) + 3
+ table.accessor.downpour_accessor_param.nonclk_coeff = strategy.get(
+ 'sparse_nonclk_coeff', 0.1)
+ table.accessor.downpour_accessor_param.click_coeff = strategy.get(
+ 'sparse_click_coeff', 1)
+ table.accessor.downpour_accessor_param.base_threshold = strategy.get(
+ 'sparse_base_threshold', 1.5)
+ table.accessor.downpour_accessor_param.delta_threshold = strategy.get(
+ 'sparse_delta_threshold', 0.25)
+ table.accessor.downpour_accessor_param.delta_keep_days = strategy.get(
+ 'sparse_delta_keep_days', 16)
+ table.accessor.downpour_accessor_param.delete_after_unseen_days = strategy.get(
+ 'sparse_delete_after_unseen_days', 30)
+ table.accessor.downpour_accessor_param.show_click_decay_rate = strategy.get(
+ 'sparse_show_click_decay_rate', 0.98)
+ table.accessor.downpour_accessor_param.delete_threshold = strategy.get(
+ 'sparse_delete_threshold', 0.8)
+ converter = strategy.get(
+ 'sparse_converter',
+ "(scripts/xbox_compressor_mf.py | bin/xbox_pb_converter)")
+ deconverter = strategy.get(
+ 'sparse_deconverter',
+ "(bin/xbox_pb_deconverter | scripts/xbox_decompressor_mf.awk)")
+
+ table1 = table.accessor.table_accessor_save_param.add()
+ table1.param = 1
+ table1.converter = converter
+ table1.deconverter = deconverter
+
+ table2 = table.accessor.table_accessor_save_param.add()
+ table2.param = 2
+ table2.converter = converter
+ table2.deconverter = deconverter
+
+ def get_desc(self):
+ """
+ Return downpour server program_desc
+ """
+ return self._server
+
+
+class DownpourWorker(Worker):
+ """
+ DownpourWorker class is used to generate worker program_desc
+ Args:
+ window (int): push params frequency
+ worker: it is pslib.DownpourTrainerParameter
+ Examples:
+ worker = DownpourWorker(1)
+ """
+
+ def __init__(self, window):
+ self.window = window
+ self._worker = pslib.DownpourTrainerParameter()
+
+ def add_sparse_table(self,
+ table_id,
+ slot_key_vars,
+ slot_value_vars,
+ slot_value_grads=None):
+ """
+ Args:
+ table_id(int): id of sparse params table
+ slot_key_vars(list): slot key id
+ slot_value_vars(list): slot key value after embedding
+ slot_value_grads(list): grad of all params, default is None
+ Returns:
+ return None
+ """
+ if slot_value_grads is None:
+ slot_value_grad_names = \
+ [var.name + "@GRAD" for var in slot_value_vars]
+ else:
+ value_to_key = {}
+ for i in range(len(slot_key_vars)):
+ value_to_key[slot_value_vars[i].name] = slot_key_vars[i]
+ slot_value_grad_names = []
+ all_grad_names = [var.name for var in slot_value_grads]
+ for var in slot_value_vars:
+ if var.name + "@GRAD" in all_grad_names:
+ slot_value_grad_names.append(var.name + "@GRAD")
+ sorted_slot_value_vars = [i for i in slot_value_vars if \
+ i.name + "@GRAD" in slot_value_grad_names]
+ sorted_slot_value_vars += [i for i in slot_value_vars if \
+ i.name + "@GRAD" not in slot_value_grad_names]
+ sorted_slot_key_vars = \
+ [value_to_key[v.name] for v in sorted_slot_value_vars]
+
+ target_table = None
+ for table in self._worker.sparse_table:
+ if table.table_id == table_id:
+ keys = table.slot_key
+ key_names = [var.name for var in sorted_slot_key_vars]
+ for key_name in key_names:
+ if key_name not in keys:
+ raise ValueError("sparse table %s slot_key error" %
+ table_id)
+ target_table = table
+ break
+
+ table = target_table
+ if table is not None:
+ self._worker.sparse_table.remove(table)
+ table = self._worker.sparse_table.add()
+ table.table_id = table_id
+ table.slot_key.extend([var.name for var in sorted_slot_key_vars])
+ table.slot_value.extend([var.name for var in sorted_slot_value_vars])
+ table.slot_gradient.extend(slot_value_grad_names)
+
+ def add_dense_table(self, table_id, learning_rate, param_vars, grad_vars,
+ dense_start_table_id, sparse_table_names):
+ r"""
+ Args:
+ table_id(int): id of sparse params table
+ learning_rate(float): the learning rate used to update parameters. \
+ Can be a float value
+ param_vars(list): all dense param. it is a list.
+ grad_vars(list): all dense grad parm it is a list.
+ dense_start_table_id(int): dense table start index
+ sparse_table_names(list): sparse table names
+ Returns:
+ return None
+ """
+ sparse_table_name_grad = []
+ for name in sparse_table_names:
+ sparse_table_name_grad.append(name + "@GRAD")
+
+ dense_param_name = []
+ for p in param_vars:
+ if p.name not in sparse_table_names:
+ dense_param_name.append(p.name)
+
+ dense_grad_name = []
+ for g in grad_vars:
+ if g.name not in sparse_table_name_grad:
+ dense_grad_name.append(g.name)
+
+ dense_param_name.sort()
+ dense_grad_name.sort()
+
+ for table in self._worker.dense_table:
+ if table.table_id == table_id:
+ desc_dense_param_name = list(table.dense_variable_name)
+ desc_dense_param_name.sort()
+
+ if dense_param_name == desc_dense_param_name:
+ desc_dense_grad_name = list(
+ table.dense_gradient_variable_name)
+ desc_dense_grad_name.sort()
+ if dense_grad_name == desc_dense_grad_name:
+ return
+ else:
+ raise ValueError(
+ "dense table %s dense_gradient_variable_name "
+ "error" % table_id)
+ else:
+ raise ValueError(
+ "dense table %s dense_variable_name error" % table_id)
+
+ table = self._worker.dense_table.add()
+ table.table_id = table_id
+
+ #def cmp_fc(x, y):
+ # if x.startswith("fc_") and y.startswith("fc_"):
+ # index_x = x.find('.')
+ # index_y = y.find('.')
+ # if index_x > 0 and index_y > 0:
+ # num_x = x[3:index_x]
+ # num_y = y[3:index_y]
+ # if num_x.isdigit() and num_y.isdigit():
+ # if int(num_x) < int(num_y):
+ # return -1
+ # if int(num_x) > int(num_y):
+ # return 1
+ # if x[index_x + 1] == 'w' and y[index_y + 1] == 'b':
+ # return -1
+ # if x[index_x + 1] == 'b' and y[index_y + 1] == 'w':
+ # return 1
+ # if x < y:
+ # return -1
+ # else:
+ # return 1
+
+ #table.dense_variable_name.extend(sorted(dense_param_name, cmp_fc))
+ #table.dense_gradient_variable_name.extend(
+ # sorted(dense_grad_name, cmp_fc))
+ table.dense_variable_name.extend(dense_param_name)
+ table.dense_gradient_variable_name.extend(dense_grad_name)
+
+ def get_desc(self):
+ """
+ Return downpour worker program_desc
+ """
+ return self._worker
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..35cda4c34b00969012b4a9f564095309d2ee9659
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/optimizer_factory.py
@@ -0,0 +1,910 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+"""Optimizer Factory."""
+
+__all__ = ["DistributedAdam", "FLEET_GLOBAL_DICT"]
+import paddle.fluid as fluid
+from paddle.fluid import core
+from paddle.fluid.distribute_lookup_table import find_distributed_lookup_table
+from paddle.fluid.distribute_lookup_table import find_distributed_lookup_table_inputs
+from paddle.fluid.distribute_lookup_table import find_distributed_lookup_table_outputs
+from google.protobuf import text_format
+from collections import OrderedDict
+import copy
+from .node import DownpourWorker, DownpourServer
+from . import ps_pb2 as pslib
+import os
+import logging
+
+OpRole = core.op_proto_and_checker_maker.OpRole
+# this dict is for store info about pull/push sparse ops.
+FLEET_GLOBAL_DICT = {
+ # global settings
+ "enable": False,
+ "emb_to_table": {},
+ "emb_to_accessor": {},
+ "emb_to_size": {},
+ # current embedding settings
+ "cur_sparse_id": 0,
+ "cur_accessor": "",
+ "click_name": "",
+ "scale_sparse_grad": None,
+}
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(message)s')
+ch = logging.StreamHandler()
+ch.setFormatter(formatter)
+logger.addHandler(ch)
+
+
+class DistributedOptimizerImplBase(object):
+ """
+ DistributedOptimizerImplBase
+ base class of optimizers
+ """
+
+ def __init__(self, optimizer):
+ self._optimizer = optimizer
+ self._learning_rate = optimizer._learning_rate
+ self._regularization = optimizer.regularization
+
+ def minimize(self,
+ losses,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ """
+ Args:
+ losses(Variable): loss variable defined by user
+ startup_program(Program): startup program that defined by user
+ parameter_list(str list): parameter names defined by users
+ no_grad_set(set): a set of variables that is defined by users
+ so that these variables do not need gradient computation
+ """
+ pass
+
+
+class DistributedAdam(DistributedOptimizerImplBase):
+ """
+ DistributedAdam
+ adam optimizer in distributed training
+ """
+
+ def __init__(self, optimizer):
+ # todo(guru4elephant): add more optimizers here as argument
+ # todo(guru4elephant): make learning_rate as a variable
+ super(DistributedAdam, self).__init__(optimizer)
+ self._window = 1
+ self.type = "downpour"
+ self.data_norm_name = [
+ ".batch_size", ".batch_square_sum", ".batch_sum",
+ ".batch_size@GRAD", ".batch_square_sum@GRAD", ".batch_sum@GRAD"
+ ]
+ self.supported_embedding_types = [
+ "lookup_table", "pull_sparse", "pull_sparse_v2", "pull_box_sparse",
+ "pull_gpups_sparse"
+ ]
+ self.supported_embedding_grad_types = [
+ "lookup_table_grad", "push_sparse", "push_sparse_v2"
+ ]
+ op_maker = core.op_proto_and_checker_maker
+ self.op_role_key = op_maker.kOpRoleAttrName()
+
+ def _find_distributed_lookup_table_inputs(self, program, table_names):
+ """
+ Find input variable of distribute lookup table in program.
+ We could support multi-distribute table now.
+ Args:
+ program(Program): given program, locate distributed lookup table
+ table_name(str): given table names that is found beforehand
+ Returns:
+ inputs
+ """
+ local_vars = program.current_block().vars
+ inputs_dict = dict()
+ for table_name in table_names:
+ inputs_dict[table_name] = []
+
+ for op in program.global_block().ops:
+ if op.type in self.supported_embedding_types:
+ if op.input("W")[0] in table_names:
+ inputs_dict[op.input("W")[0]].extend(
+ [local_vars[name] for name in op.input("Ids")])
+ return inputs_dict
+
+ def _find_distributed_lookup_table_outputs(self, program, table_names):
+ """
+ Find output variable of distribute lookup table in program.
+ We could support multi-distribute table now.
+ Args:
+ programs(Program): given program, locate distributed lookup table
+ table_name(str): given table name that is found beforehand
+ Returns:
+ outputs
+ """
+ local_vars = program.current_block().vars
+ outputs_dict = dict()
+ for table_name in table_names:
+ outputs_dict[table_name] = []
+
+ for op in program.global_block().ops:
+ if op.type in self.supported_embedding_types:
+ if op.input("W")[0] in table_names:
+ outputs_dict[op.input("W")[0]].extend(
+ [local_vars[name] for name in op.output("Out")])
+ return outputs_dict
+
+ def _find_distributed_lookup_table_grads(self, program, table_names):
+ local_vars = program.current_block().vars
+ grads_dict = dict()
+ for table_name in table_names:
+ grads_dict[table_name] = []
+
+ for op in program.global_block().ops:
+ if op.type in self.supported_embedding_grad_types:
+ if op.input("W")[0] in table_names:
+ grads_dict[op.input("W")[0]].extend(
+ [local_vars[name] for name in op.input("Out@GRAD")])
+ return grads_dict
+
+ def _is_optimizer_op(self, op):
+ return self.op_role_key in op.attr_names and \
+ int(op.all_attrs()[self.op_role_key]) & int(OpRole.Optimize)
+
+ def _remove_optimize_op_for_embedding(self, loss, table_name):
+ """
+ find multi-sparse-table
+ """
+ table_name = [name + "@GRAD" for name in table_name]
+ need_remove_op_index = []
+ block = loss.block.program.global_block()
+ for ids, op in list(enumerate(block.ops)):
+ if self._is_optimizer_op(op):
+ if op.input("Grad")[0] in table_name:
+ need_remove_op_index.append(ids)
+
+ need_remove_op_index.sort(reverse=True)
+ for index in need_remove_op_index:
+ block._remove_op(index)
+
+ def _find_multi_distributed_lookup_table(self, losses):
+ """
+ find multi-sparse-table
+ """
+ table_names = set()
+ cnt = 0
+ tmp_list = []
+ ret_list = []
+ for loss in losses:
+ for op in loss.block.program.global_block().ops:
+ if op.type in self.supported_embedding_types:
+ if op.attr('is_distributed') is True:
+ table_name = op.input("W")[0]
+ if table_name not in table_names:
+ table_names.add(table_name)
+ tmp_list.append([table_name, cnt])
+ cnt += 1
+ tmp_list.sort(key=lambda k: k[1])
+ for x in tmp_list:
+ ret_list.append(x[0])
+ return ret_list
+
+ def _if_last_block(self, op, _equal_dict):
+ # for conditional_block op
+ cond_str = op.input('Cond')[0]
+ bool_test = False
+ if cond_str.startswith('equal'):
+ bool_test = True
+ vars_ = op.input('Input')
+ equal_keys = _equal_dict.keys()
+ for var_cond in vars_:
+ if var_cond in equal_keys:
+ if bool_test:
+ print("the conditional block is error")
+ return False
+ return True
+
+ def _generte_cond_para_map(self, op, _fill_value_dict, _equal_fill_dict,
+ _now_program, _all_params):
+ # generate cond value to parameter map recursively
+ cond_str = op.input('Cond')[0]
+ vars_ = op.input('Input')
+
+ if self._if_last_block(op, _equal_fill_dict):
+ vars_ = op.input('Input')
+ cond_key = ""
+ if cond_str.startswith('equal'):
+ cond_key = int(_fill_value_dict[_equal_fill_dict[cond_str]])
+ else:
+ cond_key = -1
+ p_list = []
+ for var_cond in vars_:
+ if var_cond in _all_params:
+ p_list.append(var_cond)
+
+ self._cond_params[cond_key] = p_list
+ self._other_params.extend(p_list)
+ else:
+ ops_cond = _now_program.block(int(op.attr('sub_block').id)).ops
+ for op in ops_cond:
+ if op.type == 'conditional_block':
+ self._generte_cond_para_map(op, _fill_value_dict,
+ _equal_fill_dict, _now_program,
+ _all_params)
+
+ def _has_conditional_block(self, loss):
+ now_program = loss.block.program
+ root_block = now_program.block(0)
+ ops_ = root_block.ops
+ for op in ops_:
+ if op.type == 'conditional_block':
+ return True
+ return False
+
+ def _check_params_grads(self, params, grads):
+ if len(params) != len(grads):
+ raise ValueError("params size != grads size, %s vs %s" %
+ (len(params), len(grads)))
+
+ pname2grad = dict()
+ for i in range(len(params)):
+ pname = params[i].name
+ gname = grads[i].name
+ if pname != gname[:-5]:
+ raise ValueError(" params != grads , %s vs %s" % (pname, gname))
+ pname2grad[pname] = grads[i]
+
+ return pname2grad
+
+ def _generate_multi_dense_table(self,
+ params,
+ grads,
+ cond_params,
+ other_params,
+ sparse_table_names,
+ dense_table_id=0):
+ # generate multi dense table by cond value
+ pname2grad = self._check_params_grads(params, grads)
+ root_params_list = []
+ root_grads_list = []
+ dense_tables = []
+ for i, p in enumerate(params):
+ if p.name not in other_params and p.name not in sparse_table_names:
+ root_params_list.append(p)
+ root_grads_list.append(grads[i])
+ if len(root_params_list) > 0:
+ dense_tables.append(dense_table_id)
+ dense_table_id += 1
+ lists_params = [[] for i in range(len(cond_params.keys()))]
+ lists_grads = [[] for i in range(len(cond_params.keys()))]
+
+ key_id = 0
+ name2key = dict()
+ cond2denseid = dict()
+ for key, value in cond_params.items():
+ cond2denseid[key] = dense_table_id
+ dense_tables.append(dense_table_id)
+ dense_table_id += 1
+ for v in value:
+ name2key[v] = key_id
+ key_id += 1
+
+ for p in params:
+ if p.name in other_params:
+ lists_params[name2key[p.name]].append(p)
+ lists_grads[name2key[p.name]].append(pname2grad[p.name])
+
+ return dense_tables, cond2denseid, lists_params, lists_grads, root_params_list, root_grads_list
+
+ def _gen_distributed_emb_to_size_dict(self, program):
+ d_size = dict()
+ local_vars = program.current_block().vars
+
+ for op in program.global_block().ops:
+ if op.type in self.supported_embedding_types:
+ if op.attr('is_distributed') is True:
+ table_name = op.input("W")[0]
+ emb_size = local_vars[table_name].shape[-1]
+ if d_size.get(table_name) is None:
+ d_size[table_name] = emb_size
+ elif d_size[table_name] != emb_size:
+ raise ValueError("embedding size error: %s vs %s" %
+ (emb_size, d_size[table_name]))
+
+ return d_size
+
+ def _check_config_fleet_with_program_op(self, strategy, table_name,
+ emb_to_size):
+ if strategy.get(table_name) is None:
+ strategy[table_name] = dict()
+ st = strategy[table_name]
+
+ accessor = "DownpourCtrAccessor"
+ if st.get("sparse_accessor_class") is not None:
+ accessor = st["sparse_accessor_class"]
+
+ # set sparse_embedx_dim in the strategy according to accessor and use_cvm config
+ if accessor == "DownpourFeatureValueAccessor" \
+ or accessor == "DownpourCtrAccessor" \
+ or accessor == "DownpourCtrDymfAccessor" \
+ or accessor == "DownpourDoubleUnitAccessor" \
+ or accessor == "DownpourUnitAccessor":
+ if st.get("sparse_embedx_dim") is not None \
+ and strategy.get("use_cvm") == True \
+ and st["sparse_embedx_dim"] != emb_to_size[table_name] - 3:
+ raise ValueError(
+ "fleet config sparse_embedx_dim=%s not"
+ " equal to embedding dim - 3 = %s" %
+ (st["sparse_embedx_dim"], emb_to_size[table_name] - 3))
+ if st.get("sparse_embedx_dim") is not None \
+ and strategy.get("use_cvm") == False \
+ and st["sparse_embedx_dim"] != emb_to_size[table_name] - 1:
+ raise ValueError(
+ "fleet config sparse_embedx_dim=%s not"
+ " equal to embedding dim - 1 = %s" %
+ (st["sparse_embedx_dim"], emb_to_size[table_name] - 1))
+ if st.get("sparse_embedx_dim") is None \
+ and strategy.get("use_cvm") == True:
+ logger.warning(
+ "sparse embedding dim for table name '{}' is: {}, while sparse_embedx_dim "
+ "with same sparse table name is not set in config_fleet.py. "
+ "Hence automatically set sparse_embedx_dim = {} - 3.".
+ format(table_name, emb_to_size[table_name],
+ emb_to_size[table_name]))
+ st["sparse_embedx_dim"] = emb_to_size[table_name] - 3
+ if st.get("sparse_embedx_dim") is None \
+ and strategy.get("use_cvm") == False:
+ logger.warning(
+ "sparse embedding dim for table name '{}' is: {}, while sparse_embedx_dim "
+ "with same sparse table name is not set in config_fleet.py. "
+ "Hence automatically set sparse_embedx_dim = {} - 1.".
+ format(table_name, emb_to_size[table_name],
+ emb_to_size[table_name]))
+ st["sparse_embedx_dim"] = emb_to_size[table_name] - 1
+ elif accessor == "DownpourSparseValueAccessor":
+ if st.get("sparse_embedx_dim") is not None \
+ and st["sparse_embedx_dim"] != emb_to_size[table_name]:
+ raise ValueError(
+ "fleet config sparse_embedx_dim=%s not"
+ " equal to embedding dim = %s" %
+ (st["sparse_embedx_dim"], emb_to_size[table_name]))
+ if st.get("sparse_embedx_dim") is None:
+ logger.warning(
+ "sparse embedding dim for table name '{}' is: {}, while sparse_embedx_dim "
+ "with same sparse table name is not set in config_fleet.py. "
+ "Hence automatically set sparse_embedx_dim = {}.".format(
+ table_name, emb_to_size[table_name],
+ emb_to_size[table_name]))
+ st["sparse_embedx_dim"] = emb_to_size[table_name]
+
+ return strategy
+
+ def _minimize(self,
+ losses,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ strategy={}):
+ """
+ DownpounSGD is a distributed optimizer so
+ that user can call minimize to generate backward
+ operators and optimization operators within minimize function
+ Args:
+ loss(Variable): loss variable defined by user
+ startup_program(Program): startup program that defined by user
+ parameter_list(str list): parameter names defined by users
+ no_grad_set(set): a set of variables that is defined by users
+ so that these variables do not need gradient computation
+ strategy(dict): user-defined properties
+ Returns:
+ [optimize_ops, grads_and_weights]
+ """
+ # sparse table names of each program
+ prog_id_to_sparse_table = OrderedDict()
+ # inputs_dict and outputs_dict of sparse tables of each program
+ prog_id_to_inputs_dict = OrderedDict()
+ prog_id_to_outputs_dict = OrderedDict()
+ # related to PSParameter
+ ps_param = pslib.PSParameter()
+ # related to ServerParameter
+ server = DownpourServer()
+ # program to worker (related to DownpourTrainerParameter)
+ prog_id_to_worker = OrderedDict()
+ # param_grads of each program
+ prog_id_to_param_grads = OrderedDict()
+ # sparse_grads of each program
+ prog_id_to_sparse_grads = OrderedDict()
+ # unique program set
+ program_id_set = set()
+
+ sparse_table_to_index = OrderedDict()
+ sparse_table_index = 0
+ for num in range(len(losses)):
+ loss = losses[num]
+ parameters = None
+ if parameter_list != None:
+ parameters = parameter_list[num]
+ prog_id = str(id(loss.block.program))
+ # param_grads of program
+ params_grads = sorted(fluid.backward.append_backward(
+ loss, parameters, no_grad_set),
+ key=lambda x: x[0].name)
+
+ flag_use_ps_gpu = strategy.get("use_ps_gpu", False)
+ if flag_use_ps_gpu:
+ if not isinstance(startup_program, list):
+ startup_program = [startup_program]
+ optimizer = copy.deepcopy(self._optimizer)
+ optimize_ops = optimizer.apply_optimize(
+ loss,
+ startup_program=startup_program[num],
+ params_grads=params_grads)
+ embedding_table = self._find_multi_distributed_lookup_table(
+ [loss])
+ self._remove_optimize_op_for_embedding(loss, embedding_table)
+ # has condition_block op means multi-task
+ flag_multi_task = self._has_conditional_block(loss)
+ if flag_multi_task:
+ self._cond_params = dict()
+ self._other_params = []
+ now_program = loss.block.program
+ root_block = now_program.block(0)
+ all_params = []
+ for par in root_block.all_parameters():
+ all_params.append(par.name)
+
+ ops_ = root_block.ops
+ fill_value_dict = dict()
+ equal_fill_dict = dict()
+ for op in ops_:
+ # conditional_block op must has fill_constant and equal op
+ if op.type == 'fill_constant':
+ fill_value_dict[op.output('Out')[0]] = op.attr('value')
+ if op.type == 'equal':
+ equal_fill_dict[op.output('Out')[0]] = op.input('Y')[0]
+ if op.type == 'conditional_block':
+ self._generte_cond_para_map(op, fill_value_dict,
+ equal_fill_dict,
+ now_program, all_params)
+
+ if prog_id not in program_id_set:
+ program_id_set.add(prog_id)
+ sparse_table = self._find_multi_distributed_lookup_table([loss])
+ prog_id_to_sparse_table[prog_id] = sparse_table
+
+ # get sparse_table_to_index
+ for tn in sparse_table:
+ if sparse_table_to_index.get(tn) is None:
+ sparse_table_to_index[tn] = sparse_table_index
+ sparse_table_index += 1
+
+ # get {table_name: emb_size} dict from program ops
+ emb_to_size = self._gen_distributed_emb_to_size_dict(
+ loss.block.program)
+
+ # get inputs_dict
+ inputs_dict = self._find_distributed_lookup_table_inputs(
+ loss.block.program, sparse_table)
+ prog_id_to_inputs_dict[prog_id] = inputs_dict
+ # get outputs_dict
+ outputs_dict = self._find_distributed_lookup_table_outputs(
+ loss.block.program, sparse_table)
+ prog_id_to_outputs_dict[prog_id] = outputs_dict
+
+ prog_id_to_worker[prog_id] = DownpourWorker(self._window)
+
+ grads_dict = self._find_distributed_lookup_table_grads(
+ loss.block.program, sparse_table)
+ prog_id_to_sparse_grads[prog_id] = grads_dict
+
+ if prog_id not in prog_id_to_param_grads:
+ prog_id_to_param_grads[prog_id] = []
+ prog_id_to_param_grads[prog_id].append(params_grads)
+
+ #if strategy.get("parallel_compute")
+
+ # if user specify a fleet_desc.prototxt file, then load the file
+ # instead of creating default fleet_desc.prototxt.
+ # user can specify server_param or trainer_param or fs_client_param.
+ if strategy.get("fleet_desc_file") is not None:
+ fleet_desc_file = strategy["fleet_desc_file"]
+ with open(fleet_desc_file) as f:
+ text_format.Merge(f.read(), ps_param)
+ server.get_desc().CopyFrom(ps_param.server_param)
+ if len(ps_param.trainer_param) == 1:
+ for k in prog_id_to_worker:
+ prog_id_to_worker[k].get_desc().CopyFrom(
+ ps_param.trainer_param[0])
+ else:
+ if len(ps_param.trainer_param) != len(prog_id_to_worker):
+ raise ValueError(
+ "trainer param size != program size, %s vs %s" %
+ (len(ps_param.trainer_param), len(prog_id_to_worker)))
+ idx = 0
+ # prog_id_to_worker is OrderedDict
+ for k in prog_id_to_worker:
+ prog_id_to_worker[k].get_desc().CopyFrom(
+ ps_param.trainer_param[idx])
+ idx += 1
+
+ # check config in op defination and fleet config
+ if FLEET_GLOBAL_DICT["enable"]:
+ one_slot = None
+ strategy["device_worker"] = "Hogwild"
+ emb_to_table = FLEET_GLOBAL_DICT["emb_to_table"]
+ emb_to_accessor = FLEET_GLOBAL_DICT["emb_to_accessor"]
+ emb_to_size = FLEET_GLOBAL_DICT["emb_to_size"]
+ if len(sparse_table_to_index) != len(emb_to_table):
+ raise ValueError(
+ "sparse tables from program != sparse tables from op: %s "
+ "vs %s" % (len(sparse_table_to_index), len(emb_to_table)))
+ for key in sparse_table_to_index:
+ if key not in emb_to_table or \
+ sparse_table_to_index[key] != emb_to_table[key]:
+ print("sparse_table_to_index ", sparse_table_to_index)
+ print("emb_to_table ", emb_to_table)
+ raise ValueError("key error: %s" % key)
+ if strategy.get(key) is None:
+ strategy[key] = dict()
+ st = strategy[key]
+
+ accessor = None
+ if st.get("sparse_accessor_class") is not None:
+ accessor = st["sparse_accessor_class"]
+ tables = \
+ server.get_desc().downpour_server_param.downpour_table_param
+ for table in tables:
+ if table.table_id == sparse_table_to_index[key]:
+ accessor = table.accessor.accessor_class
+ break
+
+ for loss in losses:
+ for op in loss.block.program.global_block().ops:
+ if op.type in self.supported_embedding_types:
+ if accessor is not None \
+ and op.has_attr("AccessorClass"):
+ op._set_attr("AccessorClass", accessor)
+ if one_slot is None:
+ one_slot = loss.block.program. \
+ global_block().var(op.input("Ids")[0])
+
+ # if accessor is None, use default accessor in op definition
+ if accessor is None:
+ accessor = emb_to_accessor[key]
+ # set sparse_embedx_dim in strategy,
+ # user do not have to set it in config_fleet
+ if accessor == "DownpourFeatureValueAccessor" \
+ or accessor == "DownpourCtrDymfAccessor" \
+ or accessor == "DownpourCtrAccessor" \
+ or accessor == "DownpourDoubleUnitAccessor" \
+ or accessor == "DownpourUnitAccessor":
+ if st.get("sparse_embedx_dim") is not None \
+ and st["sparse_embedx_dim"] != emb_to_size[key] - 3:
+ raise ValueError(
+ "fleet config sparse_embedx_dim=%s not"
+ " equal to embedding size - 3 = %s" %
+ (st["sparse_embedx_dim"], emb_to_size[key] - 3))
+ st["sparse_embedx_dim"] = emb_to_size[key] - 3
+ elif accessor == "DownpourSparseValueAccessor":
+ if st.get("sparse_embedx_dim") is not None \
+ and st["sparse_embedx_dim"] != emb_to_size[key]:
+ raise ValueError(
+ "fleet config sparse_embedx_dim=%s not"
+ " equal to embedding size = %s" %
+ (st["sparse_embedx_dim"], emb_to_size[key]))
+ st["sparse_embedx_dim"] = emb_to_size[key]
+
+ # ServerParameter add all sparse tables
+ for tn in sparse_table_to_index:
+ sparse_table_index = sparse_table_to_index[tn]
+ st = self._check_config_fleet_with_program_op(
+ strategy, tn, emb_to_size)
+ if st.get(tn) is not None:
+ server.add_sparse_table(sparse_table_index, st[tn])
+ else:
+ server.add_sparse_table(sparse_table_index, None)
+
+ # each DownpourTrainerParameter add its own sparse tables
+ program_id_set.clear()
+ for loss in losses:
+ prog_id = str(id(loss.block.program))
+ if prog_id not in program_id_set:
+ program_id_set.add(prog_id)
+ worker = prog_id_to_worker[prog_id]
+ inputs_dict = prog_id_to_inputs_dict[prog_id]
+ outputs_dict = prog_id_to_outputs_dict[prog_id]
+ for tn in prog_id_to_sparse_table[prog_id]:
+ sparse_table_index = sparse_table_to_index[tn]
+ grads_dict = prog_id_to_sparse_grads[prog_id]
+ worker.add_sparse_table(sparse_table_index, inputs_dict[tn],
+ outputs_dict[tn], grads_dict[tn])
+
+ dense_start_table_id = len(sparse_table_to_index)
+ dense_table_index = len(sparse_table_to_index)
+ program_configs = {}
+ # ServerParameter add all dense tables
+ # each DownpourTrainerParameter add its own dense tables
+ program_id_set.clear()
+ for loss_index in range(len(losses)):
+ program_id = str(id(losses[loss_index].block.program))
+ if program_id not in program_id_set:
+ program_id_set.add(program_id)
+ worker = prog_id_to_worker[program_id]
+ sparse_table_names = prog_id_to_sparse_table[program_id]
+ sparse_table_index = \
+ [sparse_table_to_index[i] for i in sparse_table_names]
+
+ program_configs[program_id] = {
+ "pull_sparse": [t_index for t_index in sparse_table_index],
+ "push_sparse": [t_index for t_index in sparse_table_index]
+ }
+
+ params_grads = prog_id_to_param_grads[program_id]
+ for pg in params_grads:
+ params = []
+ grads = []
+ data_norm_params = []
+ data_norm_grads = []
+ for i in pg:
+ is_data_norm_data = False
+ for data_norm_name in self.data_norm_name:
+ if i[0].name.endswith(data_norm_name):
+ is_data_norm_data = True
+ data_norm_params.append(i[0])
+ if not is_data_norm_data:
+ params.append(i[0])
+
+ for i in pg:
+ is_data_norm_data = False
+ for data_norm_grad in self.data_norm_name:
+ if i[0].name.endswith(data_norm_grad):
+ is_data_norm_data = True
+ data_norm_grads.append(i[1])
+ if not is_data_norm_data:
+ grads.append(i[1])
+ # for new dense table
+ multi_task_dense_tables_push = []
+ multi_task_dense_tables_pull = []
+ if flag_multi_task:
+ dense_tables, cond2denseid, lists_params, lists_grads, root_params_list, root_grads_list = self._generate_multi_dense_table(
+ params, grads, self._cond_params,
+ self._other_params, sparse_table_names,
+ dense_table_index)
+ program_configs[program_id][
+ 'cond2denseid'] = cond2denseid
+ multi_task_dense_tables_push = dense_tables
+ multi_task_dense_tables_pull = dense_tables[:]
+
+ if strategy.get('dense_table') is not None:
+ if flag_multi_task:
+ server_dense_table_index = dense_table_index
+ if len(root_params_list) > 0:
+ server.add_dense_table(server_dense_table_index,
+ root_params_list,
+ root_grads_list,
+ strategy['dense_table'],
+ sparse_table_names)
+ server_dense_table_index += 1
+
+ for i in range(len(lists_params)):
+ server.add_dense_table(server_dense_table_index,
+ lists_params[i],
+ lists_grads[i],
+ strategy['dense_table'],
+ sparse_table_names)
+ server_dense_table_index += 1
+ else:
+ server.add_dense_table(dense_table_index, params,
+ grads,
+ strategy['dense_table'],
+ sparse_table_names)
+
+ else:
+ server.add_dense_table(dense_table_index, params, grads,
+ None, sparse_table_names)
+
+ if flag_multi_task:
+
+ if len(root_params_list) > 0:
+ worker.add_dense_table(dense_table_index,
+ self._learning_rate,
+ root_params_list,
+ root_grads_list,
+ dense_start_table_id,
+ sparse_table_names)
+ dense_table_index += 1
+
+ for i in range(len(lists_params)):
+ worker.add_dense_table(dense_table_index,
+ self._learning_rate,
+ lists_params[i],
+ lists_grads[i],
+ dense_start_table_id,
+ sparse_table_names)
+ dense_table_index += 1
+
+ dense_table_index -= 1
+ else:
+ worker.add_dense_table(dense_table_index,
+ self._learning_rate, params,
+ grads, dense_start_table_id,
+ sparse_table_names)
+
+ if FLEET_GLOBAL_DICT["enable"]:
+ cur_prog = losses[loss_index].block.program
+ cur_prog.global_block().append_op(
+ type="push_dense",
+ inputs={"Ids": one_slot},
+ attrs={
+ "InputNames": [i.name for i in grads],
+ "TableId": dense_table_index,
+ "ScaleDataNorm":
+ strategy.get("scale_datanorm", -1)
+ })
+
+ if "pull_dense" in program_configs[
+ program_id] and "push_dense" in program_configs[
+ program_id] and len(program_configs[program_id]
+ ["pull_dense"]) > 0:
+ if flag_multi_task:
+ program_configs[program_id]["pull_dense"].extend(
+ multi_task_dense_tables_pull)
+ program_configs[program_id]["push_dense"].extend(
+ multi_task_dense_tables_push)
+ else:
+ program_configs[program_id]["pull_dense"].extend(
+ [dense_table_index])
+ program_configs[program_id]["push_dense"].extend(
+ [dense_table_index])
+ else:
+ if flag_multi_task:
+ program_configs[program_id][
+ "pull_dense"] = multi_task_dense_tables_pull
+ program_configs[program_id][
+ "push_dense"] = multi_task_dense_tables_push
+ else:
+ program_configs[program_id]["pull_dense"] = [
+ dense_table_index
+ ]
+ program_configs[program_id]["push_dense"] = [
+ dense_table_index
+ ]
+
+ if len(data_norm_params) != 0 and len(data_norm_grads) != 0:
+ dense_table_index += 1
+ if strategy.get('datanorm_table') is not None:
+ server.add_data_norm_table(
+ dense_table_index, self._learning_rate,
+ data_norm_params, data_norm_grads,
+ strategy['datanorm_table'], sparse_table_names)
+ else:
+ server.add_data_norm_table(dense_table_index,
+ self._learning_rate,
+ data_norm_params,
+ data_norm_grads, None,
+ sparse_table_names)
+
+ worker.add_dense_table(dense_table_index,
+ self._learning_rate,
+ data_norm_params,
+ data_norm_grads,
+ dense_start_table_id,
+ sparse_table_names)
+
+ if FLEET_GLOBAL_DICT["enable"]:
+ cur_prog = losses[loss_index].block.program
+ cur_prog.global_block().append_op(
+ type="push_dense",
+ inputs={"Ids": one_slot},
+ attrs={
+ "InputNames":
+ [i.name for i in data_norm_grads],
+ "TableId":
+ dense_table_index,
+ "ScaleDataNorm":
+ strategy.get("scale_datanorm", -1)
+ })
+
+ program_configs[program_id]["pull_dense"].extend(
+ [dense_table_index])
+ program_configs[program_id]["push_dense"].extend(
+ [dense_table_index])
+ dense_table_index += 1
+
+ # Todo(guru4elephant): figure out how to support more sparse parameters
+ # currently only support lookup_table
+ worker_skipped_ops = ["lookup_table", "lookup_table_grad"]
+ if len(worker.get_desc().skip_op) == 0:
+ worker.get_desc().skip_op.extend(worker_skipped_ops)
+
+ ps_param.server_param.CopyFrom(server.get_desc())
+ # prog_id_to_worker is OrderedDict
+ if len(ps_param.trainer_param) == 0:
+ for k in prog_id_to_worker:
+ tp = ps_param.trainer_param.add()
+ tp.CopyFrom(prog_id_to_worker[k].get_desc())
+
+ if strategy.get("fs_uri") is not None:
+ ps_param.fs_client_param.uri = strategy["fs_uri"]
+ elif ps_param.fs_client_param.uri == "":
+ ps_param.fs_client_param.uri = "hdfs://your_hdfs_uri"
+ if strategy.get("fs_user") is not None:
+ ps_param.fs_client_param.user = strategy["fs_user"]
+ elif ps_param.fs_client_param.user == "":
+ ps_param.fs_client_param.user = "your_hdfs_user"
+ if strategy.get("fs_passwd") is not None:
+ ps_param.fs_client_param.passwd = strategy["fs_passwd"]
+ elif ps_param.fs_client_param.passwd == "":
+ ps_param.fs_client_param.passwd = "your_hdfs_passwd"
+ if strategy.get("fs_hadoop_bin") is not None:
+ ps_param.fs_client_param.hadoop_bin = strategy["fs_hadoop_bin"]
+ elif ps_param.fs_client_param.hadoop_bin == "":
+ ps_param.fs_client_param.hadoop_bin = "$HADOOP_HOME/bin/hadoop"
+
+ opt_info = {}
+ opt_info["program_id_to_worker"] = prog_id_to_worker
+ opt_info["program_configs"] = program_configs
+ opt_info["trainer"] = strategy.get("trainer", "DistMultiTrainer")
+ opt_info["device_worker"] = strategy.get("device_worker", "DownpourSGD")
+ opt_info["optimizer"] = "DownpourSGD"
+ opt_info["fleet_desc"] = ps_param
+ opt_info["worker_skipped_ops"] = worker_skipped_ops
+ opt_info["use_cvm"] = strategy.get("use_cvm", False)
+ opt_info["no_cvm"] = strategy.get("no_cvm", False)
+ opt_info["scale_sparse_gradient_with_batch_size"] = strategy.get(
+ "scale_sparse_gradient_with_batch_size", True)
+ opt_info["worker_class"] = strategy.get("worker_class",
+ "DownpourWorker")
+ opt_info["stat_var_names"] = strategy.get("stat_var_names", [])
+ opt_info["local_tables"] = strategy.get("local_tables", [])
+ opt_info["async_tables"] = strategy.get("async_tables", [])
+ opt_info["async_tables"] = strategy.get("async_tables", [])
+ opt_info["scale_datanorm"] = strategy.get("scale_datanorm", -1)
+ opt_info["check_nan_var_names"] = strategy.get("check_nan_var_names",
+ [])
+ opt_info["dump_slot"] = False
+ opt_info["dump_converter"] = ""
+ opt_info["dump_fields"] = strategy.get("dump_fields", [])
+ opt_info["dump_file_num"] = strategy.get("dump_file_num", 16)
+ opt_info["user_define_dump_filename"] = strategy.get(
+ "user_define_dump_filename", "")
+ opt_info["dump_fields_path"] = strategy.get("dump_fields_path", "")
+ opt_info["dump_param"] = strategy.get("dump_param", [])
+ gpus_env = os.getenv("FLAGS_selected_gpus", "0")
+ opt_info["worker_places"] = [int(s) for s in gpus_env.split(",")]
+ opt_info["use_ps_gpu"] = strategy.get("use_ps_gpu", False)
+ if server._server.downpour_server_param.downpour_table_param[
+ 0].accessor.accessor_class in [
+ "DownpourCtrAccessor", "DownpourCtrDoubleAccessor",
+ "DownpourUnitAccessor", "DownpourDoubleUnitAccessor",
+ "DownpourCtrDymfAccessor"
+ ]:
+ opt_info["dump_slot"] = True
+ elif server._server.downpour_server_param.downpour_table_param[
+ 0].accessor.accessor_class == "DownpourSparseValueAccessor":
+ opt_info["no_cvm"] = True
+ opt_info["adjust_ins_weight"] = strategy.get("adjust_ins_weight", {})
+ opt_info["copy_table"] = strategy.get("copy_table", {})
+ opt_info["loss_names"] = strategy.get("loss_names", [])
+
+ for loss in losses:
+ loss.block.program._fleet_opt = opt_info
+
+ param_grads_list = []
+ for loss in losses:
+ prog_id = str(id(loss.block.program))
+ param_grads_list.append(prog_id_to_param_grads[prog_id])
+ return None, param_grads_list, opt_info
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/ps_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/ps_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..eec51ef827c5766e50910ba866ba7e5bc39d175b
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/pslib/ps_pb2.py
@@ -0,0 +1,3038 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: ps.proto
+
+import sys
+
+_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode('latin1'))
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='ps.proto',
+ package='paddle',
+ syntax='proto2',
+ serialized_pb=_b(
+ '\n\x08ps.proto\x12\x06paddle\"\xb5\x02\n\x0bPSParameter\x12\x14\n\x0cworker_class\x18\x01 \x01(\t\x12\x14\n\x0cserver_class\x18\x02 \x01(\t\x12\x16\n\x0einstance_class\x18\x03 \x01(\t\x12\x15\n\x0binit_gflags\x18\x04 \x01(\t:\x00\x12-\n\x0cworker_param\x18\x65 \x01(\x0b\x32\x17.paddle.WorkerParameter\x12-\n\x0cserver_param\x18\x66 \x01(\x0b\x32\x17.paddle.ServerParameter\x12\x38\n\rtrainer_param\x18\xad\x02 \x03(\x0b\x32 .paddle.DownpourTrainerParameter\x12\x33\n\x0f\x66s_client_param\x18\xf5\x03 \x01(\x0b\x32\x19.paddle.FsClientParameter\"Q\n\x0fWorkerParameter\x12>\n\x15\x64ownpour_worker_param\x18\x01 \x01(\x0b\x32\x1f.paddle.DownpourWorkerParameter\"Q\n\x0fServerParameter\x12>\n\x15\x64ownpour_server_param\x18\x01 \x01(\x0b\x32\x1f.paddle.DownpourServerParameter\"O\n\x17\x44ownpourWorkerParameter\x12\x34\n\x14\x64ownpour_table_param\x18\x01 \x03(\x0b\x32\x16.paddle.TableParameter\"\xfd\x01\n\x18\x44ownpourTrainerParameter\x12\x30\n\x0b\x64\x65nse_table\x18\x01 \x03(\x0b\x32\x1b.paddle.DenseTableParameter\x12\x32\n\x0csparse_table\x18\x02 \x03(\x0b\x32\x1c.paddle.SparseTableParameter\x12\x1d\n\x15push_sparse_per_batch\x18\x03 \x01(\x05\x12\x1c\n\x14push_dense_per_batch\x18\x04 \x01(\x05\x12\x0f\n\x07skip_op\x18\x05 \x03(\t\x12-\n\x0eprogram_config\x18\x06 \x03(\x0b\x32\x15.paddle.ProgramConfig\"\x99\x01\n\rProgramConfig\x12\x12\n\nprogram_id\x18\x01 \x02(\t\x12\x1c\n\x14push_sparse_table_id\x18\x02 \x03(\x05\x12\x1b\n\x13push_dense_table_id\x18\x03 \x03(\x05\x12\x1c\n\x14pull_sparse_table_id\x18\x04 \x03(\x05\x12\x1b\n\x13pull_dense_table_id\x18\x05 \x03(\x05\"{\n\x13\x44\x65nseTableParameter\x12\x10\n\x08table_id\x18\x01 \x01(\x05\x12\x1b\n\x13\x64\x65nse_variable_name\x18\x02 \x03(\t\x12$\n\x1c\x64\x65nse_gradient_variable_name\x18\x03 \x03(\t\x12\x0f\n\x07\x66\x65\x61_dim\x18\x04 \x01(\x05\"z\n\x14SparseTableParameter\x12\x10\n\x08table_id\x18\x01 \x01(\x05\x12\x13\n\x0b\x66\x65\x61ture_dim\x18\x02 \x01(\x05\x12\x10\n\x08slot_key\x18\x03 \x03(\t\x12\x12\n\nslot_value\x18\x04 \x03(\t\x12\x15\n\rslot_gradient\x18\x05 \x03(\t\"\x86\x01\n\x17\x44ownpourServerParameter\x12\x34\n\x14\x64ownpour_table_param\x18\x01 \x03(\x0b\x32\x16.paddle.TableParameter\x12\x35\n\rservice_param\x18\x02 \x01(\x0b\x32\x1e.paddle.ServerServiceParameter\"\xd7\x01\n\x16ServerServiceParameter\x12*\n\x0cserver_class\x18\x01 \x01(\t:\x14\x44ownpourBrpcPsServer\x12*\n\x0c\x63lient_class\x18\x02 \x01(\t:\x14\x44ownpourBrpcPsClient\x12(\n\rservice_class\x18\x03 \x01(\t:\x11\x44ownpourPsService\x12\x1c\n\x11start_server_port\x18\x04 \x01(\r:\x01\x30\x12\x1d\n\x11server_thread_num\x18\x05 \x01(\r:\x02\x31\x32\"\xc0\x02\n\x0eTableParameter\x12\x10\n\x08table_id\x18\x01 \x01(\x04\x12\x13\n\x0btable_class\x18\x02 \x01(\t\x12\x17\n\tshard_num\x18\x03 \x01(\x04:\x04\x31\x30\x30\x30\x12\x30\n\x08\x61\x63\x63\x65ssor\x18\x04 \x01(\x0b\x32\x1e.paddle.TableAccessorParameter\x12\x1f\n\x04type\x18\x05 \x01(\x0e\x32\x11.paddle.TableType\x12\x1f\n\x10\x63ompress_in_save\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\'\n\x19\x65nable_sparse_table_cache\x18\x07 \x01(\x08:\x04true\x12(\n\x17sparse_table_cache_rate\x18\x08 \x01(\x01:\x07\x30.00055\x12\'\n\x1bsparse_table_cache_file_num\x18\t \x01(\r:\x02\x31\x36\"\xc1\x04\n\x16TableAccessorParameter\x12\x16\n\x0e\x61\x63\x63\x65ssor_class\x18\x01 \x01(\t\x12\x38\n\x10sparse_sgd_param\x18\x02 \x01(\x0b\x32\x1e.paddle.SparseSGDRuleParameter\x12\x36\n\x0f\x64\x65nse_sgd_param\x18\x03 \x01(\x0b\x32\x1d.paddle.DenseSGDRuleParameter\x12\x13\n\x07\x66\x65\x61_dim\x18\x04 \x01(\r:\x02\x31\x31\x12\x15\n\nembedx_dim\x18\x05 \x01(\r:\x01\x38\x12\x1c\n\x10\x65mbedx_threshold\x18\x06 \x01(\r:\x02\x31\x30\x12G\n\x17\x64ownpour_accessor_param\x18\x07 \x01(\x0b\x32&.paddle.DownpourTableAccessorParameter\x12\x45\n\x19table_accessor_save_param\x18\x08 \x03(\x0b\x32\".paddle.TableAccessorSaveParameter\x12\x44\n\x16sparse_commonsgd_param\x18\t \x01(\x0b\x32$.paddle.SparseCommonSGDRuleParameter\x12=\n\x0f\x65mbed_sgd_param\x18\n \x01(\x0b\x32$.paddle.SparseCommonSGDRuleParameter\x12>\n\x10\x65mbedx_sgd_param\x18\x0b \x01(\x0b\x32$.paddle.SparseCommonSGDRuleParameter\"\xba\x02\n\x1e\x44ownpourTableAccessorParameter\x12\x19\n\x0cnonclk_coeff\x18\x01 \x01(\x02:\x03\x30.1\x12\x16\n\x0b\x63lick_coeff\x18\x02 \x01(\x02:\x01\x31\x12\x1b\n\x0e\x62\x61se_threshold\x18\x03 \x01(\x02:\x03\x31.5\x12\x1d\n\x0f\x64\x65lta_threshold\x18\x04 \x01(\x02:\x04\x30.25\x12\x1b\n\x0f\x64\x65lta_keep_days\x18\x05 \x01(\x02:\x02\x31\x36\x12#\n\x15show_click_decay_rate\x18\x06 \x01(\x02:\x04\x30.98\x12\x1d\n\x10\x64\x65lete_threshold\x18\x07 \x01(\x02:\x03\x30.8\x12$\n\x18\x64\x65lete_after_unseen_days\x18\x08 \x01(\x02:\x02\x33\x30\x12\"\n\x17ssd_unseenday_threshold\x18\t \x01(\x05:\x01\x31\"S\n\x1aTableAccessorSaveParameter\x12\r\n\x05param\x18\x01 \x01(\r\x12\x11\n\tconverter\x18\x02 \x01(\t\x12\x13\n\x0b\x64\x65\x63onverter\x18\x03 \x01(\t\"e\n\x10PsRequestMessage\x12\x0e\n\x06\x63md_id\x18\x01 \x02(\r\x12\x10\n\x08table_id\x18\x02 \x01(\r\x12\x0e\n\x06params\x18\x03 \x03(\x0c\x12\x11\n\tclient_id\x18\x04 \x01(\x05\x12\x0c\n\x04\x64\x61ta\x18\x05 \x01(\x0c\"\x85\x01\n\x16SparseSGDRuleParameter\x12\x1b\n\rlearning_rate\x18\x01 \x01(\x01:\x04\x30.05\x12\x18\n\rinitial_g2sum\x18\x02 \x01(\x01:\x01\x33\x12\x1d\n\rinitial_range\x18\x03 \x01(\x01:\x06\x30.0001\x12\x15\n\rweight_bounds\x18\x04 \x03(\x02\"\xc6\x01\n\x1cSparseCommonSGDRuleParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x32\n\x05naive\x18\x02 \x01(\x0b\x32#.paddle.SparseNaiveSGDRuleParameter\x12\x36\n\x07\x61\x64\x61grad\x18\x03 \x01(\x0b\x32%.paddle.SparseAdagradSGDRuleParameter\x12,\n\x04\x61\x64\x61m\x18\x04 \x01(\x0b\x32\x1e.paddle.SparseAdamSGDParameter\"p\n\x1bSparseNaiveSGDRuleParameter\x12\x1b\n\rlearning_rate\x18\x01 \x01(\x01:\x04\x30.05\x12\x1d\n\rinitial_range\x18\x02 \x01(\x01:\x06\x30.0001\x12\x15\n\rweight_bounds\x18\x03 \x03(\x02\"\x8c\x01\n\x1dSparseAdagradSGDRuleParameter\x12\x1b\n\rlearning_rate\x18\x01 \x01(\x01:\x04\x30.05\x12\x18\n\rinitial_g2sum\x18\x02 \x01(\x01:\x01\x33\x12\x1d\n\rinitial_range\x18\x03 \x01(\x01:\x06\x30.0001\x12\x15\n\rweight_bounds\x18\x04 \x03(\x02\"\xc8\x01\n\x16SparseAdamSGDParameter\x12\x1c\n\rlearning_rate\x18\x01 \x01(\x01:\x05\x30.001\x12\x1d\n\rinitial_range\x18\x02 \x01(\x01:\x06\x30.0001\x12\x1d\n\x10\x62\x65ta1_decay_rate\x18\x03 \x01(\x01:\x03\x30.9\x12\x1f\n\x10\x62\x65ta2_decay_rate\x18\x04 \x01(\x01:\x05\x30.999\x12\x1a\n\x0b\x61\x64\x61_epsilon\x18\x05 \x01(\x01:\x05\x31\x65-08\x12\x15\n\rweight_bounds\x18\x06 \x03(\x02\"\xe1\x01\n\x15\x44\x65nseSGDRuleParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12&\n\x04\x61\x64\x61m\x18\x02 \x01(\x0b\x32\x18.paddle.AdamSGDParameter\x12(\n\x05naive\x18\x03 \x01(\x0b\x32\x19.paddle.NaiveSGDParameter\x12,\n\x07summary\x18\x04 \x01(\x0b\x32\x1b.paddle.SummarySGDParameter\x12:\n\x0emoving_average\x18\x05 \x01(\x0b\x32\".paddle.MovingAverageRuleParameter\"\xac\x01\n\x10\x41\x64\x61mSGDParameter\x12\x1c\n\rlearning_rate\x18\x01 \x01(\x01:\x05\x35\x65-06\x12 \n\x0e\x61vg_decay_rate\x18\x02 \x01(\x01:\x08\x30.999993\x12\x1e\n\x0e\x61\x64\x61_decay_rate\x18\x03 \x01(\x01:\x06\x30.9999\x12\x1a\n\x0b\x61\x64\x61_epsilon\x18\x04 \x01(\x01:\x05\x31\x65-08\x12\x1c\n\x0emom_decay_rate\x18\x05 \x01(\x01:\x04\x30.99\"J\n\x11NaiveSGDParameter\x12\x1d\n\rlearning_rate\x18\x01 \x01(\x01:\x06\x30.0002\x12\x16\n\x0e\x61vg_decay_rate\x18\x02 \x01(\x01\";\n\x13SummarySGDParameter\x12$\n\x12summary_decay_rate\x18\x01 \x01(\x01:\x08\x30.999999\".\n\x1aMovingAverageRuleParameter\x12\x10\n\x08momentum\x18\x01 \x01(\x01\"I\n\x11PsResponseMessage\x12\x13\n\x08\x65rr_code\x18\x01 \x02(\x05:\x01\x30\x12\x11\n\x07\x65rr_msg\x18\x02 \x02(\t:\x00\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\xd5\x01\n\x11\x46sClientParameter\x12:\n\x07\x66s_type\x18\x01 \x01(\x0e\x32#.paddle.FsClientParameter.FsApiType:\x04HDFS\x12\x0b\n\x03uri\x18\x02 \x01(\t\x12\x0c\n\x04user\x18\x03 \x01(\t\x12\x0e\n\x06passwd\x18\x04 \x01(\t\x12\x13\n\x0b\x62uffer_size\x18\x05 \x01(\x05\x12\x12\n\nhadoop_bin\x18\x33 \x01(\t\x12\x10\n\x08\x61\x66s_conf\x18\x65 \x01(\t\"\x1e\n\tFsApiType\x12\x08\n\x04HDFS\x10\x00\x12\x07\n\x03\x41\x46S\x10\x01*4\n\tTableType\x12\x13\n\x0fPS_SPARSE_TABLE\x10\x00\x12\x12\n\x0ePS_DENSE_TABLE\x10\x01*\xba\x04\n\x07PsCmdID\x12\x17\n\x13PS_PULL_DENSE_TABLE\x10\x00\x12\x17\n\x13PS_PUSH_DENSE_TABLE\x10\x01\x12\x18\n\x14PS_PULL_SPARSE_TABLE\x10\x02\x12\x18\n\x14PS_PUSH_SPARSE_TABLE\x10\x03\x12\x13\n\x0fPS_SHRINK_TABLE\x10\x04\x12\x15\n\x11PS_SAVE_ONE_TABLE\x10\x05\x12\x15\n\x11PS_SAVE_ALL_TABLE\x10\x06\x12\x15\n\x11PS_LOAD_ONE_TABLE\x10\x07\x12\x15\n\x11PS_LOAD_ALL_TABLE\x10\x08\x12\x16\n\x12PS_CLEAR_ONE_TABLE\x10\t\x12\x16\n\x12PS_CLEAR_ALL_TABLE\x10\n\x12\x17\n\x13PS_PUSH_DENSE_PARAM\x10\x0b\x12\x12\n\x0ePS_STOP_SERVER\x10\x0c\x12\x1b\n\x17PS_SAVE_ONE_CACHE_TABLE\x10\r\x12\x1a\n\x16PS_GET_CACHE_THRESHOLD\x10\x0e\x12\x14\n\x10PS_CACHE_SHUFFLE\x10\x0f\x12\x11\n\rPS_COPY_TABLE\x10\x10\x12\x1c\n\x18PS_COPY_TABLE_BY_FEASIGN\x10\x11\x12(\n$PS_PULL_SPARSE_TABLE_WITH_DEPENDENCY\x10\x12\x12(\n$PS_PUSH_SPARSE_TABLE_WITH_DEPENDENCY\x10\x13\x12\x17\n\x13PS_PRINT_TABLE_STAT\x10\x14\x12\x0e\n\nPS_S2S_MSG\x10\x65\x32K\n\tPsService\x12>\n\x07service\x12\x18.paddle.PsRequestMessage\x1a\x19.paddle.PsResponseMessageB\x06\x80\x01\x01\xf8\x01\x01'
+ ))
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_TABLETYPE = _descriptor.EnumDescriptor(
+ name='TableType',
+ full_name='paddle.TableType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(name='PS_SPARSE_TABLE',
+ index=0,
+ number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_DENSE_TABLE',
+ index=1,
+ number=1,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=4679,
+ serialized_end=4731,
+)
+_sym_db.RegisterEnumDescriptor(_TABLETYPE)
+
+TableType = enum_type_wrapper.EnumTypeWrapper(_TABLETYPE)
+_PSCMDID = _descriptor.EnumDescriptor(
+ name='PsCmdID',
+ full_name='paddle.PsCmdID',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(name='PS_PULL_DENSE_TABLE',
+ index=0,
+ number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_PUSH_DENSE_TABLE',
+ index=1,
+ number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_PULL_SPARSE_TABLE',
+ index=2,
+ number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_PUSH_SPARSE_TABLE',
+ index=3,
+ number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_SHRINK_TABLE',
+ index=4,
+ number=4,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_SAVE_ONE_TABLE',
+ index=5,
+ number=5,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_SAVE_ALL_TABLE',
+ index=6,
+ number=6,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_LOAD_ONE_TABLE',
+ index=7,
+ number=7,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_LOAD_ALL_TABLE',
+ index=8,
+ number=8,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_CLEAR_ONE_TABLE',
+ index=9,
+ number=9,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_CLEAR_ALL_TABLE',
+ index=10,
+ number=10,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_PUSH_DENSE_PARAM',
+ index=11,
+ number=11,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_STOP_SERVER',
+ index=12,
+ number=12,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_SAVE_ONE_CACHE_TABLE',
+ index=13,
+ number=13,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_GET_CACHE_THRESHOLD',
+ index=14,
+ number=14,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_CACHE_SHUFFLE',
+ index=15,
+ number=15,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_COPY_TABLE',
+ index=16,
+ number=16,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_COPY_TABLE_BY_FEASIGN',
+ index=17,
+ number=17,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PS_PULL_SPARSE_TABLE_WITH_DEPENDENCY',
+ index=18,
+ number=18,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PS_PUSH_SPARSE_TABLE_WITH_DEPENDENCY',
+ index=19,
+ number=19,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_PRINT_TABLE_STAT',
+ index=20,
+ number=20,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='PS_S2S_MSG',
+ index=21,
+ number=101,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=4734,
+ serialized_end=5304,
+)
+_sym_db.RegisterEnumDescriptor(_PSCMDID)
+
+PsCmdID = enum_type_wrapper.EnumTypeWrapper(_PSCMDID)
+PS_SPARSE_TABLE = 0
+PS_DENSE_TABLE = 1
+PS_PULL_DENSE_TABLE = 0
+PS_PUSH_DENSE_TABLE = 1
+PS_PULL_SPARSE_TABLE = 2
+PS_PUSH_SPARSE_TABLE = 3
+PS_SHRINK_TABLE = 4
+PS_SAVE_ONE_TABLE = 5
+PS_SAVE_ALL_TABLE = 6
+PS_LOAD_ONE_TABLE = 7
+PS_LOAD_ALL_TABLE = 8
+PS_CLEAR_ONE_TABLE = 9
+PS_CLEAR_ALL_TABLE = 10
+PS_PUSH_DENSE_PARAM = 11
+PS_STOP_SERVER = 12
+PS_SAVE_ONE_CACHE_TABLE = 13
+PS_GET_CACHE_THRESHOLD = 14
+PS_CACHE_SHUFFLE = 15
+PS_COPY_TABLE = 16
+PS_COPY_TABLE_BY_FEASIGN = 17
+PS_PULL_SPARSE_TABLE_WITH_DEPENDENCY = 18
+PS_PUSH_SPARSE_TABLE_WITH_DEPENDENCY = 19
+PS_PRINT_TABLE_STAT = 20
+PS_S2S_MSG = 101
+
+_FSCLIENTPARAMETER_FSAPITYPE = _descriptor.EnumDescriptor(
+ name='FsApiType',
+ full_name='paddle.FsClientParameter.FsApiType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(name='HDFS',
+ index=0,
+ number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(name='AFS',
+ index=1,
+ number=1,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=4647,
+ serialized_end=4677,
+)
+_sym_db.RegisterEnumDescriptor(_FSCLIENTPARAMETER_FSAPITYPE)
+
+_PSPARAMETER = _descriptor.Descriptor(
+ name='PSParameter',
+ full_name='paddle.PSParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(name='worker_class',
+ full_name='paddle.PSParameter.worker_class',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='server_class',
+ full_name='paddle.PSParameter.server_class',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='instance_class',
+ full_name='paddle.PSParameter.instance_class',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='init_gflags',
+ full_name='paddle.PSParameter.init_gflags',
+ index=3,
+ number=4,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=True,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='worker_param',
+ full_name='paddle.PSParameter.worker_param',
+ index=4,
+ number=101,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='server_param',
+ full_name='paddle.PSParameter.server_param',
+ index=5,
+ number=102,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='trainer_param',
+ full_name='paddle.PSParameter.trainer_param',
+ index=6,
+ number=301,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fs_client_param',
+ full_name='paddle.PSParameter.fs_client_param',
+ index=7,
+ number=501,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=21,
+ serialized_end=330,
+)
+
+_WORKERPARAMETER = _descriptor.Descriptor(
+ name='WorkerParameter',
+ full_name='paddle.WorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='downpour_worker_param',
+ full_name='paddle.WorkerParameter.downpour_worker_param',
+ index=0,
+ number=1,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=332,
+ serialized_end=413,
+)
+
+_SERVERPARAMETER = _descriptor.Descriptor(
+ name='ServerParameter',
+ full_name='paddle.ServerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='downpour_server_param',
+ full_name='paddle.ServerParameter.downpour_server_param',
+ index=0,
+ number=1,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=415,
+ serialized_end=496,
+)
+
+_DOWNPOURWORKERPARAMETER = _descriptor.Descriptor(
+ name='DownpourWorkerParameter',
+ full_name='paddle.DownpourWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='downpour_table_param',
+ full_name='paddle.DownpourWorkerParameter.downpour_table_param',
+ index=0,
+ number=1,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=498,
+ serialized_end=577,
+)
+
+_DOWNPOURTRAINERPARAMETER = _descriptor.Descriptor(
+ name='DownpourTrainerParameter',
+ full_name='paddle.DownpourTrainerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='dense_table',
+ full_name='paddle.DownpourTrainerParameter.dense_table',
+ index=0,
+ number=1,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_table',
+ full_name='paddle.DownpourTrainerParameter.sparse_table',
+ index=1,
+ number=2,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_sparse_per_batch',
+ full_name='paddle.DownpourTrainerParameter.push_sparse_per_batch',
+ index=2,
+ number=3,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_dense_per_batch',
+ full_name='paddle.DownpourTrainerParameter.push_dense_per_batch',
+ index=3,
+ number=4,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='skip_op',
+ full_name='paddle.DownpourTrainerParameter.skip_op',
+ index=4,
+ number=5,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='program_config',
+ full_name='paddle.DownpourTrainerParameter.program_config',
+ index=5,
+ number=6,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=580,
+ serialized_end=833,
+)
+
+_PROGRAMCONFIG = _descriptor.Descriptor(
+ name='ProgramConfig',
+ full_name='paddle.ProgramConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(name='program_id',
+ full_name='paddle.ProgramConfig.program_id',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=2,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_sparse_table_id',
+ full_name='paddle.ProgramConfig.push_sparse_table_id',
+ index=1,
+ number=2,
+ type=5,
+ cpp_type=1,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_dense_table_id',
+ full_name='paddle.ProgramConfig.push_dense_table_id',
+ index=2,
+ number=3,
+ type=5,
+ cpp_type=1,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pull_sparse_table_id',
+ full_name='paddle.ProgramConfig.pull_sparse_table_id',
+ index=3,
+ number=4,
+ type=5,
+ cpp_type=1,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pull_dense_table_id',
+ full_name='paddle.ProgramConfig.pull_dense_table_id',
+ index=4,
+ number=5,
+ type=5,
+ cpp_type=1,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=836,
+ serialized_end=989,
+)
+
+_DENSETABLEPARAMETER = _descriptor.Descriptor(
+ name='DenseTableParameter',
+ full_name='paddle.DenseTableParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='table_id',
+ full_name='paddle.DenseTableParameter.table_id',
+ index=0,
+ number=1,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_variable_name',
+ full_name='paddle.DenseTableParameter.dense_variable_name',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_gradient_variable_name',
+ full_name='paddle.DenseTableParameter.dense_gradient_variable_name',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fea_dim',
+ full_name='paddle.DenseTableParameter.fea_dim',
+ index=3,
+ number=4,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=991,
+ serialized_end=1114,
+)
+
+_SPARSETABLEPARAMETER = _descriptor.Descriptor(
+ name='SparseTableParameter',
+ full_name='paddle.SparseTableParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='table_id',
+ full_name='paddle.SparseTableParameter.table_id',
+ index=0,
+ number=1,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='feature_dim',
+ full_name='paddle.SparseTableParameter.feature_dim',
+ index=1,
+ number=2,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='slot_key',
+ full_name='paddle.SparseTableParameter.slot_key',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='slot_value',
+ full_name='paddle.SparseTableParameter.slot_value',
+ index=3,
+ number=4,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='slot_gradient',
+ full_name='paddle.SparseTableParameter.slot_gradient',
+ index=4,
+ number=5,
+ type=9,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=1116,
+ serialized_end=1238,
+)
+
+_DOWNPOURSERVERPARAMETER = _descriptor.Descriptor(
+ name='DownpourServerParameter',
+ full_name='paddle.DownpourServerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='downpour_table_param',
+ full_name='paddle.DownpourServerParameter.downpour_table_param',
+ index=0,
+ number=1,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='service_param',
+ full_name='paddle.DownpourServerParameter.service_param',
+ index=1,
+ number=2,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=1241,
+ serialized_end=1375,
+)
+
+_SERVERSERVICEPARAMETER = _descriptor.Descriptor(
+ name='ServerServiceParameter',
+ full_name='paddle.ServerServiceParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='server_class',
+ full_name='paddle.ServerServiceParameter.server_class',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=True,
+ default_value=_b("DownpourBrpcPsServer").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='client_class',
+ full_name='paddle.ServerServiceParameter.client_class',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=True,
+ default_value=_b("DownpourBrpcPsClient").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='service_class',
+ full_name='paddle.ServerServiceParameter.service_class',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=True,
+ default_value=_b("DownpourPsService").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='start_server_port',
+ full_name='paddle.ServerServiceParameter.start_server_port',
+ index=3,
+ number=4,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='server_thread_num',
+ full_name='paddle.ServerServiceParameter.server_thread_num',
+ index=4,
+ number=5,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=12,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=1378,
+ serialized_end=1593,
+)
+
+_TABLEPARAMETER = _descriptor.Descriptor(
+ name='TableParameter',
+ full_name='paddle.TableParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(name='table_id',
+ full_name='paddle.TableParameter.table_id',
+ index=0,
+ number=1,
+ type=4,
+ cpp_type=4,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_class',
+ full_name='paddle.TableParameter.table_class',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='shard_num',
+ full_name='paddle.TableParameter.shard_num',
+ index=2,
+ number=3,
+ type=4,
+ cpp_type=4,
+ label=1,
+ has_default_value=True,
+ default_value=1000,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='accessor',
+ full_name='paddle.TableParameter.accessor',
+ index=3,
+ number=4,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='type',
+ full_name='paddle.TableParameter.type',
+ index=4,
+ number=5,
+ type=14,
+ cpp_type=8,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='compress_in_save',
+ full_name='paddle.TableParameter.compress_in_save',
+ index=5,
+ number=6,
+ type=8,
+ cpp_type=7,
+ label=1,
+ has_default_value=True,
+ default_value=False,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_sparse_table_cache',
+ full_name='paddle.TableParameter.enable_sparse_table_cache',
+ index=6,
+ number=7,
+ type=8,
+ cpp_type=7,
+ label=1,
+ has_default_value=True,
+ default_value=True,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_table_cache_rate',
+ full_name='paddle.TableParameter.sparse_table_cache_rate',
+ index=7,
+ number=8,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.00055),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_table_cache_file_num',
+ full_name='paddle.TableParameter.sparse_table_cache_file_num',
+ index=8,
+ number=9,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=16,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=1596,
+ serialized_end=1916,
+)
+
+_TABLEACCESSORPARAMETER = _descriptor.Descriptor(
+ name='TableAccessorParameter',
+ full_name='paddle.TableAccessorParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='accessor_class',
+ full_name='paddle.TableAccessorParameter.accessor_class',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_sgd_param',
+ full_name='paddle.TableAccessorParameter.sparse_sgd_param',
+ index=1,
+ number=2,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_sgd_param',
+ full_name='paddle.TableAccessorParameter.dense_sgd_param',
+ index=2,
+ number=3,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fea_dim',
+ full_name='paddle.TableAccessorParameter.fea_dim',
+ index=3,
+ number=4,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=11,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_dim',
+ full_name='paddle.TableAccessorParameter.embedx_dim',
+ index=4,
+ number=5,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=8,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_threshold',
+ full_name='paddle.TableAccessorParameter.embedx_threshold',
+ index=5,
+ number=6,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=True,
+ default_value=10,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='downpour_accessor_param',
+ full_name='paddle.TableAccessorParameter.downpour_accessor_param',
+ index=6,
+ number=7,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_accessor_save_param',
+ full_name='paddle.TableAccessorParameter.table_accessor_save_param',
+ index=7,
+ number=8,
+ type=11,
+ cpp_type=10,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_commonsgd_param',
+ full_name='paddle.TableAccessorParameter.sparse_commonsgd_param',
+ index=8,
+ number=9,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embed_sgd_param',
+ full_name='paddle.TableAccessorParameter.embed_sgd_param',
+ index=9,
+ number=10,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_sgd_param',
+ full_name='paddle.TableAccessorParameter.embedx_sgd_param',
+ index=10,
+ number=11,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=1919,
+ serialized_end=2496,
+)
+
+_DOWNPOURTABLEACCESSORPARAMETER = _descriptor.Descriptor(
+ name='DownpourTableAccessorParameter',
+ full_name='paddle.DownpourTableAccessorParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='nonclk_coeff',
+ full_name='paddle.DownpourTableAccessorParameter.nonclk_coeff',
+ index=0,
+ number=1,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.1),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='click_coeff',
+ full_name='paddle.DownpourTableAccessorParameter.click_coeff',
+ index=1,
+ number=2,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(1),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='base_threshold',
+ full_name='paddle.DownpourTableAccessorParameter.base_threshold',
+ index=2,
+ number=3,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(1.5),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delta_threshold',
+ full_name='paddle.DownpourTableAccessorParameter.delta_threshold',
+ index=3,
+ number=4,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.25),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delta_keep_days',
+ full_name='paddle.DownpourTableAccessorParameter.delta_keep_days',
+ index=4,
+ number=5,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(16),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='show_click_decay_rate',
+ full_name=
+ 'paddle.DownpourTableAccessorParameter.show_click_decay_rate',
+ index=5,
+ number=6,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.98),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delete_threshold',
+ full_name='paddle.DownpourTableAccessorParameter.delete_threshold',
+ index=6,
+ number=7,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.8),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delete_after_unseen_days',
+ full_name=
+ 'paddle.DownpourTableAccessorParameter.delete_after_unseen_days',
+ index=7,
+ number=8,
+ type=2,
+ cpp_type=6,
+ label=1,
+ has_default_value=True,
+ default_value=float(30),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ssd_unseenday_threshold',
+ full_name=
+ 'paddle.DownpourTableAccessorParameter.ssd_unseenday_threshold',
+ index=8,
+ number=9,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=True,
+ default_value=1,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=2499,
+ serialized_end=2813,
+)
+
+_TABLEACCESSORSAVEPARAMETER = _descriptor.Descriptor(
+ name='TableAccessorSaveParameter',
+ full_name='paddle.TableAccessorSaveParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='param',
+ full_name='paddle.TableAccessorSaveParameter.param',
+ index=0,
+ number=1,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='converter',
+ full_name='paddle.TableAccessorSaveParameter.converter',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='deconverter',
+ full_name='paddle.TableAccessorSaveParameter.deconverter',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=2815,
+ serialized_end=2898,
+)
+
+_PSREQUESTMESSAGE = _descriptor.Descriptor(
+ name='PsRequestMessage',
+ full_name='paddle.PsRequestMessage',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(name='cmd_id',
+ full_name='paddle.PsRequestMessage.cmd_id',
+ index=0,
+ number=1,
+ type=13,
+ cpp_type=3,
+ label=2,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_id',
+ full_name='paddle.PsRequestMessage.table_id',
+ index=1,
+ number=2,
+ type=13,
+ cpp_type=3,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='params',
+ full_name='paddle.PsRequestMessage.params',
+ index=2,
+ number=3,
+ type=12,
+ cpp_type=9,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='client_id',
+ full_name='paddle.PsRequestMessage.client_id',
+ index=3,
+ number=4,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='data',
+ full_name='paddle.PsRequestMessage.data',
+ index=4,
+ number=5,
+ type=12,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b(""),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=2900,
+ serialized_end=3001,
+)
+
+_SPARSESGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseSGDRuleParameter',
+ full_name='paddle.SparseSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.SparseSGDRuleParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.05),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_g2sum',
+ full_name='paddle.SparseSGDRuleParameter.initial_g2sum',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(3),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range',
+ full_name='paddle.SparseSGDRuleParameter.initial_range',
+ index=2,
+ number=3,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.0001),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds',
+ full_name='paddle.SparseSGDRuleParameter.weight_bounds',
+ index=3,
+ number=4,
+ type=2,
+ cpp_type=6,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3004,
+ serialized_end=3137,
+)
+
+_SPARSECOMMONSGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseCommonSGDRuleParameter',
+ full_name='paddle.SparseCommonSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name',
+ full_name='paddle.SparseCommonSGDRuleParameter.name',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='naive',
+ full_name='paddle.SparseCommonSGDRuleParameter.naive',
+ index=1,
+ number=2,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adagrad',
+ full_name='paddle.SparseCommonSGDRuleParameter.adagrad',
+ index=2,
+ number=3,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adam',
+ full_name='paddle.SparseCommonSGDRuleParameter.adam',
+ index=3,
+ number=4,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3140,
+ serialized_end=3338,
+)
+
+_SPARSENAIVESGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseNaiveSGDRuleParameter',
+ full_name='paddle.SparseNaiveSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.SparseNaiveSGDRuleParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.05),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range',
+ full_name='paddle.SparseNaiveSGDRuleParameter.initial_range',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.0001),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds',
+ full_name='paddle.SparseNaiveSGDRuleParameter.weight_bounds',
+ index=2,
+ number=3,
+ type=2,
+ cpp_type=6,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3340,
+ serialized_end=3452,
+)
+
+_SPARSEADAGRADSGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseAdagradSGDRuleParameter',
+ full_name='paddle.SparseAdagradSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.SparseAdagradSGDRuleParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.05),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_g2sum',
+ full_name='paddle.SparseAdagradSGDRuleParameter.initial_g2sum',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(3),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range',
+ full_name='paddle.SparseAdagradSGDRuleParameter.initial_range',
+ index=2,
+ number=3,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.0001),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds',
+ full_name='paddle.SparseAdagradSGDRuleParameter.weight_bounds',
+ index=3,
+ number=4,
+ type=2,
+ cpp_type=6,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3455,
+ serialized_end=3595,
+)
+
+_SPARSEADAMSGDPARAMETER = _descriptor.Descriptor(
+ name='SparseAdamSGDParameter',
+ full_name='paddle.SparseAdamSGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.SparseAdamSGDParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.001),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range',
+ full_name='paddle.SparseAdamSGDParameter.initial_range',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.0001),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='beta1_decay_rate',
+ full_name='paddle.SparseAdamSGDParameter.beta1_decay_rate',
+ index=2,
+ number=3,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.9),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='beta2_decay_rate',
+ full_name='paddle.SparseAdamSGDParameter.beta2_decay_rate',
+ index=3,
+ number=4,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.999),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ada_epsilon',
+ full_name='paddle.SparseAdamSGDParameter.ada_epsilon',
+ index=4,
+ number=5,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(1e-08),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds',
+ full_name='paddle.SparseAdamSGDParameter.weight_bounds',
+ index=5,
+ number=6,
+ type=2,
+ cpp_type=6,
+ label=3,
+ has_default_value=False,
+ default_value=[],
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3598,
+ serialized_end=3798,
+)
+
+_DENSESGDRULEPARAMETER = _descriptor.Descriptor(
+ name='DenseSGDRuleParameter',
+ full_name='paddle.DenseSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name',
+ full_name='paddle.DenseSGDRuleParameter.name',
+ index=0,
+ number=1,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adam',
+ full_name='paddle.DenseSGDRuleParameter.adam',
+ index=1,
+ number=2,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='naive',
+ full_name='paddle.DenseSGDRuleParameter.naive',
+ index=2,
+ number=3,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='summary',
+ full_name='paddle.DenseSGDRuleParameter.summary',
+ index=3,
+ number=4,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='moving_average',
+ full_name='paddle.DenseSGDRuleParameter.moving_average',
+ index=4,
+ number=5,
+ type=11,
+ cpp_type=10,
+ label=1,
+ has_default_value=False,
+ default_value=None,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=3801,
+ serialized_end=4026,
+)
+
+_ADAMSGDPARAMETER = _descriptor.Descriptor(
+ name='AdamSGDParameter',
+ full_name='paddle.AdamSGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.AdamSGDParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(5e-06),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='avg_decay_rate',
+ full_name='paddle.AdamSGDParameter.avg_decay_rate',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.999993),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ada_decay_rate',
+ full_name='paddle.AdamSGDParameter.ada_decay_rate',
+ index=2,
+ number=3,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.9999),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ada_epsilon',
+ full_name='paddle.AdamSGDParameter.ada_epsilon',
+ index=3,
+ number=4,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(1e-08),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mom_decay_rate',
+ full_name='paddle.AdamSGDParameter.mom_decay_rate',
+ index=4,
+ number=5,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.99),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4029,
+ serialized_end=4201,
+)
+
+_NAIVESGDPARAMETER = _descriptor.Descriptor(
+ name='NaiveSGDParameter',
+ full_name='paddle.NaiveSGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate',
+ full_name='paddle.NaiveSGDParameter.learning_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.0002),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='avg_decay_rate',
+ full_name='paddle.NaiveSGDParameter.avg_decay_rate',
+ index=1,
+ number=2,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=False,
+ default_value=float(0),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4203,
+ serialized_end=4277,
+)
+
+_SUMMARYSGDPARAMETER = _descriptor.Descriptor(
+ name='SummarySGDParameter',
+ full_name='paddle.SummarySGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='summary_decay_rate',
+ full_name='paddle.SummarySGDParameter.summary_decay_rate',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=True,
+ default_value=float(0.999999),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4279,
+ serialized_end=4338,
+)
+
+_MOVINGAVERAGERULEPARAMETER = _descriptor.Descriptor(
+ name='MovingAverageRuleParameter',
+ full_name='paddle.MovingAverageRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='momentum',
+ full_name='paddle.MovingAverageRuleParameter.momentum',
+ index=0,
+ number=1,
+ type=1,
+ cpp_type=5,
+ label=1,
+ has_default_value=False,
+ default_value=float(0),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4340,
+ serialized_end=4386,
+)
+
+_PSRESPONSEMESSAGE = _descriptor.Descriptor(
+ name='PsResponseMessage',
+ full_name='paddle.PsResponseMessage',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='err_code',
+ full_name='paddle.PsResponseMessage.err_code',
+ index=0,
+ number=1,
+ type=5,
+ cpp_type=1,
+ label=2,
+ has_default_value=True,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='err_msg',
+ full_name='paddle.PsResponseMessage.err_msg',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=2,
+ has_default_value=True,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='data',
+ full_name='paddle.PsResponseMessage.data',
+ index=2,
+ number=3,
+ type=12,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b(""),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4388,
+ serialized_end=4461,
+)
+
+_FSCLIENTPARAMETER = _descriptor.Descriptor(
+ name='FsClientParameter',
+ full_name='paddle.FsClientParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='fs_type',
+ full_name='paddle.FsClientParameter.fs_type',
+ index=0,
+ number=1,
+ type=14,
+ cpp_type=8,
+ label=1,
+ has_default_value=True,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='uri',
+ full_name='paddle.FsClientParameter.uri',
+ index=1,
+ number=2,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='user',
+ full_name='paddle.FsClientParameter.user',
+ index=2,
+ number=3,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(name='passwd',
+ full_name='paddle.FsClientParameter.passwd',
+ index=3,
+ number=4,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='buffer_size',
+ full_name='paddle.FsClientParameter.buffer_size',
+ index=4,
+ number=5,
+ type=5,
+ cpp_type=1,
+ label=1,
+ has_default_value=False,
+ default_value=0,
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hadoop_bin',
+ full_name='paddle.FsClientParameter.hadoop_bin',
+ index=5,
+ number=51,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='afs_conf',
+ full_name='paddle.FsClientParameter.afs_conf',
+ index=6,
+ number=101,
+ type=9,
+ cpp_type=9,
+ label=1,
+ has_default_value=False,
+ default_value=_b("").decode('utf-8'),
+ message_type=None,
+ enum_type=None,
+ containing_type=None,
+ is_extension=False,
+ extension_scope=None,
+ options=None),
+ ],
+ extensions=[],
+ nested_types=[],
+ enum_types=[
+ _FSCLIENTPARAMETER_FSAPITYPE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[],
+ serialized_start=4464,
+ serialized_end=4677,
+)
+
+_PSPARAMETER.fields_by_name['worker_param'].message_type = _WORKERPARAMETER
+_PSPARAMETER.fields_by_name['server_param'].message_type = _SERVERPARAMETER
+_PSPARAMETER.fields_by_name[
+ 'trainer_param'].message_type = _DOWNPOURTRAINERPARAMETER
+_PSPARAMETER.fields_by_name['fs_client_param'].message_type = _FSCLIENTPARAMETER
+_WORKERPARAMETER.fields_by_name[
+ 'downpour_worker_param'].message_type = _DOWNPOURWORKERPARAMETER
+_SERVERPARAMETER.fields_by_name[
+ 'downpour_server_param'].message_type = _DOWNPOURSERVERPARAMETER
+_DOWNPOURWORKERPARAMETER.fields_by_name[
+ 'downpour_table_param'].message_type = _TABLEPARAMETER
+_DOWNPOURTRAINERPARAMETER.fields_by_name[
+ 'dense_table'].message_type = _DENSETABLEPARAMETER
+_DOWNPOURTRAINERPARAMETER.fields_by_name[
+ 'sparse_table'].message_type = _SPARSETABLEPARAMETER
+_DOWNPOURTRAINERPARAMETER.fields_by_name[
+ 'program_config'].message_type = _PROGRAMCONFIG
+_DOWNPOURSERVERPARAMETER.fields_by_name[
+ 'downpour_table_param'].message_type = _TABLEPARAMETER
+_DOWNPOURSERVERPARAMETER.fields_by_name[
+ 'service_param'].message_type = _SERVERSERVICEPARAMETER
+_TABLEPARAMETER.fields_by_name[
+ 'accessor'].message_type = _TABLEACCESSORPARAMETER
+_TABLEPARAMETER.fields_by_name['type'].enum_type = _TABLETYPE
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'sparse_sgd_param'].message_type = _SPARSESGDRULEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'dense_sgd_param'].message_type = _DENSESGDRULEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'downpour_accessor_param'].message_type = _DOWNPOURTABLEACCESSORPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'table_accessor_save_param'].message_type = _TABLEACCESSORSAVEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'sparse_commonsgd_param'].message_type = _SPARSECOMMONSGDRULEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'embed_sgd_param'].message_type = _SPARSECOMMONSGDRULEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name[
+ 'embedx_sgd_param'].message_type = _SPARSECOMMONSGDRULEPARAMETER
+_SPARSECOMMONSGDRULEPARAMETER.fields_by_name[
+ 'naive'].message_type = _SPARSENAIVESGDRULEPARAMETER
+_SPARSECOMMONSGDRULEPARAMETER.fields_by_name[
+ 'adagrad'].message_type = _SPARSEADAGRADSGDRULEPARAMETER
+_SPARSECOMMONSGDRULEPARAMETER.fields_by_name[
+ 'adam'].message_type = _SPARSEADAMSGDPARAMETER
+_DENSESGDRULEPARAMETER.fields_by_name['adam'].message_type = _ADAMSGDPARAMETER
+_DENSESGDRULEPARAMETER.fields_by_name['naive'].message_type = _NAIVESGDPARAMETER
+_DENSESGDRULEPARAMETER.fields_by_name[
+ 'summary'].message_type = _SUMMARYSGDPARAMETER
+_DENSESGDRULEPARAMETER.fields_by_name[
+ 'moving_average'].message_type = _MOVINGAVERAGERULEPARAMETER
+_FSCLIENTPARAMETER.fields_by_name[
+ 'fs_type'].enum_type = _FSCLIENTPARAMETER_FSAPITYPE
+_FSCLIENTPARAMETER_FSAPITYPE.containing_type = _FSCLIENTPARAMETER
+DESCRIPTOR.message_types_by_name['PSParameter'] = _PSPARAMETER
+DESCRIPTOR.message_types_by_name['WorkerParameter'] = _WORKERPARAMETER
+DESCRIPTOR.message_types_by_name['ServerParameter'] = _SERVERPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'DownpourWorkerParameter'] = _DOWNPOURWORKERPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'DownpourTrainerParameter'] = _DOWNPOURTRAINERPARAMETER
+DESCRIPTOR.message_types_by_name['ProgramConfig'] = _PROGRAMCONFIG
+DESCRIPTOR.message_types_by_name['DenseTableParameter'] = _DENSETABLEPARAMETER
+DESCRIPTOR.message_types_by_name['SparseTableParameter'] = _SPARSETABLEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'DownpourServerParameter'] = _DOWNPOURSERVERPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'ServerServiceParameter'] = _SERVERSERVICEPARAMETER
+DESCRIPTOR.message_types_by_name['TableParameter'] = _TABLEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'TableAccessorParameter'] = _TABLEACCESSORPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'DownpourTableAccessorParameter'] = _DOWNPOURTABLEACCESSORPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'TableAccessorSaveParameter'] = _TABLEACCESSORSAVEPARAMETER
+DESCRIPTOR.message_types_by_name['PsRequestMessage'] = _PSREQUESTMESSAGE
+DESCRIPTOR.message_types_by_name[
+ 'SparseSGDRuleParameter'] = _SPARSESGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'SparseCommonSGDRuleParameter'] = _SPARSECOMMONSGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'SparseNaiveSGDRuleParameter'] = _SPARSENAIVESGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'SparseAdagradSGDRuleParameter'] = _SPARSEADAGRADSGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'SparseAdamSGDParameter'] = _SPARSEADAMSGDPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'DenseSGDRuleParameter'] = _DENSESGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name['AdamSGDParameter'] = _ADAMSGDPARAMETER
+DESCRIPTOR.message_types_by_name['NaiveSGDParameter'] = _NAIVESGDPARAMETER
+DESCRIPTOR.message_types_by_name['SummarySGDParameter'] = _SUMMARYSGDPARAMETER
+DESCRIPTOR.message_types_by_name[
+ 'MovingAverageRuleParameter'] = _MOVINGAVERAGERULEPARAMETER
+DESCRIPTOR.message_types_by_name['PsResponseMessage'] = _PSRESPONSEMESSAGE
+DESCRIPTOR.message_types_by_name['FsClientParameter'] = _FSCLIENTPARAMETER
+DESCRIPTOR.enum_types_by_name['TableType'] = _TABLETYPE
+DESCRIPTOR.enum_types_by_name['PsCmdID'] = _PSCMDID
+
+PSParameter = _reflection.GeneratedProtocolMessageType(
+ 'PSParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_PSPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.PSParameter)
+ ))
+_sym_db.RegisterMessage(PSParameter)
+
+WorkerParameter = _reflection.GeneratedProtocolMessageType(
+ 'WorkerParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_WORKERPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.WorkerParameter)
+ ))
+_sym_db.RegisterMessage(WorkerParameter)
+
+ServerParameter = _reflection.GeneratedProtocolMessageType(
+ 'ServerParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SERVERPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.ServerParameter)
+ ))
+_sym_db.RegisterMessage(ServerParameter)
+
+DownpourWorkerParameter = _reflection.GeneratedProtocolMessageType(
+ 'DownpourWorkerParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_DOWNPOURWORKERPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DownpourWorkerParameter)
+ ))
+_sym_db.RegisterMessage(DownpourWorkerParameter)
+
+DownpourTrainerParameter = _reflection.GeneratedProtocolMessageType(
+ 'DownpourTrainerParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_DOWNPOURTRAINERPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DownpourTrainerParameter)
+ ))
+_sym_db.RegisterMessage(DownpourTrainerParameter)
+
+ProgramConfig = _reflection.GeneratedProtocolMessageType(
+ 'ProgramConfig',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_PROGRAMCONFIG,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.ProgramConfig)
+ ))
+_sym_db.RegisterMessage(ProgramConfig)
+
+DenseTableParameter = _reflection.GeneratedProtocolMessageType(
+ 'DenseTableParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_DENSETABLEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DenseTableParameter)
+ ))
+_sym_db.RegisterMessage(DenseTableParameter)
+
+SparseTableParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseTableParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SPARSETABLEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseTableParameter)
+ ))
+_sym_db.RegisterMessage(SparseTableParameter)
+
+DownpourServerParameter = _reflection.GeneratedProtocolMessageType(
+ 'DownpourServerParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_DOWNPOURSERVERPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DownpourServerParameter)
+ ))
+_sym_db.RegisterMessage(DownpourServerParameter)
+
+ServerServiceParameter = _reflection.GeneratedProtocolMessageType(
+ 'ServerServiceParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SERVERSERVICEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.ServerServiceParameter)
+ ))
+_sym_db.RegisterMessage(ServerServiceParameter)
+
+TableParameter = _reflection.GeneratedProtocolMessageType(
+ 'TableParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_TABLEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.TableParameter)
+ ))
+_sym_db.RegisterMessage(TableParameter)
+
+TableAccessorParameter = _reflection.GeneratedProtocolMessageType(
+ 'TableAccessorParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_TABLEACCESSORPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.TableAccessorParameter)
+ ))
+_sym_db.RegisterMessage(TableAccessorParameter)
+
+DownpourTableAccessorParameter = _reflection.GeneratedProtocolMessageType(
+ 'DownpourTableAccessorParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_DOWNPOURTABLEACCESSORPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DownpourTableAccessorParameter)
+ ))
+_sym_db.RegisterMessage(DownpourTableAccessorParameter)
+
+TableAccessorSaveParameter = _reflection.GeneratedProtocolMessageType(
+ 'TableAccessorSaveParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_TABLEACCESSORSAVEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.TableAccessorSaveParameter)
+ ))
+_sym_db.RegisterMessage(TableAccessorSaveParameter)
+
+PsRequestMessage = _reflection.GeneratedProtocolMessageType(
+ 'PsRequestMessage',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_PSREQUESTMESSAGE,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.PsRequestMessage)
+ ))
+_sym_db.RegisterMessage(PsRequestMessage)
+
+SparseSGDRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseSGDRuleParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SPARSESGDRULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseSGDRuleParameter)
+
+SparseCommonSGDRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseCommonSGDRuleParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_SPARSECOMMONSGDRULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseCommonSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseCommonSGDRuleParameter)
+
+SparseNaiveSGDRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseNaiveSGDRuleParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_SPARSENAIVESGDRULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseNaiveSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseNaiveSGDRuleParameter)
+
+SparseAdagradSGDRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseAdagradSGDRuleParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_SPARSEADAGRADSGDRULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseAdagradSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseAdagradSGDRuleParameter)
+
+SparseAdamSGDParameter = _reflection.GeneratedProtocolMessageType(
+ 'SparseAdamSGDParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SPARSEADAMSGDPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SparseAdamSGDParameter)
+ ))
+_sym_db.RegisterMessage(SparseAdamSGDParameter)
+
+DenseSGDRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'DenseSGDRuleParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_DENSESGDRULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.DenseSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(DenseSGDRuleParameter)
+
+AdamSGDParameter = _reflection.GeneratedProtocolMessageType(
+ 'AdamSGDParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_ADAMSGDPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.AdamSGDParameter)
+ ))
+_sym_db.RegisterMessage(AdamSGDParameter)
+
+NaiveSGDParameter = _reflection.GeneratedProtocolMessageType(
+ 'NaiveSGDParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_NAIVESGDPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.NaiveSGDParameter)
+ ))
+_sym_db.RegisterMessage(NaiveSGDParameter)
+
+SummarySGDParameter = _reflection.GeneratedProtocolMessageType(
+ 'SummarySGDParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_SUMMARYSGDPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.SummarySGDParameter)
+ ))
+_sym_db.RegisterMessage(SummarySGDParameter)
+
+MovingAverageRuleParameter = _reflection.GeneratedProtocolMessageType(
+ 'MovingAverageRuleParameter',
+ (_message.Message, ),
+ dict(
+ DESCRIPTOR=_MOVINGAVERAGERULEPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.MovingAverageRuleParameter)
+ ))
+_sym_db.RegisterMessage(MovingAverageRuleParameter)
+
+PsResponseMessage = _reflection.GeneratedProtocolMessageType(
+ 'PsResponseMessage',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_PSRESPONSEMESSAGE,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.PsResponseMessage)
+ ))
+_sym_db.RegisterMessage(PsResponseMessage)
+
+FsClientParameter = _reflection.GeneratedProtocolMessageType(
+ 'FsClientParameter',
+ (_message.Message, ),
+ dict(DESCRIPTOR=_FSCLIENTPARAMETER,
+ __module__='ps_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.FsClientParameter)
+ ))
+_sym_db.RegisterMessage(FsClientParameter)
+
+DESCRIPTOR.has_options = True
+DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(),
+ _b('\200\001\001\370\001\001'))
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/version.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..183c90d9dead6223a28cc2203774d29062bc0e2e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/parameter_server/version.py
@@ -0,0 +1,11 @@
+from __future__ import print_function
+
+# THIS FILE IS GENERATED FROM PADDLEPADDLE SETUP.PY
+
+from paddle.fluid.incubate.fleet.base.mode import Mode
+
+BUILD_MODE=Mode.TRANSPILER
+
+def is_transpiler():
+ return Mode.TRANSPILER == BUILD_MODE
+
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0c32e26092f6ea25771279418582a24ea449ab2
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/__init__.py
@@ -0,0 +1,13 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/fleet_util.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/fleet_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..48ce51b372489fb334da8031000091f9560aac88
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/fleet_util.py
@@ -0,0 +1,2200 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+"""Fleet Utils."""
+
+import collections
+import copy
+import json
+import logging
+import math
+import numpy as np
+import os
+import sys
+import time
+import paddle.fluid as fluid
+from paddle.fluid import core
+from paddle.fluid.log_helper import get_logger
+from paddle.distributed.fleet.utils.fs import LocalFS, HDFSClient, AFSClient
+from . import utils
+
+OpRole = core.op_proto_and_checker_maker.OpRole
+
+__all__ = ["FleetUtil", "GPUPSUtil"]
+
+_logger = get_logger(__name__,
+ logging.INFO,
+ fmt='%(asctime)s %(levelname)s: %(message)s')
+
+fleet = None
+
+
+class FleetUtil(object):
+ """
+ FleetUtil provides some common functions for users' convenience.
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.rank0_print("my log")
+
+ """
+
+ def __init__(self, mode="pslib"):
+ global fleet
+ op_maker = core.op_proto_and_checker_maker
+ self.op_role_key = op_maker.kOpRoleAttrName()
+ if mode == "pslib":
+ from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet as fleet_pslib
+ fleet = fleet_pslib
+ elif mode == "transpiler":
+ from paddle.fluid.incubate.fleet.parameter_server.distribute_transpiler import fleet as fleet_transpiler
+ fleet = fleet_transpiler
+ else:
+ raise ValueError(
+ "Please choose one mode from [\"pslib\", \"transpiler\"]")
+
+ def rank0_print(self, s):
+ """
+ Worker of rank 0 print some log.
+
+ Args:
+ s(str): string to print
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.rank0_print("my log")
+
+ """
+ if fleet.worker_index() != 0:
+ return
+ print(s)
+ sys.stdout.flush()
+
+ def rank0_info(self, s):
+ """
+ Worker of rank 0 print some log info.
+
+ Args:
+ s(str): string to log
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.rank0_info("my log info")
+
+ """
+ if fleet.worker_index() != 0:
+ return
+ _logger.info(s)
+
+ def rank0_error(self, s):
+ """
+ Worker of rank 0 print some log error.
+
+ Args:
+ s(str): string to log
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.rank0_error("my log error")
+
+ """
+ if fleet.worker_index() != 0:
+ return
+ _logger.error(s)
+
+ def set_zero(self,
+ var_name,
+ scope=fluid.global_scope(),
+ place=fluid.CPUPlace(),
+ param_type="int64"):
+ """
+ Set tensor of a Variable to zero.
+
+ Args:
+ var_name(str): name of Variable
+ scope(Scope): Scope object, default is fluid.global_scope()
+ place(Place): Place object, default is fluid.CPUPlace()
+ param_type(str): param data type, default is int64
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.set_zero(myvar.name, myscope)
+
+ """
+ param = scope.var(var_name).get_tensor()
+ param_array = np.zeros(param._get_dims()).astype(param_type)
+ param.set(param_array, place)
+
+ def print_global_auc(self,
+ scope=fluid.global_scope(),
+ stat_pos="_generated_var_2",
+ stat_neg="_generated_var_3",
+ print_prefix=""):
+ r"""
+ Print global auc of all distributed workers.
+
+ Args:
+ scope(Scope): Scope object, default is fluid.global_scope()
+ stat_pos(str): name of auc pos bucket Variable
+ stat_neg(str): name of auc neg bucket Variable
+ print_prefix(str): prefix of print auc
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.print_global_auc(myscope, stat_pos=stat_pos.name,
+ stat_neg=stat_neg.name)
+
+ # below is part of model
+ emb = my_slot_net(slots, label) # emb can be fc layer of size 1
+ similarity_norm = fluid.layers.sigmoid(fluid.layers.clip(\
+ emb, min=-15.0, max=15.0), name="similarity_norm")\
+ binary_predict = fluid.layers.concat(input=[\
+ fluid.layers.elementwise_sub(\
+ fluid.layers.ceil(similarity_norm), similarity_norm),\
+ similarity_norm], axis=1)
+ auc, batch_auc, [batch_stat_pos, batch_stat_neg, stat_pos, \
+ stat_neg] = fluid.layers.auc(input=binary_predict,\
+ label=label, curve='ROC',\
+ num_thresholds=4096)
+
+ """
+ auc_value = self.get_global_auc(scope, stat_pos, stat_neg)
+ self.rank0_print(print_prefix + " global auc = %s" % auc_value)
+
+ def get_global_auc(self,
+ scope=fluid.global_scope(),
+ stat_pos="_generated_var_2",
+ stat_neg="_generated_var_3"):
+ """
+ Get global auc of all distributed workers.
+
+ Args:
+ scope(Scope): Scope object, default is fluid.global_scope()
+ stat_pos(str): name of auc pos bucket Variable
+ stat_neg(str): name of auc neg bucket Variable
+
+ Returns:
+ auc_value(float), total_ins_num(int)
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ auc_value, _ = fleet_util.get_global_auc(myscope,
+ stat_pos=stat_pos,
+ stat_neg=stat_neg)
+
+ """
+ if scope.find_var(stat_pos) is None or scope.find_var(stat_neg) is None:
+ self.rank0_print("not found auc bucket")
+ return None
+ fleet._role_maker._barrier_worker()
+ # auc pos bucket
+ pos = np.array(scope.find_var(stat_pos).get_tensor())
+ # auc pos bucket shape
+ old_pos_shape = np.array(pos.shape)
+ # reshape to one dim
+ pos = pos.reshape(-1)
+ global_pos = np.copy(pos) * 0
+ # mpi allreduce
+ fleet._role_maker._all_reduce(pos, global_pos)
+ # reshape to its original shape
+ global_pos = global_pos.reshape(old_pos_shape)
+
+ # auc neg bucket
+ neg = np.array(scope.find_var(stat_neg).get_tensor())
+ old_neg_shape = np.array(neg.shape)
+ neg = neg.reshape(-1)
+ global_neg = np.copy(neg) * 0
+ fleet._role_maker._all_reduce(neg, global_neg)
+ global_neg = global_neg.reshape(old_neg_shape)
+
+ # calculate auc
+ num_bucket = len(global_pos[0])
+ area = 0.0
+ pos = 0.0
+ neg = 0.0
+ new_pos = 0.0
+ new_neg = 0.0
+ total_ins_num = 0
+ for i in range(num_bucket):
+ index = num_bucket - 1 - i
+ new_pos = pos + global_pos[0][index]
+ total_ins_num += global_pos[0][index]
+ new_neg = neg + global_neg[0][index]
+ total_ins_num += global_neg[0][index]
+ area += (new_neg - neg) * (pos + new_pos) / 2
+ pos = new_pos
+ neg = new_neg
+
+ auc_value = None
+ if pos * neg == 0 or total_ins_num == 0:
+ auc_value = 0.5
+ else:
+ auc_value = area / (pos * neg)
+
+ fleet._role_maker._barrier_worker()
+ return auc_value
+
+ def load_fleet_model_one_table(self, table_id, path):
+ """
+ load pslib model to one table
+
+ Args:
+ table_id(int): load model to one table, default is None, which mean
+ load all table.
+ path(str): model path
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.load_fleet_model("hdfs:/my/model/path", table_id=1)
+ """
+ fleet.load_one_table(table_id, path)
+
+ def load_fleet_model(self, path, mode=0):
+ """
+ load pslib model
+
+ Args:
+ path(str): model path
+ mode(str): 0 or 1, which means load checkpoint or delta model,
+ default is 0
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+
+ fleet_util.load_fleet_model("hdfs:/my/model/path")
+
+ fleet_util.load_fleet_model("hdfs:/my/model/path", mode=0)
+
+ """
+ fleet.init_server(path, mode=mode)
+
+ def save_fleet_model(self, path, mode=0):
+ """
+ save pslib model
+
+ Args:
+ path(str): model path
+ mode(str): 0 or 1, which means save checkpoint or delta model,
+ default is 0
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_fleet_model("hdfs:/my/model/path")
+
+ """
+ fleet.save_persistables(None, path, mode=mode)
+
+ def _get_xbox_str(self,
+ output_path,
+ day,
+ model_path,
+ xbox_base_key,
+ data_path,
+ hadoop_fs_name,
+ monitor_data={},
+ mode="patch"):
+ xbox_dict = collections.OrderedDict()
+ if mode == "base":
+ xbox_dict["id"] = str(xbox_base_key)
+ elif mode == "patch":
+ xbox_dict["id"] = str(int(time.time()))
+ else:
+ print("warning: unknown mode %s, set it to patch" % mode)
+ mode = "patch"
+ xbox_dict["id"] = str(int(time.time()))
+ xbox_dict["key"] = str(xbox_base_key)
+ if model_path.startswith("hdfs:") or model_path.startswith("afs:"):
+ model_path = model_path[model_path.find(":") + 1:]
+ xbox_dict["input"] = hadoop_fs_name + model_path.rstrip("/") + "/000"
+ xbox_dict["record_count"] = "111111"
+ xbox_dict["partition_type"] = "2"
+ xbox_dict["job_name"] = "default_job_name"
+ xbox_dict["ins_tag"] = "feasign"
+ xbox_dict["ins_path"] = data_path
+ job_id_with_host = os.popen("echo -n ${JOB_ID}").read().strip()
+ instance_id = os.popen("echo -n ${INSTANCE_ID}").read().strip()
+ start_pos = instance_id.find(job_id_with_host)
+ end_pos = instance_id.find("--")
+ if start_pos != -1 and end_pos != -1:
+ job_id_with_host = instance_id[start_pos:end_pos]
+ xbox_dict["job_id"] = job_id_with_host
+ # currently hard code here, set monitor_data empty string
+ xbox_dict["monitor_data"] = ""
+ xbox_dict["monitor_path"] = output_path.rstrip("/") + "/monitor/" \
+ + day + ".txt"
+ xbox_dict["mpi_size"] = str(fleet.worker_num())
+ return json.dumps(xbox_dict)
+
+ def write_model_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ xbox_base_key,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME",
+ donefile_name="donefile.txt"):
+ """
+ write donefile when save model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+ xbox_base_key(str|int): xbox base key
+ hadoop_fs_name(str): hdfs/afs fs name
+ hadoop_fs_ugi(str): hdfs/afs fs ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ donefile_name(str): donefile name, default is "donefile.txt"
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.write_model_donefile(output_path="hdfs:/my/output",
+ model_path="hdfs:/my/model",
+ day=20190723,
+ pass_id=66,
+ xbox_base_key=int(time.time()),
+ hadoop_fs_name="hdfs://xxx",
+ hadoop_fs_ugi="user,passwd")
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ xbox_base_key = int(xbox_base_key)
+
+ if pass_id != "-1":
+ suffix_name = "/%s/%s/" % (day, pass_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ else:
+ suffix_name = "/%s/0/" % day
+ model_path = output_path.rstrip("/") + suffix_name
+
+ if fleet.worker_index() == 0:
+ donefile_path = output_path + "/" + donefile_name
+ content = "%s\t%lu\t%s\t%s\t%d" % (day, xbox_base_key,\
+ model_path, pass_id, 0)
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if client.is_file(donefile_path):
+ pre_content = client.cat(donefile_path)
+ pre_content_list = pre_content.split("\n")
+ day_list = [i.split("\t")[0] for i in pre_content_list]
+ pass_list = [i.split("\t")[3] for i in pre_content_list]
+ exist = False
+ for i in range(len(day_list)):
+ if int(day) == int(day_list[i]) and \
+ int(pass_id) == int(pass_list[i]):
+ exist = True
+ break
+ if not exist:
+ with open(donefile_name, "w") as f:
+ f.write(pre_content + "\n")
+ f.write(content + "\n")
+ client.delete(donefile_path)
+ client.upload(donefile_name, output_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ else:
+ self.rank0_error("not write %s because %s/%s already "
+ "exists" % (donefile_name, day, pass_id))
+ else:
+ with open(donefile_name, "w") as f:
+ f.write(content + "\n")
+ client.upload(donefile_name, output_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ fleet._role_maker._barrier_worker()
+
+ def write_xbox_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ xbox_base_key,
+ data_path,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ monitor_data={},
+ hadoop_home="$HADOOP_HOME",
+ donefile_name=None):
+ """
+ write delta donefile or xbox base donefile
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day of model
+ pass_id(str|int): training pass id of model
+ xbox_base_key(str|int): xbox base key
+ data_path(str|list): training data path
+ hadoop_fs_name(str): hdfs/afs fs name
+ hadoop_fs_ugi(str): hdfs/afs fs ugi
+ monitor_data(dict): metrics
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ donefile_name(str): donefile name, default is None"
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.write_xbox_donefile(
+ output_path="hdfs:/my/output/",
+ model_path="hdfs:/my/output/20190722/01",
+ day=20190722,
+ pass_id=1,
+ xbox_base_key=int(time.time()),
+ data_path="hdfs:/my/data/",
+ hadoop_fs_name="hdfs://xxx",
+ hadoop_fs_ugi="user,passwd",
+ monitor_data={}
+ )
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ xbox_base_key = int(xbox_base_key)
+ mode = None
+
+ if pass_id != "-1":
+ mode = "patch"
+ suffix_name = "/%s/delta-%s/" % (day, pass_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ if donefile_name is None:
+ donefile_name = "xbox_patch_done.txt"
+ else:
+ mode = "base"
+ suffix_name = "/%s/base/" % day
+ model_path = output_path.rstrip("/") + suffix_name
+ if donefile_name is None:
+ donefile_name = "xbox_base_done.txt"
+
+ if isinstance(data_path, list):
+ data_path = ",".join(data_path)
+
+ if fleet.worker_index() == 0:
+ donefile_path = output_path + "/" + donefile_name
+ xbox_str = self._get_xbox_str(output_path, day, model_path, \
+ xbox_base_key, data_path, hadoop_fs_name, monitor_data={},
+ mode=mode)
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if client.is_file(donefile_path):
+ pre_content = client.cat(donefile_path)
+ last_dict = json.loads(pre_content.split("\n")[-1])
+ last_day = last_dict["input"].split("/")[-3]
+ last_pass = last_dict["input"].split("/")[-2].split("-")[-1]
+ exist = False
+ if int(day) < int(last_day) or \
+ int(day) == int(last_day) and \
+ int(pass_id) <= int(last_pass):
+ exist = True
+ if not exist:
+ with open(donefile_name, "w") as f:
+ f.write(pre_content + "\n")
+ f.write(xbox_str + "\n")
+ client.delete(donefile_path)
+ client.upload(donefile_name, output_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ else:
+ self.rank0_error("not write %s because %s/%s already "
+ "exists" % (donefile_name, day, pass_id))
+ else:
+ with open(donefile_name, "w") as f:
+ f.write(xbox_str + "\n")
+ client.upload(donefile_name, output_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ fleet._role_maker._barrier_worker()
+
+ def write_cache_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ key_num,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME",
+ donefile_name="sparse_cache.meta",
+ **kwargs):
+ """
+ write cache donefile
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day of model
+ pass_id(str|int): training pass id of model
+ key_num(str|int): save cache return value
+ hadoop_fs_name(str): hdfs/afs fs name
+ hadoop_fs_ugi(str): hdfs/afs fs ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ donefile_name(str): donefile name, default is "sparse_cache.meta"
+ kwargs(dict): user defined properties
+ file_num(int): cache file num
+ table_id(int): cache table id
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.write_cache_donefile(
+ output_path="hdfs:/my/output/",
+ day=20190722,
+ pass_id=1,
+ key_num=123456,
+ hadoop_fs_name="hdfs://xxx",
+ hadoop_fs_ugi="user,passwd",
+ )
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ key_num = int(key_num)
+ file_num = kwargs.get("file_num", 16)
+ table_id = kwargs.get("table_id", 0)
+
+ if pass_id != "-1":
+ suffix_name = "/%s/delta-%s/%03d_cache" % (day, pass_id, table_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ else:
+ suffix_name = "/%s/base/%03d_cache" % (day, table_id)
+ model_path = output_path.rstrip("/") + suffix_name
+
+ if fleet.worker_index() == 0:
+ donefile_path = model_path + "/" + donefile_name
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if client.is_file(donefile_path):
+ self.rank0_error( \
+ "not write because %s already exists" % donefile_path)
+ else:
+ meta_str = "file_prefix:part\npart_num:%s\nkey_num:%d\n" \
+ % (file_num, key_num)
+ with open(donefile_name, "w") as f:
+ f.write(meta_str)
+ client.upload(donefile_name, model_path)
+ self.rank0_error("write %s succeed" % donefile_path)
+ fleet._role_maker._barrier_worker()
+
+ def load_model(self, output_path, day, pass_id):
+ """
+ load pslib model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.load_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ suffix_name = "/%s/%s/" % (day, pass_id)
+ load_path = output_path + suffix_name
+ self.rank0_error("going to load_model %s" % load_path)
+ self.load_fleet_model(load_path)
+ self.rank0_error("load_model done")
+
+ def save_model(self, output_path, day, pass_id):
+ """
+ save pslib model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ suffix_name = "/%s/%s/" % (day, pass_id)
+ model_path = output_path + suffix_name
+ self.rank0_print("going to save_model %s" % model_path)
+ self.save_fleet_model(model_path)
+ self.rank0_print("save_model done")
+
+ def save_batch_model(self, output_path, day):
+ """
+ save batch model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_batch_model("hdfs:/my/path", 20190722)
+
+ """
+ day = str(day)
+ suffix_name = "/%s/0/" % day
+ model_path = output_path + suffix_name
+ self.rank0_print("going to save_model %s" % model_path)
+ fleet.save_persistables(None, model_path, mode=3)
+ self.rank0_print("save_batch_model done")
+
+ def save_delta_model(self, output_path, day, pass_id):
+ """
+ save delta model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_batch_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ suffix_name = "/%s/delta-%s/" % (day, pass_id)
+ model_path = output_path + suffix_name
+ self.rank0_print("going to save_delta_model %s" % model_path)
+ fleet.save_persistables(None, model_path, mode=1)
+ self.rank0_print("save_delta_model done")
+
+ def save_xbox_base_model(self, output_path, day):
+ """
+ save xbox base model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_xbox_base_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ day = str(day)
+ suffix_name = "/%s/base/" % day
+ model_path = output_path + suffix_name
+ self.rank0_print("going to save_xbox_base_model " + model_path)
+ fleet.save_persistables(None, model_path, mode=2)
+ self.rank0_print("save_xbox_base_model done")
+
+ def save_cache_model(self, output_path, day, pass_id, mode=1, **kwargs):
+ """
+ save cache model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+ mode(str|int): save mode
+ kwargs(dict): user defined properties
+ table_id(int): table id to save cache
+
+ Returns:
+ key_num(int): cache key num
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_cache_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ mode = int(mode)
+ table_id = kwargs.get("table_id", 0)
+ suffix_name = "/%s/delta-%s" % (day, pass_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ self.rank0_print("going to save_cache_model %s" % model_path)
+ key_num = fleet.save_cache_model(None,
+ model_path,
+ mode=mode,
+ table_id=table_id)
+ self.rank0_print("save_cache_model done")
+ return key_num
+
+ def save_cache_base_model(self, output_path, day, **kwargs):
+ """
+ save cache model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+ kwargs(dict): user defined properties
+ table_id(int): table id to save cache
+
+ Returns:
+ key_num(int): cache key num
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_cache_base_model("hdfs:/my/path", 20190722)
+
+ """
+ day = str(day)
+ table_id = kwargs.get("table_id", 0)
+ suffix_name = "/%s/base" % day
+ model_path = output_path.rstrip("/") + suffix_name
+ self.rank0_print("going to save_cache_base_model %s" % model_path)
+ key_num = fleet.save_cache_model(None,
+ model_path,
+ mode=2,
+ table_id=table_id)
+ self.rank0_print("save_cache_base_model done")
+ return key_num
+
+ def pull_all_dense_params(self, scope, program):
+ """
+ pull all dense params in trainer of rank 0
+
+ Args:
+ scope(Scope): fluid Scope
+ program(Program): fluid Program
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.pull_all_dense_params(my_scope, my_program)
+
+ """
+ fleet._role_maker._barrier_worker()
+ if fleet._role_maker.is_first_worker():
+ prog_id = str(id(program))
+ tables = fleet._opt_info["program_id_to_worker"][prog_id].\
+ get_desc().dense_table
+ prog_conf = fleet._opt_info['program_configs'][prog_id]
+ prog_tables = {}
+ for key in prog_conf:
+ if "dense" not in key:
+ continue
+ for table_id in prog_conf[key]:
+ prog_tables[int(table_id)] = 0
+ for table in tables:
+ if int(table.table_id) not in prog_tables:
+ continue
+ var_name_list = []
+ for i in range(0, len(table.dense_variable_name)):
+ var_name = table.dense_variable_name[i]
+ if scope.find_var(var_name) is None:
+ raise ValueError("var " + var_name +
+ " not found in scope " +
+ "when pull dense")
+ var_name_list.append(var_name)
+ fleet._fleet_ptr.pull_dense(scope, int(table.table_id),
+ var_name_list)
+ fleet._role_maker._barrier_worker()
+
+ def save_paddle_inference_model(self,
+ executor,
+ scope,
+ program,
+ feeded_vars,
+ target_vars,
+ output_path,
+ day,
+ pass_id,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME",
+ save_combine=True):
+ """
+ save paddle inference model, and upload to hdfs dnn_plugin path
+
+ Args:
+ executor(Executor): fluid Executor
+ scope(Scope): fluid Scope
+ program(Program): fluid Program
+ feeded_vars(list[Variable]): feed vars
+ target_vars(list[variable]): fetch vars
+ output_path(str): hdfs/afs output path
+ day(str|int): training day
+ pass_id(str|int): training pass
+ hadoop_fs_name(str): hadoop fs name
+ hadoop_fs_ugi(str): hadoop fs ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ save_combine(bool): whether to save in a file or separate files,
+ default is True
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_paddle_inference_model(exe,
+ join_scope,
+ join_program,
+ feeded_vars,
+ target_vars,
+ "hdfs:/my/output/path/",
+ day=20190727,
+ pass_id=6,
+ hadoop_fs_name="xxx",
+ hadoop_fs_ugi="xxx,xxx")
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ feeded_var_names = [i.name for i in feeded_vars]
+ model_name = "inference_model"
+ # pull dense before save
+ self.pull_all_dense_params(scope, program)
+ if fleet.worker_index() == 0:
+ with fluid.scope_guard(scope):
+ if save_combine:
+ fluid.io.save_inference_model(
+ dirname=model_name,
+ feeded_var_names=feeded_var_names,
+ target_vars=target_vars,
+ executor=executor,
+ main_program=program.clone(),
+ params_filename="params")
+ else:
+ fluid.io.save_inference_model(
+ dirname=model_name,
+ feeded_var_names=feeded_var_names,
+ target_vars=target_vars,
+ executor=executor,
+ main_program=program.clone())
+
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+
+ if pass_id == "-1":
+ dest = "%s/%s/base/dnn_plugin/" % (output_path, day)
+ else:
+ dest = "%s/%s/delta-%s/dnn_plugin/" % (output_path, day,
+ pass_id)
+ if not client.is_exist(dest):
+ client.makedirs(dest)
+
+ client.upload(model_name, dest, multi_processes=5, overwrite=True)
+
+ fleet._role_maker._barrier_worker()
+
+ def save_paddle_params(self,
+ executor,
+ scope,
+ program,
+ model_name,
+ output_path,
+ day,
+ pass_id,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME",
+ var_names=None,
+ save_combine=True):
+ """
+ save paddle model, and upload to hdfs dnn_plugin path
+
+ Args:
+ executor(Executor): fluid Executor
+ scope(Scope): fluid Scope
+ program(Program): fluid Program
+ model_name(str): save model local dir or filename
+ output_path(str): hdfs/afs output path
+ day(str|int): training day
+ pass_id(str|int): training pass
+ hadoop_fs_name(str): hadoop fs name
+ hadoop_fs_ugi(str): hadoop fs ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ var_names(list): save persistable var names, default is None
+ save_combine(bool): whether to save in a file or separate files,
+ default is True
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.save_paddle_params(exe,
+ join_scope,
+ join_program,
+ "paddle_dense.model.0",
+ "hdfs:/my/output/path/",
+ day=20190727,
+ pass_id=6,
+ hadoop_fs_name="xxx",
+ hadoop_fs_ugi="xxx,xxx",
+ var_names=join_all_var_names)
+ fleet_util.save_paddle_params(exe,
+ join_scope,
+ join_program,
+ "paddle_dense.model.usr.0",
+ "hdfs:/my/output/path/",
+ day=20190727,
+ pass_id=6,
+ hadoop_fs_name="xxx",
+ hadoop_fs_ugi="xxx,xxx",
+ var_names=join_user_var_names)
+ fleet_util.save_paddle_params(exe,
+ join_scope,
+ join_program,
+ "paddle_dense.model.item.0",
+ "hdfs:/my/output/path/",
+ day=20190727,
+ pass_id=6,
+ hadoop_fs_name="xxx",
+ hadoop_fs_ugi="xxx,xxx",
+ var_names=join_user_item_names)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ # pull dense before save
+ self.pull_all_dense_params(scope, program)
+ if fleet.worker_index() == 0:
+ vars = [program.global_block().var(i) for i in var_names]
+ with fluid.scope_guard(scope):
+ if save_combine:
+ fluid.io.save_vars(executor,
+ "./",
+ program,
+ vars=vars,
+ filename=model_name)
+ else:
+ fluid.io.save_vars(executor, model_name, program, vars=vars)
+
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+
+ if pass_id == "-1":
+ dest = "%s/%s/base/dnn_plugin/" % (output_path, day)
+ else:
+ dest = "%s/%s/delta-%s/dnn_plugin/" % (output_path, day,
+ pass_id)
+ if not client.is_exist(dest):
+ client.mkdirs(dest)
+ client.upload(model_name, dest, multi_processes=5, overwrite=True)
+
+ fleet._role_maker._barrier_worker()
+
+ def get_last_save_xbox_base(self,
+ output_path,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME"):
+ r"""
+ get last saved base xbox info from xbox_base_done.txt
+
+ Args:
+ output_path(str): output path
+ hadoop_fs_name(str): hdfs/afs fs_name
+ hadoop_fs_ugi(str): hdfs/afs fs_ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+
+ Returns:
+ [last_save_day, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ last_save_day, last_path, xbox_base_key = \
+ fleet_util.get_last_save_xbox_base("hdfs:/my/path", 20190722,
+ 88)
+
+ """
+ donefile_path = output_path + "/xbox_base_done.txt"
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if not client.is_file(donefile_path):
+ return [-1, -1, int(time.time())]
+ pre_content = client.cat(donefile_path)
+ last_dict = json.loads(pre_content.split("\n")[-1])
+ last_day = int(last_dict["input"].split("/")[-3])
+ last_path = "/".join(last_dict["input"].split("/")[:-1])
+ xbox_base_key = int(last_dict["key"])
+ return [last_day, last_path, xbox_base_key]
+
+ def get_last_save_xbox(self,
+ output_path,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME"):
+ r"""
+ get last saved xbox info from xbox_patch_done.txt
+
+ Args:
+ output_path(str): output path
+ hadoop_fs_name(str): hdfs/afs fs_name
+ hadoop_fs_ugi(str): hdfs/afs fs_ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+
+ Returns:
+ [last_save_day, last_save_pass, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_save_pass(int): pass id of saved
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ last_save_day, last_save_pass, last_path, xbox_base_key = \
+ fleet_util.get_last_save_xbox("hdfs:/my/path", 20190722, 88)
+
+ """
+ donefile_path = output_path + "/xbox_patch_done.txt"
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if not client.is_file(donefile_path):
+ return [-1, -1, "", int(time.time())]
+ pre_content = client.cat(donefile_path)
+ last_dict = json.loads(pre_content.split("\n")[-1])
+ last_day = int(last_dict["input"].split("/")[-3])
+ last_pass = int(last_dict["input"].split("/")[-2].split("-")[-1])
+ last_path = "/".join(last_dict["input"].split("/")[:-1])
+ xbox_base_key = int(last_dict["key"])
+ return [last_day, last_pass, last_path, xbox_base_key]
+
+ def get_last_save_model(self,
+ output_path,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ hadoop_home="$HADOOP_HOME"):
+ r"""
+ get last saved model info from donefile.txt
+
+ Args:
+ output_path(str): output path
+ hadoop_fs_name(str): hdfs/afs fs_name
+ hadoop_fs_ugi(str): hdfs/afs fs_ugi
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+
+ Returns:
+ [last_save_day, last_save_pass, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_save_pass(int): pass id of saved
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ last_save_day, last_save_pass, last_path, xbox_base_key = \
+ fleet_util.get_last_save_model("hdfs:/my/path", 20190722, 88)
+
+ """
+ last_save_day = -1
+ last_save_pass = -1
+ last_path = ""
+ donefile_path = output_path + "/donefile.txt"
+ configs = {
+ "fs.default.name": hadoop_fs_name,
+ "hadoop.job.ugi": hadoop_fs_ugi
+ }
+ client = HDFSClient(hadoop_home, configs)
+ if not client.is_file(donefile_path):
+ return [-1, -1, "", int(time.time())]
+ content = client.cat(donefile_path)
+ content = content.split("\n")[-1].split("\t")
+ last_save_day = int(content[0])
+ last_save_pass = int(content[3])
+ last_path = content[2]
+ xbox_base_key = int(content[1])
+ return [last_save_day, last_save_pass, last_path, xbox_base_key]
+
+ def get_online_pass_interval(self, days, hours, split_interval,
+ split_per_pass, is_data_hourly_placed):
+ """
+ get online pass interval
+
+ Args:
+ days(str): days to train
+ hours(str): hours to train
+ split_interval(int|str): split interval
+ split_per_pass(int}str): split per pass
+ is_data_hourly_placed(bool): is data hourly placed
+
+ Returns:
+ online_pass_interval(list)
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ online_pass_interval = fleet_util.get_online_pass_interval(
+ days="{20190720..20190729}",
+ hours="{0..23}",
+ split_interval=5,
+ split_per_pass=2,
+ is_data_hourly_placed=False)
+
+ """
+ days = os.popen("echo -n " + days).read().split(" ")
+ hours = os.popen("echo -n " + hours).read().split(" ")
+ split_interval = int(split_interval)
+ split_per_pass = int(split_per_pass)
+ splits_per_day = 24 * 60 // split_interval
+ pass_per_day = splits_per_day // split_per_pass
+ left_train_hour = int(hours[0])
+ right_train_hour = int(hours[-1])
+
+ start = 0
+ split_path = []
+ for i in range(splits_per_day):
+ h = start // 60
+ m = start % 60
+ if h < left_train_hour or h > right_train_hour:
+ start += split_interval
+ continue
+ if is_data_hourly_placed:
+ split_path.append("%02d" % h)
+ else:
+ split_path.append("%02d%02d" % (h, m))
+ start += split_interval
+
+ start = 0
+ online_pass_interval = []
+ for i in range(pass_per_day):
+ online_pass_interval.append([])
+ for j in range(start, start + split_per_pass):
+ online_pass_interval[i].append(split_path[j])
+ start += split_per_pass
+
+ return online_pass_interval
+
+ def get_global_metrics(self,
+ scope=fluid.global_scope(),
+ stat_pos_name="_generated_var_2",
+ stat_neg_name="_generated_var_3",
+ sqrerr_name="sqrerr",
+ abserr_name="abserr",
+ prob_name="prob",
+ q_name="q",
+ pos_ins_num_name="pos",
+ total_ins_num_name="total"):
+ r"""
+ get global metrics, including auc, bucket_error, mae, rmse,
+ actual_ctr, predicted_ctr, copc, mean_predict_qvalue, total_ins_num.
+
+ Args:
+ scope(Scope): Scope object, default is fluid.global_scope()
+ stat_pos_name(str): name of auc pos bucket Variable
+ stat_neg_name(str): name of auc neg bucket Variable
+ sqrerr_name(str): name of sqrerr Variable
+ abserr_name(str): name of abserr Variable
+ prob_name(str): name of prob Variable
+ q_name(str): name of q Variable
+ pos_ins_num_name(str): name of pos ins num Variable
+ total_ins_num_name(str): name of total ins num Variable
+
+ Returns:
+ [auc, bucket_error, mae, rmse, actual_ctr, predicted_ctr, copc,
+ mean_predict_qvalue, total_ins_num]
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ metric_list = fleet_util.get_global_metrics(myscope,
+ stat_pos.name,
+ stat_neg.name,
+ local_sqrerr.name,
+ local_abserr.name,
+ local_prob.name,
+ local_q.name,
+ local_pos_ins.name,
+ local_total_ins.name)
+
+ # below is part of example model
+ label = fluid.layers.data(name="click", shape=[-1, 1],\
+ dtype="int64", lod_level=0, append_batch_size=False)
+ emb = my_slot_net(slots, label) # emb can be fc layer of size 1
+ similarity_norm = fluid.layers.sigmoid(fluid.layers.clip(\
+ emb, min=-15.0, max=15.0), name="similarity_norm")\
+ binary_predict = fluid.layers.concat(input=[\
+ fluid.layers.elementwise_sub(\
+ fluid.layers.ceil(similarity_norm), similarity_norm),\
+ similarity_norm], axis=1)
+ auc, batch_auc, [batch_stat_pos, batch_stat_neg, stat_pos, \
+ stat_neg] = fluid.layers.auc(input=binary_predict,\
+ label=label, curve='ROC',\
+ num_thresholds=4096)
+ local_sqrerr, local_abserr, local_prob, local_q, local_pos_ins,\
+ local_total_ins = fluid.contrib.layers.ctr_metric_bundle(\
+ similarity_norm, label)
+
+ """
+ if scope.find_var(stat_pos_name) is None or \
+ scope.find_var(stat_neg_name) is None:
+ self.rank0_print("not found auc bucket")
+ return [None] * 9
+ elif scope.find_var(sqrerr_name) is None:
+ self.rank0_print("not found sqrerr_name=%s" % sqrerr_name)
+ return [None] * 9
+ elif scope.find_var(abserr_name) is None:
+ self.rank0_print("not found abserr_name=%s" % abserr_name)
+ return [None] * 9
+ elif scope.find_var(prob_name) is None:
+ self.rank0_print("not found prob_name=%s" % prob_name)
+ return [None] * 9
+ elif scope.find_var(q_name) is None:
+ self.rank0_print("not found q_name=%s" % q_name)
+ return [None] * 9
+ elif scope.find_var(pos_ins_num_name) is None:
+ self.rank0_print("not found pos_ins_num_name=%s" % pos_ins_num_name)
+ return [None] * 9
+ elif scope.find_var(total_ins_num_name) is None:
+ self.rank0_print("not found total_ins_num_name=%s" % \
+ total_ins_num_name)
+ return [None] * 9
+
+ # barrier worker to ensure all workers finished training
+ fleet._role_maker._barrier_worker()
+
+ # get auc
+ auc = self.get_global_auc(scope, stat_pos_name, stat_neg_name)
+ pos = np.array(scope.find_var(stat_pos_name).get_tensor())
+ # auc pos bucket shape
+ old_pos_shape = np.array(pos.shape)
+ # reshape to one dim
+ pos = pos.reshape(-1)
+ global_pos = np.copy(pos) * 0
+ # mpi allreduce
+ fleet._role_maker._all_reduce(pos, global_pos)
+ # reshape to its original shape
+ global_pos = global_pos.reshape(old_pos_shape)
+ # auc neg bucket
+ neg = np.array(scope.find_var(stat_neg_name).get_tensor())
+ old_neg_shape = np.array(neg.shape)
+ neg = neg.reshape(-1)
+ global_neg = np.copy(neg) * 0
+ fleet._role_maker._all_reduce(neg, global_neg)
+ global_neg = global_neg.reshape(old_neg_shape)
+
+ num_bucket = len(global_pos[0])
+
+ def get_metric(name):
+ metric = np.array(scope.find_var(name).get_tensor())
+ old_metric_shape = np.array(metric.shape)
+ metric = metric.reshape(-1)
+ global_metric = np.copy(metric) * 0
+ fleet._role_maker._all_reduce(metric, global_metric)
+ global_metric = global_metric.reshape(old_metric_shape)
+ return global_metric[0]
+
+ global_sqrerr = get_metric(sqrerr_name)
+ global_abserr = get_metric(abserr_name)
+ global_prob = get_metric(prob_name)
+ global_q_value = get_metric(q_name)
+ # note: get ins_num from auc bucket is not actual value,
+ # so get it from metric op
+ pos_ins_num = get_metric(pos_ins_num_name)
+ total_ins_num = get_metric(total_ins_num_name)
+ neg_ins_num = total_ins_num - pos_ins_num
+
+ mae = global_abserr / total_ins_num
+ rmse = math.sqrt(global_sqrerr / total_ins_num)
+ return_actual_ctr = pos_ins_num / total_ins_num
+ predicted_ctr = global_prob / total_ins_num
+ mean_predict_qvalue = global_q_value / total_ins_num
+ copc = 0.0
+ if abs(predicted_ctr > 1e-6):
+ copc = return_actual_ctr / predicted_ctr
+
+ # calculate bucket error
+ last_ctr = -1.0
+ impression_sum = 0.0
+ ctr_sum = 0.0
+ click_sum = 0.0
+ error_sum = 0.0
+ error_count = 0.0
+ click = 0.0
+ show = 0.0
+ ctr = 0.0
+ adjust_ctr = 0.0
+ relative_error = 0.0
+ actual_ctr = 0.0
+ relative_ctr_error = 0.0
+ k_max_span = 0.01
+ k_relative_error_bound = 0.05
+ for i in range(num_bucket):
+ click = global_pos[0][i]
+ show = global_pos[0][i] + global_neg[0][i]
+ ctr = float(i) / num_bucket
+ if abs(ctr - last_ctr) > k_max_span:
+ last_ctr = ctr
+ impression_sum = 0.0
+ ctr_sum = 0.0
+ click_sum = 0.0
+ impression_sum += show
+ ctr_sum += ctr * show
+ click_sum += click
+ if impression_sum == 0:
+ continue
+ adjust_ctr = ctr_sum / impression_sum
+ if adjust_ctr == 0:
+ continue
+ relative_error = \
+ math.sqrt((1 - adjust_ctr) / (adjust_ctr * impression_sum))
+ if relative_error < k_relative_error_bound:
+ actual_ctr = click_sum / impression_sum
+ relative_ctr_error = abs(actual_ctr / adjust_ctr - 1)
+ error_sum += relative_ctr_error * impression_sum
+ error_count += impression_sum
+ last_ctr = -1
+
+ bucket_error = error_sum / error_count if error_count > 0 else 0.0
+
+ return [
+ auc, bucket_error, mae, rmse, return_actual_ctr, predicted_ctr,
+ copc, mean_predict_qvalue,
+ int(total_ins_num)
+ ]
+
+ def print_global_metrics(self,
+ scope=fluid.global_scope(),
+ stat_pos_name="_generated_var_2",
+ stat_neg_name="_generated_var_3",
+ sqrerr_name="sqrerr",
+ abserr_name="abserr",
+ prob_name="prob",
+ q_name="q",
+ pos_ins_num_name="pos",
+ total_ins_num_name="total",
+ print_prefix=""):
+ r"""
+ print global metrics, including auc, bucket_error, mae, rmse,
+ actual_ctr, predicted_ctr, copc, mean_predict_qvalue, total_ins_num.
+
+ Args:
+ scope(Scope): Scope object, default is fluid.global_scope()
+ stat_pos_name(str): name of auc pos bucket Variable
+ stat_neg_name(str): name of auc neg bucket Variable
+ sqrerr_name(str): name of sqrerr Variable
+ abserr_name(str): name of abserr Variable
+ prob_name(str): name of prob Variable
+ q_name(str): name of q Variable
+ pos_ins_num_name(str): name of pos ins num Variable
+ total_ins_num_name(str): name of total ins num Variable
+ print_prefix(str): print prefix
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ fleet_util.print_global_metrics(myscope,
+ stat_pos.name,
+ stat_neg.name,
+ local_sqrerr.name,
+ local_abserr.name,
+ local_prob.name,
+ local_q.name,
+ local_pos_ins.name,
+ local_total_ins.name)
+
+ # below is part of model
+ label = fluid.layers.data(name="click", shape=[-1, 1],\
+ dtype="int64", lod_level=0, append_batch_size=False)
+ emb = my_slot_net(slots, label) # emb can be fc layer of size 1
+ similarity_norm = fluid.layers.sigmoid(fluid.layers.clip(\
+ emb, min=-15.0, max=15.0), name="similarity_norm")\
+ binary_predict = fluid.layers.concat(input=[\
+ fluid.layers.elementwise_sub(\
+ fluid.layers.ceil(similarity_norm), similarity_norm),\
+ similarity_norm], axis=1)
+ auc, batch_auc, [batch_stat_pos, batch_stat_neg, stat_pos, \
+ stat_neg] = fluid.layers.auc(input=binary_predict,\
+ label=label, curve='ROC',\
+ num_thresholds=4096)
+ local_sqrerr, local_abserr, local_prob, local_q, local_pos_ins, \
+ local_total_ins = fluid.contrib.layers.ctr_metric_bundle(\
+ similarity_norm, label)
+
+ """
+ if scope.find_var(stat_pos_name) is None or \
+ scope.find_var(stat_neg_name) is None:
+ self.rank0_print("not found auc bucket")
+ return
+ elif scope.find_var(sqrerr_name) is None:
+ self.rank0_print("not found sqrerr_name=%s" % sqrerr_name)
+ return
+ elif scope.find_var(abserr_name) is None:
+ self.rank0_print("not found abserr_name=%s" % abserr_name)
+ return
+ elif scope.find_var(prob_name) is None:
+ self.rank0_print("not found prob_name=%s" % prob_name)
+ return
+ elif scope.find_var(q_name) is None:
+ self.rank0_print("not found q_name=%s" % q_name)
+ return
+ elif scope.find_var(pos_ins_num_name) is None:
+ self.rank0_print("not found pos_ins_num_name=%s" % pos_ins_num_name)
+ return
+ elif scope.find_var(total_ins_num_name) is None:
+ self.rank0_print("not found total_ins_num_name=%s" % \
+ total_ins_num_name)
+ return
+
+ auc, bucket_error, mae, rmse, actual_ctr, predicted_ctr, copc,\
+ mean_predict_qvalue, total_ins_num = self.get_global_metrics(\
+ scope, stat_pos_name, stat_neg_name, sqrerr_name, abserr_name,\
+ prob_name, q_name, pos_ins_num_name, total_ins_num_name)
+ self.rank0_print(
+ "%s global AUC=%.6f BUCKET_ERROR=%.6f MAE=%.6f "
+ "RMSE=%.6f Actural_CTR=%.6f Predicted_CTR=%.6f "
+ "COPC=%.6f MEAN Q_VALUE=%.6f Ins number=%s" %
+ (print_prefix, auc, bucket_error, mae, rmse, actual_ctr,
+ predicted_ctr, copc, mean_predict_qvalue, total_ins_num))
+
+ def program_type_trans(self, prog_dir, prog_fn, is_text):
+ return utils.program_type_trans(prog_dir, prog_fn, is_text)
+
+ def draw_from_program_file(self, model_filename, is_text, output_dir,
+ output_filename):
+ """draw program from file"""
+ program = utils.load_program(model_filename, is_text)
+ utils.graphviz(program.global_block(), output_dir, output_filename)
+
+ def draw_from_program(self, program, output_dir, output_name):
+ """draw Program"""
+ utils.graphviz(program.global_block(), output_dir, output_name)
+
+ def check_two_programs(self, config):
+ train_prog = utils.load_program(config.train_prog_path,
+ config.is_text_train_program)
+ pruned_prog = utils.load_program(config.pruned_prog_path,
+ config.is_text_pruned_program)
+ if config.draw:
+ pruned_dir = os.path.dirname(config.pruned_prog_path)
+ self.draw_from_program(pruned_prog, pruned_dir,
+ config.draw_out_name)
+ res = utils.check_pruned_program_vars(train_prog, pruned_prog)
+ if res:
+ _logger.info("check_programs succeed.")
+ else:
+ _logger.info(
+ "check_programs failed. pruned program and train program not match!"
+ )
+ return res
+
+ def check_vars_and_dump(self, config):
+ _logger.info("start check_vars_and_dump.")
+ results = utils.check_saved_vars_try_dump(
+ config.dump_model_dir, config.dump_program_filename,
+ config.is_text_dump_program, config.feed_config,
+ config.fetch_config, config.batch_size, config.save_params_filename)
+ _logger.info("check_vars_and_dump succeed.")
+ return results
+
+ def parse_program_proto(self, prog_path, is_text, output_dir):
+ """
+ Parse program.proto into a more readable format.
+ This function will generate three files:
+ output_dir/vars_all.log,
+ output_dir/vars_persistable.log,
+ output_dir/ops.log.
+
+ Args:
+ prog_path(str): proto file path to be parsed.
+ is_text(bool): proto file is human-readale format or not(binary).
+ output_dir(str): output dir.
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import FleetUtil
+ fleet_util = FleetUtil()
+ program_path = "./program.pbtxt"
+ is_text = True
+ output_dir = "/tmp/"
+ fleet_util.parse_program_proto(program_path, is_text, output_dir)
+ """
+ program = utils.load_program(prog_path, is_text)
+ utils.parse_program(program, output_dir)
+
+ def _is_optimizer_op(self, op):
+ return self.op_role_key in op.attr_names and \
+ int(op.all_attrs()[self.op_role_key]) & int(OpRole.Optimize)
+
+ def split_program_by_device(self, program):
+ ops_list = []
+ type_list = []
+ pre = None
+ type_cpu = "cpu"
+ for op in program.global_block().ops:
+ if self._is_optimizer_op(op):
+ break
+ if op.has_attr("op_device"):
+ cur_attr = op.attr(
+ "op_device") if op.attr("op_device") != "" else type_cpu
+ if pre is None or pre != cur_attr:
+ ops_list.append([])
+ type_list.append(cur_attr)
+ ops_list[-1].append(op)
+ pre = cur_attr
+ l = len(type_list)
+ i = 0
+ type_heter = None
+ while i < l:
+ while i < l and type_list[i] == type_cpu:
+ i += 1
+ if i == l:
+ break
+
+ type_heter = type_list[i]
+ i += 1
+ start = i
+ valid = True
+ while i < l and type_list[i] != type_heter:
+ if type_list[i] != type_cpu:
+ valid = False
+ break
+ i += 1
+
+ if i == l:
+ break
+ elif not valid:
+ continue
+
+ for j in range(start, i):
+ for op in ops_list[j]:
+ op._set_attr("op_device", type_heter)
+ type_list[j] = type_heter
+ j += 1
+
+ pre = None
+ merged_ops_list = []
+ merged_type_list = []
+ for i in range(l):
+ if pre is None or pre != type_list[i]:
+ merged_ops_list.append([])
+ merged_type_list.append(type_list[i])
+ merged_ops_list[-1].extend(ops_list[i])
+ pre = type_list[i]
+
+ data_vars = set()
+ for k in program.global_block().vars:
+ var = program.global_block().var(k)
+ if not var.persistable:
+ data_vars.add(var.name)
+
+ l = len(merged_ops_list)
+ inputs_pre = set()
+ outputs_pre = set()
+ in_from_pre = [[] for i in range(l)]
+ for i in range(l):
+ inputs = set()
+ outputs = set()
+ for op in merged_ops_list[i]:
+ for input in op.input_names:
+ for tmp in op.input(input):
+ if tmp not in outputs:
+ inputs.add(tmp)
+ for output in op.output_names:
+ for tmp in op.output(output):
+ outputs.add(tmp)
+ if i == 0:
+ in_from_pre[i] = []
+ elif i == 1:
+ in_from_pre[i] = (outputs_pre | data_vars) & inputs
+ else:
+ in_from_pre[i] = outputs_pre & inputs
+ inputs_pre = copy.deepcopy(inputs)
+ outputs_pre = copy.deepcopy(outputs)
+
+ l = len(in_from_pre)
+ start_list = []
+ end_list = []
+ send_list = [[] for i in range(l)]
+ sum = 0
+ program_list = []
+ for i in range(l):
+ start_list.append(sum)
+ end_list.append(sum + len(merged_ops_list[i]) - 1)
+ sum += len(merged_ops_list[i])
+ if i < l - 1:
+ send_list[i].extend(list(in_from_pre[i + 1]))
+ prog = program.clone()
+ if merged_type_list[i] != type_cpu:
+ prog = prog._prune_with_input(list(in_from_pre[i]),
+ list(send_list[i]))
+ program_list.append(prog)
+ else:
+ program_list.append(prog)
+ recv_list = [list(i) for i in in_from_pre]
+ found = False
+ heter_index = None
+ for i in range(len(merged_type_list)):
+ t = merged_type_list[i]
+ if t != type_cpu:
+ if found:
+ print("only one region of program can be heter")
+ found = True
+ heter_index = i
+ if heter_index is None:
+ print("warning: non heter program")
+ return None
+ else:
+ return [start_list[heter_index], end_list[heter_index], send_list[heter_index], \
+ recv_list[heter_index], program_list[heter_index]]
+
+
+class GPUPSUtil(FleetUtil):
+ """
+ GPUPSUtil provides some common functions for users' convenience.
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ fleet_util = GPUPSUtil()
+ fleet_util.rank0_print("my log")
+ """
+
+ def __init__(self, fs_client=None):
+ super(GPUPSUtil, self).__init__("pslib")
+ self._afs = fs_client
+ # self._afs = fs_client._fs
+
+ def init(self, fs_name, fs_user, fs_passwd, fs_conf):
+ r"""
+ init for fs config
+
+ Args:
+ fs_name(str): fs name
+ fs_user(str): fs user
+ fs_passwd(str): fs password
+ fs_conf(str): fs and afs conf path
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ fleet_util = GPUPSUtil()
+ fleet_util.init(20190722, 88, 88, "./afs.conf")
+ """
+ self._afs.init(fs_name, fs_user, fs_passwd, fs_conf)
+
+ def set_fsclient(self, fs_client):
+ r"""
+ set fs_client for fs config
+
+ Args:
+ fs_client(AFSClient): fs_client object
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ """
+ self._afs = fs_client
+
+ def get_last_save_xbox_base(self, output_path):
+ r"""
+ get last saved base xbox info from xbox_base_done.txt
+
+ Args:
+ output_path(str): output path
+
+ Returns:
+ [last_save_day, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ last_save_day, last_path, xbox_base_key = \
+ fleet_util.get_last_save_xbox_base("hdfs:/my/path")
+
+ """
+ donefile_path = output_path + "/xbox_base_done.txt"
+
+ if not self._afs.is_file(donefile_path):
+ return [-1, -1, int(time.time())]
+ self._afs.download(donefile_path, "./xbox_base_done.txt")
+ # pre_content = self._afs.cat(donefile_path)
+ pre_content = ""
+ with open("xbox_base_done.txt", "r") as f:
+ pre_content = f.read()
+ pre_content = pre_content.strip()
+ last_dict = json.loads(pre_content.split("\n")[-1])
+ last_day = int(last_dict["input"].split("/")[-3])
+ last_path = "/".join(last_dict["input"].split("/")[:-1])
+ xbox_base_key = int(last_dict["key"])
+ return [last_day, last_path, xbox_base_key]
+
+ def get_last_save_xbox(self, output_path):
+ r"""
+ get last saved xbox info from xbox_patch_done.txt
+
+ Args:
+ output_path(str): output path
+
+ Returns:
+ [last_save_day, last_save_pass, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_save_pass(int): pass id of saved
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ last_save_day, last_save_pass, last_path, xbox_base_key = \
+ fleet_util.get_last_save_xbox("hdfs:/my/path")
+
+ """
+ donefile_path = output_path + "/xbox_patch_done.txt"
+
+ if not self._afs.is_file(donefile_path):
+ return [-1, -1, "", int(time.time())]
+ self._afs.download(donefile_path, "xbox_patch_done.txt")
+ pre_content = ""
+ with open("xbox_patch_done.txt", "r") as f:
+ pre_content = f.read()
+ pre_content = pre_content.strip()
+ last_dict = json.loads(pre_content.split("\n")[-1])
+ last_day = int(last_dict["input"].split("/")[-3])
+ last_pass = int(last_dict["input"].split("/")[-2].split("-")[-1])
+ last_path = "/".join(last_dict["input"].split("/")[:-1])
+ xbox_base_key = int(last_dict["key"])
+ os.remove("xbox_patch_done.txt")
+ return [last_day, last_pass, last_path, xbox_base_key]
+
+ def get_last_save_model(self, output_path):
+ r"""
+ get last saved model info from donefile.txt
+
+ Args:
+ output_path(str): output path
+
+ Returns:
+ [last_save_day, last_save_pass, last_path, xbox_base_key]
+ last_save_day(int): day of saved model
+ last_save_pass(int): pass id of saved
+ last_path(str): model path
+ xbox_base_key(int): xbox key
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ last_save_day, last_save_pass, last_path, xbox_base_key = \
+ fleet_util.get_last_save_model("hdfs:/my/path")
+
+ """
+ last_save_day = -1
+ last_save_pass = -1
+ last_path = ""
+ donefile_path = output_path + "/donefile.txt"
+ if not self._afs.is_file(donefile_path):
+ return [-1, -1, "", int(time.time())]
+ self._afs.download(donefile_path, "./donefile.txt")
+ content = ""
+ with open("donefile.txt", "r") as f:
+ content = f.read()
+ content = content.strip().split("\n")[-1].split("\t")
+ last_save_day = int(content[0])
+ last_save_pass = int(content[3])
+ last_path = content[2]
+ xbox_base_key = int(content[1])
+ os.remove("donefile.txt")
+ return [last_save_day, last_save_pass, last_path, xbox_base_key]
+
+ def write_model_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ xbox_base_key,
+ donefile_name="donefile.txt"):
+ """
+ write donefile when save model
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day
+ pass_id(str|int): training pass id
+ xbox_base_key(str|int): xbox base key
+ donefile_name(str): donefile name, default is "donefile.txt"
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ fleet_util.write_model_donefile(output_path="hdfs:/my/output",
+ model_path="hdfs:/my/model",
+ day=20190723,
+ pass_id=66,
+ xbox_base_key=int(time.time()))
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ xbox_base_key = int(xbox_base_key)
+
+ if pass_id != "-1":
+ suffix_name = "/%s/%s/" % (day, pass_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ else:
+ suffix_name = "/%s/0/" % day
+ model_path = output_path.rstrip("/") + suffix_name
+
+ if fleet.worker_index() == 0:
+ donefile_path = output_path + "/" + donefile_name
+ content = "%s\t%lu\t%s\t%s\t%d" % (day, xbox_base_key,\
+ model_path, pass_id, 0)
+ if self._afs.is_file(donefile_path):
+ self._afs.download(donefile_path, donefile_name)
+ pre_content = ""
+ with open(donefile_name, "r") as f:
+ pre_content = f.read()
+ pre_content_list = pre_content.strip().split("\n")
+ day_list = [i.split("\t")[0] for i in pre_content_list]
+ pass_list = [i.split("\t")[3] for i in pre_content_list]
+ os.remove(donefile_name)
+ exist = False
+ for i in range(len(day_list)):
+ if int(day) == int(day_list[i]) and \
+ int(pass_id) == int(pass_list[i]):
+ exist = True
+ break
+ if not exist:
+ with open(donefile_name, "w") as f:
+ f.write(pre_content.strip() + "\n")
+ f.write(content + "\n")
+ self._afs.delete(donefile_path)
+ self._afs.upload(donefile_name, donefile_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ else:
+ self.rank0_error("not write %s because %s/%s already "
+ "exists" % (donefile_name, day, pass_id))
+ else:
+ with open(donefile_name, "w") as f:
+ f.write(content + "\n")
+ self._afs.upload(donefile_name, donefile_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+
+ def write_xbox_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ xbox_base_key,
+ data_path,
+ hadoop_fs_name,
+ hadoop_fs_ugi,
+ monitor_data={},
+ hadoop_home="$HADOOP_HOME",
+ donefile_name=None):
+ """
+ write delta donefile or xbox base donefile
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day of model
+ pass_id(str|int): training pass id of model
+ xbox_base_key(str|int): xbox base key
+ data_path(str|list): training data path
+ monitor_data(dict): metrics
+ hadoop_home(str): hadoop home, default is "$HADOOP_HOME"
+ donefile_name(str): donefile name, default is None"
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ fleet_util.write_xbox_donefile(
+ output_path="hdfs:/my/output/",
+ model_path="hdfs:/my/output/20190722/01",
+ day=20190722,
+ pass_id=1,
+ xbox_base_key=int(time.time()),
+ data_path="hdfs:/my/data/",
+ monitor_data={})
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ xbox_base_key = int(xbox_base_key)
+ mode = None
+ if pass_id != "-1":
+ mode = "patch"
+ suffix_name = "/%s/delta-%s/" % (day, pass_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ if donefile_name is None:
+ donefile_name = "xbox_patch_done.txt"
+ else:
+ mode = "base"
+ suffix_name = "/%s/base/" % day
+ model_path = output_path.rstrip("/") + suffix_name
+ if donefile_name is None:
+ donefile_name = "xbox_base_done.txt"
+
+ if isinstance(data_path, list):
+ data_path = ",".join(data_path)
+ if fleet.worker_index() == 0:
+ donefile_path = output_path + "/" + donefile_name
+ xbox_str = self._get_xbox_str(output_path, day, model_path, \
+ xbox_base_key, data_path, hadoop_fs_name, monitor_data={},
+ mode=mode)
+
+ if self._afs.is_exist(donefile_path):
+ self.rank0_info("exist %s succeed" % (donefile_path))
+ self._afs.download(donefile_path, donefile_name)
+ pre_content = ""
+ with open(donefile_name, "r") as f:
+ pre_content = f.read()
+ last_dict = json.loads(pre_content.strip().split("\n")[-1])
+ last_day = last_dict["input"].split("/")[-3]
+ last_pass = last_dict["input"].split("/")[-2].split("-")[-1]
+
+ os.remove(donefile_name)
+ self.rank0_info("remove %s succeed" % (donefile_name))
+ exist = False
+ if int(day) < int(last_day) or \
+ int(day) == int(last_day) and \
+ int(pass_id) <= int(last_pass):
+ exist = True
+ if not exist:
+ with open(donefile_name, "w") as f:
+ f.write(pre_content.strip() + "\n")
+ f.write(xbox_str + "\n")
+ self._afs.delete(donefile_path)
+ self._afs.upload(donefile_name, donefile_path)
+ self.rank0_info("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+ else:
+ self.rank0_info("not write %s because %s/%s already "
+ "exists" % (donefile_name, day, pass_id))
+ else:
+ with open(donefile_name, "w") as f:
+ f.write(xbox_str + "\n")
+ self._afs.upload(donefile_name, donefile_path)
+ self.rank0_error("write %s/%s %s succeed" % \
+ (day, pass_id, donefile_name))
+
+ def write_cache_donefile(self,
+ output_path,
+ day,
+ pass_id,
+ key_num,
+ donefile_name="sparse_cache.meta",
+ **kwargs):
+ """
+ write cache donefile
+
+ Args:
+ output_path(str): output path
+ day(str|int): training day of model
+ pass_id(str|int): training pass id of model
+ key_num(str|int): save cache return value
+ donefile_name(str): donefile name, default is "sparse_cache.meta"
+ kwargs(dict): user defined properties
+ file_num(int): cache file num
+ table_id(int): cache table id
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.incubate.fleet.utils.fleet_util import GPUPSUtil
+ from paddle.distributed.fleet.utils.fs import AFSClient
+ hdfs_client = AFSClient()
+ fleet_util = GPUPSUtil()
+ fleet_util.set_fsclient(hdfs_client)
+ fleet_util.write_cache_donefile(
+ output_path="hdfs:/my/output/",
+ day=20190722,
+ pass_id=1,
+ key_num=123456)
+
+ """
+ day = str(day)
+ pass_id = str(pass_id)
+ key_num = int(key_num)
+ file_num = kwargs.get("file_num", 16)
+ table_id = kwargs.get("table_id", 0)
+
+ if pass_id != "-1":
+ suffix_name = "/%s/delta-%s/%03d_cache" % (day, pass_id, table_id)
+ model_path = output_path.rstrip("/") + suffix_name
+ else:
+ suffix_name = "/%s/base/%03d_cache" % (day, table_id)
+ model_path = output_path.rstrip("/") + suffix_name
+
+ if fleet.worker_index() == 0:
+ donefile_path = model_path + "/" + donefile_name
+
+ if self._afs.is_file(donefile_path):
+ self.rank0_error( \
+ "not write because %s already exists" % donefile_path)
+ else:
+ meta_str = "file_prefix:part\npart_num:%s\nkey_num:%d\n" \
+ % (file_num, key_num)
+ with open(donefile_name, "w") as f:
+ f.write(meta_str)
+ self._afs.upload(donefile_name, donefile_path)
+ self.rank0_error("write %s succeed" % donefile_path)
+
+ def _get_xbox_str(self,
+ output_path,
+ day,
+ model_path,
+ xbox_base_key,
+ data_path,
+ hadoop_fs_name,
+ monitor_data={},
+ mode="patch"):
+ xbox_dict = collections.OrderedDict()
+ if mode == "base":
+ xbox_dict["id"] = str(xbox_base_key)
+ elif mode == "patch":
+ xbox_dict["id"] = str(int(time.time()))
+ else:
+ print("warning: unknown mode %s, set it to patch" % mode)
+ mode = "patch"
+ xbox_dict["id"] = str(int(time.time()))
+ xbox_dict["key"] = str(xbox_base_key)
+ if model_path.startswith("hdfs:") or model_path.startswith("afs:"):
+ model_path = model_path[model_path.find(":") + 1:]
+ xbox_dict["input"] = hadoop_fs_name + model_path.rstrip("/") + "/000"
+ xbox_dict["record_count"] = "111111"
+ xbox_dict["partition_type"] = "2"
+ xbox_dict["job_name"] = "default_job_name"
+ xbox_dict["ins_tag"] = "feasign"
+ xbox_dict["ins_path"] = data_path
+ xbox_dict["job_id"] = os.environ.get("PADDLE_JOB_ID", "")
+ # currently hard code here, set monitor_data empty string
+ xbox_dict["monitor_data"] = ""
+ xbox_dict["monitor_path"] = output_path.rstrip("/") + "/monitor/" \
+ + day + ".txt"
+ xbox_dict["mpi_size"] = str(fleet.worker_num())
+ return json.dumps(xbox_dict)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/hdfs.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/hdfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb1b36e33c504e3370cd1ed861887f0667c2260d
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/hdfs.py
@@ -0,0 +1,333 @@
+# Copyright (c) 2018 PaddlePaddle 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.
+"""HDFS Utils."""
+
+import os
+import sys
+import subprocess
+import multiprocessing
+from datetime import datetime
+
+import re
+import copy
+import errno
+import time
+import logging
+import six
+#from . import fs
+from paddle.distributed.fleet.utils.fs import FS, LocalFS, FSFileExistsError, FSFileNotExistsError, ExecuteError, FSTimeOut, FSShellCmdAborted
+from paddle.fluid import core
+import functools
+
+import shutil
+
+__all__ = ["HDFSClient"]
+
+
+def _handle_errors(max_time_out=None):
+
+ def decorator(f):
+
+ @functools.wraps(f)
+ def handler(*args, **kwargs):
+ o = args[0]
+ time_out = max_time_out
+ if time_out is None:
+ time_out = float(o._time_out) / 1000.0
+ else:
+ time_out /= 1000.0
+ inter = float(o._sleep_inter) / 1000.0
+
+ start = time.time()
+ last_print_time = start
+ while True:
+ try:
+ return f(*args, **kwargs)
+ #important: only ExecuteError need to retry
+ except ExecuteError as e:
+ if time.time() - start >= time_out:
+ raise FSTimeOut("args:{} timeout:{}".format(
+ args,
+ time.time() - start))
+
+ time.sleep(inter)
+
+ if time.time() - last_print_time > 30:
+ print("hadoop operator timeout:args:{} timeout:{}".format(
+ args,
+ time.time() - start))
+ last_print_time = time.time()
+
+ return handler
+
+ return decorator
+
+
+class HDFSClient(FS):
+
+ def __init__(
+ self,
+ hadoop_home,
+ configs,
+ time_out=5 * 60 * 1000, #ms
+ sleep_inter=1000): #ms
+ # Raise exception if JAVA_HOME not exists.
+
+ self.pre_commands = []
+ hadoop_bin = '%s/bin/hadoop' % hadoop_home
+ self.pre_commands.append(hadoop_bin)
+ dfs = 'fs'
+ self.pre_commands.append(dfs)
+
+ if configs:
+ for k, v in six.iteritems(configs):
+ config_command = '-D%s=%s' % (k, v)
+ self.pre_commands.append(config_command)
+
+ self._time_out = time_out
+ self._sleep_inter = sleep_inter
+ self._base_cmd = " ".join(self.pre_commands)
+ self._bd_err_re = re.compile(
+ r'\s?responseErrorMsg\s?\:.*, errorCode\:\s?[0-9]+, path\:')
+
+ def _run_cmd(self, cmd, redirect_stderr=False):
+ exe_cmd = "{} -{}".format(self._base_cmd, cmd)
+ ret, output = core.shell_execute_cmd(exe_cmd, 0, 0, redirect_stderr)
+ ret = int(ret)
+ if ret == 134:
+ raise FSShellCmdAborted(cmd)
+ return ret, output.splitlines()
+
+ @_handle_errors()
+ def list_dirs(self, fs_path):
+ if not self.is_exist(fs_path):
+ return []
+
+ dirs, files = self._ls_dir(fs_path)
+ return dirs
+
+ @_handle_errors()
+ def ls_dir(self, fs_path):
+ """
+ list directory under fs_path, and only give the pure name, not include the fs_path
+ """
+ if not self.is_exist(fs_path):
+ return [], []
+
+ return self._ls_dir(fs_path)
+
+ def _ls_dir(self, fs_path):
+ cmd = "ls {}".format(fs_path)
+ ret, lines = self._run_cmd(cmd)
+
+ if ret != 0:
+ raise ExecuteError(cmd)
+
+ dirs = []
+ files = []
+ for line in lines:
+ arr = line.split()
+ if len(arr) != 8:
+ continue
+
+ p = os.path.basename(arr[7])
+ if arr[0][0] == 'd':
+ dirs.append(p)
+ else:
+ files.append(p)
+
+ return dirs, files
+
+ def _test_match(self, lines):
+ for l in lines:
+ m = self._bd_err_re.match(l)
+ if m != None:
+ return m
+
+ return None
+
+ @_handle_errors()
+ def is_dir(self, fs_path):
+ if not self.is_exist(fs_path):
+ return False
+
+ return self._is_dir(fs_path)
+
+ def _is_dir(self, fs_path):
+ cmd = "test -d {}".format(fs_path, redirect_stderr=True)
+ ret, lines = self._run_cmd(cmd)
+ if ret:
+ # other error
+ if self._test_match(lines):
+ raise ExecuteError(cmd)
+
+ return False
+
+ return True
+
+ def is_file(self, fs_path):
+ if not self.is_exist(fs_path):
+ return False
+
+ return not self._is_dir(fs_path)
+
+ @_handle_errors()
+ def is_exist(self, fs_path):
+ cmd = "ls {} ".format(fs_path)
+ ret, out = self._run_cmd(cmd, redirect_stderr=True)
+ if ret != 0:
+ for l in out:
+ if "No such file or directory" in l:
+ return False
+ raise ExecuteError(cmd)
+
+ return True
+
+ # can't retry
+ def upload(self, local_path, fs_path):
+ if self.is_exist(fs_path):
+ raise FSFileExistsError("{} exists".format(fs_path))
+
+ local = LocalFS()
+ if not local.is_exist(local_path):
+ raise FSFileNotExistsError("{} not exists".format(local_path))
+
+ return self._try_upload(local_path, fs_path)
+
+ @_handle_errors()
+ def _try_upload(self, local_path, fs_path):
+ cmd = "put {} {}".format(local_path, fs_path)
+ ret = 0
+ try:
+ ret, lines = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+ except Exception as e:
+ self.delete(fs_path)
+ raise e
+
+ # can't retry
+ def download(self, fs_path, local_path):
+ if self.is_exist(local_path):
+ raise FSFileExistsError("{} exists".format(local_path))
+
+ if not self.is_exist(fs_path):
+ raise FSFileNotExistsError("{} not exits".format(fs_path))
+
+ return self._try_download(fs_path, local_path)
+
+ @_handle_errors()
+ def _try_download(self, fs_path, local_path):
+ cmd = "get {} {}".format(fs_path, local_path)
+ ret = 0
+ try:
+ ret, lines = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+ except Exception as e:
+ local_fs = LocalFS()
+ local_fs.delete(local_path)
+ raise e
+
+ @_handle_errors()
+ def mkdirs(self, fs_path):
+ if self.is_exist(fs_path):
+ return
+
+ out_hdfs = False
+
+ cmd = "mkdir {} ".format(fs_path)
+ ret, out = self._run_cmd(cmd, redirect_stderr=True)
+ if ret != 0:
+ for l in out:
+ if "No such file or directory" in l:
+ out_hdfs = True
+ break
+ if not out_hdfs:
+ raise ExecuteError(cmd)
+
+ if out_hdfs and not self.is_exist(fs_path):
+ cmd = "mkdir -p {}".format(fs_path)
+ ret, lines = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+
+ def mv(self, fs_src_path, fs_dst_path, overwrite=False, test_exists=True):
+ if overwrite and self.is_exist(fs_dst_path):
+ self.delete(fs_dst_path)
+
+ if test_exists:
+ if not self.is_exist(fs_src_path):
+ raise FSFileNotExistsError(
+ "{} is not exists".format(fs_src_path))
+
+ if self.is_exist(fs_dst_path):
+ raise FSFileExistsError("{} exists already".format(fs_dst_path))
+
+ return self._try_mv(fs_src_path, fs_dst_path)
+
+ @_handle_errors()
+ def _try_mv(self, fs_src_path, fs_dst_path):
+ cmd = "mv {} {}".format(fs_src_path, fs_dst_path)
+ ret = 0
+ try:
+ ret, _ = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+ except Exception as e:
+ if not self.is_exist(fs_src_path) and \
+ self.is_exist(fs_dst_path):
+ return
+ raise e
+
+ def _rmr(self, fs_path):
+ cmd = "rmr {}".format(fs_path)
+ ret, _ = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+
+ def _rm(self, fs_path):
+ cmd = "rm {}".format(fs_path)
+ ret, _ = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError(cmd)
+
+ @_handle_errors()
+ def delete(self, fs_path):
+ if not self.is_exist(fs_path):
+ return
+
+ is_dir = self._is_dir(fs_path)
+ if is_dir:
+ return self._rmr(fs_path)
+
+ return self._rm(fs_path)
+
+ def touch(self, fs_path, exist_ok=True):
+ if self.is_exist(fs_path):
+ if exist_ok:
+ return
+ raise FSFileExistsError
+
+ return self._touchz(fs_path)
+
+ @_handle_errors()
+ def _touchz(self, fs_path):
+ cmd = "touchz {}".format(fs_path)
+ ret, _ = self._run_cmd(cmd)
+ if ret != 0:
+ raise ExecuteError
+
+ def need_upload_download(self):
+ return True
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/http_server.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/http_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..685228f07490ee699829b797373144cf70ea6522
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/http_server.py
@@ -0,0 +1,189 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+"""Http Server."""
+
+import logging
+# NOTE: HTTPServer has a different name in python2 and python3
+from http.server import HTTPServer
+import http.server as SimpleHTTPServer
+import time
+import threading
+import socket
+
+
+def get_logger(name, level, fmt):
+ logger = logging.getLogger(name)
+ logger.setLevel(level)
+ handler = logging.FileHandler('http.log', mode='w')
+ formatter = logging.Formatter(fmt=fmt)
+ handler.setFormatter(formatter)
+ logger.addHandler(handler)
+ return logger
+
+
+_http_server_logger = get_logger(__name__,
+ logging.INFO,
+ fmt='%(asctime)s-%(levelname)s: %(message)s')
+
+
+class KVHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+ """
+ kv handler class for kv http server,
+ it defines the way to get/set kv in server.
+ """
+
+ def do_GET(self):
+ """
+ get method for kv handler, get value according to key.
+ """
+ log_str = "GET " + self.address_string() + self.path
+ paths = self.path.split('/')
+ if len(paths) < 3:
+ print('len of request path must be 3: ' + self.path)
+ self.send_status_code(400)
+ return
+ _, scope, key = paths
+ with self.server.kv_lock:
+ value = self.server.kv.get(scope, {}).get(key)
+ if value is None:
+ log_str += ' , key not found: ' + key
+ self.send_status_code(404)
+ else:
+ log_str += ' , key found: ' + key
+ self.send_response(200)
+ self.send_header("Content-Length", str(len(value)))
+ self.end_headers()
+ self.wfile.write(value)
+ _http_server_logger.info(log_str)
+
+ def do_PUT(self):
+ """
+ put method for kv handler, set value according to key.
+ """
+ log_str = "PUT " + self.address_string() + self.path
+ paths = self.path.split('/')
+ if len(paths) < 3:
+ print('len of request path must be 3: ' + self.path)
+ self.send_status_code(400)
+ return
+ _, scope, key = paths
+ content_length = int(self.headers['Content-Length'])
+ try:
+ value = self.rfile.read(content_length)
+ except:
+ print("receive error invalid request")
+ self.send_status_code(404)
+ return
+ with self.server.kv_lock:
+ if self.server.kv.get(scope) is None:
+ self.server.kv[scope] = {}
+ self.server.kv[scope][key] = value
+ self.send_status_code(200)
+ _http_server_logger.info(log_str)
+
+ def do_DELETE(self):
+ """
+ delete method for kv handler, set value according to key.
+ """
+ log_str = "DELETE " + self.address_string() + self.path
+ paths = self.path.split('/')
+ if len(paths) < 3:
+ print('len of request path must be 3: ' + self.path)
+ self.send_status_code(400)
+ return
+ _, scope, key = paths
+ with self.server.delete_kv_lock:
+ if self.server.delete_kv.get(scope) is None:
+ self.server.delete_kv[scope] = []
+ self.server.delete_kv[scope].append(key)
+ self.send_status_code(200)
+ _http_server_logger.info(log_str)
+
+ def log_message(self, format, *args):
+ """
+ ignore all logging messages in kv handler.
+ """
+ pass
+
+ def send_status_code(self, code):
+ """
+ send status code back to client.
+ """
+ self.send_response(code)
+ self.send_header("Content-Length", 0)
+ self.end_headers()
+
+
+class KVHTTPServer(HTTPServer, object):
+ """
+ it is a http server storing kv pairs.
+ """
+
+ def __init__(self, port, handler):
+ """Init."""
+ super(KVHTTPServer, self).__init__(('', port), handler)
+ self.delete_kv_lock = threading.Lock()
+ self.delete_kv = {}
+ self.kv_lock = threading.Lock()
+ self.kv = {}
+
+ def get_deleted_size(self, key):
+ """
+ get deleted size in key.
+ """
+ ret = 0
+ with self.delete_kv_lock:
+ ret = self.delete_kv.get(key, 0)
+ return ret
+
+
+class KVServer:
+ """
+ it is a server storing kv pairs, has a http server inside.
+ """
+
+ def __init__(self, port, size={}):
+ """Init."""
+ self.http_server = KVHTTPServer(port, KVHandler)
+ self.listen_thread = None
+ self.size = {}
+
+ def start(self):
+ """
+ start server until user calls stop to let it quit.
+ """
+ self.listen_thread = threading.Thread(
+ target=lambda: self.http_server.serve_forever())
+ self.listen_thread.start()
+
+ def stop(self):
+ """
+ stop server and clear its resources.
+ """
+ self.http_server.shutdown()
+ self.listen_thread.join()
+ self.http_server.server_close()
+
+ def should_stop(self):
+ """
+ return whether the server should stop.
+
+ Returns:
+ ret(bool): whether the server should stop
+ """
+ for key in self.size:
+ s = self.http_server.get_deleted_size(key)
+ if s != self.size.get(key, 0):
+ return False
+ return True
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/utils.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..3890da7ecec4c6a8d5dab100568aeaf6571ec080
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/incubate/fleet/utils/utils.py
@@ -0,0 +1,428 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function, absolute_import
+import os
+import sys
+import logging
+import subprocess
+import numpy as np
+from collections import OrderedDict
+import paddle.fluid as fluid
+from paddle.fluid import core
+from paddle.fluid.log_helper import get_logger
+
+from google.protobuf import text_format
+from paddle.fluid import debugger
+from paddle.fluid.framework import Program
+from paddle.fluid.proto import framework_pb2
+
+__all__ = [
+ "load_program", "save_program", "program_type_trans",
+ "check_saved_vars_try_dump", "parse_program", "check_pruned_program_vars",
+ "graphviz"
+]
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(message)s')
+ch = logging.StreamHandler()
+ch.setFormatter(formatter)
+logger.addHandler(ch)
+
+persistable_vars_out_fn = "vars_persistable.log"
+all_vars_out_fn = "vars_all.log"
+ops_out_fn = "ops.log"
+
+feed_fetch_type_list = [
+ core.VarDesc.VarType.FEED_MINIBATCH, core.VarDesc.VarType.FETCH_LIST
+]
+not_expected_op_types = ["lookup_table"]
+
+
+def load_program(model_filename, is_text=False):
+ if is_text:
+ return load_program_text(model_filename)
+ return load_program_binary(model_filename)
+
+
+def load_program_binary(model_filename):
+ """load program from binary string file"""
+ with open(model_filename, "rb") as f:
+ program_desc_str = f.read()
+ return Program.parse_from_string(program_desc_str)
+
+
+def load_program_text(model_filename):
+ """load program from human-readable text file"""
+ with open(model_filename, "r") as f:
+ program_desc_text = f.read()
+
+ prog_desc = framework_pb2.ProgramDesc()
+ text_format.Merge(program_desc_text, prog_desc)
+ return Program.parse_from_string(prog_desc.SerializeToString())
+
+
+def save_program(program, model_filename='__model__', is_text=False):
+ if is_text:
+ with open(model_filename, "w") as f:
+ f.write(str(program))
+ else:
+ with open(model_filename, "wb") as f:
+ f.write(program.desc.serialize_to_string())
+
+
+def check_pruned_program_vars(train_prog, pruned_prog):
+ is_match = True
+
+ pruned_vars = [(v.name, v) for v in pruned_prog.list_vars()
+ if fluid.io.is_persistable(v)]
+ pruned_vars = OrderedDict(pruned_vars)
+ pruned_vars_name = [name for name in pruned_vars]
+ logger.info(
+ "persistable vars in pruned program: {}".format(pruned_vars_name))
+
+ for var_name in pruned_vars:
+ var = pruned_vars[var_name]
+ # feed and fetch op is added in pruned program when pruning, not need to be found in train program
+ if var.type in feed_fetch_type_list:
+ break
+ try:
+ train_prog_var = train_prog.global_block().var(var_name)
+ except ValueError as e:
+ logger.error(
+ "not find variable '%s' in train program. please check pruning."
+ % var_name)
+ logger.error(e)
+ continue
+ if var.shape != train_prog_var.shape or var.dtype != train_prog_var.dtype:
+ logger.error(
+ "variable: {} not match. in pruned program shape: {} dtype:{}, in train program shape: {} dtype: {}"
+ .format(var_name, var.shape, var.dtype, train_prog_var.shape,
+ train_prog_var.dtype))
+ is_match = False
+ return is_match
+
+
+def graphviz(block, output_dir="", filename='debug'):
+ dot_path = os.path.join(output_dir, filename + '.dot')
+ pdf_path = os.path.join(output_dir, filename + '.pdf')
+ debugger.draw_block_graphviz(block, path=dot_path)
+ cmd = ["dot", "-Tpdf", dot_path, "-o", pdf_path]
+ p = subprocess.Popen(cmd,
+ stdin=subprocess.PIPE,
+ stdout=subprocess.PIPE,
+ stderr=subprocess.PIPE)
+ p.wait()
+
+
+def program_type_trans(prog_dir, prog_fn, is_text):
+ prog = load_program(os.path.join(prog_dir, prog_fn), is_text)
+ prog_out_fn = prog_fn + ".bin" if is_text else prog_fn + ".pbtxt"
+ save_program(prog, os.path.join(prog_dir, prog_out_fn), 1 - is_text)
+ return prog_out_fn
+
+
+def append_save_op(block, var, path):
+ block.append_op(type='save',
+ inputs={'X': [var]},
+ outputs={},
+ attrs={'file_path': path})
+
+
+def append_load_op(block, var, path):
+ block.append_op(type='load',
+ inputs={},
+ outputs={'Out': [var]},
+ attrs={'file_path': path})
+
+
+def save_var(np_array, var_name, shape_list, dtype, save_path):
+ program = fluid.Program()
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ with fluid.program_guard(program):
+ d0_data = fluid.layers.data(var_name, shape=shape_list, dtype=dtype)
+ append_save_op(program.global_block(), d0_data, save_path)
+ exe.run(feed={var_name: np_array}, fetch_list=[])
+
+
+def load_var(var_name, shape_list, dtype, save_path):
+ program = fluid.Program()
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ with fluid.program_guard(program):
+ d0_data = fluid.layers.data(var_name, shape=shape_list, dtype=dtype)
+ append_load_op(program.global_block(), d0_data, save_path)
+ outs = exe.run(feed={}, fetch_list=[d0_data])
+ return outs
+
+
+def reader(batch_size, fn, dim):
+ data = []
+ if isinstance(dim, list) or isinstance(dim, tuple):
+ shape = list(dim)
+ _temp = 1
+ for x in dim:
+ _temp = _temp * x
+ dim = _temp
+ else:
+ shape = [dim]
+
+ shape = [batch_size] + shape
+ dim = dim * batch_size
+
+ for line in open(fn, 'r'):
+ fields = line.strip().split(' ')
+ fields = [float(d) for d in fields]
+ while len(fields) >= dim:
+ tmp = fields[:dim]
+ fields = fields[dim:]
+ data.append(np.array(tmp).reshape(shape))
+ return data
+
+
+def feed_gen(batch_size, feeded_vars_dims, feeded_vars_filelist):
+ batch_feed = []
+ for i, fn in enumerate(feeded_vars_filelist):
+ batch_feed.append(reader(batch_size, fn, feeded_vars_dims[i]))
+ return batch_feed
+
+
+def try_load_model_vars(dump_dir, dump_prog_fn, is_text_dump_program,
+ batch_size, feed_config, fetch_config, save_filename,
+ saved_params):
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ scope = fluid.core.Scope()
+ with fluid.scope_guard(scope):
+ if is_text_dump_program:
+ dump_prog_fn = program_type_trans(dump_dir, dump_prog_fn,
+ is_text_dump_program)
+ inference_program, feed_target_names, fetch_targets = \
+ fluid.io.load_inference_model(dump_dir, exe, model_filename=dump_prog_fn,
+ params_filename=save_filename)
+
+ # check program vars and saved vars shape
+ orig_para_shape = {
+ each_var.name: tuple(each_var.desc.shape())
+ for each_var in saved_params
+ }
+ for each_var in saved_params:
+ var_temp = fluid.global_scope().find_var(each_var.name)
+ assert var_temp != None, "can't not find var: " + each_var.name
+ new_shape = (np.array(var_temp.get_tensor())).shape
+ assert each_var.name in orig_para_shape, each_var.name + "MUST in var list"
+ orig_shape = orig_para_shape.get(each_var.name)
+ if new_shape != orig_shape:
+ raise RuntimeError(
+ "Shape not matching: the Program requires a parameter with a shape of ({}), "
+ "while the loaded parameter (namely [ {} ]) has a shape of ({})."
+ .format(orig_shape, each_var.name, new_shape))
+
+ # check feed/fetch vars in program and config
+ fetch_targets_names = [v.name for v in fetch_targets]
+ if not feed_target_names:
+ logger.warning("no feed targets in program.")
+ if not fetch_targets_names:
+ logger.warning("no fetch targets in program.")
+ fetch_list = fetch_targets
+ feed_name_list = feed_target_names
+ if feed_config.feeded_vars_names is not None and feed_target_names != feed_config.feeded_vars_names:
+ logger.warning(
+ "feed vars in program and config are diff: feed in program: {}. feed in config {}."
+ .format(feed_target_names, feed_config.feeded_vars_names))
+ feed_name_list = feed_config.feeded_vars_names
+ # remove feed op in inference_program. new feed op will be added in exe.run
+ global_block = inference_program.global_block()
+ need_to_remove_op_index = []
+ for i, op in enumerate(global_block.ops):
+ op.desc.set_is_target(False)
+ if op.type == "feed": # only remove feed op here
+ need_to_remove_op_index.append(i)
+ for index in need_to_remove_op_index[::-1]:
+ global_block._remove_op(index)
+ if fetch_config.fetch_vars_names is not None and fetch_targets_names != fetch_config.fetch_vars_names:
+ logger.warning(
+ "fetch vars in program and config are diff: fetch in program: {}. fetch in config {}."
+ .format(fetch_targets_names, fetch_config.fetch_vars_names))
+ fetch_list = [
+ inference_program.global_block().var(i)
+ for i in fetch_config.fetch_vars_names
+ ]
+ # remove fetch op in inference_program. new fetch op will be added in exe.run
+ global_block = inference_program.global_block()
+ need_to_remove_op_index = []
+ for i, op in enumerate(global_block.ops):
+ op.desc.set_is_target(False)
+ if op.type == "fetch": # only remove fetch op here
+ need_to_remove_op_index.append(i)
+ for index in need_to_remove_op_index[::-1]:
+ global_block._remove_op(index)
+
+ # if fetch_list have lod tensor
+ return_numpy = all([v.lod_level == 0 for v in fetch_list])
+
+ # try dump fetch_targets
+ feed_tensors = []
+ assert len(feed_config.feeded_vars_names) == len(
+ feed_config.feeded_vars_dims) == len(feed_config.feeded_vars_types)
+ # check program vars and feed tensor shape in config
+ for i in range(len(feed_config.feeded_vars_names)):
+ var = inference_program.global_block().var(
+ feed_config.feeded_vars_names[i])
+ if not isinstance(feed_config.feeded_vars_dims[i], (list, tuple)):
+ tensor_shape = (feed_config.feeded_vars_dims[i], )
+ else:
+ tensor_shape = tuple(feed_config.feeded_vars_dims[i])
+ feed_config.feeded_vars_dims[i] = tensor_shape
+ var_shape = var.shape[1:]
+ if tensor_shape != var_shape:
+ raise RuntimeError(
+ "feed variable '{}' shape not match. infer program shape: {}. feed tensor shape: {}"
+ .format(feed_config.feeded_vars_names[i], var_shape,
+ tensor_shape))
+
+ if not feed_config.feeded_vars_filelist:
+ logger.info("generate random feed vars.")
+ for i in range(len(feed_config.feeded_vars_names)):
+ var = inference_program.global_block().var(
+ feed_config.feeded_vars_names[i])
+ # create fake feed tensor. if lod_level > 1, should create_lod_tensor()
+ if var.lod_level == 0:
+ feed_tensors.append(
+ np.array(np.random.random(
+ tuple([batch_size] +
+ list(feed_config.feeded_vars_dims[i]))),
+ dtype=feed_config.feeded_vars_types[i]))
+ elif var.lod_level == 1:
+ t = np.array(np.random.random(
+ tuple([batch_size] +
+ list(feed_config.feeded_vars_dims[i]))),
+ dtype=feed_config.feeded_vars_types[i])
+ feed_tensors.append(
+ fluid.create_lod_tensor(t, [[1] * batch_size], place))
+ else:
+ raise RuntimeError(
+ "vars with lod_level >= 2 is not supported now in this infer program check tool."
+ )
+ results = exe.run(inference_program,
+ feed={
+ name: feed_tensors[i]
+ for i, name in enumerate(feed_name_list)
+ },
+ fetch_list=fetch_list,
+ return_numpy=return_numpy)
+ else:
+ logger.info("load feed vars from files: {}.".format(
+ feed_config.feeded_vars_filelist))
+ feed_vars = [
+ inference_program.global_block().var(
+ feed_config.feeded_vars_names[i])
+ for i in range(len(feed_config.feeded_vars_names))
+ ]
+ feeder = fluid.DataFeeder(feed_list=feed_vars, place=place)
+ batch_feed = feed_gen(batch_size, feed_config.feeded_vars_dims,
+ feed_config.feeded_vars_filelist)
+ slots = [batch_feed]
+ results = exe.run(inference_program,
+ feed=feeder.feed(slots),
+ fetch_list=fetch_list,
+ return_numpy=return_numpy)
+ for i, v in enumerate(fetch_list):
+ logger.info("fetch_targets name: %s" % v.name)
+ logger.info("fetch_targets: {}".format(results[i]))
+ return results
+
+
+def check_not_expected_ops(prog):
+ op_types_set = set()
+ for op in prog.global_block().ops:
+ if op.type in not_expected_op_types and op.type not in op_types_set:
+ logger.warning(
+ "find op type '{}' in program, please check if your program is pruned correctly !"
+ .format(op.type))
+ op_types_set.add(op.type)
+
+
+def check_saved_vars_try_dump(dump_dir,
+ dump_prog_fn,
+ is_text_dump_program,
+ feed_config,
+ fetch_config,
+ batch_size=1,
+ save_filename=None):
+ dump_prog = load_program(os.path.join(dump_dir, dump_prog_fn),
+ is_text_dump_program)
+ saved_params = [
+ v for v in dump_prog.list_vars() if fluid.io.is_persistable(v)
+ ]
+ logger.info("persistable vars in dump program: {}".format(
+ [v.name for v in saved_params]))
+
+ check_not_expected_ops(dump_prog)
+
+ return try_load_model_vars(dump_dir, dump_prog_fn, is_text_dump_program,
+ batch_size, feed_config, fetch_config,
+ save_filename, saved_params)
+
+
+def parse_program(program, output_dir):
+ # persistable vars
+ output = {}
+ persistable_vars = [
+ v for v in program.list_vars() if fluid.io.is_persistable(v)
+ ]
+ output["persistable_vars"] = [{
+ 'name': str(v.name),
+ 'shape': str(v.shape),
+ 'lod_level': int(v.lod_level),
+ 'dtype': str(v.dtype),
+ 'type': str(v.type)
+ } for v in persistable_vars]
+ with open(os.path.join(output_dir, persistable_vars_out_fn), 'w') as f:
+ f.write("persistable vars:\n")
+ for var in output["persistable_vars"]:
+ f.write(str(var))
+ f.write("\n")
+
+ # all vars
+ all_vars = [v for v in program.list_vars()]
+ output["all_vars"] = [{
+ 'name': str(v.name),
+ 'shape': str(v.shape),
+ 'lod_level': int(v.lod_level),
+ 'dtype': str(v.dtype)
+ } if v.type not in feed_fetch_type_list else {
+ 'name': str(v.name),
+ 'type': str(v.type)
+ } for v in all_vars]
+ with open(os.path.join(output_dir, all_vars_out_fn), 'w') as f:
+ f.write("all vars:\n")
+ for var in output["all_vars"]:
+ f.write(str(var))
+ f.write("\n")
+
+ # ops
+ ops = program.global_block().ops
+ output["ops"] = [{
+ 'type': op.type,
+ 'input_arg_names': str(op.input_arg_names),
+ 'output_arg_names': str(op.output_arg_names)
+ } for op in ops]
+ with open(os.path.join(output_dir, ops_out_fn), 'w') as f:
+ f.write("ops:\n")
+ for op in output["ops"]:
+ f.write(str(op))
+ f.write("\n")
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6b8b102487923d84b90bafba8ce0bd52f09b6b3
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/__init__.py
@@ -0,0 +1,18 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .wrapper import Config, DataType, PlaceType, PrecisionType, Tensor, Predictor
+from .wrapper import convert_to_mixed_precision
+
+from ..core import create_predictor, get_version, _get_phi_kernel_name, get_num_bytes_of_data_type, PredictorPool, get_trt_compile_version, get_trt_runtime_version
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/wrapper.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..83811012e529458e91df34d8dcedfc7efc4b0942
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/inference/wrapper.py
@@ -0,0 +1,89 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..core import AnalysisConfig, PaddleDType, PaddlePlace
+from ..core import PaddleInferPredictor, PaddleInferTensor
+from ..core import convert_to_mixed_precision_bind
+from .. import core
+
+import os
+import numpy as np
+from typing import Set
+
+DataType = PaddleDType
+PlaceType = PaddlePlace
+PrecisionType = AnalysisConfig.Precision
+Config = AnalysisConfig
+Tensor = PaddleInferTensor
+Predictor = PaddleInferPredictor
+
+
+def tensor_copy_from_cpu(self, data):
+ '''
+ Support input type check based on tensor.copy_from_cpu.
+ '''
+ if isinstance(data, np.ndarray) or (isinstance(data, list) and len(data) > 0
+ and isinstance(data[0], str)):
+ self.copy_from_cpu_bind(data)
+ else:
+ raise TypeError(
+ "In copy_from_cpu, we only support numpy ndarray and list[str] data type."
+ )
+
+
+def tensor_share_external_data(self, data):
+ '''
+ Support input type check based on tensor.share_external_data.
+ '''
+ if isinstance(data, core.LoDTensor):
+ self.share_external_data_bind(data)
+ else:
+ raise TypeError(
+ "In share_external_data, we only support LoDTensor data type.")
+
+
+def convert_to_mixed_precision(model_file: str,
+ params_file: str,
+ mixed_model_file: str,
+ mixed_params_file: str,
+ mixed_precision: PrecisionType,
+ backend: PlaceType,
+ keep_io_types: bool = True,
+ black_list: Set = set()):
+ '''
+ Convert a fp32 model to mixed precision model.
+
+ Args:
+ model_file: fp32 model file, e.g. inference.pdmodel.
+ params_file: fp32 params file, e.g. inference.pdiparams.
+ mixed_model_file: The storage path of the converted mixed-precision model.
+ mixed_params_file: The storage path of the converted mixed-precision params.
+ mixed_precision: The precision, e.g. PrecisionType.Half.
+ backend: The backend, e.g. PlaceType.GPU.
+ keep_io_types: Whether the model input and output dtype remains unchanged.
+ black_list: Operators that do not convert precision.
+ '''
+ mixed_model_dirname = os.path.dirname(mixed_model_file)
+ mixed_params_dirname = os.path.dirname(mixed_params_file)
+ if not os.path.exists(mixed_model_dirname):
+ os.makedirs(mixed_model_dirname)
+ if not os.path.exists(mixed_params_dirname):
+ os.makedirs(mixed_params_dirname)
+ convert_to_mixed_precision_bind(model_file, params_file, mixed_model_file,
+ mixed_params_file, mixed_precision, backend,
+ keep_io_types, black_list)
+
+
+Tensor.copy_from_cpu = tensor_copy_from_cpu
+Tensor.share_external_data = tensor_share_external_data
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/initializer.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/initializer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e59c8be062191c1c4f1826d1b429cb0f4571d57
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/initializer.py
@@ -0,0 +1,1274 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import math
+import functools
+from . import framework
+from . import core
+from .framework import _non_static_mode, in_dygraph_mode, _in_legacy_dygraph, default_main_program, _current_expected_place
+from .lazy_init import lazy_init_helper
+from .framework import program_guard
+import numpy as np
+from .core import VarDesc
+from . import unique_name
+from .data_feeder import check_variable_and_dtype, check_type, check_dtype
+from paddle import _C_ops, _legacy_C_ops
+import paddle
+
+__all__ = [
+ 'Constant', 'Uniform', 'Normal', 'TruncatedNormal', 'Xavier', 'Bilinear',
+ 'MSRA', 'ConstantInitializer', 'UniformInitializer', 'NormalInitializer',
+ 'TruncatedNormalInitializer', 'XavierInitializer', 'BilinearInitializer',
+ 'MSRAInitializer', 'NumpyArrayInitializer', 'set_global_initializer'
+]
+
+_global_weight_initializer_ = None
+_global_bias_initializer_ = None
+
+
+class Initializer(object):
+ """Base class for variable initializers
+
+ Defines the common interface of variable initializers.
+ They add operations to the init program that are used
+ to initialize variables. Users should not use this class
+ directly, but need to use one of its implementations.
+ """
+
+ def __init__(self):
+ pass
+
+ def __call__(self, param, block=None):
+ if not lazy_init_helper().state:
+ return self.forward(param, block)
+
+ return self._lazy_init(param, block)
+
+ def forward(self, param, block=None):
+ """Add corresponding initialization operations to the network
+ """
+ raise NotImplementedError()
+
+ def _lazy_init(self, param, block=None):
+ """
+ Apply lazy initialization
+ """
+ assert in_dygraph_mode()
+
+ def init_op_creator(forward, param, block):
+ new_var = param._to_static_var(True, block=block)
+ # Record initializer operator
+ with lazy_init_helper():
+ forward(new_var, block)
+
+ # Add hook function for initializing param in dygraph mode
+ param.set_init_func(functools.partial(self.forward, param, block))
+ param._init_op_creator = functools.partial(init_op_creator,
+ self.forward, param)
+
+ return param
+
+ def _check_block(self, block):
+ if block is None:
+ block = default_main_program().global_block()
+
+ return block
+
+ def _compute_fans(self, var):
+ """Compute the fan_in and the fan_out for layers
+
+ This method computes the fan_in and the fan_out
+ for neural network layers, if not specified. It is
+ not possible to perfectly estimate fan_in and fan_out.
+ This method will estimate it correctly for matrix multiply and
+ convolutions.
+
+ Args:
+ var: variable for which fan_in and fan_out have to be computed
+
+ Returns:
+ tuple of two integers (fan_in, fan_out)
+ """
+ shape = var.shape
+ if not shape or len(shape) == 0:
+ fan_in = fan_out = 1
+ elif len(shape) == 1:
+ fan_in = fan_out = shape[0]
+ elif len(shape) == 2:
+ # This is the case for simple matrix multiply
+ fan_in = shape[0]
+ fan_out = shape[1]
+ else:
+ # Assume this to be a convolutional kernel
+ # In PaddlePaddle, the shape of the kernel is like:
+ # [num_filters, num_filter_channels, ...] where the remaining
+ # dimensions are the filter_size
+ receptive_field_size = np.prod(shape[2:])
+ fan_in = shape[1] * receptive_field_size
+ fan_out = shape[0] * receptive_field_size
+
+ return (fan_in, fan_out)
+
+
+class ConstantInitializer(Initializer):
+ """Implements the constant initializer
+
+ Args:
+ value (float32): constant value to initialize the variable
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ x = fluid.data(name="data", shape=[8, 32, 32], dtype="float32")
+ fc = fluid.layers.fc(
+ input=x,
+ size=10,
+ param_attr=fluid.initializer.Constant(value=2.0))
+
+ """
+
+ def __init__(self, value=0.0, force_cpu=False):
+ assert value is not None
+ super(ConstantInitializer, self).__init__()
+ self._value = value
+ self._force_cpu = force_cpu
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with constant.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert (isinstance(var, framework.Variable)
+ or isinstance(var, framework.EagerParamBase))
+ assert isinstance(block, framework.Block)
+
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ if self._force_cpu:
+ place = core.CPUPlace()
+ _C_ops.full_(var, var.shape, str(float(self._value)), var.dtype,
+ place)
+ return None
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.fill_constant(var, 'value', float(self._value),
+ 'force_cpu', self._force_cpu, 'dtype',
+ int(var.dtype), 'str_value',
+ str(float(self._value)), 'shape',
+ var.shape)
+ return None
+ else:
+ op = block.append_op(type="fill_constant",
+ outputs={"Out": var},
+ attrs={
+ "shape": var.shape,
+ "dtype": int(var.dtype),
+ "value": float(self._value),
+ 'str_value': str(float(self._value)),
+ 'force_cpu': self._force_cpu
+ },
+ stop_gradient=True)
+
+ var.op = op
+ return op
+
+
+class UniformInitializer(Initializer):
+ """Implements the random uniform distribution initializer
+
+ Args:
+ low (float): lower boundary of the uniform distribution
+ high (float): upper boundary of the uniform distribution
+ seed (int): random seed
+ diag_num (int): the number of diagonal elements to initialize.
+ If set to 0, diagonal initialization will be not performed.
+ diag_step (int): Step size between two diagonal elements,
+ which is generally the width of the square matrix.
+ diag_val (float): the value of the diagonal element to be initialized,
+ default 1.0. It takes effect only if the diag_num is greater than 0.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[None, 1], dtype='float32')
+ fc = fluid.layers.fc(input=x, size=10,
+ param_attr=fluid.initializer.Uniform(low=-0.5, high=0.5))
+ """
+
+ def __init__(self,
+ low=-1.0,
+ high=1.0,
+ seed=0,
+ diag_num=0,
+ diag_step=0,
+ diag_val=1.0):
+ assert low is not None
+ assert high is not None
+ assert high >= low
+ assert seed is not None
+ assert diag_num is not None
+ assert diag_step is not None
+ assert diag_val is not None
+ if diag_num > 0 or diag_step > 0:
+ assert (diag_num > 0 and diag_step > 0)
+ super(UniformInitializer, self).__init__()
+ self._low = low
+ self._high = high
+ self._seed = seed
+ self._diag_num = diag_num
+ self._diag_step = diag_step
+ self._diag_val = diag_val
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with Uniform distribution.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(block, framework.Block)
+ check_variable_and_dtype(var, "Out",
+ ["uint16", "float16", "float32", "float64"],
+ "uniform_random")
+
+ if self._seed == 0:
+ self._seed = block.program.random_seed
+
+ # to be compatible of fp16 initializers
+ if var.dtype == VarDesc.VarType.FP16:
+ out_dtype = VarDesc.VarType.FP32
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['uniform_random', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_dtype = var.dtype
+ out_var = var
+
+ if framework._non_static_mode():
+ if in_dygraph_mode():
+ out_var = _C_ops.uniform_random(var.shape, out_dtype, self._low,
+ self._high, self._seed,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ out_var = _legacy_C_ops.uniform_random(
+ 'shape', var.shape, 'min', self._low, 'max', self._high,
+ 'seed', self._seed, 'dtype', out_dtype, 'diag_num',
+ self._diag_num, 'diag_step', self._diag_step, 'diag_val',
+ self._diag_val)
+ if var.dtype == VarDesc.VarType.FP16:
+ if in_dygraph_mode():
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ elif _in_legacy_dygraph():
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype',
+ out_var.dtype, 'out_dtype',
+ var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ op = block.append_op(type="uniform_random",
+ inputs={},
+ outputs={"Out": out_var},
+ attrs={
+ "shape": var.shape,
+ "dtype": out_dtype,
+ "min": self._low,
+ "max": self._high,
+ "seed": self._seed,
+ "diag_num": self._diag_num,
+ "diag_step": self._diag_step,
+ "diag_val": self._diag_val
+ },
+ stop_gradient=True)
+
+ if var.dtype == VarDesc.VarType.FP16:
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+
+ var.op = op
+ return op
+
+
+class NormalInitializer(Initializer):
+ """Implements the Random Normal(Gaussian) distribution initializer
+
+ Args:
+ loc (float): mean of the normal distribution
+ scale (float): standard deviation of the normal distribution
+ seed (int): random seed
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(name="data", shape=[None, 32, 32], dtype="float32")
+ fc = fluid.layers.fc(input=x, size=10,
+ param_attr=fluid.initializer.Normal(loc=0.0, scale=2.0))
+
+ """
+
+ def __init__(self, loc=0.0, scale=1.0, seed=0):
+ assert loc is not None
+ assert scale is not None
+ assert seed is not None
+ super(NormalInitializer, self).__init__()
+ self._mean = loc
+ self._std_dev = scale
+ self._seed = seed
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with Normal distribution.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(block, framework.Block)
+
+ check_variable_and_dtype(var, "Out",
+ ["uint16", "float16", "float32", "float64"],
+ "guassian_random")
+
+ if self._seed == 0:
+ self._seed = block.program.random_seed
+
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ out_var = _C_ops.gaussian_random(var.shape, self._mean,
+ self._std_dev, self._seed,
+ var.dtype, place)
+ out_var._share_underline_tensor_to(var)
+ return None
+
+ if _in_legacy_dygraph():
+ out_var = _legacy_C_ops.gaussian_random(
+ 'shape', var.shape, 'dtype', var.dtype, 'mean', self._mean,
+ 'std', self._std_dev, 'seed', self._seed, 'use_mkldnn', False)
+
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ op = block.append_op(type="gaussian_random",
+ outputs={"Out": var},
+ attrs={
+ "shape": var.shape,
+ "dtype": var.dtype,
+ "mean": self._mean,
+ "std": self._std_dev,
+ "seed": self._seed,
+ "use_mkldnn": False
+ },
+ stop_gradient=True)
+ var.op = op
+ return op
+
+
+class TruncatedNormalInitializer(Initializer):
+ """Implements the Random TruncatedNormal(Gaussian) distribution initializer
+
+ Args:
+ loc (float): mean of the normal distribution
+ scale (float): standard deviation of the normal distribution
+ seed (int): random seed
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[None, 1], dtype='float32')
+ fc = fluid.layers.fc(input=x, size=10,
+ param_attr=fluid.initializer.TruncatedNormal(loc=0.0, scale=2.0))
+ """
+
+ def __init__(self, loc=0.0, scale=1.0, seed=0):
+ assert loc is not None
+ assert scale is not None
+ assert seed is not None
+ super(TruncatedNormalInitializer, self).__init__()
+ self._mean = loc
+ self._std_dev = scale
+ self._seed = seed
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with TruncatedNormal distribution.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(var, framework.Variable)
+ assert isinstance(block, framework.Block)
+
+ if self._seed == 0:
+ self._seed = block.program.random_seed
+
+ # to be compatible of fp16 initalizers
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ out_dtype = VarDesc.VarType.FP32
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['truncated_gaussian_random', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_dtype = var.dtype
+ out_var = var
+
+ if in_dygraph_mode():
+ out_var = _C_ops.truncated_gaussian_random(
+ var.shape, self._mean, self._std_dev, self._seed, out_dtype,
+ _current_expected_place())
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+
+ if _in_legacy_dygraph():
+ out_var = _legacy_C_ops.truncated_gaussian_random(
+ 'shape', var.shape, 'dtype', out_dtype, 'mean', self._mean,
+ 'std', self._std_dev, 'seed', self._seed)
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype', out_var.dtype,
+ 'out_dtype', var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ op = block.append_op(type="truncated_gaussian_random",
+ outputs={"Out": out_var},
+ attrs={
+ "shape": var.shape,
+ "dtype": out_dtype,
+ "mean": self._mean,
+ "std": self._std_dev,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+ var.op = op
+ return op
+
+
+class XavierInitializer(Initializer):
+ r"""
+ This class implements the Xavier weight initializer from the paper
+ `Understanding the difficulty of training deep feedforward neural
+ networks `_
+ by Xavier Glorot and Yoshua Bengio.
+
+ This initializer is designed to keep the scale of the gradients
+ approximately same in all the layers. In case of Uniform distribution,
+ the range is [-x, x], where
+
+ .. math::
+
+ x = \sqrt{\\frac{6.0}{fan\_in + fan\_out}}
+
+ In case of Normal distribution, the mean is 0 and the standard deviation
+ is
+
+ .. math::
+
+ \sqrt{\\frac{2.0}{fan\_in + fan\_out}}
+
+
+ Args:
+ uniform (bool,default True): whether to use uniform ,if False use normal distribution
+ fan_in (float,default None): fan_in for Xavier initialization. If None, it is
+ inferred from the variable.
+ fan_out (float,default None): fan_out for Xavier initialization. If None, it is
+ inferred from the variable.
+ seed (int): random seed
+
+ Note:
+ It is recommended to set fan_in and fan_out to None for most cases.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ queries = fluid.data(name='x', shape=[None,1], dtype='float32')
+ fc = fluid.layers.fc(
+ input=queries, size=10,
+ param_attr=fluid.initializer.Xavier(uniform=False))
+
+ """
+
+ def __init__(self, uniform=True, fan_in=None, fan_out=None, seed=0):
+ assert uniform is not None
+ assert seed is not None
+ super(XavierInitializer, self).__init__()
+ self._uniform = uniform
+ self._fan_in = fan_in
+ self._fan_out = fan_out
+ self._seed = seed
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with Xavier initialization.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(block, framework.Block)
+ check_variable_and_dtype(var, "Out",
+ ["uint16", "float16", "float32", "float64"],
+ "xavier_init")
+
+ f_in, f_out = self._compute_fans(var)
+
+ # If fan_in and fan_out are passed, use them
+ fan_in = f_in if self._fan_in is None else self._fan_in
+ fan_out = f_out if self._fan_out is None else self._fan_out
+
+ if self._seed == 0:
+ self._seed = block.program.random_seed
+
+ # to be compatible of fp16 initalizers
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ out_dtype = VarDesc.VarType.FP32
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['xavier_init', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_dtype = var.dtype
+ out_var = var
+
+ if framework._non_static_mode():
+ if self._uniform:
+ limit = math.sqrt(6.0 / float(fan_in + fan_out))
+ if in_dygraph_mode():
+ out_var = _C_ops.uniform_random(out_var.shape, out_dtype,
+ -limit, limit, self._seed,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ out_var = _legacy_C_ops.uniform_random(
+ 'shape', out_var.shape, 'min', -limit, 'max', limit,
+ 'seed', self._seed, 'dtype', out_dtype)
+ else:
+ std = math.sqrt(2.0 / float(fan_in + fan_out))
+
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ out_var = _C_ops.gaussian_random(out_var.shape, 0.0, std,
+ self._seed, out_dtype,
+ place)
+ else:
+ out_var = _legacy_C_ops.gaussian_random(
+ 'shape', out_var.shape, 'dtype', out_dtype, 'mean', 0.0,
+ 'std', std, 'seed', self._seed)
+
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ if in_dygraph_mode():
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ elif _in_legacy_dygraph():
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype',
+ out_var.dtype, 'out_dtype',
+ var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ if self._uniform:
+ limit = math.sqrt(6.0 / float(fan_in + fan_out))
+ op = block.append_op(type="uniform_random",
+ inputs={},
+ outputs={"Out": out_var},
+ attrs={
+ "shape": out_var.shape,
+ "dtype": out_dtype,
+ "min": -limit,
+ "max": limit,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+ else:
+ std = math.sqrt(2.0 / float(fan_in + fan_out))
+ op = block.append_op(type="gaussian_random",
+ outputs={"Out": out_var},
+ attrs={
+ "shape": out_var.shape,
+ "dtype": out_var.dtype,
+ "mean": 0.0,
+ "std": std,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+
+ var.op = op
+ return op
+
+
+class MSRAInitializer(Initializer):
+ r"""Implements the MSRA initializer a.k.a. Kaiming Initializer
+
+ This class implements the weight initialization from the paper
+ `Delving Deep into Rectifiers: Surpassing Human-Level Performance on
+ ImageNet Classification `_
+ by Kaiming He, Xiangyu Zhang, Shaoqing Ren and Jian Sun. This is a
+ robust initialization method that particularly considers the rectifier
+ nonlinearities. In case of Uniform distribution, the range is [-x, x], where
+
+ .. math::
+
+ x = gain \times \sqrt{\frac{3}{fan\_in}}
+
+ In case of Normal distribution, the mean is 0 and the standard deviation
+ is
+
+ .. math::
+
+ \frac{gain}{\sqrt{{fan\_in}}}
+
+ Args:
+ uniform (bool, optional): whether to use uniform or normal distribution
+ fan_in (float32|None, optional): fan_in (in_features) of trainable Tensor, If None, it will be infered automaticly. If you don't want to use in_features of the Tensor, you can set the value of 'fan_in' smartly by yourself. default is None.
+ seed (int32, optional): random seed.
+ negative_slope (float, optional): negative_slope (only used with leaky_relu). default is 0.0.
+ nonlinearity(str, optional): the non-linear function. default is relu.
+
+ Note:
+ It is recommended to set fan_in to None for most cases.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ x = fluid.data(name="data", shape=[8, 32, 32], dtype="float32")
+ fc = fluid.layers.fc(input=x, size=10,
+ param_attr=fluid.initializer.MSRA(uniform=False))
+
+ """
+
+ def __init__(self,
+ uniform=True,
+ fan_in=None,
+ seed=0,
+ negative_slope=0,
+ nonlinearity='relu'):
+ """Constructor for MSRAInitializer
+ """
+ assert uniform is not None
+ assert seed is not None
+ super(MSRAInitializer, self).__init__()
+ self._uniform = uniform
+ self._fan_in = fan_in
+ self._seed = seed
+ self._negative_slope = negative_slope
+ self._nonlinearity = nonlinearity
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with MSRA initialization.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(var, framework.Variable)
+ assert isinstance(block, framework.Block)
+ f_in, f_out = self._compute_fans(var)
+
+ # If fan_in is passed, use it
+ fan_in = f_in if self._fan_in is None else self._fan_in
+
+ if self._seed == 0:
+ self._seed = block.program.random_seed
+
+ # to be compatible of fp16 initalizers
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ out_dtype = VarDesc.VarType.FP32
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['masra_init', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_dtype = var.dtype
+ out_var = var
+
+ if framework._non_static_mode():
+ if self._uniform:
+ gain = calculate_gain(self._nonlinearity, self._negative_slope)
+ limit = gain * math.sqrt(3.0 / float(fan_in))
+ if in_dygraph_mode():
+ out_var = _C_ops.uniform_random(var.shape, out_dtype,
+ -limit, limit, self._seed,
+ _current_expected_place())
+ else:
+ out_var = _legacy_C_ops.uniform_random(
+ 'shape', out_var.shape, 'min', -limit, 'max', limit,
+ 'seed', self._seed, 'dtype', int(out_dtype))
+ else:
+ gain = calculate_gain(self._nonlinearity, self._negative_slope)
+ std = gain / math.sqrt(float(fan_in))
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ out_var = _C_ops.gaussian_random(out_var.shape, 0.0, std,
+ self._seed, out_dtype,
+ place)
+ else:
+ out_var = _legacy_C_ops.gaussian_random(
+ 'shape', out_var.shape, 'dtype', int(out_dtype), 'mean',
+ 0.0, 'std', std, 'seed', self._seed)
+
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ if in_dygraph_mode():
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ elif _in_legacy_dygraph():
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype',
+ out_var.dtype, 'out_dtype',
+ var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ if self._uniform:
+ gain = calculate_gain(self._nonlinearity, self._negative_slope)
+ limit = gain * math.sqrt(3.0 / float(fan_in))
+ op = block.append_op(type="uniform_random",
+ inputs={},
+ outputs={"Out": out_var},
+ attrs={
+ "shape": out_var.shape,
+ "dtype": int(out_dtype),
+ "min": -limit,
+ "max": limit,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+
+ else:
+ gain = calculate_gain(self._nonlinearity, self._negative_slope)
+ std = gain / math.sqrt(float(fan_in))
+ op = block.append_op(type="gaussian_random",
+ outputs={"Out": out_var},
+ attrs={
+ "shape": out_var.shape,
+ "dtype": int(out_dtype),
+ "mean": 0.0,
+ "std": std,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+
+ if var.dtype == VarDesc.VarType.FP16 or (
+ var.dtype == VarDesc.VarType.BF16 and not self._uniform):
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+
+ var.op = op
+ return op
+
+
+class BilinearInitializer(Initializer):
+ """
+ This initializer can be used in transposed convolution operator to
+ act as upsampling. Users can upsample a feature map with shape of
+ (B, C, H, W) by any integer factor. The usage is:
+
+ Examples:
+
+ .. code-block:: python
+
+ import math
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.regularizer import L2Decay
+
+ factor = 2
+ C = 2
+ B = 8
+ H = W = 32
+ w_attr = paddle.ParamAttr(learning_rate=0.,
+ regularizer=L2Decay(0.),
+ initializer=nn.initializer.Bilinear())
+ data = paddle.rand([B, 3, H, W], dtype='float32')
+ conv_up = nn.Conv2DTranspose(3,
+ out_channels=C,
+ kernel_size=2 * factor - factor % 2,
+ padding=int(
+ math.ceil((factor - 1) / 2.)),
+ stride=factor,
+ weight_attr=w_attr,
+ bias_attr=False)
+ x = conv_up(data)
+
+ Where, `out_channels=C` and `groups=C` means this is channel-wise transposed
+ convolution. The filter shape will be (C, 1, K, K) where K is `kernel_size`,
+ This initializer will set a (K, K) interpolation kernel for every channel
+ of the filter identically. The resulting shape of the output feature map
+ will be (B, C, factor * H, factor * W). Note that the learning rate and the
+ weight decay are set to 0 in order to keep coefficient values of bilinear
+ interpolation unchanged during training.
+
+ """
+
+ def __init__(self):
+ """Constructor for BilinearInitializer.
+ """
+ super(BilinearInitializer, self).__init__()
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with Bilinear initialization.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ if not isinstance(var, framework.Variable):
+ raise ValueError("var must be framework.Variable.")
+
+ if not isinstance(block, framework.Block):
+ raise ValueError("block must be framework.Block.")
+
+ shape = var.shape
+ if len(shape) != 4:
+ raise ValueError("the length of shape must be 4.")
+ if shape[2] != shape[3]:
+ raise ValueError("shape[2] must be equal to shape[3].")
+
+ weight = np.zeros(np.prod(var.shape), dtype='float32')
+ size = shape[3]
+ # factor
+ f = np.ceil(size / 2.)
+ # center
+ c = (2 * f - 1 - f % 2) / (2. * f)
+ for i in range(np.prod(shape)):
+ x = i % size
+ y = (i / size) % size
+ weight[i] = (1 - abs(x / f - c)) * (1 - abs(y / f - c))
+ weight = np.reshape(weight, shape)
+
+ # to be compatible of fp16 initalizers
+ if var.dtype in [
+ VarDesc.VarType.FP16, VarDesc.VarType.BF16, VarDesc.VarType.FP64
+ ]:
+ out_dtype = VarDesc.VarType.FP32
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['bilinear_init', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_dtype = var.dtype
+ out_var = var
+
+ if out_dtype == VarDesc.VarType.FP32:
+ value_name = "fp32_values"
+ values = [float(v) for v in weight.flat]
+ else:
+ raise TypeError("Unsupported dtype %s", var.dtype)
+
+ if np.prod(shape) > 1024 * 1024:
+ raise ValueError("The size of input is too big. ")
+
+ if framework._non_static_mode():
+ if in_dygraph_mode():
+ _C_ops.assign_value_(out_var, list(shape), out_dtype, values,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.assign_value(out_var, 'shape', list(shape),
+ 'dtype', out_dtype, value_name,
+ values)
+ if var.dtype in [
+ VarDesc.VarType.FP16, VarDesc.VarType.BF16,
+ VarDesc.VarType.FP64
+ ]:
+ if in_dygraph_mode():
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ elif _in_legacy_dygraph():
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype',
+ out_var.dtype, 'out_dtype',
+ var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ op = block.append_op(type='assign_value',
+ outputs={'Out': [out_var]},
+ attrs={
+ 'dtype': out_dtype,
+ 'shape': list(shape),
+ value_name: values
+ })
+
+ if var.dtype in [
+ VarDesc.VarType.FP16, VarDesc.VarType.BF16,
+ VarDesc.VarType.FP64
+ ]:
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+
+ var.op = op
+ return op
+
+
+class NumpyArrayInitializer(Initializer):
+ """Init an parameter with an numpy array
+ This op initialize the variable by numpy array.
+
+ Args:
+ value (numpy): numpy array to initialize the variable
+
+ Returns:
+ A Tensor variable initialized by numpy.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+ x = fluid.data(name="x", shape=[2, 1], dtype='float32')
+ fc = fluid.layers.fc(input=x, size=10,
+ param_attr=fluid.initializer.NumpyArrayInitializer(numpy.array([1,2])))
+ """
+
+ def __init__(self, value):
+ import numpy
+ assert isinstance(value, numpy.ndarray)
+ super(NumpyArrayInitializer, self).__init__()
+ self._value = value
+
+ def forward(self, var, block=None):
+ """Initialize the input tensor with Numpy array.
+
+ Args:
+ var(Tensor): Tensor that needs to be initialized.
+ block(Block, optional): The block in which initialization ops
+ should be added. Used in static graph only, default None.
+
+ Returns:
+ The initialization op
+ """
+ block = self._check_block(block)
+
+ assert isinstance(var, framework.Variable)
+ assert isinstance(block, framework.Block)
+
+ # to be compatible of fp16 initalizers
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ out_dtype = VarDesc.VarType.FP32
+ np_value = self._value.astype("float32")
+ out_var = block.create_var(name=unique_name.generate(".".join(
+ ['numpy_array_init', var.name, 'tmp'])),
+ shape=var.shape,
+ dtype=out_dtype,
+ type=VarDesc.VarType.LOD_TENSOR,
+ persistable=False)
+ else:
+ out_var = var
+ out_dtype = var.dtype
+ np_value = self._value
+
+ if out_dtype == VarDesc.VarType.FP32:
+ value_name = "fp32_values"
+ values = [float(v) for v in np_value.flat]
+ elif out_dtype == VarDesc.VarType.INT32:
+ value_name = "int32_values"
+ values = [int(v) for v in np_value.flat]
+ else:
+ raise ValueError("Unsupported dtype %s", self._value.dtype)
+ if self._value.size > 1024 * 1024 * 1024:
+ raise ValueError("The size of input is too big. Please consider "
+ "saving it to file and 'load_op' to load it")
+
+ if framework._non_static_mode():
+ if in_dygraph_mode():
+ _C_ops.assign_value_(out_var,
+ list(self._value.shape), out_dtype, values,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.assign_value(out_var, 'shape',
+ list(self._value.shape), 'dtype',
+ out_dtype, value_name, values)
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ if in_dygraph_mode():
+ var_tmp = _C_ops.cast(out_var, var.dtype)
+ elif _in_legacy_dygraph():
+ var_tmp = _legacy_C_ops.cast(out_var, 'in_dtype',
+ out_var.dtype, 'out_dtype',
+ var.dtype)
+ var_tmp._share_underline_tensor_to(var)
+ else:
+ out_var._share_underline_tensor_to(var)
+ return None
+ else:
+ op = block.append_op(type='assign_value',
+ outputs={'Out': out_var},
+ attrs={
+ 'dtype': out_dtype,
+ 'shape': list(self._value.shape),
+ value_name: values
+ },
+ stop_gradient=True)
+
+ if var.dtype in [VarDesc.VarType.FP16, VarDesc.VarType.BF16]:
+ block.append_op(type="cast",
+ inputs={"X": out_var},
+ outputs={"Out": var},
+ attrs={
+ "in_dtype": out_var.dtype,
+ "out_dtype": var.dtype
+ })
+
+ var.op = op
+ return op
+
+
+def set_global_initializer(weight_init, bias_init=None):
+ """
+ This API is used to set up global model parameter initializer in framework.
+
+ After this API is invoked, the global initializer will takes effect in subsequent code.
+
+ The model parameters include ``weight`` and ``bias`` . In the framework, they correspond
+ to ``paddle.ParamAttr`` , which is inherited from ``paddle.Tensor`` , and is a persistable Variable.
+ This API only takes effect for model parameters, not for variables created through apis such as
+ :ref:`api_fluid_layers_create_global_var` , :ref:`api_fluid_layers_create_tensor`.
+
+ If the initializer is also set up by ``param_attr`` or ``bias_attr`` when creating a network layer,
+ the global initializer setting here will not take effect because it has a lower priority.
+
+ If you want to cancel the global initializer in framework, please set global initializer to ``None`` .
+
+ Args:
+ weight_init (Initializer): set the global initializer for ``weight`` of model parameters.
+ bias_init (Initializer, optional): set the global initializer for ``bias`` of model parameters.
+ Default: None.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+
+ nn.initializer.set_global_initializer(nn.initializer.Uniform(), nn.initializer.Constant())
+ x_var = paddle.uniform((2, 4, 8, 8), dtype='float32', min=-1., max=1.)
+
+ # The weight of conv1 is initialized by Uniform
+ # The bias of conv1 is initialized by Constant
+ conv1 = nn.Conv2D(4, 6, (3, 3))
+ y_var1 = conv1(x_var)
+
+ # If set param_attr/bias_attr too, global initializer will not take effect
+ # The weight of conv2 is initialized by Xavier
+ # The bias of conv2 is initialized by Normal
+ conv2 = nn.Conv2D(4, 6, (3, 3),
+ weight_attr=nn.initializer.XavierUniform(),
+ bias_attr=nn.initializer.Normal())
+ y_var2 = conv2(x_var)
+
+ # Cancel the global initializer in framework, it will takes effect in subsequent code
+ nn.initializer.set_global_initializer(None)
+ """
+
+ check_type(weight_init, 'weight_init', (Initializer, type(None)),
+ 'set_global_initializer')
+ global _global_weight_initializer_
+ _global_weight_initializer_ = weight_init
+
+ check_type(bias_init, 'bias_init', (Initializer, type(None)),
+ 'set_global_initializer')
+ global _global_bias_initializer_
+ _global_bias_initializer_ = bias_init
+
+
+def _global_weight_initializer():
+ """
+ Return the global weight initializer, The user doesn't need to use it.
+ """
+ return _global_weight_initializer_
+
+
+def _global_bias_initializer():
+ """
+ Return the global weight initializer, The user doesn't need to use it.
+ """
+ return _global_bias_initializer_
+
+
+def calculate_gain(nonlinearity, param=None):
+ """
+ Get the recommended ``gain`` value of some nonlinearity function. ``gain`` value can be used in some
+ ``paddle.nn.initializer`` api to adjust the initialization value.
+
+ Args:
+ nonlinearity(str): name of nonlinearity activation function. If it is a linear function, such as:
+ `linear/conv1d/conv2d/conv3d/conv1d_transpose/conv2d_transpose/conv3d_transpose` , 1.0 will be returned.
+ param(bool|int|float, optional): optional parameter for somme nonlinearity function. Now, it only applies to
+ 'leaky_relu'. Default: None, it will be calculated as 0.01 in the formula.
+
+ Returns:
+ A float value, which is the recommended gain for this nonlinearity function.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ gain = paddle.nn.initializer.calculate_gain('tanh') # 5.0 / 3
+ gain = paddle.nn.initializer.calculate_gain('leaky_relu', param=1.0) # 1.0 = math.sqrt(2.0 / (1+param^2))
+ initializer = paddle.nn.initializer.Orthogonal(gain)
+
+ """
+ if param is None:
+ param = 0.01
+ else:
+ assert isinstance(param, (bool, int, float))
+ param = float(param)
+ recommended_gain = {
+ 'sigmoid': 1,
+ 'linear': 1,
+ 'conv1d': 1,
+ 'conv2d': 1,
+ 'conv3d': 1,
+ 'conv1d_transpose': 1,
+ 'conv2d_transpose': 1,
+ 'conv3d_transpose': 1,
+ 'tanh': 5.0 / 3,
+ 'relu': math.sqrt(2.0),
+ 'leaky_relu': math.sqrt(2.0 / (1 + param**2)),
+ 'selu': 3.0 / 4
+ }
+ if nonlinearity in recommended_gain.keys():
+ return recommended_gain[nonlinearity]
+ else:
+ raise ValueError(
+ "nonlinearity function {} is not suppported now.".format(
+ nonlinearity))
+
+
+# We short the class name, since users will use the initializer with the package
+# name. The sample code:
+#
+# import paddle.fluid as fluid
+#
+# hidden = fluid.layers.fc(...,
+# param_attr=ParamAttr(fluid.initializer.Xavier()))
+#
+# It is no need to add an `Initializer` as the class suffix
+Constant = ConstantInitializer
+Uniform = UniformInitializer
+Normal = NormalInitializer
+TruncatedNormal = TruncatedNormalInitializer
+Xavier = XavierInitializer
+MSRA = MSRAInitializer
+Bilinear = BilinearInitializer
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/input.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/input.py
new file mode 100644
index 0000000000000000000000000000000000000000..502a89ec36d366f038104d9f59a3f88b8e7397ac
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/input.py
@@ -0,0 +1,338 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import warnings
+from .framework import Variable, _non_static_mode, static_only
+from .layer_helper import LayerHelper
+from .data_feeder import check_variable_and_dtype, check_dtype
+from ..utils import deprecated
+
+__all__ = ['one_hot', 'embedding']
+
+
+@deprecated(since='2.0.0', update_to='paddle.nn.functional.one_hot')
+def one_hot(input, depth, allow_out_of_range=False):
+ """
+ :alias_main: paddle.nn.functional.one_hot
+ :alias: paddle.nn.functional.one_hot,paddle.nn.functional.common.one_hot
+ :old_api: paddle.fluid.one_hot
+
+ The operator converts each id in the input to an one-hot vector with a
+ depth length. The value in the vector dimension corresponding to the id
+ is 1, and the value in the remaining dimension is 0.
+
+ The shape of output Tensor or LoDTensor is generated by appending depth dimension
+ behind the last dimension of the input shape.
+
+ .. code-block:: text
+
+ Example 1 (allow_out_of_range=False):
+
+ input:
+ X.shape = [4]
+ X.data = [1, 1, 3, 0]
+ depth = 4
+
+ output:
+ Out.shape = [4, 4]
+ Out.data = [[0., 1., 0., 0.],
+ [0., 1., 0., 0.],
+ [0., 0., 0., 1.],
+ [1., 0., 0., 0.]]
+
+ Example 2 (allow_out_of_range=True):
+
+ input:
+ X.shape = [4]
+ X.data = [1, 1, 5, 0]
+ depth = 4
+ allow_out_of_range = True
+
+ output:
+ Out.shape = [4, 4]
+ Out.data = [[0., 1., 0., 0.],
+ [0., 1., 0., 0.],
+ [0., 0., 0., 0.], # This id is 5, which goes beyond depth, so set it all-zeros data.
+ [1., 0., 0., 0.]]
+
+ Example 3 (allow_out_of_range=False):
+
+ input:
+ X.shape = [4]
+ X.data = [1, 1, 5, 0]
+ depth = 4
+ allow_out_of_range = False
+
+ output: Throw an exception for Illegal value
+ The second dimension in X is 5, which is greater than depth.
+ Allow_out_of_range =False means that does not allow the word id to exceed depth,
+ so it throws an exception.
+
+
+ Args:
+ input(Variable): Tensor or LoDTensor with shape :math:`[N_1, N_2, ..., N_k]` ,
+ which contains at least one dimension. The data type is int32 or int64.
+ depth(int): An integer defining the depth of the one hot dimension. If input
+ is word id, depth is generally the dictionary size.
+ allow_out_of_range(bool): A bool value indicating whether the input
+ indices could be out of range :math:`[0, depth)` . When input indices are
+ out of range, exceptions :code:`Illegal value` is raised if :attr:`allow_out_of_range`
+ is False, or zero-filling representations is created if it is set True.
+ Default: False.
+
+ Returns:
+ Variable: The one-hot representations of input. A Tensor or LoDTensor with type float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # Correspond to the first example above, where label.shape is 4 and one_hot_label.shape is [4, 4].
+ label = fluid.data(name="label", shape=[4], dtype="int64")
+ one_hot_label = fluid.one_hot(input=label, depth=4)
+ """
+ check_variable_and_dtype(input, 'input', ['int32', 'int64'], 'one_hot_v2')
+ helper = LayerHelper("one_hot_v2", **locals())
+
+ one_hot_out = helper.create_variable_for_type_inference(dtype='float32')
+
+ if _non_static_mode():
+ inputs = {'X': input}
+ attrs = {'depth': depth, 'allow_out_of_range': allow_out_of_range}
+ else:
+ if not isinstance(depth, Variable):
+ # user attribute
+ inputs = {'X': input}
+ attrs = {'depth': depth, 'allow_out_of_range': allow_out_of_range}
+ else:
+ depth.stop_gradient = True
+ inputs = {'X': input, 'depth_tensor': depth}
+ attrs = {'allow_out_of_range': allow_out_of_range}
+ helper.append_op(type="one_hot_v2",
+ inputs=inputs,
+ attrs=attrs,
+ outputs={'Out': one_hot_out},
+ stop_gradient=True)
+ return one_hot_out
+
+
+@static_only
+@deprecated(since='2.0.0', update_to='paddle.nn.functional.embedding')
+def embedding(input,
+ size,
+ is_sparse=False,
+ is_distributed=False,
+ padding_idx=None,
+ param_attr=None,
+ dtype='float32'):
+ r"""
+ :api_attr: Static Graph
+
+ The operator is used to lookup embeddings vector of ids provided by :attr:`input` .
+ It automatically constructs a 2D embedding matrix based on the
+ input :attr:`size` (vocab_size, emb_size) and :attr:`dtype` .
+
+ The shape of output Tensor is generated by appending an emb_size dimension to the
+ last dimension of the input Tensor shape.
+
+ **Note:** The id in :attr:`input` must satisfy :math:`0 =< id < size[0]` ,
+ otherwise the program will throw an exception and exit.
+
+ .. code-block:: text
+
+ Case 1:
+
+ input is a Tensor. padding_idx = -1
+ input.data = [[1, 3], [2, 4], [4, 127]]
+ input.shape = [3, 2]
+ Given size = [128, 16]
+ output is a Tensor:
+ out.shape = [3, 2, 16]
+ out.data = [[[0.129435295, 0.244512452, ..., 0.436322452],
+ [0.345421456, 0.524563927, ..., 0.144534654]],
+
+ [[0.345249859, 0.124939536, ..., 0.194353745],
+ [0.945345345, 0.435394634, ..., 0.435345365]],
+
+ [[0.945345345, 0.435394634, ..., 0.435345365],
+ [0.0, 0.0, ..., 0.0 ]]] # padding data
+ The input padding_idx is less than 0, it is automatically converted to padding_idx = -1 + 128 = 127
+ It will pad all-zero data when ids is 127.
+
+ Case 2:
+
+ input is a LoDTensor with 1-level LoD. padding_idx = 0
+ input.lod = [[2, 3]]
+ input.data = [[1], [3], [2], [4], [0]]
+ input.shape = [5, 1]
+ Given size = [128, 16]
+ output is a LoDTensor:
+ out.lod = [[2, 3]]
+ out.shape = [5, 1, 16]
+ out.data = [[[0.129435295, 0.244512452, ..., 0.436322452]],
+ [[0.345421456, 0.524563927, ..., 0.144534654]],
+ [[0.345249859, 0.124939536, ..., 0.194353745]],
+ [[0.945345345, 0.435394634, ..., 0.435345365]],
+ [[0.0, 0.0, ..., 0.0 ]]] # padding data
+ It will pad all-zero data when ids is 0.
+
+
+ Args:
+ input(Variable): A Tensor or LoDTensor with type int64, which contains the id information.
+ The value of the input id should satisfy :math:`0<= id < size[0]` .
+ size(tuple|list): The shape of lookup table parameter. It should have two elements which
+ indicates the size of the dictionary of embeddings and the size of each embedding vector respectively.
+ is_sparse(bool): The flag indicating whether to use sparse update. This parameter only
+ affects the performance of the backwards gradient update. It is recommended to set
+ True because sparse update is faster. But some optimizer does not support sparse update
+ In these case, is_sparse must be False. Default: False.
+ is_distributed(bool): Whether to store the embedding matrix in a distributed manner. Only used
+ in multi-machine distributed CPU training. Default: False.
+ padding_idx(int|long|None): padding_idx needs to be in the interval [-vocab_size, vocab_size).
+ If :math:`padding\_idx < 0`, the :math:`padding\_idx` will automatically be converted
+ to :math:`vocab\_size + padding\_idx` . It will output all-zero padding data whenever lookup
+ encounters :math:`padding\_idx` in id. And the padding data will not be updated while training.
+ If set None, it makes no effect to output. Default: None.
+ param_attr(ParamAttr): To specify the weight parameter property. Default: None, which means the
+ default weight parameter property is used. In addition,
+ user-defined or pre-trained word vectors can be loaded with the :attr:`param_attr` parameter.
+ The local word vector needs to be transformed into numpy format, and the shape of local word
+ vector should be consistent with :attr:`size` .
+ dtype(str): It refers to the data type of output Tensor.
+ It must be float32 or float64. Default: float32.
+
+ Returns:
+ Variable: Embedding Tensor or LoDTensor mapped by input. The data type is the same as :attr:`dtype` .
+
+ Static Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+
+ x = paddle.static.data(name="x", shape = [2, 4], dtype=np.int64)
+ embedding = paddle.nn.Embedding(10, 3,
+ weight_attr=paddle.nn.initializer.Constant(value=1.0))
+ adam = paddle.optimizer.SGD(parameters=[embedding.weight], learning_rate=0.01)
+ output = embedding(x)
+ m_output=paddle.mean(output)
+
+ adam.minimize(m_output)
+
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(paddle.static.default_startup_program())
+
+ x = np.array([[7, 2, 4, 5],[4, 3, 2, 9]], dtype=np.int64)
+
+ # x is a Numpy.
+ # x.data = [[7, 2, 4, 5], [4, 3, 2, 9]]
+ # x.shape = [2, 4]
+
+ out, = exe.run(paddle.static.default_main_program(), feed={'x':x}, fetch_list=[output])
+
+ # out is a Numpy.
+ # out.data = [[1., 1., 1.],
+ # [1., 1., 1.],
+ # [1., 1., 1.],
+ # [1., 1., 1.]],
+ #
+ # [[1., 1., 1.],
+ # [1., 1., 1.],
+ # [1., 1., 1.],
+ # [0., 0., 0.]]]
+ # out.shape = [2, 4, 3]
+
+
+ Dygraph Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ x_data = np.arange(3, 6).reshape((3, 1)).astype(np.int64)
+
+ # x is a Tensor.
+ # x.data = [[3], [4], [5]]
+ # x.shape = [3, 1]
+ x = paddle.to_tensor(x_data, stop_gradient=False)
+
+ # embedding weight shape = [10, 3]
+ embedding = paddle.nn.Embedding(10, 3, sparse=True)
+
+ # embedding weight data = [10, 3]
+ w0 = np.full(shape=(10, 3), fill_value=2).astype(np.float32)
+
+ # embedding.weight.shape = [10, 3]
+ # embedding.weight.data =
+ # [[2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.],
+ # [2., 2., 2.]]
+ embedding.weight.set_value(w0)
+
+ adam = paddle.optimizer.Adam(
+ parameters=[embedding.weight], learning_rate=0.01)
+ adam.clear_grad()
+
+ # out is Tensor
+ # out.shape: [3, 1, 3]
+ # out.layout: NCHW
+ # out.dtype: float
+ # out.data: [2 2 2 2 2 2 2 2 2]
+ out = embedding(x)
+
+ out.backward()
+ adam.step()
+
+ """
+
+ helper = LayerHelper('embedding', **locals())
+ check_variable_and_dtype(input, 'input', ['int64'], 'fluid.embedding')
+ check_dtype(dtype, 'dtype', ['float16', 'float32', 'float64', 'uint16'],
+ 'fluid.embedding')
+ remote_prefetch = is_sparse and (not is_distributed)
+ if remote_prefetch:
+ assert is_sparse is True and is_distributed is False
+ w = helper.create_parameter(attr=helper.param_attr,
+ shape=size,
+ dtype=dtype,
+ is_bias=False)
+ tmp = helper.create_variable_for_type_inference(dtype)
+ padding_idx = -1 if padding_idx is None else padding_idx if padding_idx >= 0 else (
+ size[0] + padding_idx)
+ helper.append_op(type='lookup_table_v2',
+ inputs={
+ 'Ids': input,
+ 'W': w
+ },
+ outputs={'Out': tmp},
+ attrs={
+ 'is_sparse': is_sparse,
+ 'is_distributed': is_distributed,
+ 'remote_prefetch': remote_prefetch,
+ 'padding_idx': padding_idx
+ })
+ return tmp
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/install_check.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/install_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..98d7fa6a037a6c62ee02ea07b0a489141d8331f2
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/install_check.py
@@ -0,0 +1,165 @@
+# Copyright (c) 2019 PaddlePaddle 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 os
+import paddle
+from .framework import Program, program_guard, unique_name, cuda_places, cpu_places
+from .param_attr import ParamAttr
+from .initializer import Constant
+from . import layers
+from . import backward
+from .dygraph import Layer, nn
+from . import executor
+from . import optimizer
+from . import core
+from . import compiler
+import logging
+import numpy as np
+
+__all__ = ['run_check']
+
+
+class SimpleLayer(Layer):
+
+ def __init__(self, input_size):
+ super(SimpleLayer, self).__init__()
+ self._linear1 = nn.Linear(
+ input_size,
+ 3,
+ param_attr=ParamAttr(initializer=Constant(value=0.1)))
+
+ def forward(self, inputs):
+ x = self._linear1(inputs)
+ x = layers.reduce_sum(x)
+ return x
+
+
+def run_check():
+ """To check whether install is successful
+ This func should not be called only if you need to verify installation
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ fluid.install_check.run_check()
+
+ # If installed successfully, output may be
+ # Running Verify Fluid Program ...
+ # W0805 04:24:59.496919 35357 device_context.cc:268] Please NOTE: device: 0, CUDA Capability: 70, Driver API Version: 10.2, Runtime API Version: 10.1
+ # W0805 04:24:59.505594 35357 device_context.cc:276] device: 0, cuDNN Version: 7.6.
+ # Your Paddle Fluid works well on SINGLE GPU or CPU.
+ # Your Paddle Fluid works well on MUTIPLE GPU or CPU.
+ # Your Paddle Fluid is installed successfully! Let's start deep Learning with Paddle Fluid now
+ """
+ paddle.enable_static()
+
+ print("Running Verify Fluid Program ... ")
+
+ device_list = []
+ if core.is_compiled_with_cuda():
+ try:
+ core.get_cuda_device_count()
+ except Exception as e:
+ logging.warning(
+ "You are using GPU version Paddle Fluid, But Your CUDA Device is not set properly"
+ "\n Original Error is {}".format(e))
+ return 0
+ device_list = cuda_places()
+ else:
+ device_list = [core.CPUPlace(), core.CPUPlace()]
+
+ np_inp_single = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+ inp = []
+ for i in range(len(device_list)):
+ inp.append(np_inp_single)
+ np_inp_muti = np.array(inp)
+ np_inp_muti = np_inp_muti.reshape(len(device_list), 2, 2)
+
+ def test_parallerl_exe():
+ train_prog = Program()
+ startup_prog = Program()
+ scope = core.Scope()
+ with executor.scope_guard(scope):
+ with program_guard(train_prog, startup_prog):
+ with unique_name.guard():
+ build_strategy = compiler.BuildStrategy()
+ build_strategy.enable_inplace = True
+ inp = layers.data(name="inp", shape=[2, 2])
+ simple_layer = SimpleLayer(input_size=2)
+ out = simple_layer(inp)
+ exe = executor.Executor(
+ core.CUDAPlace(0) if core.is_compiled_with_cuda() and
+ (core.get_cuda_device_count() > 0) else core.CPUPlace())
+ loss = paddle.mean(out)
+ loss.persistable = True
+ optimizer.SGD(learning_rate=0.01).minimize(loss)
+ startup_prog.random_seed = 1
+ compiled_prog = compiler.CompiledProgram(
+ train_prog).with_data_parallel(
+ build_strategy=build_strategy,
+ loss_name=loss.name,
+ places=device_list)
+ exe.run(startup_prog)
+
+ exe.run(compiled_prog,
+ feed={inp.name: np_inp_muti},
+ fetch_list=[loss.name])
+
+ def test_simple_exe():
+ train_prog = Program()
+ startup_prog = Program()
+ scope = core.Scope()
+ with executor.scope_guard(scope):
+ with program_guard(train_prog, startup_prog):
+ with unique_name.guard():
+ inp0 = layers.data(name="inp",
+ shape=[2, 2],
+ append_batch_size=False)
+ simple_layer0 = SimpleLayer(input_size=2)
+ out0 = simple_layer0(inp0)
+ param_grads = backward.append_backward(
+ out0,
+ parameter_list=[simple_layer0._linear1.weight.name])[0]
+ exe0 = executor.Executor(
+ core.CUDAPlace(0) if core.is_compiled_with_cuda() and
+ (core.get_cuda_device_count() > 0) else core.CPUPlace())
+ exe0.run(startup_prog)
+ exe0.run(feed={inp0.name: np_inp_single},
+ fetch_list=[out0.name, param_grads[1].name])
+
+ test_simple_exe()
+
+ print("Your Paddle Fluid works well on SINGLE GPU or CPU.")
+ try:
+ test_parallerl_exe()
+ print("Your Paddle Fluid works well on MUTIPLE GPU or CPU.")
+ print(
+ "Your Paddle Fluid is installed successfully! Let's start deep Learning with Paddle Fluid now"
+ )
+ except Exception as e:
+ logging.warning(
+ "Your Paddle Fluid has some problem with multiple GPU. This may be caused by:"
+ "\n 1. There is only 1 or 0 GPU visible on your Device;"
+ "\n 2. No.1 or No.2 GPU or both of them are occupied now"
+ "\n 3. Wrong installation of NVIDIA-NCCL2, please follow instruction on https://github.com/NVIDIA/nccl-tests "
+ "\n to test your NCCL, or reinstall it following https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html"
+ )
+
+ print("\n Original Error is: {}".format(e))
+ print(
+ "Your Paddle Fluid is installed successfully ONLY for SINGLE GPU or CPU! "
+ "\n Let's start deep Learning with Paddle Fluid now")
+
+ paddle.disable_static()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/io.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/io.py
new file mode 100644
index 0000000000000000000000000000000000000000..7169a90a98f4152104807df219b561a0f3369e8a
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/io.py
@@ -0,0 +1,2376 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import os
+import errno
+import warnings
+import six
+import logging
+import pickle
+import contextlib
+from functools import reduce
+import sys
+from io import BytesIO
+
+import numpy as np
+import math
+import paddle
+from paddle.fluid import layers
+from paddle.fluid.executor import Executor, global_scope
+from paddle.fluid.evaluator import Evaluator
+from paddle.fluid.framework import Program, Parameter, default_main_program, default_startup_program, Variable, \
+ program_guard, dygraph_not_support, static_only
+from paddle.reader import cache, map_readers, buffered, compose, chain, shuffle, \
+ ComposeNotAligned, firstn, xmap_readers, multiprocess_reader
+from .wrapped_decorator import signature_safe_contextmanager
+from paddle.fluid.compiler import CompiledProgram
+from paddle.fluid.log_helper import get_logger
+from . import reader
+from . import unique_name
+from .reader import *
+from . import dataloader
+from .dataloader import *
+from . import core
+from .. import compat as cpt
+from paddle.utils import deprecated
+from paddle.fluid.framework import static_only
+
+batch = paddle.batch
+
+__all__ = [
+ 'save_vars',
+ 'save_params',
+ 'save_persistables',
+ 'load_vars',
+ 'load_params',
+ 'load_persistables',
+ 'save_inference_model',
+ 'load_inference_model',
+ 'batch',
+ 'save',
+ 'load',
+ 'load_program_state',
+ 'set_program_state',
+ 'get_program_parameter',
+ 'get_program_persistable_vars',
+] + reader.__all__
+
+_logger = get_logger(__name__,
+ logging.INFO,
+ fmt='%(asctime)s-%(levelname)s: %(message)s')
+
+
+class _open_buffer(object):
+
+ def __init__(self, buffer):
+ self.buffer = buffer
+
+ def __enter__(self):
+ return self.buffer
+
+
+class _buffer_reader(_open_buffer):
+
+ def __init__(self, buffer):
+ super(_buffer_reader, self).__init__(buffer)
+ self.initial_tell = self.buffer.tell()
+
+ def __exit__(self, *args):
+ # `args[0]` is type of exception. When the `read` is abnormal, the file pointer returns to the initial position.
+ if args[0] is not None:
+ self.buffer.seek(self.initial_tell)
+
+
+class _buffer_writer(_open_buffer):
+
+ def __exit__(self, *args):
+ self.buffer.flush()
+
+
+def _is_file_path(path):
+ return isinstance(path, str)
+
+
+def _open_file_buffer(path_or_buffer, mode):
+
+ if _is_file_path(path_or_buffer):
+ return open(path_or_buffer, mode)
+ else:
+ if 'w' in mode:
+ return _buffer_writer(path_or_buffer)
+ elif 'r' in mode:
+ return _buffer_reader(path_or_buffer)
+ else:
+ raise ValueError(
+ "Expected 'r' or 'w' in mode but got {}".format(mode))
+
+
+def _is_memory_buffer(buffer):
+ return isinstance(buffer, BytesIO)
+
+
+def is_parameter(var):
+ """
+ Check whether the given variable is an instance of Parameter.
+
+ Args:
+ var(Variable): The variable to be checked.
+
+ Returns:
+ bool: True if the given `var` is an instance of Parameter,
+ False if not.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ param = fluid.default_main_program().global_block().var('fc.w')
+ res = fluid.io.is_parameter(param)
+ """
+ return isinstance(var, Parameter)
+
+
+def is_persistable(var):
+ """
+ Check whether the given variable is persistable.
+
+ Args:
+ var(Variable): The variable to be checked.
+
+ Returns:
+ bool: True if the given `var` is persistable
+ False if not.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ param = fluid.default_main_program().global_block().var('fc.b')
+ res = fluid.io.is_persistable(param)
+ """
+ if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
+ var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
+ var.desc.type() == core.VarDesc.VarType.READER:
+ return False
+ return var.persistable
+
+
+def is_belong_to_optimizer(var):
+ if not (isinstance(var, Parameter) or var.desc.need_check_feed()):
+ return is_persistable(var)
+
+ return False
+
+
+@dygraph_not_support
+def get_program_parameter(program):
+ """
+ Get all the parameters from Program.
+
+ Args:
+ var(Program): The Program to get parameters
+
+ Returns:
+ list: The list contains all parameters in the program
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ data = fluid.data(name="img", shape=[64, 784])
+ w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
+ b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
+ list_para = fluid.io.get_program_parameter( fluid.default_main_program() )
+ """
+ return list(filter(is_parameter, program.list_vars()))
+
+
+@dygraph_not_support
+def get_program_persistable_vars(program):
+ """
+ Get all the persistable vars from Program.
+
+ Args:
+ var(Program): The Program to get persistable vars
+
+ Returns:
+ list: The list contains all persistable vars in the program
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ data = fluid.data(name="img", shape=[64, 784])
+ w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
+ b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
+ list_para = fluid.io.get_program_persistable_vars( fluid.default_main_program() )
+ """
+ return list(filter(is_persistable, program.list_vars()))
+
+
+def _clone_var_in_block_(block, var):
+ assert isinstance(var, Variable)
+ if var.desc.type() == core.VarDesc.VarType.LOD_TENSOR:
+ return block.create_var(name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ lod_level=var.lod_level,
+ persistable=True)
+ else:
+ return block.create_var(name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ persistable=True)
+
+
+@signature_safe_contextmanager
+def _load_program_scope(main=None, startup=None, scope=None):
+ prog = main if main else paddle.fluid.Program()
+ startup_prog = startup if startup else paddle.fluid.Program()
+ scope = scope if scope else paddle.fluid.core.Scope()
+ with paddle.fluid.scope_guard(scope):
+ with paddle.fluid.program_guard(prog, startup_prog):
+ with paddle.fluid.unique_name.guard():
+ with paddle.fluid.framework._dygraph_guard(None):
+ yield
+
+
+def _get_valid_program(main_program=None):
+ if main_program is None:
+ main_program = default_main_program()
+ elif isinstance(main_program, CompiledProgram):
+ main_program = main_program._program
+ if main_program is None:
+ raise TypeError(
+ "The type of input main_program is invalid, expected tyep is Program, but received None"
+ )
+ warnings.warn(
+ "The input is a CompiledProgram, this is not recommended.")
+ if not isinstance(main_program, Program):
+ raise TypeError(
+ "The type of input main_program is invalid, expected type is fluid.Program, but received %s"
+ % type(main_program))
+ return main_program
+
+
+@dygraph_not_support
+def save_vars(executor,
+ dirname,
+ main_program=None,
+ vars=None,
+ predicate=None,
+ filename=None):
+ """
+ Save specific variables in the `Program` to files.
+
+ There are two ways to specify the variables to be saved: set variables in
+ a list and assign it to the `vars`, or use the `predicate` function to select
+ variables that make `predicate(variable) == True`. The first way has a higher priority.
+
+ The `dirname` is used to specify the folder where to save variables.
+ If you prefer to save variables in separate files in the `dirname` folder,
+ do not set `filename`. If you prefer to save all variables in a single file,
+ use `filename` to specify it.
+
+ Args:
+ executor(Executor): The executor to run for saving variables.
+ dirname(str, optional): The folder where to save variables.
+ When you need to save the parameter to the memory, set it to None.
+ main_program(Program, optional): The program whose variables will be saved.
+ If it is None, the default main program will
+ be used automatically.
+ Default: None
+ vars(list[Variable], optional): The list contains all variables to be saved.
+ Default: None
+ predicate(function, optional): The function selects the variables that make
+ `predicate(variable) == True`.
+ Default: None
+ filename(str, optional): If you prefer to save all variables in a single file,
+ use `filename` to specify it. Otherwise, let `filename` be None.
+ Default: None
+
+ Returns:
+ str: When saving parameters to a file, returns None.
+ When saving parameters to memory, returns a binary string containing parameters.
+
+ Raises:
+ TypeError: If `main_program` is not an instance of Program nor None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ main_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(main_prog, startup_prog):
+ data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
+ w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
+ b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
+ hidden_w = fluid.layers.matmul(x=data, y=w)
+ hidden_b = fluid.layers.elementwise_add(hidden_w, b)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(startup_prog)
+
+ # The first usage: use `vars` to set the saved variables.
+ var_list = [w, b]
+ path = "./my_paddle_vars"
+ fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
+ filename="vars_file")
+ # w and b will be save in a file named "var_file".
+
+ # The second usage: use `predicate` to select the saved variable.
+ def name_has_fc(var):
+ res = "fc" in var.name
+ return res
+ param_path = "./my_paddle_model"
+ fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate = name_has_fc)
+ # all variables whose names contain "fc " are saved.
+ """
+ save_to_memory = False
+ if dirname is None and filename is None:
+ save_to_memory = True
+
+ main_program = _get_valid_program(main_program)
+
+ if vars is None:
+ return save_vars(executor,
+ main_program=main_program,
+ dirname=dirname,
+ vars=list(filter(predicate, main_program.list_vars())),
+ filename=filename)
+ else:
+ params_var_name = "saved_params"
+ # give warning when there is no var in model
+ if len(list(vars)) == 0:
+ warnings.warn(
+ "no variable in your model, please ensure there are any variables in your model to save"
+ )
+ return None
+
+ save_program = Program()
+ save_block = save_program.global_block()
+
+ save_var_map = {}
+ for each_var in vars:
+ # NOTE: don't save the variable which type is RAW
+ if each_var.type == core.VarDesc.VarType.RAW:
+ continue
+ new_var = _clone_var_in_block_(save_block, each_var)
+ if filename is None and save_to_memory is False:
+ save_file_path = os.path.join(os.path.normpath(dirname),
+ new_var.name)
+ save_block.append_op(
+ type='save',
+ inputs={'X': [new_var]},
+ outputs={},
+ attrs={'file_path': os.path.normpath(save_file_path)})
+ else:
+ save_var_map[new_var.name] = new_var
+
+ if filename is not None or save_to_memory:
+ save_var_list = []
+ for name in sorted(save_var_map.keys()):
+ save_var_list.append(save_var_map[name])
+
+ save_path = str()
+ if save_to_memory is False:
+ save_path = os.path.join(os.path.normpath(dirname), filename)
+
+ saved_params = save_block.create_var(type=core.VarDesc.VarType.RAW,
+ name=params_var_name)
+ saved_params.desc.set_persistable(True)
+ save_block.append_op(type='save_combine',
+ inputs={'X': save_var_list},
+ outputs={'Y': saved_params},
+ attrs={
+ 'file_path': save_path,
+ 'save_to_memory': save_to_memory
+ })
+
+ # NOTE(zhiqiu): save op will add variable kLookupTablePath in save_program.desc,
+ # which leads to diff on save_program and its desc. Call _sync_with_cpp
+ # to keep consistency.
+ save_program._sync_with_cpp()
+ executor.run(save_program)
+ if save_to_memory:
+ return global_scope().find_var(params_var_name).get_bytes()
+
+
+@dygraph_not_support
+def save_params(executor, dirname, main_program=None, filename=None):
+ """
+ Save all parameters from the :code:`main_program` to
+ the folder :code:`dirname` or file :code:`filename`. You can refer to
+ :ref:`api_guide_model_save_reader_en` for more details.
+
+ Use the :code:`dirname` to specify the saving folder. If you would like to
+ save parameters in separate files, set :code:`filename` None; if you would
+ like to save all parameters in a single file, use :code:`filename` to specify
+ the file name.
+
+ Note:
+ Some variables are not Parameter while they are necessary for
+ training, such as learning rate, global step, etc. So you can NOT save
+ and continue your training just by :ref:`api_fluid_io_save_params`
+ and :ref:`api_fluid_io_load_params`. Please use :ref:`api_fluid_io_save_persistables`
+ and :ref:`api_fluid_io_load_persistables` instead.
+
+ If you want to save your model for the inference, please use the
+ :ref:`api_fluid_io_save_inference_model`. You can refer to
+ :ref:`api_guide_model_save_reader_en` for more details.
+
+ Args:
+ executor(Executor): The executor to run for saving parameters, You can
+ refer to :ref:`api_guide_executor_en`.
+ dirname(str, optional): The saving directory path.
+ When you need to save the parameter to the memory, set it to None.
+ main_program(Program, optional): The program whose parameters will be
+ saved. You can refer to
+ :ref:`api_guide_Program_en` for more
+ details. If it is None, the default main
+ program will be used.
+ Default: None
+ filename(str, optional): The file to save all parameters. If you prefer
+ to save parameters in different files, set it
+ to None.
+ Default: None
+
+ Returns:
+ str: When saving parameters to a file, returns None.
+ When saving parameters to memory, returns a binary string containing parameters.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+
+ paddle.enable_static()
+ params_path = "./my_paddle_model"
+ image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+
+ loss = fluid.layers.cross_entropy(input=predict, label=label)
+ avg_loss = paddle.mean(loss)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+ fluid.io.save_params(executor=exe, dirname=params_path)
+ # The parameters weights and bias of the fc layer in the network are going to
+ # be saved in different files in the path "./my_paddle_model"
+ """
+ return save_vars(executor,
+ dirname=dirname,
+ main_program=main_program,
+ vars=None,
+ predicate=is_parameter,
+ filename=filename)
+
+
+def _save_distributed_persistables(executor, dirname, main_program):
+ """
+ save_persistables for distributed training.
+ the method will do things listed below:
+ 1.save part of persistable variables on trainer.
+ 2.receive "remote prefetch variables" from parameter servers and merge them.
+ 3.save "distributed lookup table" on parameter servers.
+ 4.receive "optimizer variables" from parameter servers and merge them.
+
+ Args:
+ executor(Executor): The executor to run for saving parameters.
+ dirname(str): The saving directory path.
+ main_program(Program): The program whose parameters will be
+ saved. the main_program must be the trainer_program
+ get after transpiler.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ param_path = "./my_paddle_model"
+ t = distribute_transpiler.DistributeTranspiler()
+ t.transpile(...)
+ train_program = t.get_trainer_program()
+ _save_distributed_persistables(executor=exe, dirname=param_path, main_program=train_program)
+ """
+
+ def __save_remote_params(executor, dirname, remote_params_map):
+ """
+ receive params on pserver through rpc.
+ if the params are be sliced, will concat them to one, then save it.
+ """
+ if not remote_params_map:
+ return
+
+ prog = Program()
+ block = prog.global_block()
+
+ # recv optimize vars from pserver
+ for name, remote_params in remote_params_map.items():
+ origin = remote_params[0].origin
+ is_slice = remote_params[0].is_slice
+
+ slices = [None] * len(remote_params)
+ slice_varnames = [None] * len(remote_params)
+ remote_varnames = [None] * len(remote_params)
+ endpoints = [None] * len(remote_params)
+
+ for idx, optimizer in enumerate(remote_params):
+ block_id = optimizer.block_id
+ slice = optimizer.slice
+ endpoint = optimizer.endpoint
+
+ index = block_id if is_slice else idx
+ slices[index] = slice
+ slice_varnames[index] = "{}.slice.{}".format(slice.name, idx)
+ remote_varnames[index] = slice.name
+ endpoints[index] = endpoint
+
+ slice_shapes = []
+ for slice in slices:
+ tmp = [str(dim) for dim in slice.shape]
+ slice_shapes.append(",".join(tmp))
+
+ block.append_op(type='recv_save',
+ attrs={
+ "trainer_id": 0,
+ "shape": origin.shape,
+ "slice_shapes": slice_shapes,
+ "slice_varnames": slice_varnames,
+ "remote_varnames": remote_varnames,
+ "endpoints": endpoints,
+ "file_path": os.path.join(dirname, origin.name)
+ })
+
+ executor.run(prog)
+
+ def __save_distributed_lookup_tables(executor, dirname,
+ distributed_lookup_table, endpoints):
+ """
+ because the distributed lookup table may too huge to merge and save at one place,
+ it will be saved at parameter server independent respectively.
+
+ the save directory is dirname/"__lookup_table__".
+
+ """
+ prog = Program()
+ block = prog.global_block()
+
+ # if there is lookup table, the trainer 0 will notify all pserver to save.
+ lookup_table_filename = os.path.join(dirname, "__lookup_table__")
+ attrs = {}
+ attrs['epmap'] = endpoints
+ attrs['dir'] = lookup_table_filename
+ attrs['lookup_table'] = distributed_lookup_table
+ block.append_op(type='checkpoint_notify',
+ inputs={},
+ outputs={},
+ attrs=attrs)
+ executor.run(prog)
+
+ def __exclude_vars(exclude_var_names=[]):
+
+ def is_valid(var):
+ if var.name in exclude_var_names:
+ return False
+ if var.desc.type() == core.VarDesc.VarType.FEED_MINIBATCH or \
+ var.desc.type() == core.VarDesc.VarType.FETCH_LIST or \
+ var.desc.type() == core.VarDesc.VarType.READER:
+ return False
+ return var.persistable
+
+ return is_valid
+
+ if not isinstance(main_program, Program):
+ raise TypeError("'main_program' should be an instance of Program.")
+
+ if not main_program._is_distributed:
+ raise ValueError(
+ "'_save_distributed_persistables' just be designed for distributed training."
+ )
+
+ remote_params_map = main_program._parameters_on_pservers.get_distributed_vars_by_vtypes(
+ ["Optimizer", "RemotePrefetch"], groupby=True)
+
+ exclude_var_names = []
+ if remote_params_map:
+ exclude_var_names.extend(remote_params_map.keys())
+
+ if main_program._distributed_lookup_table:
+ if isinstance(main_program._distributed_lookup_table, list):
+ exclude_var_names.extend(main_program._distributed_lookup_table)
+ else:
+ exclude_var_names.append(main_program._distributed_lookup_table)
+
+ local_vars = list(
+ filter(__exclude_vars(exclude_var_names), main_program.list_vars()))
+ save_vars(executor,
+ main_program=main_program,
+ dirname=dirname,
+ vars=local_vars)
+
+ if main_program._is_chief:
+ if remote_params_map:
+ __save_remote_params(executor, dirname, remote_params_map)
+ if main_program._distributed_lookup_table:
+ __save_distributed_lookup_tables(
+ executor, dirname, main_program._distributed_lookup_table,
+ main_program._endpoints)
+
+
+@dygraph_not_support
+def save_persistables(executor, dirname, main_program=None, filename=None):
+ """
+ Save all persistable variables from :code:`main_program` to
+ the folder :code:`dirname` or file :code:`filename`. You can refer to
+ :ref:`api_guide_model_save_reader_en` for more details. And then
+ saves these persistables variables to the folder :code:`dirname` or file
+ :code:`filename`.
+
+ The :code:`dirname` is used to specify the folder where persistable variables
+ are going to be saved. If you would like to save variables in separate
+ files, set :code:`filename` None; if you would like to save all variables in a
+ single file, use :code:`filename` to specify the file name.
+
+ Args:
+ executor(Executor): The executor to run for saving persistable variables.
+ You can refer to :ref:`api_guide_executor_en` for
+ more details.
+
+ dirname(str, optional): The saving directory path.
+ When you need to save the parameter to the memory, set it to None.
+ main_program(Program, optional): The program whose persistbale variables will
+ be saved. You can refer to
+ :ref:`api_guide_Program_en` for more details.
+ If it is None, the default main program will
+ be used.
+ Default: None.
+ filename(str, optional): The file to save all variables. If you prefer to
+ save variables in different files, set it to None.
+ Default: None.
+
+ Returns:
+ str: When saving parameters to a file, returns None.
+ When saving parameters to memory, returns a binary string containing parameters.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ dir_path = "./my_paddle_model"
+ file_name = "persistables"
+ image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ loss = fluid.layers.cross_entropy(input=predict, label=label)
+ avg_loss = paddle.mean(loss)
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+ fluid.io.save_persistables(executor=exe, dirname=dir_path, filename=file_name)
+ # The persistables variables weights and bias in the fc layer of the network
+ # are going to be saved in the same file named "persistables" in the path
+ # "./my_paddle_model"
+ """
+ if main_program and main_program._is_distributed:
+ return _save_distributed_persistables(executor,
+ dirname=dirname,
+ main_program=main_program)
+ else:
+ return save_vars(executor,
+ dirname=dirname,
+ main_program=main_program,
+ vars=None,
+ predicate=is_persistable,
+ filename=filename)
+
+
+def load_vars(executor,
+ dirname,
+ main_program=None,
+ vars=None,
+ predicate=None,
+ filename=None):
+ """
+ :api_attr: Static Graph
+
+ This API loads variables from files by executor.
+
+ There are two ways to specify the variables to be loaded: the first way, set
+ variables in a list and assign it to the `vars`; the second way, use the
+ `predicate` function to select variables that make `predicate(variable) == True`.
+ The first way has a higher priority.
+
+ The `dirname` is used to specify the folder where to load variables.
+ If variables were saved in separate files in the folder `dirname`,
+ set `filename` None. If all variables were saved in a single file,
+ use `filename` to specify it.
+
+ Args:
+ executor(Executor): The executor to run for loading variables.
+ dirname(str): The folder where to load the variables.
+ main_program(Program, optional): The program whose variables will be loaded.
+ If it is None, the default main program will
+ be used automatically.
+ Default: None
+ vars(list[Variable], optional): The list that contains all variables to be loaded.
+ Default: None
+ predicate(function, optional): The function selects variables that make
+ `predicate(variable) == True`.
+ Default: None
+ filename(str, optional): The file which saved all required variables. If variables
+ were saved in separate files, set it to be None.
+ Default: None
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ main_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(main_prog, startup_prog):
+ data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
+ w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
+ b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
+ hidden_w = fluid.layers.matmul(x=data, y=w)
+ hidden_b = fluid.layers.elementwise_add(hidden_w, b)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(startup_prog)
+
+ # The first usage: using `vars` to specify the variables.
+ path = "./my_paddle_vars"
+ var_list = [w, b]
+ fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
+ filename="vars_file")
+ fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
+ filename="vars_file")
+ # w and b will be loaded, and they are supposed to
+ # be saved in the same file named 'var_file' in the path "./my_paddle_vars".
+
+ # The second usage: using the `predicate` function to select variables
+ param_path = "./my_paddle_model"
+ def name_has_fc(var):
+ res = "fc" in var.name
+ return res
+ fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog,
+ vars=None, predicate=name_has_fc)
+ fluid.io.load_vars(executor=exe, dirname=param_path, main_program=main_prog,
+ vars=None, predicate=name_has_fc)
+ # Load All variables in the `main_program` whose name includes "fc".
+ # And all the variables are supposed to be saved in separate files.
+
+ """
+ vars_from_memory = False
+ if dirname is not None:
+ dirname = os.path.normpath(dirname)
+ else:
+ vars_from_memory = True
+
+ if vars is None:
+ if main_program is None:
+ main_program = default_main_program()
+ if not isinstance(main_program, Program):
+ raise TypeError(
+ "The type of input main_program is invalid, expected type is fluid.Program, but received %s"
+ % type(main_program))
+
+ load_vars(executor,
+ dirname=dirname,
+ main_program=main_program,
+ vars=list(filter(predicate, main_program.list_vars())),
+ filename=filename)
+ else:
+ load_prog = Program()
+ load_block = load_prog.global_block()
+
+ if main_program is None:
+ main_program = default_main_program()
+
+ if not isinstance(main_program, Program):
+ raise TypeError(
+ "The type of input main_program is invalid, expected type is fluid.Program, but received %s"
+ % type(main_program))
+
+ # save origin param shape
+ orig_para_shape = {}
+ load_var_map = {}
+
+ check_vars = []
+ sparse_vars = []
+
+ for each_var in vars:
+ assert isinstance(each_var, Variable)
+
+ if each_var.type == core.VarDesc.VarType.RAW:
+ continue
+
+ if isinstance(each_var, Parameter):
+ orig_para_shape[each_var.name] = tuple(
+ each_var.desc.get_shape())
+
+ if each_var.type == core.VarDesc.VarType.SELECTED_ROWS:
+ sparse_vars.append(each_var)
+ continue
+
+ new_var = _clone_var_in_block_(load_block, each_var)
+ check_vars.append(each_var)
+
+ if filename is None:
+ if dirname is None:
+ raise ValueError(
+ "The directory path and params cannot be None at the same time."
+ )
+ load_block.append_op(
+ type='load',
+ inputs={},
+ outputs={'Out': [new_var]},
+ attrs={'file_path': os.path.join(dirname, new_var.name)})
+ else:
+ load_var_map[new_var.name] = new_var
+
+ for each_var in sparse_vars:
+ assert isinstance(each_var, Variable)
+
+ if filename is not None:
+ raise ValueError(
+ "SelectedRows can not be load with load_combine")
+
+ new_var = _clone_var_in_block_(load_block, each_var)
+
+ var_path = os.path.join(dirname, new_var.name)
+ if not os.path.exists(var_path):
+ raise ValueError(
+ "SelectedRows var {} can not find at {}".format(
+ new_var.name, var_path))
+
+ if os.path.isfile(var_path):
+ load_block.append_op(
+ type='load',
+ inputs={},
+ outputs={'Out': [new_var]},
+ attrs={'file_path': os.path.join(dirname, new_var.name)})
+ else:
+ blocks = []
+ block_paths = os.listdir(var_path)
+
+ for block in block_paths:
+ if block.startswith(new_var.name):
+ blocks.append(block)
+
+ slices = []
+ for block in blocks:
+ slice = load_block.create_var(name=block,
+ type=new_var.type,
+ shape=new_var.shape,
+ dtype=new_var.dtype,
+ persistable=False)
+ slices.append(slice)
+
+ file_path = os.path.join(var_path, block, "Param")
+ load_block.append_op(type='load',
+ inputs={},
+ outputs={'Out': [slice]},
+ attrs={'file_path': file_path})
+
+ load_block.append_op(type='lookup_sparse_table_merge',
+ inputs={'X': slices},
+ outputs={'Out': new_var},
+ attrs={})
+
+ if filename is not None:
+ load_var_list = []
+ for name in sorted(load_var_map.keys()):
+ load_var_list.append(load_var_map[name])
+
+ if vars_from_memory is False:
+ filename = os.path.join(dirname, filename)
+
+ load_block.append_op(type='load_combine',
+ inputs={},
+ outputs={"Out": load_var_list},
+ attrs={
+ 'file_path': filename,
+ 'model_from_memory': vars_from_memory
+ })
+ executor.run(load_prog)
+
+ # check var shape
+ for each_var in check_vars:
+ if not isinstance(each_var, Parameter):
+ continue
+ var_temp = paddle.fluid.global_scope().find_var(each_var.name)
+ assert var_temp != None, "can't not find var: " + each_var.name
+ new_shape = (np.array(var_temp.get_tensor())).shape
+ assert each_var.name in orig_para_shape, each_var.name + "MUST in var list"
+ orig_shape = orig_para_shape.get(each_var.name)
+ if new_shape != orig_shape:
+ raise RuntimeError(
+ "Variable's shape does not match, the Program requires a parameter with the shape of ({}), "
+ "while the loaded parameter (namely [ {} ]) has a shape of ({})."
+ .format(orig_shape, each_var.name, new_shape))
+
+
+@dygraph_not_support
+def load_params(executor, dirname, main_program=None, filename=None):
+ """
+ :api_attr: Static Graph
+
+ This API filters out all parameters from the give ``main_program``
+ and then tries to load these parameters from the directory ``dirname`` or
+ the file ``filename``.
+
+ Use the ``dirname`` to specify the directory where parameters were saved. If
+ parameters were saved in separate files under the directory `dirname`, set
+ ``filename`` as None; if all parameters were saved in a single file, use
+ ``filename`` to specify the file name.
+
+ **Note**:
+ Some variables are not Parameter while they are necessary for
+ training, such as learning rate, global step, etc. So you cannot save and
+ continue your training just by using :ref:`api_fluid_io_save_params` and
+ :ref:`api_fluid_io_load_params`. Please use :ref:`api_fluid_io_save_persistables`
+ and :ref:`api_fluid_io_load_persistables` instead.
+
+ If you want to load the pre-trained model structure and parameters
+ for the inference, please use the :ref:`api_fluid_io_load_inference_model` API. You can
+ refer to :ref:`api_guide_model_save_reader_en` for more details.
+
+ Args:
+ executor(Executor): The executor used for loading parameters.
+ See :ref:`api_guide_executor_en` for more details about it.
+ dirname(str): The directory path.
+ main_program(Program, optional): The program whose parameters will be
+ loaded. If it is None, the ``default_main_program``
+ will be used automatically. See :ref:`api_guide_Program_en`
+ for more about ``Program``.
+ Default: None.
+ filename(str, optional): The file which saved all parameters. If parameters
+ were saved in separated files, set it to None.
+ Default: None.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ param_path = "./my_paddle_model"
+ prog = fluid.default_main_program()
+ fluid.io.load_params(executor=exe, dirname=param_path,
+ main_program=None)
+ """
+ load_vars(executor,
+ dirname=dirname,
+ main_program=main_program,
+ predicate=is_parameter,
+ filename=filename)
+
+
+@dygraph_not_support
+def load_persistables(executor, dirname, main_program=None, filename=None):
+ """
+ :api_attr: Static Graph
+
+ This API filters out all variables with ``persistable==True`` from the
+ given ``main_program`` and then tries to load these variables from the
+ directory ``dirname`` or the file ``filename``.
+
+ Use the ``dirname`` to specify the directory where persistable variables
+ (refer to :ref:`api_guide_model_save_reader_en`) were saved. If variables
+ were saved in separate files, set ``filename`` as None; if all variables
+ were saved in a single file, use ``filename`` to specify the file name.
+
+ Args:
+ executor(Executor): The executor used for loading persistable variables.
+ See :ref:`api_guide_executor_en` for more details about it.
+ dirname(str): The directory path.
+ main_program(Program, optional): The program whose persistable variables will
+ be loaded. If it is None, the ``default_main_program``
+ will be used automatically. See :ref:`api_guide_Program_en`
+ for more about ``Program``.
+ Default: None.
+ filename(str, optional): The file which saved all persistable variables. If variables
+ were saved in separated files, set it to None.
+ Default: None.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ param_path = "./my_paddle_model"
+ prog = fluid.default_main_program()
+ fluid.io.load_persistables(executor=exe, dirname=param_path,
+ main_program=None)
+ """
+
+ if main_program and main_program._is_distributed:
+ _load_distributed_persistables(executor,
+ dirname=dirname,
+ main_program=main_program)
+ else:
+ load_vars(executor,
+ dirname=dirname,
+ main_program=main_program,
+ predicate=is_persistable,
+ filename=filename)
+
+
+def _load_distributed_persistables(executor, dirname, main_program=None):
+ """
+ customized load_persistables for distributed training.
+ it should be used on parameter server,
+
+ Args:
+ executor(Executor): The executor to run for saving parameters.
+ dirname(str): The load directory path.
+ main_program(Program): The program whose parameters will be
+ loaded. the main_program must be the pserver_program
+ get after transpiler.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ param_path = "./my_paddle_model"
+ t = distribute_transpiler.DistributeTranspiler()
+ t.transpile(...)
+ pserver_prog = t.get_pserver_program(...)
+ _load_distributed_persistables(executor=exe, dirname=param_path, main_program=pserver_prog)
+ """
+
+ def __is_distributed_part_var(varname):
+ trainer_idx = varname.find(".trainer_")
+ block_idx = varname.find(".block")
+ return trainer_idx or block_idx
+
+ def __load_persistable_vars(executor, dirname, need_load_vars):
+ load_prog = Program()
+ load_block = load_prog.global_block()
+ need_delete_vars = []
+
+ for param in need_load_vars:
+ origin_var = param.origin
+ slice_var = param.slice
+ is_slice = param.is_slice
+ offset = param.offset
+
+ if is_slice:
+ slice = load_block.create_var(name=slice_var.name,
+ type=slice_var.type,
+ shape=slice_var.shape,
+ dtype=slice_var.dtype,
+ persistable=True)
+
+ load_block.append_op(type='load',
+ inputs={},
+ outputs={'Out': [slice]},
+ attrs={
+ 'file_path':
+ os.path.join(dirname, origin_var.name),
+ 'seek':
+ offset,
+ 'shape':
+ slice.shape
+ })
+ else:
+ origin = load_block.create_var(name="{}".format(
+ origin_var.name),
+ type=origin_var.type,
+ shape=origin_var.shape,
+ dtype=origin_var.dtype,
+ persistable=True)
+ load_block.append_op(
+ type='load',
+ inputs={},
+ outputs={'Out': [origin]},
+ attrs={'file_path': os.path.join(dirname, origin_var.name)})
+
+ load_block.append_op(
+ type='delete_var',
+ inputs={'X': need_delete_vars},
+ )
+
+ executor.run(load_prog)
+
+ if not isinstance(main_program, Program):
+ raise TypeError("'main_program' should be an instance of Program.")
+
+ if not main_program._is_distributed:
+ raise ValueError(
+ "'_load_distributed_persistables' just be designed for distributed training."
+ )
+
+ if not main_program._ps_endpoint:
+ raise ValueError(
+ "'_load_distributed_persistables' need current_endpoint set in DistributeTranspiler.transpile"
+ )
+
+ need_load_vars = main_program._parameters_on_pservers.get_distributed_vars_by_ep(
+ main_program._ps_endpoint)
+ __load_persistable_vars(executor, dirname, need_load_vars)
+
+
+def prepend_feed_ops(inference_program,
+ feed_target_names,
+ feed_holder_name='feed'):
+ if len(feed_target_names) == 0:
+ return
+
+ global_block = inference_program.global_block()
+ feed_var = global_block.create_var(name=feed_holder_name,
+ type=core.VarDesc.VarType.FEED_MINIBATCH,
+ persistable=True)
+
+ for i, name in enumerate(feed_target_names):
+ if not global_block.has_var(name):
+ raise ValueError(
+ "The feeded_var_names[{i}]: '{name}' doesn't exist in pruned inference program. "
+ "Please check whether '{name}' is a valid feed_var name, or remove it from feeded_var_names "
+ "if '{name}' is not involved in the target_vars calculation.".
+ format(i=i, name=name))
+ out = global_block.var(name)
+ global_block._prepend_op(type='feed',
+ inputs={'X': [feed_var]},
+ outputs={'Out': [out]},
+ attrs={'col': i})
+
+
+def append_fetch_ops(inference_program,
+ fetch_target_names,
+ fetch_holder_name='fetch'):
+ global_block = inference_program.global_block()
+ fetch_var = global_block.create_var(name=fetch_holder_name,
+ type=core.VarDesc.VarType.FETCH_LIST,
+ persistable=True)
+
+ for i, name in enumerate(fetch_target_names):
+ global_block.append_op(type='fetch',
+ inputs={'X': [name]},
+ outputs={'Out': [fetch_var]},
+ attrs={'col': i})
+
+
+@static_only
+@deprecated(since="2.0.0", update_to="paddle.static.save_inference_model")
+def save_inference_model(dirname,
+ feeded_var_names,
+ target_vars,
+ executor,
+ main_program=None,
+ model_filename=None,
+ params_filename=None,
+ export_for_deployment=True,
+ program_only=False,
+ clip_extra=True):
+ """
+ Prune the given `main_program` to build a new program especially for inference,
+ and then save it and all related parameters to given `dirname` .
+ If you just want to save parameters of your trained model, please use the
+ :ref:`api_fluid_io_save_params` . You can refer to :ref:`api_guide_model_save_reader_en`
+ for more details.
+
+ Note:
+ The :code:`dirname` is used to specify the folder where inference model
+ structure and parameters are going to be saved. If you would like to save params of
+ Program in separate files, set `params_filename` None; if you would like to save all
+ params of Program in a single file, use `params_filename` to specify the file name.
+
+ Args:
+ dirname(str): The directory path to save the inference model.
+ feeded_var_names(list[str]): list of string. Names of variables that need to be fed
+ data during inference.
+ target_vars(list[Variable]): list of Variable. Variables from which we can get
+ inference results.
+ executor(Executor): The executor that saves the inference model. You can refer
+ to :ref:`api_guide_executor_en` for more details.
+ main_program(Program, optional): The original program, which will be pruned to
+ build the inference model. If is set None,
+ the global default :code:`_main_program_` will be used.
+ Default: None.
+ model_filename(str, optional): The name of file to save the inference program
+ itself. If is set None, a default filename
+ :code:`__model__` will be used.
+ params_filename(str, optional): The name of file to save all related parameters.
+ If it is set None, parameters will be saved
+ in separate files .
+ export_for_deployment(bool, optional): If True, programs are modified to only support
+ direct inference deployment. Otherwise,
+ more information will be stored for flexible
+ optimization and re-training. Currently, only
+ True is supported.
+ Default: True.
+ program_only(bool, optional): If True, It will save inference program only, and do not
+ save params of Program.
+ Default: False.
+
+ Returns:
+ list, The fetch variables' name list.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ path = "./infer_model"
+
+ # User defined network, here a softmax regession example
+ image = fluid.data(name='img', shape=[None, 28, 28], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+
+ loss = fluid.layers.cross_entropy(input=predict, label=label)
+ avg_loss = paddle.mean(loss)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ # Feed data and train process
+
+ # Save inference model. Note we don't save label and loss in this example
+ fluid.io.save_inference_model(dirname=path,
+ feeded_var_names=['img'],
+ target_vars=[predict],
+ executor=exe)
+
+ # In this example, the save_inference_mode inference will prune the default
+ # main program according to the network's input node (img) and output node(predict).
+ # The pruned inference program is going to be saved in the "./infer_model/__model__"
+ # and parameters are going to be saved in separate files under folder
+ # "./infer_model".
+
+ """
+ if isinstance(feeded_var_names, six.string_types):
+ feeded_var_names = [feeded_var_names]
+ elif export_for_deployment:
+ if len(feeded_var_names) > 0:
+ # TODO(paddle-dev): polish these code blocks
+ if not (bool(feeded_var_names) and all(
+ isinstance(name, six.string_types)
+ for name in feeded_var_names)):
+ raise ValueError("'feed_var_names' should be a list of str.")
+
+ if isinstance(target_vars, Variable):
+ target_vars = [target_vars]
+ elif export_for_deployment:
+ if not (bool(target_vars)
+ and all(isinstance(var, Variable) for var in target_vars)):
+ raise ValueError("'target_vars' should be a list of Variable.")
+
+ main_program = _get_valid_program(main_program)
+
+ # remind user to set auc_states to zeros if the program contains auc op
+ all_ops = main_program.global_block().ops
+ for op in all_ops:
+ # clear device of Op
+ device_attr_name = core.op_proto_and_checker_maker.kOpDeviceAttrName()
+ op._set_attr(device_attr_name, "")
+ if op.type == 'auc':
+ warnings.warn(
+ "please ensure that you have set the auc states to zeros before saving inference model"
+ )
+ break
+
+ with program_guard(main_program):
+ uniq_target_vars = []
+ for i, var in enumerate(target_vars):
+ uniq_target_vars.append(var)
+ target_vars = uniq_target_vars
+ target_var_name_list = [var.name for var in target_vars]
+
+ # when a pserver and a trainer running on the same machine, mkdir may conflict
+ save_dirname = dirname
+ try:
+ save_dirname = os.path.normpath(dirname)
+ os.makedirs(save_dirname)
+ except OSError as e:
+ if e.errno != errno.EEXIST:
+ raise
+
+ if model_filename is not None:
+ model_basename = os.path.basename(model_filename)
+ else:
+ model_basename = "__model__"
+ model_basename = os.path.join(save_dirname, model_basename)
+
+ # When export_for_deployment is true, we modify the program online so that
+ # it can only be loaded for inference directly. If it's false, the whole
+ # original program and related meta are saved so that future usage can be
+ # more flexible.
+
+ origin_program = main_program.clone()
+
+ if export_for_deployment:
+ main_program = main_program.clone()
+ global_block = main_program.global_block()
+ need_to_remove_op_index = []
+ for i, op in enumerate(global_block.ops):
+ op.desc.set_is_target(False)
+ if op.type == "feed" or op.type == "fetch":
+ need_to_remove_op_index.append(i)
+
+ for index in need_to_remove_op_index[::-1]:
+ global_block._remove_op(index)
+
+ main_program.desc.flush()
+
+ main_program = main_program._prune_with_input(
+ feeded_var_names=feeded_var_names, targets=target_vars)
+ main_program = main_program._inference_optimize(prune_read_op=True)
+ fetch_var_names = [v.name for v in target_vars]
+
+ for target_v in target_vars:
+ if not main_program.global_block().has_var(target_v.name):
+ main_program.global_block().create_var(
+ name=target_v.name,
+ shape=target_v.shape,
+ dtype=target_v.dtype,
+ persistable=target_v.persistable)
+
+ prepend_feed_ops(main_program, feeded_var_names)
+ append_fetch_ops(main_program, fetch_var_names)
+
+ main_program.desc._set_version()
+ paddle.fluid.core.save_op_version_info(main_program.desc)
+ with open(model_basename, "wb") as f:
+ f.write(
+ main_program._remove_training_info(
+ clip_extra=clip_extra).desc.serialize_to_string())
+ else:
+ # TODO(panyx0718): Save more information so that it can also be used
+ # for training and more flexible post-processing.
+ with open(model_basename + ".main_program", "wb") as f:
+ f.write(
+ main_program._remove_training_info(
+ clip_extra=clip_extra).desc.serialize_to_string())
+
+ if program_only:
+ warnings.warn(
+ "save_inference_model specified the param `program_only` to True, It will not save params of Program."
+ )
+ return target_var_name_list
+
+ main_program._copy_dist_param_info_from(origin_program)
+
+ if params_filename is not None:
+ params_filename = os.path.basename(params_filename)
+
+ save_persistables(executor, save_dirname, main_program, params_filename)
+ return target_var_name_list
+
+
+@static_only
+@deprecated(since="2.0.0", update_to="paddle.static.load_inference_model")
+def load_inference_model(dirname,
+ executor,
+ model_filename=None,
+ params_filename=None,
+ pserver_endpoints=None):
+ """
+ Load the inference model from a given directory. By this API, you can get the model
+ structure(Inference Program) and model parameters. If you just want to load
+ parameters of the pre-trained model, please use the :ref:`api_fluid_io_load_params` API.
+ You can refer to :ref:`api_guide_model_save_reader_en` for more details.
+
+ Args:
+ dirname(str): One of the following:
+ - The given directory path.
+ - Set to None when reading the model from memory.
+ executor(Executor): The executor to run for loading inference model.
+ See :ref:`api_guide_executor_en` for more details about it.
+ model_filename(str, optional): One of the following:
+ - The name of file to load the inference program.
+ - If it is None, the default filename ``__model__`` will be used.
+ - When ``dirname`` is ``None``, it must be set to a string containing model.
+ Default: ``None``.
+ params_filename(str, optional): It is only used for the case that all
+ parameters were saved in a single binary file. One of the following:
+ - The name of file to load all parameters.
+ - When ``dirname`` is ``None``, it must be set to a string containing all the parameters.
+ - If parameters were saved in separate files, set it as ``None``.
+ Default: ``None``.
+
+ pserver_endpoints(list, optional): It is only needed by the distributed inference.
+ If using a distributed look up table during the training,
+ this table is also needed by the inference process. Its value is
+ a list of pserver endpoints.
+
+ Returns:
+ list: The return of this API is a list with three elements:
+ (program, feed_target_names, fetch_targets). The `program` is a
+ ``Program`` (refer to :ref:`api_guide_Program_en`), which is used for inference.
+ The `feed_target_names` is a list of ``str``, which contains names of variables
+ that need to feed data in the inference program. The `fetch_targets` is a list of
+ ``Variable`` (refer to :ref:`api_guide_Program_en`). It contains variables from which
+ we can get inference results.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ paddle.enable_static()
+ # Build the model
+ main_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(main_prog, startup_prog):
+ data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
+ w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
+ b = fluid.layers.create_parameter(shape=[200], dtype='float32')
+ hidden_w = fluid.layers.matmul(x=data, y=w)
+ hidden_b = fluid.layers.elementwise_add(hidden_w, b)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(startup_prog)
+
+ # Save the inference model
+ path = "./infer_model"
+ fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
+ target_vars=[hidden_b], executor=exe, main_program=main_prog)
+
+ # Demo one. Not need to set the distributed look up table, because the
+ # training doesn't use a distributed look up table.
+ [inference_program, feed_target_names, fetch_targets] = (
+ fluid.io.load_inference_model(dirname=path, executor=exe))
+ tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
+ results = exe.run(inference_program,
+ feed={feed_target_names[0]: tensor_img},
+ fetch_list=fetch_targets)
+
+ # Demo two. If the training uses a distributed look up table, the pserver
+ # endpoints list should be supported when loading the inference model.
+ # The below is just an example.
+ endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
+ [dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
+ fluid.io.load_inference_model(dirname=path,
+ executor=exe,
+ pserver_endpoints=endpoints))
+
+ # In this example, the inference program was saved in the file
+ # "./infer_model/__model__" and parameters were saved in
+ # separate files under the directory "./infer_model".
+ # By the inference program, feed_target_names and
+ # fetch_targets, we can use an executor to run the inference
+ # program for getting the inference result.
+ """
+ load_from_memory = False
+ if dirname is not None:
+ load_dirname = os.path.normpath(dirname)
+ if not os.path.isdir(load_dirname):
+ raise ValueError("There is no directory named '%s'" % dirname)
+
+ if model_filename is None:
+ model_filename = '__model__'
+
+ model_filename = os.path.join(load_dirname,
+ os.path.basename(model_filename))
+
+ if params_filename is not None:
+ params_filename = os.path.basename(params_filename)
+
+ with open(model_filename, "rb") as f:
+ program_desc_str = f.read()
+ else:
+ load_from_memory = True
+ if params_filename is None:
+ raise ValueError(
+ "The path of params cannot be None when the directory path is None."
+ )
+ load_dirname = dirname
+ program_desc_str = model_filename
+ params_filename = params_filename
+
+ program = Program.parse_from_string(program_desc_str)
+ if not core._is_program_version_supported(program._version()):
+ raise ValueError("Unsupported program version: %d\n" %
+ program._version())
+ # Binary data also need versioning.
+ load_persistables(executor, load_dirname, program, params_filename)
+
+ if pserver_endpoints:
+ program = _endpoints_replacement(program, pserver_endpoints)
+
+ feed_target_names = program.desc.get_feed_target_names()
+ fetch_target_names = program.desc.get_fetch_target_names()
+ fetch_targets = [
+ program.global_block().var(name) for name in fetch_target_names
+ ]
+
+ return [program, feed_target_names, fetch_targets]
+
+
+def _endpoints_replacement(program, endpoints):
+ ENDPOINT_MAP = "epmap"
+ for op in program.global_block().ops:
+ if op.has_attr(ENDPOINT_MAP):
+ op.set_attr(ENDPOINT_MAP, endpoints)
+ program._sync_with_cpp()
+ return program
+
+
+def get_parameter_value(para, executor):
+ """
+ Get the LoDTensor value of the given parameter.
+
+ Args:
+ para(Parameter): The parameter to get value from.
+ executor(Executor): The executor to run for retrieving the value.
+
+ Returns:
+ numpy.array: The given parameter's values.
+
+ Raises:
+ AssertionError: If the `para` is not an instance of Parameter.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ param = fluid.default_main_program().global_block().var('fc.w')
+ p = fluid.io.get_parameter_value(param, exe)
+
+ """
+ assert is_parameter(para), "The input variable is not parameter."
+
+ get_program = Program()
+ block = get_program.global_block()
+ new_var = _clone_var_in_block_(block, para)
+ return executor.run(get_program, feed={}, fetch_list=[new_var])[0]
+
+
+def get_parameter_value_by_name(name, executor, program=None):
+ """
+ Get the LoDTensor value of a certain parameter by its name.
+
+ Args:
+ name(str): The parameter's name.
+ executor(Executor): The executor to run for retrieving the value.
+ program(Program | None): The program where to find the parameter.
+ If it's set to be None, the function will
+ try to find the parameter in the default
+ main program.
+
+ Returns:
+ numpy.array: The parameter's values.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ exe = fluid.Executor(fluid.CPUPlace())
+ p = fluid.io.get_parameter_value('fc.w', exe)
+ """
+ if program is None:
+ program = default_main_program()
+ var = program.global_block().var(name)
+ return get_parameter_value(var, executor)
+
+
+def _save_persistable_nodes(executor, dirname, graph):
+ """
+ Save persistable nodes to the given directory by the executor.
+
+ Args:
+ executor(Executor): The executor to run for saving node values.
+ dirname(str): The directory path.
+ graph(IrGraph): All the required persistable nodes in the graph will be saved.
+ """
+ persistable_node_names = set()
+ persistable_nodes = []
+ all_persistable_nodes = graph.all_persistable_nodes()
+ for node in all_persistable_nodes:
+ name = cpt.to_text(node.name())
+ if name not in persistable_node_names:
+ persistable_node_names.add(name)
+ persistable_nodes.append(node)
+ program = Program()
+ var_list = []
+ for node in persistable_nodes:
+ var_desc = node.var()
+ if var_desc.type() == core.VarDesc.VarType.RAW or \
+ var_desc.type() == core.VarDesc.VarType.READER:
+ continue
+ var = program.global_block().create_var(
+ name=var_desc.name(),
+ shape=var_desc.shape(),
+ dtype=var_desc.dtype(),
+ type=var_desc.type(),
+ lod_level=var_desc.lod_level(),
+ persistable=var_desc.persistable())
+ var_list.append(var)
+ save_vars(executor=executor, dirname=dirname, vars=var_list)
+
+
+def _load_persistable_nodes(executor, dirname, graph):
+ """
+ Load persistable node values from the given directory by the executor.
+
+ Args:
+ executor(Executor): The executor to run for loading node values.
+ dirname(str): The directory path.
+ graph(IrGraph): All the required persistable nodes in the graph will be loaded.
+ """
+ persistable_node_names = set()
+ persistable_nodes = []
+ all_persistable_nodes = graph.all_persistable_nodes()
+ for node in all_persistable_nodes:
+ name = cpt.to_text(node.name())
+ if name not in persistable_node_names:
+ persistable_node_names.add(name)
+ persistable_nodes.append(node)
+ program = Program()
+ var_list = []
+
+ def _exist(var):
+ return os.path.exists(os.path.join(dirname, var.name))
+
+ for node in persistable_nodes:
+ var_desc = node.var()
+ if var_desc.type() == core.VarDesc.VarType.RAW or \
+ var_desc.type() == core.VarDesc.VarType.READER:
+ continue
+ var = program.global_block().create_var(
+ name=var_desc.name(),
+ shape=var_desc.shape(),
+ dtype=var_desc.dtype(),
+ type=var_desc.type(),
+ lod_level=var_desc.lod_level(),
+ persistable=var_desc.persistable())
+ if _exist(var):
+ var_list.append(var)
+ else:
+ _logger.warn("Cannot find the var %s!!!" % (node.name()))
+ load_vars(executor=executor, dirname=dirname, vars=var_list)
+
+
+def _unpack_saved_dict(saved_obj, protocol):
+ temp_saved_obj = {}
+ unpack_infor = {}
+ # When pickle protocol=2 or protocol=3 the serialized object cannot be larger than 4G.
+ if 1 < protocol < 4:
+ if isinstance(saved_obj, dict):
+ for key, value in saved_obj.items():
+ if isinstance(value, np.ndarray):
+ MAX_NUMBER_OF_ELEMENT = int(
+ (2**30 - 1) / value.dtype.itemsize)
+ num_element = np.prod(value.shape)
+ if num_element > MAX_NUMBER_OF_ELEMENT:
+ unpack_infor[key] = {}
+ unpack_infor[key]["OriginShape"] = value.shape
+ unpack_infor[key]["slices"] = []
+ value = value.flatten()
+ for i in range(
+ int(
+ math.ceil(num_element * 1.0 /
+ MAX_NUMBER_OF_ELEMENT))):
+ part_name = key + "@@." + str(i)
+ unpack_infor[key]["slices"].append(part_name)
+ temp_saved_obj[part_name] = value[
+ i *
+ MAX_NUMBER_OF_ELEMENT:MAX_NUMBER_OF_ELEMENT *
+ (i + 1)]
+
+ if unpack_infor:
+ for key, value in unpack_infor.items():
+ if key in saved_obj:
+ saved_obj.pop(key)
+ for part in value['slices']:
+ saved_obj[part] = temp_saved_obj[part]
+ saved_obj['UnpackBigParamInfor@@'] = unpack_infor
+ return saved_obj
+
+
+def _pack_loaded_dict(load_obj):
+ if isinstance(load_obj, dict):
+ unpack_info = 'UnpackBigParamInfor@@'
+ if unpack_info in load_obj:
+ removes = []
+ for key, value in load_obj[unpack_info].items():
+ slices = [load_obj[part] for part in value["slices"]]
+ load_obj[key] = np.concatenate(slices).reshape(
+ value["OriginShape"])
+ removes += value["slices"]
+ for key in removes:
+ load_obj.pop(key)
+ load_obj.pop(unpack_info)
+
+ return load_obj
+
+
+@static_only
+def _legacy_save(param_dict, model_path, protocol=2):
+
+ def get_tensor(var):
+ if isinstance(var, (core.VarBase, core.eager.Tensor)):
+ return var.numpy()
+ elif isinstance(var, core.LoDTensor):
+ return np.array(var)
+ return var
+
+ param_dict = {name: get_tensor(param_dict[name]) for name in param_dict}
+
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if _is_file_path(
+ model_path
+ ) and sys.platform == 'darwin' and sys.version_info.major == 3:
+ pickle_bytes = pickle.dumps(param_dict, protocol=protocol)
+ with open(model_path, 'wb') as f:
+ max_bytes = 2**30
+ for i in range(0, len(pickle_bytes), max_bytes):
+ f.write(pickle_bytes[i:i + max_bytes])
+ else:
+ with _open_file_buffer(model_path, 'wb') as f:
+ pickle.dump(param_dict, f, protocol=protocol)
+
+
+@static_only
+def save(program, model_path, protocol=4, **configs):
+ """
+
+ This function save parameters, optimizer information and network description to model_path.
+
+ The parameters contains all the trainable Tensor, will save to a file with suffix ".pdparams".
+ The optimizer information contains all the Tensor used by optimizer. For Adam optimizer, contains beta1, beta2, momentum etc. All the information will save to a file with suffix ".pdopt". (If the optimizer have no Tensor need to save (like SGD), the fill will not generated).
+ The network description is the description of the program. It's only used for deployment. The description will save to a file with a suffix ".pdmodel".
+
+ Args:
+ program(Program) : The program to saved.
+ model_path(str): the file prefix to save the program. The format is "dirname/file_prefix". If file_prefix is empty str. A exception will be raised
+ protocol(int, optional): The protocol version of pickle module must be greater than 1 and less than 5.
+ Default: 4
+ configs(dict, optional) : optional keyword arguments.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ x = static.data(name="x", shape=[10, 10], dtype='float32')
+ y = static.nn.fc(x, 10)
+ z = static.nn.fc(y, 10)
+
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+ prog = static.default_main_program()
+
+ static.save(prog, "./temp")
+ """
+
+ base_name = os.path.basename(model_path)
+ assert base_name != "", \
+ "The input model_path MUST be format of dirname/filename [dirname\\filename in Windows system], but received model_path is empty string."
+ if 'pickle_protocol' in configs:
+ protocol = configs['pickle_protocol']
+ warnings.warn(
+ "'pickle_protocol' is a deprecated argument. Please use 'protocol' instead."
+ )
+
+ if not isinstance(protocol, int):
+ raise ValueError("The 'protocol' MUST be `int`, but received {}".format(
+ type(protocol)))
+
+ if protocol < 2 or protocol > 4:
+ raise ValueError(
+ "Expected 1<'protocol'<5, but received protocol={}".format(
+ protocol))
+
+ dir_name = os.path.dirname(model_path)
+ if dir_name and not os.path.exists(dir_name):
+ os.makedirs(dir_name)
+
+ def get_tensor(var):
+ t = global_scope().find_var(var.name).get_tensor()
+ return np.array(t)
+
+ parameter_list = list(filter(is_parameter, program.list_vars()))
+ param_dict = {p.name: get_tensor(p) for p in parameter_list}
+
+ param_dict = _unpack_saved_dict(param_dict, protocol)
+
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if sys.platform == 'darwin' and sys.version_info.major == 3:
+ pickle_bytes = pickle.dumps(param_dict, protocol=protocol)
+ with open(model_path + ".pdparams", 'wb') as f:
+ max_bytes = 2**30
+ for i in range(0, len(pickle_bytes), max_bytes):
+ f.write(pickle_bytes[i:i + max_bytes])
+ else:
+ with open(model_path + ".pdparams", 'wb') as f:
+ pickle.dump(param_dict, f, protocol=protocol)
+
+ optimizer_var_list = list(
+ filter(is_belong_to_optimizer, program.list_vars()))
+
+ opt_dict = {p.name: get_tensor(p) for p in optimizer_var_list}
+ with open(model_path + ".pdopt", 'wb') as f:
+ pickle.dump(opt_dict, f, protocol=protocol)
+
+ main_program = program.clone()
+ program.desc.flush()
+ main_program.desc._set_version()
+ paddle.fluid.core.save_op_version_info(program.desc)
+
+ with open(model_path + ".pdmodel", "wb") as f:
+ f.write(program.desc.serialize_to_string())
+
+
+def _pickle_loads_mac(path, f):
+ pickle_bytes = bytearray(0)
+ file_size = os.path.getsize(path)
+ max_bytes = 2**30
+ for _ in range(0, file_size, max_bytes):
+ pickle_bytes += f.read(max_bytes)
+ load_result = pickle.loads(pickle_bytes, encoding='latin1')
+ return load_result
+
+
+@static_only
+def load(program, model_path, executor=None, var_list=None):
+ """
+ :api_attr: Static Graph
+
+ This function get parameters and optimizer information from program, and then get corresponding value from file.
+ An exception will throw if shape or dtype of the parameters is not match.
+
+ This function can also load model file saved with [ save_params, save_persistables, save_vars ].
+ var_list can not be None when load single model file
+ ( filename is not None When save_params, save_persistables or save_vars is called ).
+
+ Args:
+ program(Program): The program will be loaded
+ model_path(str): The file prefix store the program
+ executor(Executor, optional): The executor used for initialize the parameter
+ When startup program is not run.
+ var_list(list|tuple, optional): The Tensor list/tuple to load single model file saved with
+ [ save_params, save_persistables, save_vars ].
+ Default: None
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ x = static.data(name="x", shape=[10, 10], dtype='float32')
+ y = static.nn.fc(x, 10)
+ z = static.nn.fc(y, 10)
+
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+ prog = static.default_main_program()
+
+ static.save(prog, "./temp")
+ static.load(prog, "./temp")
+ """
+
+ assert executor is None or isinstance(executor, Executor)
+
+ model_prefix = model_path
+ if model_prefix.endswith(".pdparams"):
+ model_prefix = model_prefix[:-9]
+ elif model_prefix.endswith(".pdopt"):
+ model_prefix = model_prefix[:-6]
+ elif model_prefix.endswith(".pdmodel"):
+ model_prefix = model_prefix[:-8]
+
+ parameter_file_name = model_prefix + ".pdparams"
+
+ if not os.path.exists(parameter_file_name):
+ # model file save by fluid.save not found, try to load model file saved with
+ # [save_vars, save_params, save_persistables]
+ _logger.debug(
+ "{} not found, try to load model file saved with [ save_params, save_persistables, save_vars ]"
+ .format(parameter_file_name))
+ if executor is None:
+ raise ValueError(
+ "executor is required when loading model file saved with [ save_params, save_persistables, save_vars ]"
+ )
+
+ if var_list is not None:
+ var_list_names = [var.name for var in var_list]
+ else:
+ var_list_names = None
+
+ if os.path.isdir(model_path):
+ binary_file_set = set()
+ for root, dirs, files in os.walk(model_path, topdown=False):
+ for f in files:
+ binary_file_set.add(
+ os.path.join(root, f).replace("\\", "/"))
+ program_var_list = list(program.list_vars())
+ loaded_var_list = []
+ for var in program_var_list:
+ var_path = os.path.join(model_path, var.name).replace("\\", "/")
+ load_condition = var_list_names is None or var.name in var_list_names
+ if var_path in binary_file_set and load_condition:
+ loaded_var_list.append(var)
+ binary_file_set.remove(var_path)
+ if len(binary_file_set) > 0:
+ unused_var_list = " ".join(list(binary_file_set))
+ _logger.warning("variable file [ %s ] not used" %
+ (" ".join(list(binary_file_set))))
+ try:
+ load_vars(executor=executor,
+ dirname=model_path,
+ vars=loaded_var_list)
+ except RuntimeError as e:
+ _logger.error(e)
+ raise e
+ except:
+ raise RuntimeError(
+ "Failed to load model file, please make sure model file is saved with the "
+ "following APIs: save_params, save_persistables, save_vars")
+
+ return
+ elif os.path.isfile(model_path):
+ if var_list == None:
+ raise ValueError(
+ "var_list is required when loading model file saved with [ save_params, save_persistables, save_vars ]"
+ )
+ program_var_list = program.list_vars()
+ program_var_name_set = set([var.name for var in program_var_list])
+
+ # check all the variable inlcuded in program
+ for var in var_list:
+ if var.name not in program_var_name_set:
+ raise LookupError(
+ "loaded var [{}] is not in program variable list")
+
+ dir_name, file_name = os.path.split(model_path)
+ try:
+ load_vars(executor=executor,
+ dirname=dir_name,
+ vars=var_list,
+ filename=file_name)
+ except RuntimeError as e:
+ _logger.error(e)
+ raise e
+ except:
+ raise RuntimeError("Failed to load model file , please make sure model file is saved with the " \
+ "the following APIs: [ save_params, save_persistables, save_vars ]. " \
+ "When these API called, filename CANNOT be None")
+
+ return
+
+ def set_var(var, ndarray):
+ t = global_scope().find_var(var.name).get_tensor()
+ p = t._place()
+ if p.is_cpu_place():
+ place = paddle.fluid.CPUPlace()
+ elif p.is_cuda_pinned_place():
+ place = paddle.fluid.CUDAPinnedPlace()
+ elif p.is_xpu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(t._place())
+ place = paddle.fluid.XPUPlace(p.xpu_device_id())
+ elif p.is_npu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(t._place())
+ place = paddle.fluid.NPUPlace(p.npu_device_id())
+ elif p.is_mlu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(t._place())
+ place = paddle.fluid.MLUPlace(p.mlu_device_id())
+ else:
+ p = paddle.fluid.core.Place()
+ p.set_place(t._place())
+ place = paddle.fluid.CUDAPlace(p.gpu_device_id())
+
+ t.set(ndarray, place)
+
+ parameter_list = list(filter(is_parameter, program.list_vars()))
+
+ if executor:
+ paddle.fluid.core._create_loaded_parameter(parameter_list,
+ global_scope(),
+ executor._default_executor)
+ with open(parameter_file_name, 'rb') as f:
+
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if sys.platform == 'darwin' and sys.version_info.major == 3:
+ load_dict = _pickle_loads_mac(parameter_file_name, f)
+ else:
+ load_dict = pickle.load(f, encoding='latin1')
+ load_dict = _pack_loaded_dict(load_dict)
+ for v in parameter_list:
+ assert v.name in load_dict, \
+ "Can not find [{}] in model file [{}]".format(
+ v.name, parameter_file_name)
+ set_var(v, load_dict[v.name])
+
+ optimizer_var_list = list(
+ filter(is_belong_to_optimizer, program.list_vars()))
+
+ if len(optimizer_var_list) > 0:
+ opt_file_name = model_prefix + ".pdopt"
+ assert os.path.exists(opt_file_name), \
+ "Optimizer file [{}] not exits".format(opt_file_name)
+
+ if executor:
+ paddle.fluid.core._create_loaded_parameter(
+ optimizer_var_list, global_scope(), executor._default_executor)
+
+ with open(opt_file_name, 'rb') as f:
+ load_dict = pickle.load(f, encoding='latin1')
+ for v in optimizer_var_list:
+ assert v.name in load_dict, \
+ "Can not find [{}] in model file [{}]".format(
+ v.name, opt_file_name)
+ set_var(v, load_dict[v.name])
+
+
+def load_program_state(model_path, var_list=None):
+ """
+
+ Load program state from local file
+
+ Args:
+ model_path(str): The file prefix store the program
+ var_list(list|tuple, optional): The Tensor list/tuple to load saved with
+ [ save_params, save_persistables, save_vars ].
+ Default: None.
+ The var_list is only used to get name,
+ will not be modified.
+ Returns:
+ state_dict(dict): the dict store Parameter and optimizer information
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ x = static.data(name="x", shape=[10, 10], dtype='float32')
+ y = static.nn.fc(x, 10)
+ z = static.nn.fc(y, 10)
+
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+ prog = static.default_main_program()
+
+ static.save(prog, "./temp")
+ program_state = static.load_program_state("./temp")
+ """
+ model_prefix = model_path
+ if model_prefix.endswith(".pdparams"):
+ model_prefix = model_prefix[:-9]
+ elif model_prefix.endswith(".pdopt"):
+ model_prefix = model_prefix[:-6]
+ elif model_prefix.endswith(".pdmodel"):
+ model_prefix = model_prefix[:-8]
+
+ parameter_file_name = model_prefix + ".pdparams"
+ if not os.path.exists(parameter_file_name):
+ # model file saved with fluid.save is not found, try to load model file saved with
+ # [save_vars, save_params, save_persistables]
+ _logger.debug(
+ "{} not found, try to load model file saved with [ save_params, save_persistables, save_vars ]"
+ .format(parameter_file_name))
+
+ var_name_list = []
+ if var_list is None and os.path.isfile(model_path):
+ raise ValueError(
+ "var_list can not be None when model_path is a file type")
+
+ for root, dirs, files in os.walk(model_path, topdown=False):
+ for f in files:
+ file_path = os.path.join(root, f)
+ var_temp_name = os.path.relpath(file_path, model_path)
+ var_temp_name = var_temp_name.replace("\\", "/")
+ var_name_list.append(var_temp_name)
+
+ with _load_program_scope():
+ load_prog = Program()
+ load_block = load_prog.global_block()
+
+ def clone_var_to_block(block, var):
+ if not isinstance(var, Variable):
+ raise TypeError("value in var_list must be variable")
+ return block.create_var(
+ name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ lod_level=var.lod_level if var.desc.type()
+ == core.VarDesc.VarType.LOD_TENSOR else None,
+ persistable=True)
+
+ def _load_vars_with_try_catch(exe,
+ dirname,
+ vars,
+ filename,
+ raise_error=True):
+ try:
+ load_vars(executor=exe,
+ dirname=dirname,
+ vars=vars,
+ filename=filename)
+ return True
+ except:
+ error_str = "Failed to load model/variables `%s`, please make sure " \
+ "model/variables file is saved with the following APIs: " \
+ "save_params, save_persistables, save_vars."
+ filenames = [var.name for var in vars
+ ] if filename is None else filename
+ if raise_error:
+ raise RuntimeError(error_str % filenames)
+ else:
+ warnings.warn(error_str % filenames, RuntimeWarning)
+ return False
+
+ place = paddle.fluid.CPUPlace()
+ exe = paddle.fluid.Executor(place)
+
+ loaded_var_list = []
+
+ if os.path.isfile(model_path):
+ # when model_path is file, var_list cannot be None
+ dir_name, file_name = os.path.split(model_path)
+ for var in var_list:
+ loaded_var_list.append(clone_var_to_block(load_block, var))
+ _load_vars_with_try_catch(exe, dir_name, loaded_var_list,
+ file_name)
+ else:
+ # var_list can be None or not None
+ if var_list is not None:
+ for var in var_list:
+ loaded_var_list.append(
+ clone_var_to_block(load_block, var))
+ _load_vars_with_try_catch(exe, model_path, loaded_var_list,
+ None)
+ else:
+ for var_name in var_name_list:
+ # NOTE(chenweihang): If identify which files the user wants
+ # to load from the disk, we load these variables one by one.
+ # If a file does not exist, we only warn the user that the
+ # file may be an irrelevant file, but does not throw an error
+ # to ensure that other legal variables can be loaded.
+ temp_var = load_block.create_var(name=var_name,
+ persistable=True)
+ if _load_vars_with_try_catch(exe, model_path,
+ [temp_var], None, False):
+ loaded_var_list.append(temp_var)
+
+ res_dict = {}
+ for var in loaded_var_list:
+ res_dict[var.name] = np.asarray(
+ paddle.fluid.global_scope().find_var(var.name).get_tensor())
+
+ return res_dict
+
+ assert os.path.exists(parameter_file_name), \
+ "Parameter file [{}] not exits".format(parameter_file_name)
+
+ with open(parameter_file_name, 'rb') as f:
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if sys.platform == 'darwin' and sys.version_info.major == 3:
+ para_dict = _pickle_loads_mac(parameter_file_name, f)
+ else:
+ para_dict = pickle.load(f, encoding='latin1')
+ para_dict = _pack_loaded_dict(para_dict)
+
+ opt_file_name = model_prefix + ".pdopt"
+ if os.path.exists(opt_file_name):
+ with open(opt_file_name, 'rb') as f:
+ opti_dict = pickle.load(f, encoding='latin1')
+
+ para_dict.update(opti_dict)
+
+ return para_dict
+
+
+@static_only
+def set_program_state(program, state_dict):
+ """
+ Set program parameter from state_dict
+
+ An exception will throw if shape or dtype of the parameters is not match.
+
+ NOTICE: This function MUST called after run start_up_program
+
+ Args:
+ program(Program): The program to be set
+ state_dict(dict): the dict store Parameter and optimizer information
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ x = static.data(name="x", shape=[10, 10], dtype='float32')
+ y = static.nn.fc(x, 10)
+ z = static.nn.fc(y, 10)
+
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+ prog = static.default_main_program()
+
+ static.save(prog, "./temp")
+ program_state = static.load_program_state("./temp")
+
+ static.set_program_state(prog, program_state)
+ """
+ state_dict = _pack_loaded_dict(state_dict)
+ parameter_list = list(filter(is_persistable, program.list_vars()))
+
+ used_para_list = {}
+ for para in parameter_list:
+ var_temp = paddle.fluid.global_scope().find_var(para.name)
+ assert var_temp != None, \
+ "Variable [ {} ] Not found, Please make sure run startup program".format(para.name)
+ if para.name in state_dict:
+ # set value from state dict
+ orig_para_np = np.array(var_temp.get_tensor())
+ new_para_np = state_dict[para.name]
+ assert orig_para_np.shape == new_para_np.shape, \
+ "Parameter's shape does not match, the Program requires a parameter with the shape of ({}), " \
+ "while the loaded parameter (namely [ {} ]) has a shape of ({})." \
+ .format(orig_para_np.shape, para.name, new_para_np.shape)
+ assert orig_para_np.dtype == new_para_np.dtype, \
+ "Parameter's data type does not match, the Program requires a parameter with a dtype of ({}), " \
+ "while the loaded parameter (namely [ {} ]) has a dtype of ({})." \
+ .format(orig_para_np.dtype, para.name, new_para_np.dtype)
+
+ ten = var_temp.get_tensor()
+ ten_place = ten._place()
+
+ #assert ten_place.is_gpu_place() or ten_place.is_cpu_place(), \
+ # "Place not support, only support CPUPlace and GPUPlace, now is {}".format(str(ten_place))
+ py_place = paddle.fluid.CPUPlace()
+ if ten_place.is_cuda_pinned_place():
+ place = paddle.fluid.CUDAPinnedPlace()
+ elif ten_place.is_gpu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(ten_place)
+ py_place = paddle.fluid.CUDAPlace(p.gpu_device_id())
+ elif ten_place.is_xpu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(ten_place)
+ py_place = paddle.fluid.XPUPlace(p.xpu_device_id())
+ elif ten_place.is_npu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(ten_place)
+ py_place = paddle.fluid.NPUPlace(p.npu_device_id())
+ elif ten_place.is_mlu_place():
+ p = paddle.fluid.core.Place()
+ p.set_place(ten_place)
+ py_place = paddle.fluid.MLUPlace(p.mlu_device_id())
+
+ ten.set(new_para_np, py_place)
+
+ used_para_list[para.name] = 1
+
+ unused_para_list = []
+ for k, v in state_dict.items():
+ if k not in used_para_list:
+ unused_para_list.append(k)
+ if len(unused_para_list) > 0:
+ warnings.warn(
+ "This list is not set, Because of Paramerter not found in program. There are: {}"
+ .format(" ".join(unused_para_list)))
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/ir.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/ir.py
new file mode 100644
index 0000000000000000000000000000000000000000..aca134a1df55a9982a3779e03313481cce712e5f
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/ir.py
@@ -0,0 +1,560 @@
+# Copyright (c) 2021 PaddlePaddle 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 copy
+import inspect
+from os import path
+import paddle
+from . import core, unique_name
+from .framework import _apply_pass, OpProtoHolder
+
+from .proto import framework_pb2
+try:
+ from .proto import pass_desc_pb2
+except ModuleNotFoundError:
+ import sys
+ sys.path.append(path.join(path.dirname(__file__), 'proto'))
+ from .proto import pass_desc_pb2
+
+
+def get_data_vars(program):
+ data_vars = []
+ for var_name, var in program.global_block().vars.items():
+ if var.is_data:
+ data_vars.append(var_name)
+ return data_vars
+
+
+def _update_grad_persistable(main_program):
+ grad_merge_attr_name = "grad_merge_cond_name"
+ op_role_var_attr_name = core.op_proto_and_checker_maker.kOpRoleVarAttrName()
+ has_grad_merge = False
+ has_persistable_grad_var = False
+ grad_vars = []
+ for block_id in range(main_program.num_blocks):
+ block = main_program.block(block_id)
+ for op in block.ops:
+ if grad_merge_attr_name in op.attr_names:
+ has_grad_merge = True
+
+ if op_role_var_attr_name not in op.attr_names:
+ continue
+
+ p_g = op.attr(op_role_var_attr_name)
+ for g in p_g[1::2]:
+ g_var = block._find_var_recursive(g)
+ if g_var is None:
+ continue
+ grad_vars.append(g_var)
+ if g_var.persistable:
+ has_persistable_grad_var = True
+
+ if has_grad_merge and has_persistable_grad_var:
+ for g_var in grad_vars:
+ g_var.persistable = True
+
+
+def apply_build_strategy(main_program, startup_program, build_strategy,
+ pass_attrs):
+
+ def update_attr(attrs, attr_types, name, value, typ=None):
+ if name not in attrs:
+ attrs[name] = value
+ if typ:
+ attr_types[name] = typ
+
+ def apply_pass(name):
+ attrs = dict(pass_attrs)
+ attr_types = {}
+ update_attr(attrs, attr_types, "nranks", 1, "size_t")
+ update_attr(attrs, attr_types, "use_cuda", False, "bool")
+ # TODO(zjl): how to skip fetch variables ?
+ update_attr(attrs, attr_types, "mem_opt_skip_vars",
+ get_data_vars(main_program), "list[str]")
+ _apply_pass(main_program, startup_program, name, attrs, attr_types)
+
+ _update_grad_persistable(main_program)
+ use_cuda = pass_attrs.get("use_cuda", False)
+ build_strategy = build_strategy._copy()
+ if build_strategy.sync_batch_norm:
+ apply_pass("sync_batch_norm_pass")
+ build_strategy.sync_batch_norm = False
+ if build_strategy.fuse_relu_depthwise_conv and use_cuda:
+ apply_pass("fuse_relu_depthwise_conv_pass")
+ build_strategy.fuse_relu_depthwise_conv = False
+ if build_strategy.fuse_bn_act_ops and use_cuda:
+ apply_pass("fuse_bn_act_pass")
+ build_strategy.fuse_bn_act_ops = False
+ if build_strategy.fuse_bn_add_act_ops and use_cuda:
+ apply_pass("fuse_bn_add_act_pass")
+ build_strategy.fuse_bn_add_act_ops = False
+ if build_strategy.enable_auto_fusion and use_cuda:
+ apply_pass("fusion_group_pass")
+ build_strategy.enable_auto_fusion = False
+ if build_strategy.fuse_gemm_epilogue:
+ apply_pass("fuse_gemm_epilogue_pass")
+ build_strategy.fuse_gemm_epilogue = False
+ if build_strategy.fuse_elewise_add_act_ops:
+ apply_pass("fuse_elewise_add_act_pass")
+ build_strategy.fuse_elewise_add_act_ops = False
+ if build_strategy.fuse_all_optimizer_ops:
+ apply_pass([
+ "coalesce_grad_tensor_pass",
+ "fuse_adam_op_pass",
+ "fuse_sgd_op_pass",
+ "fuse_momentum_op_pass",
+ ])
+ build_strategy.fuse_all_optimizer_ops = False
+ # TODO(zjl): support fuse all reduce ops
+ if build_strategy.cache_runtime_context:
+ apply_pass("runtime_context_cache_pass")
+ build_strategy.cache_runtime_context = False
+ if build_strategy.enable_addto and use_cuda:
+ # NOTE: how to get fetch vars to skip memory optimization?
+ apply_pass("inplace_addto_op_pass")
+ build_strategy.enable_addto = False
+ if build_strategy.enable_inplace:
+ apply_pass("buffer_shared_inplace_pass")
+ build_strategy.enable_inplace = False
+ build_strategy._clear_finalized()
+ return build_strategy
+
+
+class RegisterPassHelper(object):
+ _register_helpers = list()
+
+ def __init__(self, pass_pairs, pass_type=str(), input_specs=dict()):
+ self._pass_type = pass_type
+ self._pass_pairs = pass_pairs
+ self._input_specs = input_specs
+ RegisterPassHelper._register_helpers.append(self)
+
+ def _get_args_from_func(self, func):
+ args = list()
+ arg_specs = inspect.getfullargspec(func)
+ for arg_name in arg_specs.args:
+ input_spec = self._input_specs.get(arg_name)
+ if isinstance(input_spec, paddle.static.InputSpec):
+ args.append(
+ PassDesc.VarHelper(arg_name, input_spec.shape,
+ input_spec.dtype))
+ elif isinstance(input_spec, paddle.ParamAttr):
+ args.append(paddle.ParamAttr(arg_name))
+ else:
+ args.append(PassDesc.VarHelper(arg_name, [-1]))
+ return args
+
+ def _prune_program_desc(self, ops):
+ for op_desc in ops:
+ default_attrs = core.get_op_attrs_default_value(
+ paddle.compat.to_bytes(op_desc.type))
+ remove_attrs = list()
+ for attr in op_desc.attrs:
+ # attr must not in
+ if attr.name not in [
+ "op_namescope", "op_callstack", "op_device"
+ ]:
+ attr_list_fields = attr.ListFields()
+ # attr format must be: name, type, value
+ if len(attr_list_fields) == 3:
+ attr_value = attr.ListFields()[-1][-1]
+ default_attr_value = default_attrs.get(attr.name)
+ # value must not default
+ if default_attr_value != attr_value:
+ continue
+ remove_attrs.append(attr)
+ for attr in remove_attrs:
+ op_desc.attrs.remove(attr)
+
+ def _func_to_program_desc(self, func, ops):
+ vars = list()
+ program = paddle.static.Program()
+ startup_program = paddle.static.Program()
+ with paddle.static.program_guard(program, startup_program):
+ args = self._get_args_from_func(func)
+ vars.extend(args)
+ outs = func(*args)
+ if not isinstance(outs, (list, tuple)):
+ outs = [outs]
+ for out in outs:
+ if isinstance(out, PassDesc.OpHelper):
+ op_outs = out.Outputs()
+ if len(op_outs) != 1:
+ raise ValueError(
+ "Operator '{}' has multiple outputs, please specify one output variable."
+ .format(out._type))
+ for op_out in op_outs.values():
+ vars.extend(op_out)
+ else:
+ vars.append(out)
+ block_desc = program.current_block().desc
+ for i in range(block_desc.op_size()):
+ ops.add().ParseFromString(block_desc.op(i).serialize_to_string())
+ self._prune_program_desc(ops)
+ return vars, program.current_block().ops
+
+ def _convert_vars_to_pass_desc(self, patterns, replaces, desc):
+
+ def _add_element_conditions(conditions, elements):
+ for element in elements:
+ if element._condition:
+ conditions.append(element._condition)
+ _add_element_conditions(conditions, element._elements)
+
+ for (pattern, replace) in zip(patterns, replaces):
+ # Convert maps of inputs and outputs.
+ var_map = desc.var_maps.add()
+ var_map.pattern_var = pattern.name
+ var_map.replace_var = replace.name
+ conditions = desc.var_attr_conditions
+ # Convert shape condition.
+ if pattern.name in self._input_specs:
+ condition = conditions.add()
+ pattern.Attr("shape")._to_pass_desc_attr(condition.attr)
+ condition.condition_value.name = ""
+ condition.condition_value.type = framework_pb2.AttrType.LONGS
+ condition.condition_value.longs.extend(pattern.shape)
+ condition.type = pass_desc_pb2.PassDesc.ConditionType.kEQ
+ # Convert attr conditions.
+ if PassDesc.VarHelper == pattern.__class__:
+ for attr in pattern._attrs.values():
+ _add_element_conditions(conditions, [attr])
+
+ def _convert_ops_to_pass_desc(self, patterns, replaces, desc):
+ for replace in replaces:
+ if isinstance(replace, PassDesc.OpHelper):
+ for attr in replace._attrs.values():
+ # Convert attr maps.
+ mapped = attr._mapped
+ if inspect.isfunction(mapped):
+ mapped = mapped(patterns)
+ attr_map = desc.op_attr_maps.add()
+ mapped._to_pass_desc_attr(attr_map.pattern_attr)
+ attr._to_pass_desc_attr(attr_map.replace_attr)
+ if mapped._operation is not None:
+ attr_map.operation.CopyFrom(mapped._operation)
+
+ def SerializeMultiPassDesc(self):
+ switch_static_mode = paddle.in_dynamic_mode()
+ if switch_static_mode:
+ paddle.enable_static()
+ multi_pass_desc = pass_desc_pb2.MultiPassDesc()
+ multi_pass_desc.pass_type = self._pass_type
+ # Traverse all pass pairs and convert them to PassDesc data.
+ # Here need to add cache in the future.
+ for (pattern, replace) in self._pass_pairs:
+ pass_desc = multi_pass_desc.pass_descs.add()
+ # Convert ProgramDescs of pattern and replace subgraphs.
+ pattern_vars, pattern_ops = self._func_to_program_desc(
+ pattern, pass_desc.pattern)
+ replace_vars, replace_ops = self._func_to_program_desc(
+ replace, pass_desc.replace)
+ self._convert_vars_to_pass_desc(pattern_vars, replace_vars,
+ pass_desc)
+ self._convert_ops_to_pass_desc(pattern_ops, replace_ops, pass_desc)
+ if switch_static_mode:
+ paddle.disable_static()
+ return multi_pass_desc.SerializeToString()
+
+
+class PassDesc(object):
+
+ class AttrHelper(object):
+
+ def __init__(self, obj, name, element_index=None):
+ self._obj = obj
+ self._name = name
+ self._operation_type = None
+ self._element_index = element_index
+ self._elements = list()
+ self._operation = None
+ self._condition = None
+ self._mapped = None
+
+ def __getitem__(self, index):
+ element = PassDesc.AttrHelper(self._obj,
+ self._name,
+ element_index=index)
+ self._elements.append(element)
+ return element
+
+ def _to_pass_desc_attr(self, pass_desc_attr):
+ if isinstance(self._obj, PassDesc.VarHelper):
+ pass_desc_attr.role = pass_desc_pb2.PassDesc.RoleType.kVariable
+ pass_desc_attr.var_name = self._obj.name
+ else:
+ pass_desc_attr.role = pass_desc_pb2.PassDesc.RoleType.kOperator
+ pass_desc_attr.op_index = self._obj._index
+ pass_desc_attr.name = self._name
+ if self._operation_type is not None:
+ pass_desc_attr.operation = self._operation_type
+ if self._element_index is not None:
+ pass_desc_attr.element_index = self._element_index
+
+ def _to_op_desc_attr(self, value, op_desc_attr):
+ op_desc_attr.name = ""
+ if isinstance(value, int):
+ op_desc_attr.type = framework_pb2.AttrType.INT
+ op_desc_attr.i = value
+ else:
+ raise NotImplementedError("Unimplemented transform operation.")
+
+ def _clone_with_operation(self, type, value=None):
+ attr = PassDesc.AttrHelper(self._obj, self._name,
+ self._element_index)
+ self._elements.append(attr)
+ if value is None:
+ attr._operation_type = type
+ return attr
+ operation = pass_desc_pb2.PassDesc.Operation()
+ operation.type = type
+ if isinstance(value, PassDesc.AttrHelper):
+ value._to_pass_desc_attr(operation.attr)
+ else:
+ self._to_op_desc_attr(value, operation.value)
+ attr._operation = operation
+ attr._operation_type = self._operation_type
+ return attr
+
+ def __sub__(self, value):
+ return self._clone_with_operation(
+ pass_desc_pb2.PassDesc.OperationType.kSub, value)
+
+ def __add__(self, value):
+ return self._clone_with_operation(
+ pass_desc_pb2.PassDesc.OperationType.kAdd, value)
+
+ def Mod(self, value):
+ return self._clone_with_operation(
+ pass_desc_pb2.PassDesc.OperationType.kMod, value)
+
+ def Size(self):
+ return self._clone_with_operation(
+ pass_desc_pb2.PassDesc.OperationType.kSize)
+
+ def _set_with_condition(self, type, value):
+ condition = pass_desc_pb2.PassDesc.AttrCondition()
+ self._to_pass_desc_attr(condition.attr)
+ condition.type = type
+ if isinstance(value, PassDesc.AttrHelper):
+ value._to_pass_desc_attr(condition.condition_attr)
+ else:
+ self._to_op_desc_attr(value, condition.condition_value)
+ if self._operation:
+ condition.operation.CopyFrom(self._operation)
+ self._condition = condition
+
+ def EQ(self, value):
+ self._set_with_condition(pass_desc_pb2.PassDesc.ConditionType.kEQ,
+ value)
+
+ def MappedPattern(self,
+ var=None,
+ op=None,
+ index=0,
+ name=None,
+ element_index=None):
+ if all([var, op]):
+ raise ValueError("Only mapped one of which var or op.")
+
+ def mapped_var(pattern_ops):
+ raise NotImplementedError(
+ "Mapping to variable is not implemented.")
+
+ def mapped_op(pattern_ops):
+ ops = [o for o in pattern_ops if o._type == op]
+ if len(ops) <= index:
+ raise ValueError(
+ "Index '{}' of operator '{}' is incorrect.".format(
+ index, op))
+ return PassDesc.AttrHelper(ops[index],
+ name,
+ element_index=element_index)
+
+ self._mapped = mapped_op if var is None else mapped_var
+
+ class VarHelper(paddle.static.Variable):
+
+ def __init__(self, *args, **kwargs):
+ block = paddle.static.default_main_program().current_block()
+ self._var = paddle.static.data(*args, **kwargs)
+ self._attrs = dict()
+
+ def __getattr__(self, name):
+ return getattr(self._var, name)
+
+ def Attr(self, name):
+ attr = self._attrs.get(name)
+ if attr is None:
+ attr = PassDesc.AttrHelper(self, name)
+ self._attrs[name] = attr
+ return attr
+
+ class OpHelper(object):
+
+ def __init__(self, type=None):
+ self._type = type
+
+ def __getattr__(self, name):
+ op = PassDesc.OpHelper(name)
+ op.Init()
+ return op
+
+ def __call__(self, *args, **kwargs):
+ if len(args) > 0:
+ raise ValueError(
+ "Each input argument needs to specify a parameter name.")
+ for (in_name, in_args) in kwargs.items():
+ op_input = self._inputs.get(in_name)
+ if op_input is None:
+ raise ValueError(
+ "Operator '{}' does not have input named '{}'.".format(
+ self._type, in_name))
+ if isinstance(in_args, (list, tuple)):
+ if len(in_args) == 0:
+ raise ValueError(
+ "Input '{}' of operator '{}' cannot be empty.".
+ format(in_name, self._type))
+ else:
+ in_args = [in_args]
+ for in_arg in in_args:
+ if isinstance(in_arg, PassDesc.OpHelper):
+ op_outs = in_arg.Outputs()
+ if len(op_outs) != 1:
+ raise ValueError(
+ "The size of outputs of operator '{}' is not equal 1, please specify one output variable."
+ .format(in_arg._type))
+ for op_out in op_outs.values():
+ op_input.extend(op_out)
+ else:
+ op_input.append(in_arg)
+ self._desc.set_input(in_name, [i.name for i in op_input])
+ block = paddle.static.default_main_program().current_block()
+ for out_name, op_output in self._outputs.items():
+ op_output_name = unique_name.generate(self._type)
+ op_output.append(block.create_var(name=op_output_name))
+ self._desc.set_output(out_name, [op_output_name])
+ return self
+
+ def Init(self):
+ block = paddle.static.default_main_program().current_block()
+ self._proto = OpProtoHolder.instance().op_proto_map.get(self._type)
+ if self._proto is None:
+ raise AttributeError(
+ "type object 'OpHelper' has no attribute '{}'".format(
+ self._type))
+ self._index = len(block.ops)
+ self._desc = block.desc.append_op()
+ self._desc.set_type(self._type)
+ self._attrs = dict()
+ self._inputs = {i.name: list() for i in self._proto.inputs}
+ self._outputs = {o.name: list() for o in self._proto.outputs}
+ block.ops.append(self)
+
+ def Attr(self, name):
+ attr = self._attrs.get(name)
+ if attr is None:
+ attr = PassDesc.AttrHelper(self, name)
+ self._attrs[name] = attr
+ return attr
+
+ def SetAttr(self, name, value):
+ if isinstance(value, PassDesc.AttrHelper):
+ self.Attr(name)._mapped = value
+ else:
+ self._desc._set_attr(name, value)
+
+ def Output(self, name):
+ output = self._outputs.get(name)
+ if output is None:
+ raise ValueError(
+ "Operator '{}' does not have output named '{}'.".format(
+ self._type, name))
+ return output
+
+ def Outputs(self):
+ return self._outputs
+
+ def SetOutputs(self, **kwargs):
+ for param, arg in kwargs.items():
+ if arg is None:
+ self._desc.remove_output(param)
+ else:
+ self._desc.set_output(param, [arg.name])
+
+ OP = OpHelper()
+
+
+def RegisterPass(function=None, input_specs=dict()):
+ """
+ The function decorator of Register Pass. Decorator @RegisterPass handles
+ the function and register it into a core.Pass instance. Use name of function
+ as Pass type.
+
+ Args:
+ function (callable): The function with return of callable pair(s) that
+ represents the pattern subgraph and the replace subgraph.
+ input_specs (dict[str, InputSpec]): Dict of InputSpec to specific the shape/dtype
+ information of Tensor. Some operators limit the shape and dtype of datas when
+ create subgraph with Paddle APIs. So user need specify InputSpec of data to
+ ensure create a correctly subgraph. Of course, this argument is not limited to
+ matching subgraph. The default is dict().
+
+ Returns:
+ callables: Callable pair(s).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ from paddle.fluid.ir import RegisterPass
+
+ @RegisterPass
+ def multi_add_to_addn():
+ def pattern(x, y, z):
+ return paddle.add(paddle.add(x, y), z)
+ def replace(x, y, z):
+ return paddle.add_n([x, y, z])
+ return pattern, replace
+ """
+
+ def _is_pass_pair(check_pair):
+ if isinstance(check_pair, (list, tuple)):
+ if len(check_pair) == 2:
+ if all(map(inspect.isfunction, check_pair)):
+ return True
+ return False
+
+ def decorated(python_func):
+ pass_type = python_func.__name__
+ signature = inspect.signature(python_func)
+ if len(signature.parameters) > 0:
+ raise NotImplementedError(
+ "Pass function with parameter is not supported now.")
+ elif len(signature.parameters) == 0:
+ pass_pairs = python_func()
+ if _is_pass_pair(pass_pairs):
+ pass_pairs = [pass_pairs]
+ elif not all(map(_is_pass_pair, pass_pairs)):
+ raise ValueError(
+ "Return value of Pass function must be (callable, callable)."
+ )
+ helper = RegisterPassHelper(pass_pairs, pass_type, input_specs)
+ core.register_pass(pass_type, helper.SerializeMultiPassDesc)
+ return python_func
+
+ if inspect.isfunction(function):
+ return decorated(function)
+
+ return decorated
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..42b67a5a0dfa8599bfe454e59a4d78e3ac1627e5
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper.py
@@ -0,0 +1,188 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import copy
+import six
+
+from .framework import Parameter, dtype_is_floating, _non_static_mode, OpProtoHolder, _global_flags
+from . import unique_name
+from paddle.fluid.initializer import Constant, Xavier
+from .param_attr import ParamAttr
+from . import core
+from six.moves import zip
+from .layer_helper_base import LayerHelperBase
+from .dygraph_utils import _append_activation_in_dygraph
+
+
+class LayerHelper(LayerHelperBase):
+
+ def __init__(self, layer_type, **kwargs):
+ self.kwargs = kwargs
+ name = self.kwargs.get('name', None)
+ # TODO(panyx0718, minqiyang): dygraph mode
+ # can not use both `layer_type` and `name`. Deprecate LayerHelper
+ # and write a Helper for dygraph mode.
+ if name is None:
+ self.kwargs['name'] = unique_name.generate(layer_type)
+
+ super(LayerHelper, self).__init__(self.kwargs['name'],
+ layer_type=layer_type)
+
+ def append_op(self, *args, **kwargs):
+ return self.main_program.current_block().append_op(*args, **kwargs)
+
+ def multiple_input(self, input_param_name='input'):
+ inputs = self.kwargs.get(input_param_name, [])
+ ret = []
+ if isinstance(inputs, list) or isinstance(inputs, tuple):
+ for inp in inputs:
+ ret.append(self.to_variable(inp))
+ else:
+ ret.append(self.to_variable(inputs))
+ return ret
+
+ def input(self, input_param_name='input'):
+ inputs = self.multiple_input(input_param_name)
+ if len(inputs) != 1:
+ raise "{0} layer only takes one input".format(self.layer_type)
+ return inputs[0]
+
+ @property
+ def param_attr(self):
+ return ParamAttr._to_attr(self.kwargs.get('param_attr', None))
+
+ @property
+ def bias_attr(self):
+ return ParamAttr._to_attr(self.kwargs.get('bias_attr', None))
+
+ #TODO (jiabin): reconstruct this in LayerObjHelper and avoid dependency of param_attr
+ def multiple_param_attr(self, length):
+ param_attr = self.param_attr
+ if isinstance(param_attr, ParamAttr):
+ param_attr = [param_attr]
+
+ if len(param_attr) != 1 and len(param_attr) != length:
+ raise ValueError("parameter number mismatch")
+ elif len(param_attr) == 1 and length != 1:
+ tmp = [None] * length
+ for i in six.moves.range(length):
+ tmp[i] = copy.deepcopy(param_attr[0])
+ param_attr = tmp
+ return param_attr
+
+ def iter_inputs_and_params(self, input_param_name='input'):
+ inputs = self.multiple_input(input_param_name)
+ param_attrs = self.multiple_param_attr(len(inputs))
+ for ipt, param_attr in zip(inputs, param_attrs):
+ yield ipt, param_attr
+
+ def input_dtype(self, input_param_name='input'):
+ inputs = self.multiple_input(input_param_name)
+ dtype = None
+ for each in inputs:
+ if dtype is None:
+ dtype = each.dtype
+ elif dtype != each.dtype:
+ raise ValueError("Data Type mismatch: %d to %d" %
+ (dtype, each.dtype))
+ return dtype
+
+ def get_parameter(self, name):
+ param = self.main_program.global_block().var(name)
+ if not isinstance(param, Parameter):
+ raise ValueError("no Parameter name %s found" % name)
+ return param
+
+ #TODO (jiabin): reconstruct this in LayerObjHelper and avoid dependency of bias_attr
+ def append_bias_op(self, input_var, dim_start=1, dim_end=None):
+ """
+ Append bias operator and return its output. If the user does not set
+ bias_attr, append_bias_op will return input_var
+
+ :param input_var: the input variable. The len(input_var.shape) is
+ larger or equal than 2.
+ :bias_initializer: an instance of a subclass of Initializer used to
+ initialize the bias
+ :param dim_start:
+ :param dim_end: the shape of the bias will be
+ input_var.shape[dim_start:dim_end]. The bias is broadcasted to other
+ dimensions and added to input_var to get the output
+ """
+ size = list(input_var.shape[dim_start:dim_end])
+ bias_attr = self.bias_attr
+ if not bias_attr:
+ return input_var
+
+ b = self.create_parameter(attr=bias_attr,
+ shape=size,
+ dtype=input_var.dtype,
+ is_bias=True)
+ tmp = self.create_variable_for_type_inference(dtype=input_var.dtype)
+ self.append_op(type='elementwise_add',
+ inputs={
+ 'X': [input_var],
+ 'Y': [b]
+ },
+ outputs={'Out': [tmp]},
+ attrs={'axis': dim_start})
+ return tmp
+
+ #TODO (jiabin): reconstruct this in LayerObjHelper and avoid dependency of act
+ def append_activation(self, input_var):
+ act = self.kwargs.get('act', None)
+ if act is None:
+ return input_var
+ if isinstance(act, six.string_types):
+ act = {'type': act}
+ else:
+ raise TypeError(str(act) + " should be unicode or str")
+
+ use_cudnn = None
+ if 'use_cudnn' in self.kwargs and self.kwargs.get('use_cudnn'):
+ use_cudnn = self.kwargs.get('use_cudnn')
+ act['use_cudnn'] = use_cudnn
+ use_mkldnn = self.kwargs.get(
+ 'use_mkldnn',
+ _global_flags().get("FLAGS_use_mkldnn", False))
+ if use_mkldnn:
+ act['use_mkldnn'] = use_mkldnn
+ act_type = act.pop('type')
+ if _non_static_mode():
+ res = _append_activation_in_dygraph(input_var, act_type, use_cudnn,
+ use_mkldnn)
+ return res
+ else:
+ tmp = self.create_variable_for_type_inference(dtype=input_var.dtype)
+ self.append_op(type=act_type,
+ inputs={"X": [input_var]},
+ outputs={"Out": [tmp]},
+ attrs=act)
+ return tmp
+
+ #TODO (jiabin): should we remove this since it has never be used
+ def _get_default_initializer(self, dtype):
+ if dtype is None or dtype_is_floating(dtype) is True:
+ return Xavier()
+ else:
+ # For integer and boolean types, initialize with all zeros
+ return Constant()
+
+ #TODO (jiabin): reconstruct this in LayerObjHelper and avoid dependency of kwargs
+ def is_instance(self, param_name, cls):
+ param = self.kwargs.get(param_name, None)
+ if not isinstance(param, cls):
+ raise TypeError("The input {0} parameter of method {1} must be {2}",
+ param_name, self.layer_type, cls.__name__)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper_base.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper_base.py
new file mode 100644
index 0000000000000000000000000000000000000000..eeeea1a29090dfd6925ef9fe059c378b6facf0e9
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layer_helper_base.py
@@ -0,0 +1,483 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import copy
+import numpy as np
+
+from .framework import Variable, default_main_program, default_startup_program, _non_static_mode, _current_expected_place, _in_eager_without_dygraph_check
+from . import unique_name
+from .param_attr import ParamAttr, WeightNormParamAttr
+from . import core
+from .initializer import _global_weight_initializer, _global_bias_initializer
+
+__all__ = ['LayerHelperBase']
+
+
+class LayerHelperBase(object):
+ # global dtype
+ __dtype = "float32"
+
+ def __init__(self, name, layer_type):
+ self._layer_type = layer_type
+ self._name = name
+
+ @property
+ def name(self):
+ return self._name
+
+ @property
+ def layer_type(self):
+ return self._layer_type
+
+ @property
+ def main_program(self):
+ return default_main_program()
+
+ @property
+ def startup_program(self):
+ return default_startup_program()
+
+ @classmethod
+ def set_default_dtype(cls, dtype):
+ cls.__dtype = dtype
+
+ @classmethod
+ def get_default_dtype(cls):
+ return cls.__dtype
+
+ def to_variable(self, value, name=None):
+ r"""
+ The API will create a ``Variable`` object from numpy\.ndarray or Variable object.
+
+ Parameters:
+ value(ndarray): The numpy\.ndarray object that needs to be converted, it can be multi-dimension, and the data type is one of numpy\.{float16, float32, float64, int16, int32, int64, uint8, uint16}.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: ``Tensor`` created from the specified numpy\.ndarray object, data type and shape is the same as ``value`` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+
+ with fluid.dygraph.guard():
+ x = np.ones([2, 2], np.float32)
+ y = fluid.dygraph.to_variable(x)
+
+ """
+ if isinstance(value, np.ndarray):
+ if _in_eager_without_dygraph_check():
+ return core.eager.Tensor(value, _current_expected_place(),
+ False, False, name if name else None,
+ True)
+ else:
+ py_var = core.VarBase(value=value,
+ name=name if name else '',
+ persistable=False,
+ place=_current_expected_place(),
+ zero_copy=False)
+ return py_var
+ elif isinstance(value, (core.VarBase, Variable, core.eager.Tensor)):
+ return value
+ else:
+ raise TypeError(
+ "The type of input value is invalid, expected type is 'ndarray' or 'Variable', but received %s"
+ % type(value))
+
+ def _create_weight_normalize(self, attr, shape, dtype):
+ from .layers import elementwise_mul, elementwise_div, reshape
+
+ # Remove these ops when LayerHelper and layers support indicating
+ # program and block.
+ def __norm_op(x,
+ out=None,
+ p=2,
+ dim=None,
+ keep_dim=False,
+ block=self.startup_program.global_block()):
+ if out is None:
+ out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_norm'])),
+ dtype=dtype,
+ persistable=False)
+ abs_out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_abs'])),
+ dtype=dtype,
+ persistable=False)
+ block.append_op(type='abs',
+ inputs={'X': x},
+ outputs={'Out': abs_out})
+ pow_out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_pow'])),
+ dtype=dtype,
+ persistable=False)
+ block.append_op(type='pow',
+ inputs={'X': abs_out},
+ outputs={'Out': pow_out},
+ attrs={'factor': float(p)})
+ sum_out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_sum'])),
+ dtype=dtype,
+ persistable=False)
+ block.append_op(type='reduce_sum',
+ inputs={'X': pow_out},
+ outputs={'Out': sum_out},
+ attrs={
+ 'dim': dim,
+ 'keep_dim': keep_dim,
+ 'reduce_all': True if dim is None else False
+ })
+ block.append_op(type='pow',
+ inputs={'X': sum_out},
+ outputs={'Out': out},
+ attrs={'factor': 1. / p})
+ return out
+
+ def __reshape_op(x,
+ shape,
+ out=None,
+ block=self.startup_program.global_block()):
+ if out is None:
+ out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_reshape'])),
+ dtype=dtype,
+ persistable=False)
+ x_shape = block.create_var(name="Xshape", dtype=x.dtype)
+ block.append_op(type="reshape2",
+ inputs={'X': x},
+ attrs={'shape': shape},
+ outputs={
+ "Out": out,
+ "XShape": x_shape
+ })
+ return out
+
+ def __transpose_op(x,
+ axis,
+ out=None,
+ block=self.startup_program.global_block()):
+ if out is None:
+ out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_transpose'])),
+ dtype=dtype,
+ persistable=False)
+ block.append_op(type='transpose',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'axis': axis})
+ return out
+
+ def __norm_except_dim(x,
+ out=None,
+ dim=None,
+ block=self.startup_program.global_block()):
+ """Computes the norm over all dimensions except dim"""
+ if out is None:
+ out = block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'weight_norm_norm'])),
+ dtype=dtype,
+ persistable=False)
+ if dim is None:
+ __norm_op(x, out, dim=dim, block=block)
+ elif dim == 0:
+ out_shape = [x.shape[0]] + [1] * (len(x.shape) - 1)
+ reshape = __reshape_op(x, shape=[x.shape[0], -1], block=block)
+ norm = __norm_op(reshape, dim=[1], block=block)
+ __reshape_op(norm, out=out, shape=out_shape, block=block)
+ elif dim == len(x.shape) - 1:
+ out_shape = [1] * (len(x.shape) - 1) + [x.shape[-1]]
+ reshape = __reshape_op(x, shape=[-1, x.shape[-1]], block=block)
+ norm = __norm_op(reshape, dim=[0], block=block)
+ __reshape_op(norm, out=out, shape=out_shape, block=block)
+ else:
+ perm = list(range(len(x.shape)))
+ perm[0], perm[dim] = dim, 0
+ transpose = __transpose_op(x, perm, block=block)
+ out_shape = [transpose.shape[0]
+ ] + [1] * (len(transpose.shape) - 1)
+ reshape = __reshape_op(transpose,
+ shape=[transpose.shape[0], -1],
+ block=block)
+ norm = __norm_op(reshape, dim=[1], block=block)
+ reshape2 = __reshape_op(norm, shape=out_shape, block=block)
+ __transpose_op(reshape2, perm, out=out, block=block)
+ return out
+
+ def __weight_normalize(g, v, dim):
+ """Calculations for weight normalization"""
+ norm = __norm_except_dim(v,
+ dim=dim,
+ block=self.main_program.current_block())
+ scale = elementwise_div(
+ x=g, y=norm) # The shapes of g and norm are the same.
+ # Currently, elementwise_mul only support broadcast when the shape
+ # of y is a subset of the shape of x. Thus, we reshape y to squeeze
+ # to achieve the subset.
+ w = elementwise_mul(x=v,
+ y=scale if dim is None else reshape(
+ x=scale, shape=[v.shape[dim]]),
+ axis=-1 if dim is None else dim)
+ # To serialize the original parameter for inference, maybe a
+ # parameter rather than a variable should be returned.
+ return w
+
+ g_param_attr = copy.deepcopy(attr)
+ g_param_attr.name = attr.name + '_g'
+ g_param_shape = [1] * len(shape)
+ if attr.dim is not None:
+ g_param_shape[attr.dim] = shape[attr.dim]
+ v_param_attr = copy.deepcopy(attr)
+ v_param_attr.name = attr.name + '_v'
+ v_param_shape = shape
+
+ # Add to startup_program to initialize g and v.
+ # Try to reconstruct the initializer of w by initializing g and v.
+ # Set the initializers of g and v as below, then the distribution
+ # of w is the same as initializing w with the given initializer.
+ # For Data-Dependent Initialization, please compute the init-values
+ # of g and v in external and then feed the values to g and v by
+ # executing an extra program.
+ g_param = self.startup_program.global_block().create_parameter(
+ dtype=dtype,
+ shape=g_param_shape,
+ **g_param_attr._to_kwargs(with_initializer=False))
+ v_param = self.startup_program.global_block().create_parameter(
+ dtype=dtype,
+ shape=v_param_shape,
+ **v_param_attr._to_kwargs(with_initializer=True))
+ __norm_except_dim(x=v_param,
+ out=g_param,
+ dim=attr.dim,
+ block=self.startup_program.global_block())
+
+ # keep g_param shape to be consistent with that in main_program
+ __reshape_op(g_param,
+ g_param_shape,
+ out=g_param,
+ block=self.startup_program.global_block())
+
+ # Add weight normalization to main_program
+ g_param = self.main_program.global_block().create_parameter(
+ dtype=dtype, shape=g_param_shape, **g_param_attr._to_kwargs())
+ v_param = self.main_program.global_block().create_parameter(
+ dtype=dtype, shape=v_param_shape, **v_param_attr._to_kwargs())
+ w_param = __weight_normalize(g_param, v_param, dim=attr.dim)
+ return w_param
+
+ # TODO: hide the func after we move the layers to Layers
+ def create_parameter(self,
+ attr,
+ shape,
+ dtype=None,
+ is_bias=False,
+ default_initializer=None,
+ stop_gradient=False,
+ type=core.VarDesc.VarType.LOD_TENSOR):
+ """Create parameters for this layers.
+
+ Args:
+ attr: [ParamAttr] should be the parameter attribute for this parameter
+ shape: shape of the parameter
+ dtype: data type of this parameter
+ is_bias: if this is a bias parameter
+ default_initializer: set the default initializer for this parameter
+
+ Returns created parameter Variable.
+ """
+ # Deepcopy the attr so that parameters can be shared in program
+ attr = copy.deepcopy(attr)
+ attr = ParamAttr._to_attr(attr)
+ if not attr:
+ return None
+ assert isinstance(attr, ParamAttr)
+ for i, size in enumerate(shape):
+ assert size > 0, ("Expected every dim's size to be larger than 0, "
+ "but the size of the {}-th dim is {}".format(
+ i, size))
+ # set global dtype
+ if not dtype:
+ dtype = self.__dtype
+ if is_bias:
+ suffix = 'b'
+ default_initializer = _global_bias_initializer(
+ ) if _global_bias_initializer() is not None else default_initializer
+ else:
+ suffix = 'w'
+ default_initializer = _global_weight_initializer(
+ ) if _global_weight_initializer(
+ ) is not None else default_initializer
+ if attr.name is None:
+ attr.name = unique_name.generate(".".join([self.name, suffix]))
+
+ if default_initializer is None and attr.initializer is None:
+ if isinstance(dtype, core.VarDesc.VarType):
+ if dtype != core.VarDesc.VarType.FP32 and \
+ dtype != core.VarDesc.VarType.FP64 and \
+ dtype != core.VarDesc.VarType.FP16 and \
+ dtype != core.VarDesc.VarType.BF16:
+ raise TypeError(
+ "Can not create parameter with default initializer when dtype is not float type. Set default_initializer to fit the parameter dtype!"
+ )
+ else:
+ if not (dtype.startswith("float")
+ or dtype in ["double", "uint16"]):
+ raise TypeError(
+ "Can not create parameter with default initializer when dtype is not float type. Set default_initializer to fit the parameter dtype!"
+ )
+ if is_bias:
+ attr._set_default_bias_initializer()
+ else:
+ attr._set_default_param_initializer()
+ else:
+ attr._set_default_initializer(default_initializer)
+
+ # If weight normalization is set, insert extra parameters and ops.
+ # Refer to https://arxiv.org/pdf/1602.07868.pdf
+ if isinstance(attr, WeightNormParamAttr):
+ param = self._create_weight_normalize(attr, shape, dtype)
+ WeightNormParamAttr.params_with_weight_norm.append(param)
+ return param
+ if _non_static_mode():
+ # In dygraph mode, we want the returned parameter to be
+ # initialized so that it can be used imperatively.
+ # check parameter name
+ is_used = unique_name.dygraph_parameter_name_checker(attr.name)
+ if is_used:
+ raise ValueError(
+ "parameter name [{}] have be been used. "
+ "In dygraph mode, the name of parameter can't be same."
+ "Please check the parameter attr value passed to self.create_parameter or "
+ "constructor of dygraph Layers".format(attr.name))
+ return self.main_program.global_block().create_parameter(
+ dtype=dtype,
+ shape=shape,
+ type=type,
+ stop_gradient=stop_gradient,
+ **attr._to_kwargs(with_initializer=True))
+ else:
+ self.startup_program.global_block().create_parameter(
+ dtype=dtype,
+ shape=shape,
+ type=type,
+ **attr._to_kwargs(with_initializer=True))
+ return self.main_program.global_block().create_parameter(
+ dtype=dtype, shape=shape, type=type, **attr._to_kwargs())
+
+ def create_variable_for_type_inference(self,
+ dtype,
+ stop_gradient=False,
+ shape=None):
+ """Create a temporary variable that should be type inferred layer.
+
+ Note:
+ The default type will be set to LOD_TENSOR. However, when
+ the var is used as operator output, its type will be updated
+ based on operator's `VarTypeInference` implementation in
+ infer_var_type.
+ """
+ # set global dtype
+ if not dtype:
+ dtype = self.__dtype
+ return self.main_program.current_block().create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'tmp'])),
+ dtype=dtype,
+ shape=shape,
+ type=core.VarDesc.VarType.LOD_TENSOR,
+ persistable=False,
+ stop_gradient=stop_gradient)
+
+ def create_sparse_variable_for_type_inference(self,
+ dtype,
+ stop_gradient=False,
+ shape=None):
+ """Create a temporary sparse variable that should be type inferred layer.
+
+ Note:
+ The default type will be set to SPARSE_COO. However, when
+ the var is used as operator output, its type will be updated
+ based on operator's `VarTypeInference` implementation in
+ infer_var_type.
+ """
+ # set global dtype
+ if not dtype:
+ dtype = self.__dtype
+ return self.main_program.current_block().create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [self.name, 'tmp'])),
+ dtype=dtype,
+ shape=shape,
+ type=core.VarDesc.VarType.SPARSE_COO,
+ persistable=False,
+ stop_gradient=stop_gradient)
+
+ def create_variable(self, *args, **kwargs):
+ """Create Variable for this layers.
+ Returns created Variable.
+ """
+ return self.main_program.current_block().create_var(*args, **kwargs)
+
+ def create_global_variable(self, persistable=False, *args, **kwargs):
+ """
+ create global variable, note that there is no initializer for this global variable.
+ Args:
+ persistable(bool): True if it is a checkpoint value.
+ *args: See create_var's documentation
+ **kwargs: See create_var's documentation
+
+ Returns(Variable): the created variable.
+ """
+ return self.main_program.global_block().create_var(
+ *args, persistable=persistable, **kwargs)
+
+ def create_or_get_global_variable(self, name, *args, **kwargs):
+ """
+ Creates a global variable if not exists and returns the variable and
+ a boolean flag which is true when it is a new variable.
+ """
+ if self.main_program.global_block().has_var(name):
+ return self.main_program.global_block().var(name), False
+ else:
+ return self.create_global_variable(name=name, *args, **kwargs), True
+
+ def set_variable_initializer(self, var, initializer):
+ """Set target Variable's initializer
+
+ Args:
+ var: target Variable
+ initializer: initializer to use
+ """
+ assert isinstance(var, Variable)
+ if _non_static_mode():
+ initializer(var, self.main_program.global_block())
+ else:
+ self.startup_program.global_block().create_var(
+ name=var.name,
+ type=var.type,
+ dtype=var.dtype,
+ shape=var.shape,
+ persistable=True,
+ initializer=initializer)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d49b9100361c00ba3530e50b1d6e5f4232ae953
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/__init__.py
@@ -0,0 +1,58 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from . import ops
+from .ops import *
+from . import nn
+from .nn import *
+from . import io
+from .io import *
+from . import tensor
+from .tensor import *
+from . import control_flow
+from .control_flow import *
+from . import device
+from .device import *
+from . import math_op_patch
+from .math_op_patch import *
+from . import loss
+from .loss import *
+from . import detection
+from .detection import *
+from . import metric_op
+from .metric_op import *
+from .learning_rate_scheduler import *
+from .collective import *
+from .distributions import *
+from .sequence_lod import *
+from . import rnn
+
+__all__ = []
+__all__ += nn.__all__
+__all__ += io.__all__
+__all__ += tensor.__all__
+__all__ += control_flow.__all__
+__all__ += ops.__all__
+__all__ += device.__all__
+__all__ += detection.__all__
+__all__ += metric_op.__all__
+__all__ += learning_rate_scheduler.__all__
+__all__ += distributions.__all__
+__all__ += sequence_lod.__all__
+__all__ += loss.__all__
+__all__ += rnn.__all__
+
+from .rnn import *
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/collective.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/collective.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d62bb17ea4d6203c124a451f72abbcac3037dd1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/collective.py
@@ -0,0 +1,195 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+from ..layer_helper import LayerHelper, unique_name
+from ..framework import Variable, in_dygraph_mode, _in_legacy_dygraph
+import paddle
+from paddle import _C_ops, _legacy_C_ops
+
+
+def _allreduce(x, out=None, reduce_type="sum", sync_mode=False):
+ helper = LayerHelper("allreduce", **locals())
+ # Convert string reduce type to op int type
+ red_typ_int = 0
+ if reduce_type == "sum":
+ red_typ_int = 0
+ elif reduce_type == "prod":
+ red_typ_int = 1
+ elif reduce_type == "max":
+ red_typ_int = 2
+ elif reduce_type == "min":
+ red_typ_int = 3
+ else:
+ raise TypeError("reduce type can only be [sum|prod|max|min]")
+
+ if out is None:
+ out = helper.create_variable(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [x.name, 'tmp'])),
+ shape=x.shape,
+ dtype=x.dtype,
+ type=x.type,
+ persistable=x.persistable,
+ stop_gradient=True)
+ helper.append_op(type='allreduce',
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={
+ "reduce_type": red_typ_int,
+ "sync_mode": sync_mode
+ })
+ return out
+
+
+def _broadcast(x, root, sync_mode=False):
+ helper = LayerHelper("broadcast", **locals())
+ helper.append_op(type='broadcast',
+ inputs={'X': [x]},
+ outputs={'Out': [x]},
+ attrs={
+ "sync_mode": sync_mode,
+ "root": root
+ })
+ return x
+
+
+def _c_allreduce(x,
+ out=None,
+ reduce_type='sum',
+ ring_id=0,
+ use_calc_stream=False):
+ helper = LayerHelper('c_allreduce', **locals())
+
+ if reduce_type not in ['sum', 'prob', 'max', 'min']:
+ raise TypeError('reduce type can only be "sum|prod|max|min]"')
+
+ op_type = 'c_allreduce_' + reduce_type
+ if out is None:
+ out = helper.create_variable(
+ name=unique_name.generate_with_ignorable_key('.'.join(
+ [x.name, op_type])),
+ shape=x.shape,
+ dtype=x.dtype,
+ type=x.type,
+ persistable=x.persistable)
+
+ helper.append_op(type=op_type,
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={
+ 'ring_id': ring_id,
+ 'use_calc_stream': use_calc_stream
+ })
+ return out
+
+
+def _c_broadcast(x, root=0, ring_id=0, use_calc_stream=False):
+ op_type = 'c_broadcast'
+ helper = LayerHelper(op_type, **locals())
+ helper.append_op(type=op_type,
+ inputs={'X': [x]},
+ outputs={'Out': [x]},
+ attrs={
+ 'root': root,
+ 'ring_id': ring_id,
+ 'use_calc_stream': use_calc_stream
+ })
+ return x
+
+
+def _c_allgather(x, nranks, ring_id=0, use_calc_stream=False):
+ op_type = 'c_allgather'
+
+ if in_dygraph_mode():
+ group = paddle.distributed.collective._get_default_group()
+ tensor_shape = list(x.shape)
+ tensor_shape[0] *= nranks
+ out = paddle.empty(tensor_shape, x.dtype)
+ task = group.process_group.all_gather(x, out)
+ task.wait()
+ return out
+
+ if _in_legacy_dygraph():
+ attrs = ('nranks', nranks, 'ring_id', ring_id, 'use_calc_stream',
+ use_calc_stream)
+ return _legacy_C_ops.c_allgather(x, *attrs)
+
+ helper = LayerHelper(op_type, **locals())
+ out_shape = list(x.shape[:])
+ if out_shape[0] > 0:
+ out_shape[0] *= nranks
+ out = helper.create_variable(name=unique_name.generate_with_ignorable_key(
+ '.'.join([x.name, op_type])),
+ shape=out_shape,
+ dtype=x.dtype,
+ type=x.type,
+ persistable=x.persistable)
+ helper.append_op(type=op_type,
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={
+ 'nranks': nranks,
+ 'ring_id': ring_id,
+ 'use_calc_stream': use_calc_stream
+ })
+ return out
+
+
+def _c_reducescatter(x, nranks, ring_id=0, use_calc_stream=False):
+ if not isinstance(x, Variable):
+ raise TypeError('x must be a Variable')
+
+ if x.shape[0] > 0 and x.shape[0] % nranks != 0:
+ raise ValueError(
+ 'x.shape[0](%d) cannot be evenly divided by nranks(%d)' %
+ (x.shape[0], nranks))
+
+ op_type = 'c_reducescatter'
+ helper = LayerHelper(op_type, **locals())
+ out_shape = list(x.shape[:])
+ if out_shape[0] > 0:
+ out_shape[0] //= nranks
+ out = helper.create_variable(name=unique_name.generate_with_ignorable_key(
+ '.'.join([x.name, op_type])),
+ shape=out_shape,
+ dtype=x.dtype,
+ type=x.type,
+ persistable=x.persistable)
+ helper.append_op(type=op_type,
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={
+ 'nranks': nranks,
+ 'ring_id': ring_id,
+ 'use_calc_stream': use_calc_stream
+ })
+ return out
+
+
+def _c_sync_calc_stream(x):
+ op_type = 'c_sync_calc_stream'
+ helper = LayerHelper(op_type, **locals())
+ helper.append_op(type=op_type, inputs={'X': [x]}, outputs={'Out': [x]})
+ return x
+
+
+def _c_sync_comm_stream(x, ring_id):
+ op_type = 'c_sync_comm_stream'
+ helper = LayerHelper(op_type, **locals())
+ helper.append_op(type=op_type,
+ inputs={'X': [x]},
+ outputs={'Out': [x]},
+ attrs={'ring_id': ring_id})
+ return x
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/control_flow.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/control_flow.py
new file mode 100644
index 0000000000000000000000000000000000000000..49a779a2eb065c096952b0cb2a8af074c941aea0
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/control_flow.py
@@ -0,0 +1,4518 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+from ..wrapped_decorator import signature_safe_contextmanager
+
+from .layer_function_generator import autodoc, templatedoc
+from .tensor import assign, cast, fill_constant
+from .. import core
+from ..framework import (
+ Program,
+ Variable,
+ Operator,
+ _non_static_mode,
+ static_only,
+ _in_legacy_dygraph,
+ in_dygraph_mode,
+)
+from ..layer_helper import LayerHelper, unique_name
+from .nn import logical_and, logical_not, logical_or
+from .utils import (
+ assert_same_structure,
+ map_structure,
+ hold_mutable_vars,
+ copy_mutable_vars,
+ padding_to_same_structure,
+ is_sequence,
+ pack_sequence_as,
+ flatten,
+ to_sequence,
+)
+import numpy
+import warnings
+import six
+from functools import reduce, partial
+from ..data_feeder import (
+ convert_dtype,
+ check_variable_and_dtype,
+ check_type,
+ check_dtype,
+)
+from ... import compat as cpt
+from ..backward import _infer_var_data_type_shape_
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'While',
+ 'Switch',
+ 'increment',
+ 'array_write',
+ 'create_array',
+ 'less_than',
+ 'less_equal',
+ 'greater_than',
+ 'greater_equal',
+ 'equal',
+ 'not_equal',
+ 'array_read',
+ 'array_length',
+ 'cond',
+ 'IfElse',
+ 'DynamicRNN',
+ 'StaticRNN',
+ 'reorder_lod_tensor_by_rank',
+ 'Print',
+ 'Assert',
+ 'is_empty',
+ 'case',
+ 'switch_case',
+ 'while_loop',
+]
+
+
+def select_output(input, outputs, mask):
+ """
+ **select_output**
+ This API takes in one input and multiple outputs and an integer mask. It
+ selects the output specified by the mask and copy the input to selected
+ output. It is useful in control flow.
+
+ Args:
+ input(Variable): The input variable
+ outputs(tuple|list): The output variables
+ mask(Variable): A tensor containing 1 integer number selecting which
+ output to be copied with input
+
+ Returns:
+ Variable: The outputs variables
+ """
+ helper = LayerHelper('select_output', **locals())
+ check_type(input, 'input', (Variable), 'select_output')
+ check_variable_and_dtype(mask, 'mask', ['int32'], 'select_output')
+ check_type(outputs, 'outputs', (list, tuple), 'select_output')
+
+ helper.append_op(
+ type='select_output',
+ inputs={'X': input, 'Mask': mask},
+ outputs={'Out': outputs},
+ )
+ return outputs
+
+
+def _select_input_infer_shape(first_shape, second_shape):
+ """
+ This function infer the output shape by following algorithm:
+ 1. if the dims is different, raise a error.
+ 2. compare axis one by one:
+ if a == b: we set axis to a
+ if a != b: we set axis to -1
+ for compatibility，non declarative mode, we just return second_shape.
+ """
+ if len(first_shape) != len(second_shape):
+ warnings.warn(
+ f"the input shapes of select_input should have the same rank, but get {first_shape}, {second_shape}"
+ )
+ return second_shape
+ out_shape = list(
+ map(lambda a, b: a if a == b else -1, first_shape, second_shape)
+ )
+ return out_shape
+
+
+def select_input(inputs, mask):
+ """
+ **select_input**
+
+ This API takes in multiple inputs and uses an integer mask to select one
+ input to output. It is useful in control flow.
+
+ Args:
+ inputs(tuple|list): The input variables
+ mask(Variable): A tensor containing 1 integer number selecting which
+ input to output
+
+ Returns:
+ Variable: The selected input variable
+ """
+ helper = LayerHelper('select_input', **locals())
+ check_type(inputs, 'inputs', (list, tuple), 'select_input')
+ check_variable_and_dtype(mask, 'mask', ['int32'], 'select_input')
+
+ # Select input should expand the shape. If it is - 1 and valid number, use - 1 first. If the dim is different, an error will be reported directly
+ # assert inputs[0].dtype == inputs[1].dtype, f"Expect the inputs should have the same dtype, but get {inputs[0].dtype} and {inputs[1].dtype}"
+ output_shape = _select_input_infer_shape(inputs[0].shape, inputs[1].shape)
+ output_dtype = inputs[1].dtype
+ output_type = inputs[1].type
+
+ out = helper.create_variable(
+ dtype=output_dtype, shape=output_shape, type=output_type
+ )
+ helper.append_op(
+ type='select_input',
+ inputs={'X': inputs, 'Mask': mask},
+ outputs={'Out': out},
+ )
+ return out
+
+
+def select_input_with_buildin_type(inputs, mask, name):
+ from paddle.fluid.dygraph.dygraph_to_static.variable_trans_func import (
+ to_static_variable,
+ )
+ from paddle.fluid.dygraph.dygraph_to_static.utils import UndefinedVar
+
+ false_var, true_var = inputs
+
+ if isinstance(false_var, UndefinedVar) and isinstance(
+ true_var, UndefinedVar
+ ):
+ """None -> UndefinedVar, so the real value is a [None, UndefinedVar] or [None, None], we just return None."""
+ return None
+
+ if isinstance(false_var, Variable) and isinstance(true_var, Variable):
+ try:
+ return select_input(inputs, mask)
+ except Exception as e:
+ raise RuntimeError(
+ f"Exceptions throwed while doing select_input on {name}:\n{e}"
+ )
+
+ elif isinstance(false_var, (support_ret_buildin_type)) and isinstance(
+ false_var, type(true_var)
+ ):
+ if false_var == true_var:
+ return false_var
+ else:
+ inputs = [
+ to_static_variable(false_var),
+ to_static_variable(true_var),
+ ]
+ # Deal with the situations like this: false_var is int and true_var is Variable
+ elif (
+ isinstance(false_var, support_ret_buildin_type)
+ and isinstance(true_var, Variable)
+ ) or (
+ isinstance(true_var, support_ret_buildin_type)
+ and isinstance(false_var, Variable)
+ ):
+ inputs = [to_static_variable(false_var), to_static_variable(true_var)]
+ warnings.warn(
+ "Return results from different branches in cond are not same type: "
+ "false_var returned by fasle_fn is '{}' and true_var of true_fn is "
+ "'{}'".format(type(false_var), type(true_var))
+ )
+ elif (
+ isinstance(false_var, UndefinedVar)
+ and isinstance(true_var, (Variable,) + support_ret_buildin_type)
+ ) or (
+ isinstance(true_var, UndefinedVar)
+ and isinstance(false_var, (Variable,) + support_ret_buildin_type)
+ ):
+
+ def create_var_if_not_undefined_var(a):
+ if isinstance(a, UndefinedVar):
+ return a
+ return to_static_variable(a)
+
+ true_var, false_var = to_static_variable(true_var), to_static_variable(
+ false_var
+ )
+ inputs = [false_var, true_var]
+ else:
+ raise TypeError(
+ "Unsupported return type of true_fn and false_fn in cond: false_var "
+ "returned by fasle_fn is '{}' and true_var of true_fn is '{}'".format(
+ type(false_var), type(true_var)
+ )
+ )
+ try:
+ return select_input(inputs, mask)
+ except Exception as e:
+ raise RuntimeError(
+ f"Exceptions throwed while doing select_input on {name}:\n{e}"
+ )
+
+
+def split_lod_tensor(input, mask, level=0):
+ """
+ This function takes in an input that contains the complete lod information,
+ and takes in a mask which is used to mask certain parts of the input.
+ The output is the true branch and the false branch with the mask applied to
+ the input at a certain level in the tensor. Mainly used in IfElse to split
+ data into two parts.
+
+ Args:
+ input(Variable|tuple|list|None): The input tensor that contains complete
+ lod information needed to construct the output.
+ mask(Variable|list): A bool column vector which masks the input.
+ level(int): The specific lod level to split.
+
+ Returns:
+ tuple(Variable, Variable):
+ The true branch of tensor as per the mask applied to input.
+
+ The false branch of tensor as per the mask applied to input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[1])
+ x.persistable = True
+
+ y = fluid.layers.data(name='y', shape=[1])
+ y.persistable = True
+
+ out_true, out_false = fluid.layers.split_lod_tensor(
+ input=x, mask=y, level=level)
+
+ """
+ check_type(
+ input,
+ 'input',
+ (Variable, list, tuple, type(None)),
+ 'fluid.layers.split_lod_tensor',
+ )
+ check_type(mask, 'mask', (Variable, list), 'fluid.layers.split_lod_tensor')
+ check_type(level, 'level', int, 'fluid.layers.split_lod_tensor')
+ helper = LayerHelper('split_lod_tensor', **locals())
+ out_true = helper.create_variable_for_type_inference(dtype=input.dtype)
+ out_false = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type='split_lod_tensor',
+ inputs={
+ 'X': input,
+ 'Mask': mask,
+ },
+ outputs={'OutTrue': out_true, 'OutFalse': out_false},
+ attrs={'level': level},
+ )
+ return out_true, out_false
+
+
+def merge_lod_tensor(in_true, in_false, x, mask, level=0):
+ """
+ **merge_lod_tensor**
+
+ This function takes in an input :math:`x`, the True branch, the False
+ branch and a binary :math:`mask`. Using this information, this function
+ merges the True and False branches of the tensor into a single tensor as
+ output at a certain lod level indicated by :math:`level`. Used in IfElse
+ to merge the output if True block and False Block.
+
+ Args:
+ in_true(Variable|tuple|list|None): The True branch to be merged.
+ in_false(Variable|tuple|list|None): The False branch to be merged.
+ x(Variable|tuple|list|None): The input tensor that contains complete
+ lod information needed to construct the output.
+ mask(Variable|list): A bool column vector which masks the input.
+ level(int): The specific lod level to merge.
+
+ Returns:
+ Variable: The merged output tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = layers.data(
+ name='x', shape=[1], dtype='float32', stop_gradient=False)
+ y = layers.data(
+ name='y', shape=[1], dtype='bool', stop_gradient=False)
+
+ level = 0
+
+ out_true, out_false = layers.split_lod_tensor(
+ input=x, mask=y, level=level)
+ out = layers.merge_lod_tensor(
+ in_true=out_true, in_false=out_false, mask=y, x=x, level=level)
+ """
+ helper = LayerHelper('merge_lod_tensor', **locals())
+ check_type(
+ x,
+ 'x',
+ (Variable, list, tuple, type(None)),
+ 'fluid.layers.merge_lod_tensor',
+ )
+ check_type(mask, 'mask', (Variable, list), 'fluid.layers.merge_lod_tensor')
+ check_type(
+ in_true,
+ 'in_true',
+ (Variable, list, tuple, type(None)),
+ 'fluid.layers.merge_lod_tensor',
+ )
+ check_type(
+ in_false,
+ 'in_false',
+ (Variable, list, tuple, type(None)),
+ 'fluid.layers.merge_lod_tensor',
+ )
+ out = helper.create_variable_for_type_inference(dtype=in_true.dtype)
+ helper.append_op(
+ type='merge_lod_tensor',
+ inputs={'X': x, 'Mask': mask, 'InTrue': in_true, 'InFalse': in_false},
+ outputs={'Out': out},
+ attrs={'level': level},
+ )
+ return out
+
+
+@static_only
+def Print(
+ input,
+ first_n=-1,
+ message=None,
+ summarize=20,
+ print_tensor_name=True,
+ print_tensor_type=True,
+ print_tensor_shape=True,
+ print_tensor_layout=True,
+ print_tensor_lod=True,
+ print_phase='both',
+):
+ '''
+ :api_attr: Static Graph
+
+ **Print operator**
+
+ This creates a print op that will print when a tensor is accessed.
+
+ Wraps the tensor passed in so that whenever that a tensor is accessed,
+ the message `message` is printed, along with the current value of the
+ tensor `t`.
+
+ Args:
+ input (Variable): A Tensor to print.
+ summarize (int): Number of elements in the tensor to be print. If it's
+ value is -1, then all elements in the tensor will be print.
+ message (str): A string message to print as a prefix.
+ first_n (int): Only log `first_n` number of times.
+ print_tensor_name (bool, optional): Print the tensor name. Default: True.
+ print_tensor_type (bool, optional): Print the tensor type. Defaultt: True.
+ print_tensor_shape (bool, optional): Print the tensor shape. Default: True.
+ print_tensor_layout (bool, optional): Print the tensor layout. Default: True.
+ print_tensor_lod (bool, optional): Print the tensor lod. Default: True.
+ print_phase (str): Which phase to displace, including 'forward',
+ 'backward' and 'both'. Default: 'both'. If set to 'backward', will
+ only print the gradients of input tensor; If set to 'both', will
+ both print the input tensor itself and the gradients of input tensor.
+
+ Returns:
+ Variable: Output tensor.
+
+ NOTES:
+ The input and output are two different variables, and in the
+ following process, you should use the output variable but not the input,
+ otherwise, the print layer doesn't have backward.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+
+ x = paddle.full(shape=[2, 3], fill_value=3, dtype='int64')
+ out = paddle.static.Print(x, message="The content of input layer:")
+
+ main_program = paddle.static.default_main_program()
+ exe = paddle.static.Executor(place=paddle.CPUPlace())
+ res = exe.run(main_program, fetch_list=[out])
+ # Variable: fill_constant_1.tmp_0
+ # - message: The content of input layer:
+ # - lod: {}
+ # - place: CPUPlace
+ # - shape: [2, 3]
+ # - layout: NCHW
+ # - dtype: long
+ # - data: [3 3 3 3 3 3]
+ '''
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['float32', 'float64', 'int32', 'int64', 'bool'],
+ 'fluid.layers.Print',
+ )
+
+ helper = LayerHelper('print' + "_" + input.name, **locals())
+ output = helper.create_variable_for_type_inference(input.dtype)
+ helper.append_op(
+ type='print',
+ inputs={'In': input},
+ outputs={'Out': output},
+ attrs={
+ 'first_n': first_n,
+ 'summarize': summarize,
+ 'message': message or "",
+ 'print_tensor_name': print_tensor_name,
+ 'print_tensor_type': print_tensor_type,
+ 'print_tensor_shape': print_tensor_shape,
+ 'print_tensor_layout': print_tensor_layout,
+ 'print_tensor_lod': print_tensor_lod,
+ 'print_phase': print_phase.upper(),
+ },
+ )
+ return output
+
+
+def Assert(cond, data=None, summarize=20, name=None):
+ '''
+ This API creates an op that asserts the given condition is true. If the
+ condition is false, prints the tensors in data. ``summarize`` specifies the
+ number of the elements in the tensors to print.
+
+ Args:
+ cond (Variable): The boolean condition tensor whose numel should be 1.
+ data (list|tuple, optional): list or tuple of tensors to print when
+ condition is not true. If it's ``None``, no tensor will be printed.
+ The default value is ``None``.
+ summarize (int, optional): Number of elements in the tensor to be
+ printed. If its value is -1, then all elements in the tensor will
+ be printed. The default value is 20.
+ name (str, optional): The default value is ``None`` . Normally users
+ don't have to set this parameter. For more information, please
+ refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Operator: the created operation.
+
+ Raises:
+ TypeError: If ``cond`` is not boolean Variable.
+ TypeError: If ``data`` is not a list or tuple or ``None``.
+ TypeError: If ``summarize`` is not int.
+ TypeError: If ``name`` is not a string or ``None`` .
+ fluid.core.EnforceNotMet: If the condition is False in running time.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ x = layers.fill_constant(shape=[2, 3], dtype='float32', value=2.0)
+ condition = layers.reduce_max(x) < 1.0 # False
+ layers.Assert(condition, [x], 10, "example_assert_layer")
+
+ exe = fluid.Executor()
+ try:
+ exe.run(fluid.default_main_program())
+ # Print x and throws paddle.fluid.core.EnforceNotMet exception
+ # Example printed message for x:
+ #
+ # Variable: fill_constant_0.tmp_0
+ # - lod: {}
+ # - place: CPUPlace()
+ # - shape: [2, 3]
+ # - layout: NCHW
+ # - dtype: float
+ # - data: [2 2 2 2 2 2]
+ except fluid.core.EnforceNotMet as e:
+ print("Assert Exception Example")
+
+ '''
+ check_variable_and_dtype(cond, "cond", ["bool"], "fluid.layers.Assert")
+ check_type(data, "data", (list, tuple, type(None)), "fluid.layers.Assert")
+ check_type(summarize, "summarize", int, "fluid.layers.Assert")
+ check_type(name, "name", (str, type(None)), "fluid.layers.Assert")
+
+ layer_name = name if name else ('assert_' + cond.name)
+ helper = LayerHelper(layer_name, **locals())
+
+ op = helper.append_op(
+ type="assert",
+ inputs={"Cond": cond, "Data": [] if data is None else list(data)},
+ attrs={"summarize": summarize},
+ )
+
+ return op
+
+
+class BlockGuard(object):
+ """
+ BlockGuard class.
+
+ BlockGuard class is used to create a sub-block in a program by
+ using the Python `with` keyword.
+ """
+
+ def __init__(self, main_program):
+ if not isinstance(main_program, Program):
+ raise TypeError("BlockGuard takes a program")
+ self.main_program = main_program
+
+ def __enter__(self):
+ self.main_program._create_block()
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.main_program._rollback()
+ if exc_type is not None:
+ return False # re-raise exception
+ return True
+
+
+class BlockGuardWithCompletion(BlockGuard):
+ """
+ BlockGuardWithCompletion class.
+
+ BlockGuardWithCompletion class is used to create an op with a block in a program.
+ """
+
+ def __init__(self, rnn):
+ if not isinstance(rnn, StaticRNN):
+ raise TypeError("BlockGuardWithCompletion takes a StaticRNN")
+ super(BlockGuardWithCompletion, self).__init__(rnn.helper.main_program)
+ self.rnn = rnn
+
+ def __enter__(self):
+ self.rnn.status = StaticRNN.IN_RNN_BLOCK
+ return super(BlockGuardWithCompletion, self).__enter__()
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ if exc_type is not None:
+ return False
+ self.rnn.status = StaticRNN.AFTER_RNN_BLOCK
+ self.rnn._complete_op()
+ return super(BlockGuardWithCompletion, self).__exit__(
+ exc_type, exc_val, exc_tb
+ )
+
+
+class StaticRNNMemoryLink(object):
+ """
+ StaticRNNMemoryLink class.
+
+ StaticRNNMemoryLink class is used to create a link between two
+ memory cells of a StaticRNN.
+
+
+ NOTE: This is a internal data structure of a very low-level API.
+ Please use StaticRNN instead.
+
+ Args:
+ init(Variable): the initial variable for Memory.
+ pre_mem(Variable): the memory variable in previous time step.
+ mem(Variable): the memory variable in current time step.
+ """
+
+ def __init__(self, init, pre_mem, mem=None):
+ self.init = init
+ self.pre_mem = pre_mem
+ self.mem = mem
+
+
+class StaticRNN(object):
+ """
+ :api_attr: Static Graph
+
+ StaticRNN class.
+
+ The StaticRNN can process a batch of sequence data. The first dimension of inputs
+ represents sequence length, the length of each input sequence must be equal.
+ StaticRNN will unfold sequence into time steps, user needs to define how to process
+ each time step during the :code:`with` step.
+
+ Args:
+ name (str, optional): Please refer to :ref:`api_guide_Name`, Default None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # create prev memory parameter, batch size comes from word
+ prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # use hidden to update prev
+ rnn.update_memory(prev, hidden)
+ # mark hidden as output
+ rnn.step_output(hidden)
+ # get StaticrNN final output
+ result = rnn()
+
+ """
+
+ BEFORE_RNN_BLOCK = 0
+ IN_RNN_BLOCK = 1
+ AFTER_RNN_BLOCK = 2
+
+ def __init__(self, name=None):
+ check_type(name, "name", (str, type(None)), "fluid.layers.StaticRNN")
+ self.helper = LayerHelper("static_rnn", name=name)
+ self.memories = {} # memory map, from pre_mem.name --> MemoryLink
+ self.inputs = [] # input variable list in current block
+ self.outputs = [] # output variable list in parent block
+ self.status = StaticRNN.BEFORE_RNN_BLOCK # status flag.
+ # sequence length, since it is a static RNN, sequence length are fixed.
+ self.seq_len = None
+
+ def step(self):
+ """
+ Define operators in each step. step is used in :code:`with` block, OP in :code:`with` block
+ will be executed sequence_len times (sequence_len is the length of input)
+ """
+ return BlockGuardWithCompletion(self)
+
+ def _assert_in_rnn_block_(self, method):
+ if self.status != StaticRNN.IN_RNN_BLOCK:
+ raise ValueError("You must invoke {0} in rnn block".format(method))
+
+ def memory(
+ self,
+ init=None,
+ shape=None,
+ batch_ref=None,
+ init_value=0.0,
+ init_batch_dim_idx=0,
+ ref_batch_dim_idx=1,
+ ):
+ """
+ Create a memory variable for static rnn.
+ If the :code:`init` is not None, :code:`memory` will be initialized by
+ this Variable. If the :code:`init` is None, :code:`shape` and :code:`batch_ref`
+ must be set, and this function will create a new variable with shape and batch_ref
+ to initialize :code:`init` Variable.
+
+ Args:
+ init(Variable, optional): Tensor used to init memory. If it is not set,
+ :code:`shape` and :code:`batch_ref` must be provided.
+ Default: None.
+ shape(list|tuple): When :code:`init` is None use this arg to initialize memory shape.
+ NOTE the shape does not contain batch_size. Default: None.
+ batch_ref(Variable, optional): When :code:`init` is None, memory's batch size will
+ be set as batch_ref's ref_batch_dim_idx value. Default: None.
+ init_value(float, optional): When :code:`init` is None, used to init memory's value. Default: 0.0.
+ init_batch_dim_idx(int, optional): the batch_size axis of the :code:`init` Variable. Default: 0.
+ ref_batch_dim_idx(int, optional): the batch_size axis of the :code:`batch_ref` Variable. Default: 1.
+
+ Returns:
+ Variable: The memory variable.
+
+ Examples 1:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # create prev memory parameter, batch size comes from word
+ prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # use hidden to update prev
+ rnn.update_memory(prev, hidden)
+
+
+ Examples 2:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+ boot_memory = fluid.layers.data(name='boot', shape=[hidden_size], dtype='float32', lod_level=1)
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # init memory
+ prev = rnn.memory(init=boot_memory)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # update hidden with prev
+ rnn.update_memory(prev, hidden)
+
+ """
+ self._assert_in_rnn_block_('memory')
+ check_type(
+ init,
+ "init",
+ (Variable, type(None)),
+ "fluid.layers.StaticRNN.memory",
+ )
+ check_type(
+ shape,
+ "shape",
+ (list, tuple, type(None)),
+ "fluid.layers.StaticRNN.memory",
+ )
+ check_type(
+ batch_ref,
+ "batch_ref",
+ (Variable, type(None)),
+ "fluid.layers.StaticRNN.memory",
+ )
+ if init is None:
+ if shape is None or batch_ref is None:
+ raise ValueError(
+ "if init is None, memory at least need shape and batch_ref"
+ )
+ parent_block = self._parent_block()
+ var_name = unique_name.generate_with_ignorable_key(
+ "@".join([self.helper.name, "memory_boot"])
+ )
+ boot_var = parent_block.create_var(
+ name=var_name,
+ shape=shape,
+ dtype=batch_ref.dtype,
+ persistable=False,
+ )
+
+ parent_block.append_op(
+ type="fill_constant_batch_size_like",
+ inputs={'Input': [batch_ref]},
+ outputs={'Out': [boot_var]},
+ attrs={
+ 'value': init_value,
+ 'shape': boot_var.shape,
+ 'dtype': boot_var.dtype,
+ 'input_dim_idx': ref_batch_dim_idx,
+ 'output_dim_idx': init_batch_dim_idx,
+ },
+ )
+
+ return self.memory(init=boot_var)
+ else:
+ pre_mem = self.helper.create_variable(
+ name=unique_name.generate_with_ignorable_key(
+ "@".join([self.helper.name, "mem"])
+ ),
+ dtype=init.dtype,
+ shape=init.shape,
+ )
+ self.memories[pre_mem.name] = StaticRNNMemoryLink(
+ init=init, pre_mem=pre_mem
+ )
+ return pre_mem
+
+ def step_input(self, x):
+ """
+ Mark a sequence as a StaticRNN input.
+
+ Args:
+ x(Variable): The input sequence, the shape of x
+ should be [seq_len, ...].
+
+ Returns:
+ Variable: The current time step data in the input sequence.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # create prev memory parameter, batch size comes from word
+ prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # use hidden to update prev
+ rnn.update_memory(prev, hidden)
+
+ """
+ self._assert_in_rnn_block_('step_input')
+ check_type(x, "x", Variable, "fluid.layers.StaticRNN.step_input")
+ if self.seq_len is None:
+ self.seq_len = x.shape[0]
+ elif x.shape[0] != -1 and self.seq_len != x.shape[0]:
+ raise ValueError("Static RNN only take fix seq_len input")
+
+ ipt = self.helper.create_variable(
+ name=x.name, dtype=x.dtype, shape=list(x.shape[1:]), type=x.type
+ )
+ self.inputs.append(ipt)
+ return ipt
+
+ def step_output(self, o):
+ """
+ Mark a sequence as a StaticRNN output.
+
+ Args:
+ o(Variable): The output sequence.
+
+ Returns:
+ None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # create prev memory parameter, batch size comes from word
+ prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # use hidden to update prev
+ rnn.update_memory(prev, hidden)
+ rnn.step_output(hidden)
+
+ result = rnn()
+
+ """
+ self._assert_in_rnn_block_('step_output')
+ check_type(o, "o", Variable, "fluid.layers.StaticRNN.step_output")
+
+ tmp_o = self.helper.create_variable_for_type_inference(dtype=o.dtype)
+ self.helper.append_op(
+ type='rnn_memory_helper',
+ inputs={'X': [o]},
+ outputs={'Out': tmp_o},
+ attrs={'dtype': o.dtype},
+ )
+
+ out_var = self._parent_block().create_var(
+ name=tmp_o.name,
+ shape=[self.seq_len] + list(tmp_o.shape),
+ dtype=tmp_o.dtype,
+ )
+
+ self.outputs.append(out_var)
+
+ def output(self, *outputs):
+ """
+ Mark the StaticRNN output variables.
+
+ Args:
+ outputs: The output Tensor, can mark multiple variables as output
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ vocab_size, hidden_size=10000, 200
+ x = fluid.data(name="x", shape=[None, 1, 1], dtype='int64')
+ # create word sequence
+ x_emb = layers.embedding(
+ input=x,
+ size=[vocab_size, hidden_size],
+ dtype='float32',
+ is_sparse=False)
+ # transform batch size to dim 1
+ x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
+
+ rnn = fluid.layers.StaticRNN()
+ with rnn.step():
+ # mark created x_emb as input, each step process a word
+ word = rnn.step_input(x_emb)
+ # create prev memory parameter, batch size comes from word
+ prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
+ hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
+ # use hidden to update prev
+ rnn.update_memory(prev, hidden)
+ # mark each step's hidden and word as output
+ rnn.output(hidden, word)
+
+ result = rnn()
+ """
+ for each in outputs:
+ self.step_output(each)
+
+ def update_memory(self, mem, var):
+ """
+ Update the memory from :code:`mem` to :code:`var`.
+
+ Args:
+ mem(Variable): the memory variable.
+ var(Variable): the plain variable generated in RNN block, used to update memory.
+ var and mem should have same dims and data type.
+
+ Returns:
+ None
+
+ """
+ check_type(mem, "mem", Variable, "fluid.layers.StaticRNN.update_memory")
+ check_type(var, "var", Variable, "fluid.layers.StaticRNN.update_memory")
+ self.memories[mem.name].mem = var
+
+ def _parent_block(self):
+ prog = self.helper.main_program
+ parent_idx = prog.current_block().parent_idx
+ assert parent_idx >= 0
+ parent_block = prog.block(parent_idx)
+ return parent_block
+
+ def __call__(self, *args, **kwargs):
+ if self.status != StaticRNN.AFTER_RNN_BLOCK:
+ raise ValueError("RNN output can only be retrieved after rnn block")
+ if len(self.outputs) == 0:
+ raise ValueError("RNN has no output")
+ elif len(self.outputs) == 1:
+ return self.outputs[0]
+ else:
+ return self.outputs
+
+ def _complete_op(self):
+ main_program = self.helper.main_program
+ rnn_block = main_program.current_block()
+ parent_block = self._parent_block()
+
+ local_inputs = set()
+
+ for op in rnn_block.ops:
+ assert isinstance(op, Operator)
+ for oname in op.output_names:
+ for out_var_name in op.output(oname):
+ local_inputs.add(out_var_name)
+
+ for var in self.inputs:
+ local_inputs.add(var.name)
+ for m in self.memories:
+ local_inputs.add(m)
+
+ # NOTE(zcd): the params have two categories of variables.
+ # - the variables that are the out of StaticRnn.
+ # - the variables that are the parameters of some layers, for example, conv2d.
+ params = list()
+ for op in rnn_block.ops:
+ assert isinstance(op, Operator)
+ for iname in op.input_names:
+ for in_var_name in op.input(iname):
+ if in_var_name not in local_inputs:
+ params.append(in_var_name)
+
+ parameters = [
+ parent_block._find_var_recursive(name) for name in set(params)
+ ]
+
+ step_scope = parent_block.create_var(
+ type=core.VarDesc.VarType.STEP_SCOPES
+ )
+
+ inlinks = [parent_block.var(i.name) for i in self.inputs]
+ outlinks = self.outputs
+
+ # NOTE(zcd): the states maybe empty in some case.
+ boot_memories = []
+ pre_memories = []
+ memories = []
+ for _, mem in six.iteritems(self.memories):
+ boot_memories.append(mem.init)
+ pre_memories.append(mem.pre_mem.name)
+ assert (
+ mem.mem is not None
+ ), "%s should be updated in every step." % (mem.init.name)
+ mem_var = rnn_block.var(mem.mem.name)
+ assert isinstance(mem_var, Variable)
+ new_mem = self.helper.create_variable_for_type_inference(
+ dtype=mem_var.dtype
+ )
+ rnn_block.append_op(
+ type='rnn_memory_helper',
+ inputs={'X': [mem_var]},
+ outputs={'Out': [new_mem]},
+ attrs={'dtype': mem_var.dtype},
+ )
+
+ memories.append(new_mem.name)
+
+ parent_block.append_op(
+ type='recurrent',
+ inputs={
+ 'inputs': inlinks,
+ 'initial_states': boot_memories,
+ 'parameters': parameters,
+ },
+ outputs={'outputs': outlinks, 'step_scopes': [step_scope]},
+ attrs={
+ 'has_states': len(pre_memories) > 0,
+ 'ex_states': pre_memories,
+ 'states': memories,
+ 'sub_block': rnn_block,
+ },
+ )
+
+
+class WhileGuard(BlockGuard):
+ def __init__(self, while_op):
+ if not isinstance(while_op, While):
+ raise TypeError("WhileGuard takes a while op")
+ super(WhileGuard, self).__init__(while_op.helper.main_program)
+ self.while_op = while_op
+
+ def __enter__(self):
+ self.while_op.status = While.IN_WHILE_BLOCK
+ return super(WhileGuard, self).__enter__()
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ if exc_type is not None:
+ return False
+ self.while_op.status = While.AFTER_WHILE_BLOCK
+ self.while_op._complete()
+ return super(WhileGuard, self).__exit__(exc_type, exc_val, exc_tb)
+
+
+def get_inputs_outputs_in_block(
+ current_block, inner_inputs, inner_outputs, helper
+):
+ """
+ Find inputs and outputs in current control flow block.
+ :param current_block: Current control flow block.
+ :param inner_inputs: Input var name of ops in current block.
+ :param inner_outputs: Output var name of ops in current block.
+ :return: inner_inputs, inner_outputs
+ """
+
+ def is_ignore_vars(op, var_name):
+ # NOTE(dev): There are some persistable var created in some non-standard API
+ # such as "contrib.layers.shuffle_batch". It create a "Seed" used both in
+ # Input and Output. This var shall not be considered as a loop_var in
+ # control_flow.
+ IGNORE_VAR_NAMES = {"shuffle_batch": ["shuffle_batch_seed"]}
+ if op.type in IGNORE_VAR_NAMES:
+ var_names = IGNORE_VAR_NAMES[op.type]
+ for name in var_names:
+ if name in var_name:
+ return True
+ return False
+
+ # Step1: update inner_inputs and inner_outputs
+ # NOTE: Here assumes that all variables are input or output of Ops,
+ # but some variables are created without appendding a real op.
+ # For example, in `arr = create_array(dtype)`, `arr` is not a output of a op.
+ for op in current_block.ops:
+ assert isinstance(op, Operator)
+ for iname in op.input_names:
+ for in_var_name in op.input(iname):
+ if in_var_name not in inner_outputs and not is_ignore_vars(
+ op, in_var_name
+ ):
+ inner_inputs.add(in_var_name)
+
+ for oname in op.output_names:
+ for out_var_name in op.output(oname):
+ inner_outputs.add(out_var_name)
+
+ # Step2: Remove LOD_TENSOR_ARRAY created in current control flow block.
+ remove_inner_inputs = set()
+ parent_block = helper.main_program.block(current_block.parent_idx)
+
+ for in_var_name in inner_inputs:
+ parent_block_var = parent_block._find_var_recursive(in_var_name)
+ current_block_var = None
+ if current_block.has_var(in_var_name):
+ current_block_var = current_block.var(in_var_name)
+ if (
+ not parent_block_var
+ and current_block_var
+ and current_block_var.type == core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ ):
+ remove_inner_inputs.add(in_var_name)
+
+ inner_inputs = inner_inputs - remove_inner_inputs
+
+ return inner_inputs, inner_outputs
+
+
+class While(object):
+ """
+ :api_attr: Static Graph
+
+ while loop control flow. Repeat while body until cond is False.
+
+ Note:
+ A new OP :ref:`api_fluid_layers_while_loop` is highly recommended instead of ``While`` if the shape of parameter ``cond`` is [1].
+ OP :ref:`api_fluid_layers_while_loop` is easier to use and is called with less code but does the same thing as ``While`` .
+
+ Notice:
+ Local variables created in ``While`` are similar to that created in while of C++, and cannot be referenced externally.
+ As a result, they cannot be obtained through ``fetch_list`` of ``Executor``. If you would like to access the variable
+ out of ``while`` , PaddlePaddle provides ``assign`` API to assign local variables to external. Please refer to example
+ code 2 or refer to `issue#22724 `_.
+
+ Args:
+ cond(Variable): A Tensor whose data type is bool controlling whether to continue looping.
+ is_test(bool, optional): A flag indicating whether execution is in test phase. Default value is False.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Examples 1:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0) # loop counter
+
+ loop_len = fluid.layers.fill_constant(shape=[1],dtype='int64', value=10) # loop length
+
+ cond = fluid.layers.less_than(x=i, y=loop_len)
+ while_op = fluid.layers.While(cond=cond)
+ with while_op.block():
+ i = fluid.layers.increment(x=i, value=1, in_place=True)
+ fluid.layers.less_than(x=i, y=loop_len, cond=cond)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ res = exe.run(fluid.default_main_program(), feed={}, fetch_list=[i])
+ print(res) # [array([10])]
+
+
+ Examples 2:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
+ loop_len = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
+ one = fluid.layers.fill_constant(shape=[1], dtype='float32', value=1)
+ data = fluid.data(name='data', shape=[1], dtype='float32')
+ sums = fluid.layers.fill_constant(shape=[1], dtype='float32', value=0) # Define the variable to be obtained ouside of While, which name should be different from the variable inside the While to be obtained
+
+ cond = fluid.layers.less_than(x=i, y=loop_len)
+ while_op = fluid.layers.While(cond=cond)
+ with while_op.block():
+ sums_tensor = fluid.layers.elementwise_add(x=data, y=data)
+ fluid.layers.assign(sums_tensor, sums) # Update the value of sums_tensor defined in While to the sums which defined outside of While through layers.assign
+ i = fluid.layers.increment(x=i, value=1, in_place=True)
+ data = fluid.layers.elementwise_add(x=data, y=one)
+ fluid.layers.less_than(x=i, y=loop_len, cond=cond)
+
+ feed_data = np.ones(1).astype('float32')
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+ res = exe.run(fluid.default_main_program(), feed={'data': feed_data}, fetch_list=sums)
+ print(res[0]) # [2.] # Because the data in While does not update the value outside the While, the value of sums is [2.] after the loop
+ """
+
+ BEFORE_WHILE_BLOCK = 0
+ IN_WHILE_BLOCK = 1
+ AFTER_WHILE_BLOCK = 2
+
+ def __init__(self, cond, is_test=False, name=None):
+ self.helper = LayerHelper("while", name=name)
+ self.status = While.BEFORE_WHILE_BLOCK
+ check_variable_and_dtype(cond, 'cond', ['bool'], 'fluid.layers.While')
+ if reduce(lambda a, b: a * b, cond.shape, 1) != 1:
+ raise TypeError(
+ "condition expected shape as [1], but given shape as {0}.".format(
+ list(cond.shape)
+ )
+ )
+ self.cond_var = cond
+ self.is_test = is_test
+
+ def block(self):
+ return WhileGuard(self)
+
+ def _complete(self):
+ main_program = self.helper.main_program
+ while_block = main_program.current_block()
+ parent_block = main_program.block(
+ main_program.current_block().parent_idx
+ )
+
+ inner_outputs = {self.cond_var.name}
+ x_name_list = set()
+ x_name_list, inner_outputs = get_inputs_outputs_in_block(
+ while_block, x_name_list, inner_outputs, self.helper
+ )
+
+ out_vars = []
+ for inner_out_name in inner_outputs:
+ inner_var = parent_block._find_var_recursive(inner_out_name)
+ if inner_var:
+ out_vars.append(inner_var)
+
+ x_name_list |= set(map(lambda x: x.name, out_vars))
+ # NOTE(dev): cond_var has been contained in Input('Condition'), so
+ # we remove it from Input('X')
+ x_name_list -= {self.cond_var.name}
+
+ step_scope = parent_block.create_var(
+ type=core.VarDesc.VarType.STEP_SCOPES
+ )
+
+ parent_block.append_op(
+ type='while',
+ inputs={
+ 'X': [
+ parent_block._var_recursive(x_name)
+ for x_name in x_name_list
+ ],
+ 'Condition': [self.cond_var],
+ },
+ outputs={'Out': out_vars, 'StepScopes': [step_scope]},
+ attrs={'sub_block': while_block, "is_test": self.is_test},
+ )
+
+
+support_ret_buildin_type = (bool, float, six.integer_types)
+
+
+def assign_skip_lod_tensor_array(input, output):
+ """
+ Assign input to output, but skip the process of copying LoDTensorArray unless it's created in while_block.
+ """
+
+ def has_shape_diff(x_var, y_var):
+ if len(x_var.shape) != len(y_var.shape):
+ return True
+ for x_dim, y_dim in zip(x_var.shape, y_var.shape):
+ if x_dim != y_dim and -1 not in [x_dim, y_dim]:
+ return True
+ return False
+
+ if not isinstance(input, (Variable, core.VarBase)):
+ if isinstance(output, Variable) and isinstance(
+ input, support_ret_buildin_type
+ ):
+ assign(input, output)
+ else:
+ output = input
+ return
+
+ if input.type == core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ main_program = input.block.program
+ parent_block = main_program.block(
+ main_program.current_block().parent_idx
+ )
+ if parent_block and not parent_block._find_var_recursive(input.name):
+ assign(input, output)
+ else:
+ if (
+ isinstance(output, Variable)
+ and isinstance(input, Variable)
+ and has_shape_diff(input, output)
+ ):
+ warnings.warn(
+ "In dy2static mode, we attemp to assign a variable with shape {} into a variable with shape{}, which is not always right.".format(
+ input.shape, output.shape
+ )
+ )
+ assign(input, output)
+
+
+def while_loop(cond, body, loop_vars, is_test=False, name=None):
+ """
+ :api_attr: Static Graph
+
+ while_loop is one of the control flows. Repeats while_loop `body` until `cond` returns False.
+
+ Notice:
+ Local variables defined in ``body`` cannot be obtained through ``fetch_list`` of ``Executor`` , variables should
+ be defined outside ``body`` and placed in ``loop_vars`` for looping, then these variables can be fetched by ``fetch_list`` .
+
+ Args:
+ cond(Callable): A callable returning a boolean tensor controlling whether to continue looping. And ``cond`` takes
+ as many arguments as ``loop_vars`` .
+ body(Callable): A callable returning a tuple or list of tensors or LoDTensorArrays of the same arity
+ (length and structure) and types as ``loops_vars`` . And ``body`` takes as many arguments as ``loop_vars`` .
+ loop_vars(list|tuple): A list or tuple of tensors or LoDTensorArrays that is passed to both ``cond`` and ``body`` .
+ is_test(bool, optional): A flag indicating whether execution is in test phase. Default value is False.
+ name(str, optional): Normally there is no need for users to set this property. For more information, please
+ refer to :ref:`api_guide_Name`. Default is None.
+
+ Returns:
+ A list or tuple of Tensors or LoDTensorArrays which returned by ``body`` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ def cond(i, ten):
+ return i < ten
+
+ def body(i, ten):
+ i = i + 1
+ return [i, ten]
+
+ main_program = paddle.static.default_main_program()
+ startup_program = paddle.static.default_startup_program()
+ with paddle.static.program_guard(main_program, startup_program):
+ i = paddle.full(shape=[1], fill_value=0, dtype='int64') # loop counter
+ ten = paddle.full(shape=[1], fill_value=10, dtype='int64') # loop length
+ i, ten = paddle.static.nn.while_loop(cond, body, [i, ten])
+
+ exe = paddle.static.Executor(paddle.CPUPlace())
+ res = exe.run(main_program, feed={}, fetch_list=[i])
+ print(res) # [array([10])]
+ """
+ helper = LayerHelper('while_loop', **locals())
+
+ if not callable(cond):
+ raise TypeError("cond in while_loop should be callable")
+ if not callable(body):
+ raise TypeError("body in while_loop should be callable")
+ check_type(loop_vars, 'loop_vars', (list, tuple), 'fluid.layers.while_loop')
+ if len(loop_vars) == 0:
+ raise ValueError("loop_vars in while_loop should not be empty")
+
+ pre_cond = cond(*loop_vars)
+ check_variable_and_dtype(
+ pre_cond, 'var of cond returned', ['bool'], 'fluid.layers.while_loop'
+ )
+ if reduce(lambda a, b: a * b, pre_cond.shape, 1) != 1:
+ raise TypeError(
+ "the shape of the variable returned by cond should be [1],"
+ "but given shape as {0}.".format(list(pre_cond.shape))
+ )
+
+ if _non_static_mode():
+ now_cond = pre_cond.numpy()[0]
+ while now_cond:
+ output_vars = body(*loop_vars)
+ if not isinstance(output_vars, (list, tuple)):
+ output_vars = [output_vars]
+ if len(output_vars) != len(loop_vars):
+ raise ValueError(
+ "body in while_loop should return the same arity "
+ "(length and structure) and types as loop_vars"
+ )
+ now_cond = cond(*output_vars).numpy()[0]
+ map_structure(assign_skip_lod_tensor_array, output_vars, loop_vars)
+ return loop_vars
+
+ while_loop_block = While(pre_cond, is_test, name)
+ has_mutable_vars_in_loop = hold_mutable_vars(loop_vars)
+ with while_loop_block.block():
+ # If a variable with mutable type is included in loop_vars, like `dict/list`,
+ # modifying it in the body function will cause origin variable to be modified
+ # synchronously. This will raise an assignment error out of while block.
+ # Here we make a copy of the mutable vars to avoid this problem.
+ if has_mutable_vars_in_loop:
+ new_loop_vars = copy_mutable_vars(loop_vars)
+ output_vars = body(*new_loop_vars)
+ else:
+ output_vars = body(*loop_vars)
+ if not isinstance(output_vars, (list, tuple)):
+ output_vars = [output_vars]
+ try:
+ loop_vars = _deal_with_undefined_var(output_vars, loop_vars)
+ assert_same_structure(output_vars, loop_vars, check_types=False)
+ except ValueError as e:
+ raise ValueError(
+ "body in while_loop should return the same arity "
+ "(length and structure) as loop_vars: {0}".format(e)
+ )
+ now_cond = cond(*output_vars)
+ map_structure(assign_skip_lod_tensor_array, output_vars, loop_vars)
+ assign(now_cond, pre_cond)
+ return loop_vars
+
+
+def _deal_with_undefined_var(output_vars, loop_vars):
+ """Deal with undefined var cases, We create undefined variable based on the results of body().
+ In Dy2Static, we use undefined var to represent the var created in control flow. This function
+ expand the loop_vars and replace original loop_vars.
+ 1. UndefinedVar = Variable # create a variable
+ 2. UndefinedVar = None # create a undefined var with RETURN_NO_VALUE_MAGIC_NUM
+ 3. UndefinedVar = List(int) # create a list of variable
+ 4. UndefinedVar = value # create a variable
+ """
+ from paddle.fluid.dygraph.dygraph_to_static.utils import (
+ UndefinedVar,
+ create_undefined_variable,
+ )
+
+ def create_var_like(o_var):
+ if (
+ isinstance(o_var, (Variable,) + support_ret_buildin_type)
+ or o_var is None
+ ):
+ return create_undefined_variable()
+ if is_sequence(o_var):
+ """
+ Create a complex container class inside the body of while, including Python list and python Dict
+ """
+ return map_structure(lambda x: create_undefined_variable(), o_var)
+
+ if len(output_vars) != len(loop_vars):
+ raise ValueError("The length of loop_vars should be the same.")
+
+ results = []
+ for o_var, l_var in zip(output_vars, loop_vars):
+ if isinstance(l_var, UndefinedVar) or l_var is None:
+ results.append(create_var_like(o_var))
+ else:
+ results.append(l_var)
+ return results
+
+
+def lod_rank_table(x, level=0):
+ """
+ LoD Rank Table Operator. Given an input variable **x** and a level number
+ of LoD, this layer creates a LodRankTable object. A LoDRankTable object
+ contains a list of bi-element tuples. Each tuple consists of an index and
+ a length, both of which are int type. Refering to specified level of LoD,
+ the index is the sequence index number and the length represents the
+ sequence length. Please note that the list is ranked in descending order by
+ the length. The following is an example:
+
+ .. code-block:: text
+
+ x is a LoDTensor:
+ x.lod = [[2, 1],
+ [5, 1, 1]]
+ x.data = [a, b, c, d, e, f, g]
+
+ 1. set level to 0:
+ Create lod rank table:
+ lod_rank_table_obj = lod_rank_table(x, level=0)
+
+ Get:
+ lod_rank_table_obj.items() = [(0, 2), (1, 1)]
+
+ 2. set level to 1:
+ Create lod rank table:
+ lod_rank_table_obj = lod_rank_table(x, level=1)
+
+ Get:
+ lod_rank_table_obj.items() = [(0, 5), (1, 1), (2, 1)]
+
+ Args:
+ x (Variable): Input variable, a LoDTensor based which to create the lod
+ rank table.
+ level (int): Specify the LoD level, on which to create the lod rank
+ table.
+
+ Returns:
+ Variable: The created LoDRankTable object.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[10],
+ dtype='float32', lod_level=1)
+ out = layers.lod_rank_table(x=x, level=0)
+ """
+ check_type(x, 'x', (Variable, list), 'lod_rank_table')
+ if isinstance(x, (list)):
+ for i, input_x in enumerate(x):
+ check_type(
+ input_x, 'input[' + str(i) + ']', Variable, 'lod_rank_table'
+ )
+
+ helper = LayerHelper("lod_rank_table", **locals())
+ table = helper.create_variable(
+ type=core.VarDesc.VarType.LOD_RANK_TABLE,
+ name=unique_name.generate("lod_rank_table"),
+ )
+ helper.append_op(
+ type='lod_rank_table',
+ inputs={'X': x},
+ outputs={'Out': table},
+ attrs={'level': level},
+ )
+ return table
+
+
+@templatedoc()
+def max_sequence_len(rank_table):
+ """
+ ${comment}
+
+ >>> import paddle.fluid as fluid
+ >>> x = fluid.layers.data(name='x', shape=[10], dtype='float32',
+ >>> lod_level=1)
+ >>> rank_table = layers.lod_rank_table(x=x, level=0)
+ >>> max_seq_len = layers.max_sequence_len(rank_table)
+
+ Args:
+ rank_table(${rank_table_type}): ${rank_table_comment}.
+
+ Returns:
+ ${out_comment}.
+ """
+ helper = LayerHelper("max_seqence_len", **locals())
+ res = helper.create_variable_for_type_inference(dtype="int64")
+ helper.append_op(
+ type="max_sequence_len",
+ inputs={"RankTable": rank_table},
+ outputs={"Out": res},
+ )
+ return res
+
+
+def lod_tensor_to_array(x, table):
+ """
+ Convert a LoDTensor to a LoDTensorArray.
+
+ This function split a LoDTesnor to a LoDTensorArray according to its LoD
+ information. LoDTensorArray is an alias of C++ std::vector in
+ PaddlePaddle. The generated LoDTensorArray of this function can be further read
+ or written by `read_from_array()` and `write_to_array()` operators. However,
+ this function is generally an internal component of PaddlePaddle `DynamicRNN`.
+ Users should not use it directly.
+
+ Args:
+ x (Variable|list): The LoDTensor to be converted to a LoDTensorArray.
+ table (ParamAttr|list): The variable that stores the level of lod
+ which is ordered by sequence length in
+ descending order. It is generally generated
+ by `layers.lod_rank_table()` API.
+
+ Returns:
+ Variable: The LoDTensorArray that has been converted from the input tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[10])
+ table = fluid.layers.lod_rank_table(x, level=0)
+ array = fluid.layers.lod_tensor_to_array(x, table)
+ """
+ check_type(x, 'x', (Variable, list), 'lod_tensor_to_array')
+ if isinstance(x, (list)):
+ for i, input_x in enumerate(x):
+ check_type(
+ input_x,
+ 'input[' + str(i) + ']',
+ Variable,
+ 'lod_tensor_to_array',
+ )
+ check_type(table, 'table', (Variable, list), 'lod_tensor_to_array')
+ if isinstance(table, (list)):
+ for i, table_x in enumerate(table):
+ check_type(
+ table_x,
+ 'table[' + str(i) + ']',
+ Variable,
+ 'lod_tensor_to_array',
+ )
+ helper = LayerHelper("lod_tensor_to_array", **locals())
+ array = helper.create_variable(
+ name=unique_name.generate("lod_tensor_to_array"),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=x.dtype,
+ )
+ helper.append_op(
+ type='lod_tensor_to_array',
+ inputs={'X': x, 'RankTable': table},
+ outputs={'Out': array},
+ )
+ return array
+
+
+def array_to_lod_tensor(x, table):
+ """Convert a LoD_Tensor_Aarry to an LoDTensor.
+
+ Args:
+ x (Variable|list): The lod tensor array to be converted to a tensor.
+ table (ParamAttr|list): The variable that stores the level of lod
+ which is ordered by sequence length in
+ descending order.
+
+ Returns:
+ Variable: The variable of type tensor that has been converted
+ from an array.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[10])
+ table = fluid.layers.lod_rank_table(x, level=0)
+ array = fluid.layers.lod_tensor_to_array(x, table)
+ lod_tensor = fluid.layers.array_to_lod_tensor(array, table)
+ """
+ check_type(x, 'x', (Variable, list), 'array_to_lod_tensor')
+ if isinstance(x, (list)):
+ for i, input_x in enumerate(x):
+ check_type(
+ input_x,
+ 'input[' + str(i) + ']',
+ Variable,
+ 'array_to_lod_tensor',
+ )
+ check_type(table, 'table', (Variable, list), 'array_to_lod_tensor')
+ if isinstance(table, (list)):
+ for i, table_x in enumerate(table):
+ check_type(
+ table_x,
+ 'table[' + str(i) + ']',
+ Variable,
+ 'array_to_lod_tensor',
+ )
+
+ helper = LayerHelper("array_to_lod_tensor", **locals())
+ tmp = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type="array_to_lod_tensor",
+ inputs={'X': x, 'RankTable': table},
+ outputs={'Out': tmp},
+ )
+ return tmp
+
+
+def increment(x, value=1.0, in_place=True):
+ """
+ The OP is usually used for control flow to increment the data of :attr:`x` by an amount :attr:`value`.
+ Notice that the number of elements in :attr:`x` must be equal to 1.
+
+ Parameters:
+ x (Variable): A tensor that must always contain only one element, its data type supports
+ float32, float64, int32 and int64.
+ value (float, optional): The amount to increment the data of :attr:`x`. Default: 1.0.
+ in_place (bool, optional): Whether the OP should be performed in-place. Default: True.
+
+ Returns:
+ Variable: The elementwise-incremented tensor with the same shape and data type as :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ counter = fluid.layers.zeros(shape=[1], dtype='float32') # [0.]
+ fluid.layers.increment(counter) # [1.]
+ """
+ if in_dygraph_mode():
+ return _C_ops.increment_(x, value)
+
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64'], 'increment'
+ )
+ helper = LayerHelper("increment", **locals())
+ if not in_place:
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ else:
+ out = x
+ helper.append_op(
+ type='increment',
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={'step': float(value)},
+ )
+ return out
+
+
+def array_write(x, i, array=None):
+ """
+ This OP writes the input ``x`` into the i-th position of the ``array``
+ :ref:`api_fluid_LoDTensorArray` and returns the modified array.
+ If ``array`` is none, a new LoDTensorArray will be created and returned.
+ This OP is often used together with :ref:`api_fluid_layers_array_read` OP.
+
+ Args:
+ x (Variable): The input data to be written into array. It's multi-dimensional
+ Tensor or LoDTensor. Data type: float32, float64, int32, int64.
+ i (Variable): 1-D Tensor with shape [1], which represents the position into which
+ ``x`` is written. Data type: int64.
+ array (LoDTensorArray, optional): The LoDTensorArray into which ``x`` is written.
+ The default value is None, when a new LoDTensorArray will be created and returned
+ as a result.
+
+ Returns:
+ Variable: The input ``array`` after ``x`` is written into.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ tmp = fluid.layers.fill_constant(shape=[3, 2], dtype='int64', value=5)
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
+ # Write tmp into the position of arr with subscript 10 and return arr.
+ arr = fluid.layers.array_write(tmp, i=i)
+
+ # Now, arr is a LoDTensorArray with length 11. We can use array_read OP to read
+ # the data at subscript 10 and print it out.
+ item = fluid.layers.array_read(arr, i=i)
+ input = fluid.layers.Print(item, message="The content of i-th LoDTensor:")
+ main_program = fluid.default_main_program()
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(main_program)
+
+ # The printed result is:
+ # 1570533133 The content of i-th LoDTensor: The place is:CPUPlace
+ # Tensor[array_read_0.tmp_0]
+ # shape: [3,2,]
+ # dtype: l
+ # data: 5,5,5,5,5,5,
+
+ # the output is 2-D Tensor with shape [3,2], which is tmp above.
+ # dtype is the corresponding C++ data type, which may vary in different environments.
+ # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t,
+ # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux,
+ # and '__int64' on Windows. They both represent 64-bit integer variables.
+
+ """
+ if _non_static_mode():
+ assert isinstance(
+ x, Variable
+ ), "The input data 'x' in array_write must be Variable in dygraph mode"
+ assert isinstance(
+ i, Variable
+ ), "The index 'i' in array_write must be Variable in dygraph mode"
+ assert i.shape == [
+ 1
+ ], "The shape of index 'i' should be [1] in dygraph mode"
+ i = i.numpy().item(0)
+ if array is None:
+ array = create_array(x.dtype)
+ assert isinstance(
+ array, list
+ ), "The 'array' in array_write must be a list in dygraph mode"
+ assert i <= len(
+ array
+ ), "The index 'i' should not be greater than the length of 'array' in dygraph mode"
+ if i < len(array):
+ array[i] = x
+ else:
+ array.append(x)
+ return array
+
+ check_variable_and_dtype(i, 'i', ['int64'], 'array_write')
+ check_type(x, 'x', (Variable), 'array_write')
+ helper = LayerHelper('array_write', **locals())
+ if array is not None:
+ if (
+ not isinstance(array, Variable)
+ or array.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ ):
+ raise TypeError(
+ "array should be tensor array vairable in array_write Op"
+ )
+ if array is None:
+ array = helper.create_variable(
+ name="{0}.out".format(helper.name),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=x.dtype,
+ )
+ helper.append_op(
+ type='write_to_array',
+ inputs={'X': [x], 'I': [i]},
+ outputs={'Out': [array]},
+ )
+ return array
+
+
+def create_array(dtype, initialized_list=None):
+ """
+ This OP creates an LOD_TENSOR_ARRAY. It is used as
+ the input of :ref:`api_fluid_layers_array_read` and
+ :ref:`api_fluid_layers_array_write`. Also it can be used
+ with :ref:`api_fluid_layers_While` to create RNN network.
+
+ Args:
+ dtype (str): The data type of the elements in the lod_tensor_array.
+ Support data type: float32, float64, int32, int64.
+ initialized_list(list): Used to initialize as default value for created array.
+ All values in initialized list should be a Tensor.
+
+ Returns:
+ Variable: The empty lod_tensor_array. The data type of elements in Tensor is ``dtype``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.create_array(dtype='float32') # Create a float32 LoDTensorArray.
+
+ """
+ array = []
+ if initialized_list is not None:
+ if not isinstance(initialized_list, (list, tuple)):
+ raise TypeError(
+ "Require type(initialized_list) should be list/tuple, but received {}".format(
+ type(initialized_list)
+ )
+ )
+ array = list(initialized_list)
+
+ # NOTE: Only support plain list like [x, y,...], not support nested list in static mode.
+ for val in array:
+ if not isinstance(val, Variable):
+ raise TypeError(
+ "All values in `initialized_list` should be Variable, but recevied {}.".format(
+ type(val)
+ )
+ )
+
+ if _non_static_mode():
+ return array
+
+ helper = LayerHelper("array", **locals())
+ tensor_array = helper.create_variable(
+ name="{0}.out".format(helper.name),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=dtype,
+ )
+
+ for val in array:
+ array_write(x=val, i=array_length(tensor_array), array=tensor_array)
+
+ return tensor_array
+
+
+@templatedoc()
+def less_than(x, y, force_cpu=None, cond=None, name=None):
+ """
+
+ ${comment}
+
+ Args:
+ x(Tensor): ${x_comment}.
+ y(Tensor): ${y_comment}.
+ force_cpu(${force_cpu_type}): ${force_cpu_comment}.
+ cond(Tensor, optional): Optional output which can be any created Tensor
+ that meets the requirements to store the result of *less_than*.
+ if cond is None, a new Tensor will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+ Returns:
+ ${out_comment}.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([1, 2, 3, 4], dtype='float32')
+ y = paddle.to_tensor([2, 2, 1, 3], dtype='float32')
+ result = paddle.less_than(x, y)
+ print(result) # [True, False, False, False]
+
+ """
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "less_than"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "less_than"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "less_than")
+ if force_cpu != None:
+ check_type(force_cpu, "force_cpu", bool, "less_than")
+
+ helper = LayerHelper("less_than", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ attrs = dict()
+ if force_cpu is not None:
+ attrs['force_cpu'] = force_cpu
+
+ helper.append_op(
+ type='less_than',
+ inputs={'X': [x], 'Y': [y]},
+ outputs={'Out': [cond]},
+ attrs=attrs,
+ )
+ return cond
+
+
+@templatedoc()
+def less_equal(x, y, cond=None, name=None):
+ """
+ :alias_main: paddle.less_equal
+ :alias: paddle.less_equal,paddle.tensor.less_equal,paddle.tensor.logic.less_equal
+ :old_api: paddle.fluid.layers.less_equal
+
+ This OP returns the truth value of :math:`x <= y` elementwise, which is equivalent function to the overloaded operator `<=`.
+
+ Args:
+ x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *less_equal*.
+ if cond is None, a new Varibale will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ label = fluid.layers.assign(np.array([1, 3], dtype='int32'))
+ limit = fluid.layers.assign(np.array([1, 2], dtype='int32'))
+ out = fluid.layers.less_equal(x=label, y=limit) #out=[True, False]
+ out1 = label<= limit #out1=[True, False]
+
+ """
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "less_equal"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "less_equal"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "less_equal")
+
+ helper = LayerHelper("less_equal", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ attrs = dict()
+
+ helper.append_op(
+ type='less_equal',
+ inputs={'X': [x], 'Y': [y]},
+ outputs={'Out': [cond]},
+ attrs=attrs,
+ )
+ return cond
+
+
+@templatedoc()
+def greater_than(x, y, cond=None, name=None):
+ """
+ :alias_main: paddle.greater_than
+ :alias: paddle.greater_than,paddle.tensor.greater_than,paddle.tensor.logic.greater_than
+ :old_api: paddle.fluid.layers.greater_than
+
+ This OP returns the truth value of :math:`x > y` elementwise, which is equivalent function to the overloaded operator `>`.
+
+ Args:
+ x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *greater_than*.
+ if cond is None, a new Varibale will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ label = fluid.layers.assign(np.array([2, 3], dtype='int32'))
+ limit = fluid.layers.assign(np.array([3, 2], dtype='int32'))
+ out = fluid.layers.greater_than(x=label, y=limit) #out=[False, True]
+ out1 = label > limit #out1=[False, True]
+ """
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "greater_than"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "greater_than"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "greater_than")
+
+ helper = LayerHelper("greater_than", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ attrs = dict()
+
+ if in_dygraph_mode():
+ return _C_ops.greater_than(x, y, -1)
+ else:
+ helper.append_op(
+ type='greater_than',
+ inputs={'X': [x], 'Y': [y]},
+ outputs={'Out': [cond]},
+ attrs=attrs,
+ )
+ return cond
+
+
+@templatedoc()
+def greater_equal(x, y, cond=None, name=None):
+ """
+ :alias_main: paddle.greater_equal
+ :alias: paddle.greater_equal,paddle.tensor.greater_equal,paddle.tensor.logic.greater_equal
+ :old_api: paddle.fluid.layers.greater_equal
+
+ This OP returns the truth value of :math:`x >= y` elementwise, which is equivalent function to the overloaded operator `>=`.
+
+ Args:
+ x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *greater_equal*.
+ if cond is None, a new Varibale will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ label = fluid.layers.assign(np.array([2, 2], dtype='int32'))
+ limit = fluid.layers.assign(np.array([2, 3], dtype='int32'))
+ out = fluid.layers.greater_equal(x=label, y=limit) #out=[True, False]
+ out_1 = label >= limit #out1=[True, False]
+
+ """
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "greater_equal"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "greater_equal"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "greater_equal")
+
+ helper = LayerHelper("greater_equal", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ attrs = dict()
+
+ helper.append_op(
+ type='greater_equal',
+ inputs={'X': [x], 'Y': [y]},
+ outputs={'Out': [cond]},
+ attrs=attrs,
+ )
+ return cond
+
+
+def equal(x, y, cond=None, name=None):
+ """
+ This layer returns the truth value of :math:`x == y` elementwise.
+
+ Args:
+ x(Variable): Tensor, data type is float32, float64, int32, int64.
+ y(Variable): Tensor, data type is float32, float64, int32, int64.
+ cond(Variable, optional): Optional output which can be any created
+ Variable that meets the requirements to store the result of *equal*.
+ if cond is None, a new Varibale will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable: output Tensor, it's shape is the same as the input's Tensor,
+ and the data type is bool.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ out_cond =fluid.data(name="input1", shape=[2], dtype='bool')
+ label = fluid.layers.assign(np.array([3, 3], dtype="int32"))
+ limit = fluid.layers.assign(np.array([3, 2], dtype="int32"))
+ label_cond = fluid.layers.assign(np.array([1, 2], dtype="int32"))
+ out1 = fluid.layers.equal(x=label,y=limit) #out1=[True, False]
+ out2 = fluid.layers.equal(x=label_cond,y=limit, cond=out_cond) #out2=[False, True] out_cond=[False, True]
+ """
+ if in_dygraph_mode():
+ default_axis = -1
+ return _C_ops.equal(x, y, default_axis)
+
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "equal"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "equal"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "equal")
+
+ helper = LayerHelper("equal", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ helper.append_op(
+ type='equal', inputs={'X': [x], 'Y': [y]}, outputs={'Out': [cond]}
+ )
+ return cond
+
+
+def not_equal(x, y, cond=None, name=None):
+ """
+ :alias_main: paddle.not_equal
+ :alias: paddle.not_equal,paddle.tensor.not_equal,paddle.tensor.logic.not_equal
+ :old_api: paddle.fluid.layers.not_equal
+
+ This OP returns the truth value of :math:`x != y` elementwise, which is equivalent function to the overloaded operator `!=`.
+
+ Args:
+ x(Variable): First input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ y(Variable): Second input to compare which is N-D tensor. The input data type should be float32, float64, int32, int64.
+ cond(Variable, optional): Optional output which can be any created Variable that meets the requirements to store the result of *not_equal*.
+ if cond is None, a new Varibale will be created to store the result.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable, the output data type is bool: The tensor variable storing the output, the output shape is same as input :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+ limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64')
+ out = fluid.layers.not_equal(x=label, y=limit)
+ """
+ check_variable_and_dtype(
+ x, "x", ["float32", "float64", "int32", "int64"], "not_equal"
+ )
+ check_variable_and_dtype(
+ y, "y", ["float32", "float64", "int32", "int64"], "not_equal"
+ )
+ if cond is not None:
+ check_type(cond, "cond", Variable, "not_equal")
+
+ helper = LayerHelper("not_equal", **locals())
+ if cond is None:
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ helper.append_op(
+ type='not_equal', inputs={'X': [x], 'Y': [y]}, outputs={'Out': [cond]}
+ )
+ return cond
+
+
+def array_read(array, i):
+ """
+ This OP is used to read data at the specified position from the input array
+ :ref:`api_fluid_LoDTensorArray` . ``array`` is the input array and ``i``
+ is the specified read position. This OP is often used together with
+ :ref:`api_fluid_layers_array_write` OP.
+
+ Case 1:
+ ::
+ Input:
+ The shape of first three tensors are [1], and that of the last one is [1,2]:
+ array = ([0.6], [0.1], [0.3], [0.4, 0.2])
+ And:
+ i = [3]
+
+ Output:
+ output = [0.4, 0.2]
+
+ Args:
+ array (LoDTensorArray): The input LoDTensorArray.
+ i (Variable): 1-D Tensor, whose shape is [1] and dtype is int64. It represents the
+ specified read position of ``array``.
+
+ Returns:
+ Variable: The LoDTensor or Tensor that is read at the specified position of ``array``.
+
+ Examples:
+ .. code-block:: python
+
+ # First we're going to create a LoDTensorArray, then we're going to write the Tensor into
+ # the specified position, and finally we're going to read the Tensor at that position.
+ import paddle.fluid as fluid
+ arr = fluid.layers.create_array(dtype='float32')
+ tmp = fluid.layers.fill_constant(shape=[3, 2], dtype='int64', value=5)
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
+ # tmp is the Tensor with shape [3,2], and if we write it into the position with subscript 10
+ # of the empty-array: arr, then the length of arr becomes 11.
+ arr = fluid.layers.array_write(tmp, i, array=arr)
+ # Read the data of the position with subscript 10.
+ item = fluid.layers.array_read(arr, i)
+
+ # You can print out the data via executor.
+ input = fluid.layers.Print(item, message="The LoDTensor of the i-th position:")
+ main_program = fluid.default_main_program()
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(main_program)
+
+ # The printed result is:
+
+ # 1569588169 The LoDTensor of the i-th position: The place is:CPUPlace
+ # Tensor[array_read_0.tmp_0]
+ # shape: [3,2,]
+ # dtype: l
+ # data: 5,5,5,5,5,5,
+
+ # the output is 2-D Tensor with shape [3,2].
+ # dtype is the corresponding C++ data type, which may vary in different environments.
+ # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t,
+ # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux,
+ # and '__int64' on Windows. They both represent 64-bit integer variables.
+ """
+ if _non_static_mode():
+ assert isinstance(
+ array, list
+ ), "The 'array' in array_read must be list in dygraph mode"
+ assert isinstance(
+ i, Variable
+ ), "The index 'i' in array_read must be Variable in dygraph mode"
+ assert i.shape == [
+ 1
+ ], "The shape of index 'i' should be [1] in dygraph mode"
+ i = i.numpy().item(0)
+ return array[i]
+
+ check_variable_and_dtype(i, 'i', ['int64'], 'array_read')
+ helper = LayerHelper('array_read', **locals())
+ if (
+ not isinstance(array, Variable)
+ or array.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ ):
+ raise TypeError("array should be tensor array vairable")
+ out = helper.create_variable_for_type_inference(dtype=array.dtype)
+ helper.append_op(
+ type='read_from_array',
+ inputs={'X': [array], 'I': [i]},
+ outputs={'Out': [out]},
+ )
+ return out
+
+
+def shrink_memory(x, i, table):
+ """
+ This function creates an operator to shrink rnn memory using the RankTable
+ as mentioned in the input parameter.
+
+ NOTE: This API is very low-level API. It is used by DynamicRNN only.
+
+ Since the Dynamic RNN uses no-padding way to implement RNN. The sequence
+ will be sorted by order, and the length of valid memory will be shrink after
+ each time step.
+
+ Args:
+ x(Variable): The memory object in the previous time step.
+ i(Variable): The step count variable. A int scalar as LoDTensor.
+ table(Variable): The RNNRankTable object.
+
+ Returns:
+ the memory variable after shrink.
+
+ Examples:
+
+ Since this API is very low level API. The example is not provided.
+ Please reference the implementation of class DynamicRNN for detail
+ usage.
+ """
+ helper = LayerHelper('shrink_memory', **locals())
+ check_type(x, 'x', Variable, 'shrink_memory')
+ check_type(i, 'i', Variable, 'shrink_memory')
+ check_type(table, 'table', Variable, 'shrink_memory')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='shrink_rnn_memory',
+ inputs={'X': [x], 'I': [i], 'RankTable': [table]},
+ outputs={'Out': [out]},
+ attrs={},
+ )
+ return out
+
+
+def array_length(array):
+ """
+ This OP is used to get the length of the input array :ref:`api_fluid_LoDTensorArray` .
+ It can be used together with :ref:`api_fluid_layers_array_read` , :ref:`api_fluid_layers_array_write` ,
+ :ref:`api_fluid_layers_While` OP to traverse, read and write LoDTensorArray.
+
+ Args:
+ array (LoDTensorArray): The input array that will be used to compute the length.
+
+ Returns:
+ Variable: 1-D Tensor with shape [1], which is the length of array. Datatype: int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ tmp = fluid.layers.zeros(shape=[10], dtype='int32')
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
+ # tmp is 1-D Tensor with shape [10]. We write tmp into arr on subscript 10,
+ # then the length of arr becomes 11.
+ arr = fluid.layers.array_write(tmp, i=i)
+ # return the length of arr
+ arr_len = fluid.layers.array_length(arr)
+
+ # You can use executor to print out the length of LoDTensorArray.
+ input = fluid.layers.Print(arr_len, message="The length of LoDTensorArray:")
+ main_program = fluid.default_main_program()
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(main_program)
+
+ # The printed result is:
+
+ # 1569576542 The length of LoDTensorArray: The place is:CPUPlace
+ # Tensor[array_length_0.tmp_0]
+ # shape: [1,]
+ # dtype: l
+ # data: 11,
+
+ # 1-D Tensor with shape [1], whose value is 11. It means that the length of LoDTensorArray
+ # is 11.
+ # dtype is the corresponding C++ data type, which may vary in different environments.
+ # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t,
+ # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux,
+ # and '__int64' on Windows. They both represent 64-bit integer variables.
+ """
+
+ if _non_static_mode():
+ assert isinstance(
+ array, list
+ ), "The 'array' in array_write must be a list in dygraph mode"
+ return len(array)
+
+ if (
+ not isinstance(array, Variable)
+ or array.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ ):
+ raise TypeError(
+ "array should be tensor array vairable in array_length Op"
+ )
+
+ helper = LayerHelper('array_length', **locals())
+ tmp = helper.create_variable_for_type_inference(dtype='int64')
+ tmp.stop_gradient = True
+ helper.append_op(
+ type='lod_array_length', inputs={'X': [array]}, outputs={'Out': [tmp]}
+ )
+ return tmp
+
+
+class ConditionalBlockGuard(BlockGuard):
+ """
+ ConditionalBlockGuard is derived from BlockGuard. It is dedicated for
+ holding a ConditionalBlock, and helping users entering and exiting the
+ ConditionalBlock via Python's 'with' keyword. However, ConditionalBlockGuard
+ is generally an internal component of IfElse, users should not use it directly.
+ """
+
+ def __init__(self, block):
+ check_type(block, "block", ConditionalBlock, "ConditionalBlockGuard")
+ super(ConditionalBlockGuard, self).__init__(block.helper.main_program)
+ self.block = block
+
+ def __enter__(self):
+ return super(ConditionalBlockGuard, self).__enter__()
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.block.complete()
+ return super(ConditionalBlockGuard, self).__exit__(
+ exc_type, exc_val, exc_tb
+ )
+
+
+class ConditionalBlock(object):
+ '''
+ **ConditionalBlock**
+
+ ConditionalBlock is an operator that bind a block to a specific condition,
+ if the condition matches, the corresponding block will be executed.
+
+ Args:
+ inputs (Variable): bool conditions.
+ is_scalar_condition (bool): whether the branch is controlled by a scalar.
+ name(str): name of this ConditionalBlock.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ cond = layers.less_than(x=label, y=limit)
+ true_image, false_image = layers.split_lod_tensor(
+ input=image, mask=cond)
+ true_cond = layers.ConditionalBlock([true_image])
+
+ with true_cond.block():
+ ...
+ with false_cond.block():
+ ...
+ '''
+
+ def __init__(self, inputs, is_scalar_condition=False, name=None):
+ for each_input in inputs:
+ check_type(each_input, "input", Variable, "ConditionalBlock")
+ self.inputs = inputs
+ self.is_scalar_condition = is_scalar_condition
+ self.helper = LayerHelper('conditional_block', name=name)
+
+ def block(self):
+ return ConditionalBlockGuard(self)
+
+ def complete(self):
+ inside_block = self.helper.main_program.current_block()
+ parent_block = self.helper.main_program.block(inside_block.parent_idx)
+
+ intermediate = set()
+ params = set()
+ params, intermediate = get_inputs_outputs_in_block(
+ inside_block, params, intermediate, helper=self.helper
+ )
+
+ # Todo(liym27) Here assume that all params are in recursive parent block
+ # but when minimize() called in control flow, some params may be in
+ # conditional grad block
+ param_list = [
+ parent_block._var_recursive(each_name) for each_name in params
+ ]
+
+ out_list = []
+ for inner_out_name in intermediate:
+ inner_var = parent_block._find_var_recursive(inner_out_name)
+ if inner_var:
+ out_list.append(inner_var)
+
+ step_scope = parent_block.create_var(
+ type=core.VarDesc.VarType.STEP_SCOPES
+ )
+ conditional_block_op = parent_block.append_op(
+ type='conditional_block',
+ inputs={
+ 'Cond': self.inputs,
+ 'Input': param_list,
+ },
+ outputs={'Out': out_list, 'Scope': [step_scope]},
+ attrs={
+ 'sub_block': inside_block,
+ 'is_scalar_condition': self.is_scalar_condition,
+ },
+ )
+
+ if self.need_append_conditional_block_grad(inside_block):
+ self.append_conditional_block_grad(
+ parent_block, inside_block, conditional_block_op
+ )
+
+ def need_append_conditional_block_grad(self, inside_block):
+ grad_sub_block_idx = inside_block.backward_block_idx
+ inside_block_idx = inside_block.idx
+
+ # if inside_block have grad_block and grad_block is not itself,
+ # we will append conditional block grad.
+ return (
+ grad_sub_block_idx != -1 and grad_sub_block_idx != inside_block_idx
+ )
+
+ def append_conditional_block_grad(
+ self, parent_block, inside_block, conditional_block_op
+ ):
+ '''
+ Append op `conditional_block_grad` manually.
+ When `optimizer.minimize/append_backward` is called in Paddle control flow,
+ grad ops will be appended before appending op `conditional_block` so that
+ op `conditional_block_grad` can't be appended when calling
+ `optimizer.minimize/append_backward`. After appending op `conditional_block`,
+ `conditional_block_grad` is appended manually.
+
+ Args:
+ parent_block (Block): The block that `conditional_block_op` blongs to.
+ inside_block (Block): The sub block of `conditional_block_op`.
+ conditional_block_op (Operator): The forward op conditional_block.
+ '''
+
+ grad_sub_block_idx = inside_block.backward_block_idx
+ grad_sub_block = self.helper.main_program.block(grad_sub_block_idx)
+
+ intermediate = set()
+ params = set()
+
+ for each_op in grad_sub_block.ops:
+ assert isinstance(each_op, Operator)
+ for iname in each_op.input_names:
+ for in_var_name in each_op.input(iname):
+ if in_var_name not in intermediate:
+ params.add(in_var_name)
+
+ for oname in each_op.output_names:
+ for out_var_name in each_op.output(oname):
+ intermediate.add(out_var_name)
+
+ param_list = []
+ for inner_input_name in params:
+ inner_var = parent_block._find_var_recursive(inner_input_name)
+ if inner_var:
+ param_list.append(cpt.to_text(inner_var.name))
+
+ grad_op_desc, op_grad_to_var = core.get_grad_op_desc(
+ conditional_block_op.desc, cpt.to_text(set()), [grad_sub_block.desc]
+ )
+
+ # append op_desc in grad_op_descs to target_block
+ op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ new_op_desc = parent_block.desc.append_op()
+ new_op_desc.copy_from(grad_op_desc[0])
+ new_op_desc._set_attr(op_role_attr_name, backward)
+ # set input and output manually
+ new_op_desc.set_input('Input', param_list)
+ new_op_desc.set_output(
+ 'Input@GRAD', [param + "@GRAD" for param in param_list]
+ )
+
+ new_vars = set()
+ for grad_var_name in new_op_desc.output_arg_names():
+ if (
+ grad_sub_block.desc.has_var_recursive(
+ cpt.to_bytes(grad_var_name)
+ )
+ or grad_var_name == core.empty_var_name()
+ ):
+ continue
+ grad_sub_block.desc.var(cpt.to_bytes(grad_var_name))
+ new_vars.add(grad_var_name)
+ if grad_var_name not in op_grad_to_var:
+ continue
+
+ # infer_shape and infer_type
+ new_op_desc.infer_var_type(grad_sub_block.desc)
+ new_op_desc.infer_shape(grad_sub_block.desc)
+
+ for arg in new_op_desc.output_arg_names():
+ if arg in new_vars:
+ _infer_var_data_type_shape_(arg, grad_sub_block)
+
+ self.helper.main_program._sync_with_cpp()
+
+
+def copy_var_to_parent_block(var, layer_helper):
+ if not isinstance(var, Variable):
+ return var
+ prog = layer_helper.main_program
+ parent_idx = prog.current_block().parent_idx
+ assert (
+ parent_idx >= 0
+ ), "Got wrong parent block index when assigning var to parent scope in control_flow"
+ parent_block = prog.block(parent_idx)
+
+ if (
+ var.type == core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ and parent_block._find_var_recursive(var.name)
+ ):
+ parent_block_var = var
+ else:
+ parent_block_var = parent_block.create_var(
+ dtype=var.dtype, shape=var.shape, type=var.type
+ )
+ assign(var, parent_block_var)
+ return parent_block_var
+
+
+def cond(pred, true_fn=None, false_fn=None, name=None, return_names=None):
+ """
+ This API returns ``true_fn()`` if the predicate ``pred`` is true else
+ ``false_fn()`` . Users could also set ``true_fn`` or ``false_fn`` to
+ ``None`` if do nothing and this API will treat the callable simply returns
+ ``None`` in this case.
+
+ ``true_fn`` and ``false_fn`` should return same nest structure of tensors
+ or both return ``None`` if user doens't like to return anything. A nest
+ structure of tensors in PaddlePaddle is tensor(s), or tuple of tensors, or
+ list of tensors.
+
+ Note:
+ 1. The tuples or lists returned by ``true_fn`` and ``false_fn`` must have
+ the same shape because of dataflow model of PaddlePaddle while the
+ tensors in the tuples or the lists can have different shapes.
+
+ 2. This API could be used under both static mode or dygraph mode. If it
+ is in dygraph mode, the API only runs one branch based on condition.
+
+ 3. If it is in static mode, any tensors or operations created outside
+ or inside of ``true_fn`` and ``false_fn`` will be in net building
+ regardless of which branch is selected at runtime. This has frequently
+ surprised users who expected a lazy semantics. For example:
+
+ .. code-block:: python
+
+ import paddle
+
+ a = paddle.zeros((1, 1))
+ b = paddle.zeros((1, 1))
+ c = a * b
+ out = paddle.static.nn.cond(a < b, lambda: a + c, lambda: b * b)
+
+ No matter whether ``a < b`` , ``c = a * b`` will be in net building and
+ run. ``a + c`` and ``b * b`` will be in net building, but only one
+ branch will be executed during runtime.
+
+ Args:
+ pred(Tensor): A boolean tensor whose numel should be 1. The boolean
+ value determines whether to return the result of ``true_fn`` or
+ ``false_fn`` .
+ true_fn(callable, optional): A callable to be performed if ``pred`` is
+ true. The default value is ``None`` .
+ false_fn(callable, optional): A callable to be performed if ``pred`` is
+ false. The default value is ``None`` .
+ name(str, optional): The default value is ``None`` . Normally users
+ don't have to set this parameter. For more information, please
+ refer to :ref:`api_guide_Name` .
+ return_names(sequence of string, optional): The default value is ``None`` .
+ Normally users don't have to set this parameters. A sequence of strings
+ to represents the name of returned vars. The structure of sequence must
+ be same with return values of true_fn and false_fn.
+
+ Returns:
+ Tensor|list(Tensor)|tuple(Tensor): returns ``true_fn()`` if the
+ predicate ``pred`` is true else ``false_fn()`` .
+
+ Raises:
+ TypeError: if ``true_fn`` or ``false_fn`` is not callable.
+ ValueError: if ``true_fn`` and ``false_fn`` don't return the same nest
+ structure of tensors.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ #
+ # pseudocode:
+ # if 0.1 < 0.23:
+ # return 1, True
+ # else:
+ # return 3, 2
+ #
+
+ def true_func():
+ return paddle.full(shape=[1, 2], dtype='int32',
+ fill_value=1), paddle.full(shape=[2, 3],
+ dtype='bool',
+ fill_value=True)
+
+
+ def false_func():
+ return paddle.full(shape=[3, 4], dtype='float32',
+ fill_value=3), paddle.full(shape=[4, 5],
+ dtype='int64',
+ fill_value=2)
+
+
+ x = paddle.full(shape=[1], dtype='float32', fill_value=0.1)
+ y = paddle.full(shape=[1], dtype='float32', fill_value=0.23)
+ pred = paddle.less_than(x=x, y=y, name=None)
+ ret = paddle.static.nn.cond(pred, true_func, false_func)
+ # ret is a tuple containing 2 tensors
+ # ret[0] = [[1 1]]
+ # ret[1] = [[ True True True]
+ # [ True True True]]
+
+ """
+ if _non_static_mode():
+ assert isinstance(pred, Variable), "The pred in cond must be Variable"
+ assert pred.size == 1, "condition input's numel should be 1"
+ pred = pred.numpy()[0]
+ if pred:
+ if true_fn is not None:
+ if not callable(true_fn):
+ raise TypeError(
+ "The true_fn in cond must be callable, but received {}".format(
+ type(true_fn).__name__
+ )
+ )
+ return true_fn()
+ else:
+ if false_fn is not None:
+ if not callable(false_fn):
+ raise TypeError(
+ "The false_fn in cond must be callable, but received {}".format(
+ type(false_fn).__name__
+ )
+ )
+ return false_fn()
+ return None
+
+ check_variable_and_dtype(pred, "pred", ['bool'], "fluid.layers.cond")
+ check_type(name, "name", (str, type(None)), "fluid.layers.cond")
+ helper = LayerHelper('cond', **locals())
+ true_output = None
+ false_output = None
+ copy_to_parent_func = lambda var: copy_var_to_parent_block(var, helper)
+ if true_fn is not None:
+ if not callable(true_fn):
+ raise TypeError(
+ "The true_fn in cond must be callable, but received {}".format(
+ type(true_fn).__name__
+ )
+ )
+ true_cond_block = ConditionalBlock([pred], is_scalar_condition=True)
+ with true_cond_block.block():
+ origin_true_output = true_fn()
+ if origin_true_output is not None:
+ true_output = map_structure(
+ copy_to_parent_func, origin_true_output
+ )
+ if false_fn is not None:
+ if not callable(false_fn):
+ raise TypeError(
+ "The false_fn in cond must be callable, but received {}".format(
+ type(false_fn).__name__
+ )
+ )
+ false_cond_block = ConditionalBlock(
+ [logical_not(pred)], is_scalar_condition=True
+ )
+ with false_cond_block.block():
+ origin_false_output = false_fn()
+ if origin_false_output is not None:
+ false_output = map_structure(
+ copy_to_parent_func, origin_false_output
+ )
+
+ if true_output is None and false_output is None:
+ return None
+
+ if true_output is None:
+ raise ValueError(
+ "Incompatible return values of true_fn and false_fn in cond: "
+ "true_fn returns None while false_fn returns non-None"
+ )
+ if false_output is None:
+ raise ValueError(
+ "Incompatible return values of true_fn and false_fn in cond: "
+ "true_fn returns non-None while false_fn returns None"
+ )
+
+ # Merge ture and false output if they are not None
+ if return_names is None:
+ is_dy2staic = False
+ return_names = ["no name"] * len(_to_sequence_except_dict(true_output))
+ else:
+ """
+ dy2static will set the return_names and expand the return values to UndefinedVar.
+ """
+ is_dy2staic = True
+
+ # TODO: expand_undefined_var will replace None to Undefinedvar(), to fix cases like:
+ # a = None
+ # if condition:
+ # a = 1
+ # Because we can not use variable to express 'None'
+ true_output, false_output = expand_undefined_var(
+ true_output, false_output, return_names
+ )
+
+ if len(_to_sequence_except_dict(true_output)) != len(
+ _to_sequence_except_dict(false_output)
+ ):
+ raise ValueError(
+ "true fn returns {} vars, but false fn returns {} vars, which is not equals".format(
+ len(_to_sequence_except_dict(true_output)),
+ len(_to_sequence_except_dict(false_output)),
+ )
+ )
+ for true_out, false_out, return_name in zip(
+ _to_sequence_except_dict(true_output),
+ _to_sequence_except_dict(false_output),
+ _to_sequence_except_dict(return_names),
+ ):
+ try:
+ assert_same_structure(true_out, false_out, check_types=False)
+ except ValueError as e:
+ raise ValueError(
+ "Incompatible return values of `{}` in true_fn and false_fn in cond: {}".format(
+ return_name, e
+ )
+ )
+
+ def check_ret_none(seq_true, seq_false, seq_names):
+ for f_true, f_false, f_name in zip(seq_true, seq_false, seq_names):
+ f_true = flatten(f_true)
+ f_false = flatten(f_false)
+ for idx in range(len(f_true)):
+ if (
+ f_true[idx] is None
+ and f_false[idx] is not None
+ or f_false[idx] is None
+ and f_true[idx] is not None
+ ):
+ warnings.warn(
+ "In cond : Var '{}' or part of it is set differently in ifelse branchs, "
+ "<{}, {}> in true branch and <{}, {}> in false branch. Set var to "
+ "'None' in ifelse block might lead to error.".format(
+ f_name,
+ type(f_true[idx]),
+ f_true[idx],
+ type(f_false[idx]),
+ f_false[idx],
+ )
+ )
+
+ check_ret_none(
+ _to_sequence_except_dict(true_output),
+ _to_sequence_except_dict(false_output),
+ _to_sequence_except_dict(return_names),
+ )
+
+ if is_dy2staic:
+ true_output, false_output = change_none_to_undefinedvar(
+ true_output, false_output
+ )
+
+ mask = cast(pred, dtype='int32')
+ merge_func = (
+ lambda name, false_var, true_var: select_input_with_buildin_type(
+ [false_var, true_var], mask, name
+ )
+ )
+
+ def merge_every_var_list(false_vars, true_vars, name):
+ return map_structure(partial(merge_func, name), false_vars, true_vars)
+
+ merged_output = list(
+ map(
+ merge_every_var_list,
+ _to_sequence_except_dict(false_output),
+ _to_sequence_except_dict(true_output),
+ _to_sequence_except_dict(return_names),
+ )
+ )
+ merged_output = pack_sequence_as(false_output, flatten(merged_output))
+ return merged_output
+
+
+def change_none_to_undefinedvar(nest1, nest2):
+ from paddle.fluid.dygraph.dygraph_to_static.utils import UndefinedVar
+
+ def map_fn(x):
+ if x is None:
+ return UndefinedVar("padding")
+ return x
+
+ nest1_out = pack_sequence_as(nest1, list(map(map_fn, flatten(nest1))))
+ nest2_out = pack_sequence_as(nest2, list(map(map_fn, flatten(nest2))))
+ return nest1_out, nest2_out
+
+
+def _to_sequence_except_dict(x):
+ """
+ In this function, dict is not viewed as sequence.
+ """
+ if isinstance(x, dict):
+ return [x]
+ return to_sequence(x)
+
+
+def _is_sequence_except_dict(x):
+ """
+ In this function, dict is not viewed as sequence.
+ """
+ if isinstance(x, dict):
+ return False
+ return is_sequence(x)
+
+
+def expand_undefined_var(nest1, nest2, names):
+ """TODO: make this function recursively.
+ nest1: Var1, (UndefinedVar, [1,2,3])
+ nest2: Var2, ([1,2,3,4], UndefinedVar)
+ In this case, we should not expand recursively.
+ """
+ from paddle.fluid.dygraph.dygraph_to_static.utils import UndefinedVar
+ from paddle.fluid.dygraph.dygraph_to_static.return_transformer import (
+ RETURN_VALUE_PREFIX,
+ )
+
+ def pack_undefined_var_as(seq):
+ return pack_sequence_as(
+ seq, [UndefinedVar("padding") for i in flatten(seq)]
+ )
+
+ def map_fn(n1, n2, name, order):
+ if not name.startswith(RETURN_VALUE_PREFIX) and (
+ isinstance(n1, UndefinedVar) or n1 is None
+ ):
+ if n1 is None and n2 is not None:
+ if order == 0:
+ warnings.warn(
+ "In cond : Var '{}' or part of it is set differently in ifelse branchs, "
+ "<{}, {}> in true branch and <{}, {}> in false branch. Set var to "
+ "'None' in ifelse block might lead to error.".format(
+ name, type(n1), n1, type(n2), n2
+ )
+ )
+ else:
+ warnings.warn(
+ "In cond : Var '{}' or part of it is set differently in ifelse branchs, "
+ "<{}, {}> in true branch and <{}, {}> in false branch. Set var to "
+ "'None' in ifelse block might lead to error.".format(
+ name, type(n2), n2, type(n1), n1
+ )
+ )
+ return pack_undefined_var_as(n2)
+ return n1
+
+ nest1_out = list(
+ map(
+ map_fn,
+ _to_sequence_except_dict(nest1),
+ _to_sequence_except_dict(nest2),
+ _to_sequence_except_dict(names),
+ [0 for i in _to_sequence_except_dict(names)],
+ )
+ )
+ nest2_out = list(
+ map(
+ map_fn,
+ _to_sequence_except_dict(nest2),
+ _to_sequence_except_dict(nest1),
+ _to_sequence_except_dict(names),
+ [1 for i in _to_sequence_except_dict(names)],
+ )
+ )
+ if not _is_sequence_except_dict(nest1):
+ nest1_out = nest1_out[0]
+ if not _is_sequence_except_dict(nest2):
+ nest2_out = nest2_out[0]
+ return nest1_out, nest2_out
+
+
+def _error_message(what, arg_name, op_name, right_value, error_value):
+ error_message = (
+ "{what} of '{arg_name}' in {op_name} must be "
+ "{right_value}, but received: {error_value}.".format(
+ what=what,
+ arg_name=arg_name,
+ op_name=op_name,
+ right_value=right_value,
+ error_value=error_value,
+ )
+ )
+
+ return error_message
+
+
+def case(pred_fn_pairs, default=None, name=None):
+ '''
+ :api_attr: Static Graph
+
+ This operator works like an if-elif-elif-else chain.
+
+ Args:
+ pred_fn_pairs(list|tuple): A list or tuple of (pred, fn) pairs. ``pred`` is a boolean Tensor with shape [1], ``fn`` is a callable. All callables return the same structure of Tensors.
+ default(callable, optional): Callable that returns a structure of Tensors.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor|list(Tensor): Tensors returned by the callable from the first pair whose pred is True,
+ or Tensors returned by ``default`` if no pred in ``pred_fn_pairs`` is True and ``default`` is not None,
+ or Tensors returned by the last callable in ``pred_fn_pairs`` if no pred in ``pred_fn_pairs`` is True and ``default`` is None.
+
+ Raises:
+ TypeError: If the type of ``pred_fn_pairs`` is not list or tuple.
+ TypeError: If the type of elements in ``pred_fn_pairs`` is not tuple.
+ TypeError: If the size of tuples in ``pred_fn_pairs`` is not 2.
+ TypeError: If the first element of 2-tuple in ``pred_fn_pairs`` is not a Tensor.
+ TypeError: If the second element of 2-tuple in ``pred_fn_pairs`` is not callable.
+ TypeError: If ``default`` is not None but it is not callable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+
+ def fn_1():
+ return paddle.full(shape=[1, 2], dtype='float32', fill_value=1)
+
+ def fn_2():
+ return paddle.full(shape=[2, 2], dtype='int32', fill_value=2)
+
+ def fn_3():
+ return paddle.full(shape=[3], dtype='int32', fill_value=3)
+
+ main_program = paddle.static.default_startup_program()
+ startup_program = paddle.static.default_main_program()
+
+ with paddle.static.program_guard(main_program, startup_program):
+ x = paddle.full(shape=[1], dtype='float32', fill_value=0.3)
+ y = paddle.full(shape=[1], dtype='float32', fill_value=0.1)
+ z = paddle.full(shape=[1], dtype='float32', fill_value=0.2)
+
+ pred_1 = paddle.less_than(z, x) # true: 0.2 < 0.3
+ pred_2 = paddle.less_than(x, y) # false: 0.3 < 0.1
+ pred_3 = paddle.equal(x, y) # false: 0.3 == 0.1
+
+ # Call fn_1 because pred_1 is True
+ out_1 = paddle.static.nn.case(
+ pred_fn_pairs=[(pred_1, fn_1), (pred_2, fn_2)], default=fn_3)
+
+ # Argument default is None and no pred in pred_fn_pairs is True. fn_3 will be called.
+ # because fn_3 is the last callable in pred_fn_pairs.
+ out_2 = paddle.static.nn.case(pred_fn_pairs=[(pred_2, fn_2), (pred_3, fn_3)])
+
+ exe = paddle.static.Executor(paddle.CPUPlace())
+ res_1, res_2 = exe.run(main_program, fetch_list=[out_1, out_2])
+ print(res_1) # [[1. 1.]]
+ print(res_2) # [3 3 3]
+ '''
+ helper = LayerHelper('case', **locals())
+
+ def _case_check_args(pred_fn_pairs, default):
+ '''
+ Check arguments pred_fn_pairs and default. Return canonical pre_fn_pairs and default.
+ '''
+ check_type(pred_fn_pairs, 'pred_fn_pairs', (list, tuple), 'case')
+
+ for pred_fn in pred_fn_pairs:
+ if not isinstance(pred_fn, tuple):
+ raise TypeError(
+ _error_message(
+ "The elements' type",
+ "pred_fn_pairs",
+ "case",
+ tuple,
+ type(pred_fn),
+ )
+ )
+ if len(pred_fn) != 2:
+ raise TypeError(
+ _error_message(
+ "The tuple's size",
+ "pred_fn_pairs",
+ "case",
+ "2",
+ str(len(pred_fn)) + "-tuple",
+ )
+ )
+ pred, fn = pred_fn
+
+ if not isinstance(pred, Variable):
+ raise TypeError(
+ _error_message(
+ "The pred's type",
+ "pred_fn_pairs",
+ "case",
+ "boolean Variable",
+ type(pred),
+ )
+ )
+
+ if not callable(fn):
+ raise TypeError(
+ "The fn for {} of pred_fn_pairs in Op(case) must"
+ " be callable.".format(pred.name)
+ )
+
+ if default is None:
+ default_index = len(pred_fn_pairs) - 1 # pick the last one
+ default = pred_fn_pairs[default_index][1]
+ pred_fn_pairs = pred_fn_pairs[:default_index]
+ elif not callable(default):
+ raise TypeError("The default in Op(case) must be callable.")
+
+ return pred_fn_pairs, default
+
+ pred_fn_pairs, default = _case_check_args(pred_fn_pairs, default)
+
+ false_fn = default
+ for pred, true_fn in reversed(pred_fn_pairs):
+ false_fn = partial(cond, pred=pred, true_fn=true_fn, false_fn=false_fn)
+
+ final_fn = false_fn
+
+ return final_fn()
+
+
+class Switch(object):
+ """
+ :api_attr: Static Graph
+
+ This class is used to implement Switch branch control function.
+ Switch branch contains several case branches and one default branch.
+ Switch control flow checks whether the case branch conditions are satisfied in turn,
+ and only executes the statement after the first case branch that satisfies the conditions.
+ If there is no case branch that satisfies the condition,
+ only the statement following the default branch is executed.
+
+ Note:
+ A new OP :ref:`api_fluid_layers_case` is highly recommended instead of ``Switch`` if the shape of parameter ``cond`` is [1].
+ OP :ref:`api_fluid_layers_case` is easier to use and is called with less code but does the same thing as ``Switch`` .
+
+ Member Functions:
+ case(condition): The case branch of Switch whose parameter cond is a scalar Variable of bool type. Only if the cond of the current case branch is True and the cond of the previous case branch is False, the statement after the case branch will be executed, and the statement after the case branch will not be executed.
+
+ default(): The default branch of Switch. When cond of all case branches is False, the statement after default branch is executed.
+
+ Case and default functions can only be used inside the scope of Switch, as shown below:
+
+ .. code-block:: python
+
+ '''
+ with fluid.layers.Switch() as switch:
+ with switch.case(cond1):
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=1)
+ with switch.case(cond2):
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=2)
+ with switch.default():
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
+ '''
+
+ Args:
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ lr = fluid.layers.create_global_var(
+ shape=[1],
+ value=0.0,
+ dtype='float32',
+ persistable=True,
+ name="learning_rate")
+ zero_var = fluid.layers.fill_constant(
+ shape=[1], dtype='float32', value=0.0)
+ one_var = fluid.layers.fill_constant(
+ shape=[1], dtype='float32', value=1.0)
+ two_var = fluid.layers.fill_constant(
+ shape=[1], dtype='float32', value=2.0)
+
+ global_step = fluid.layers.autoincreased_step_counter(counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)
+
+ with fluid.layers.control_flow.Switch() as switch:
+ with switch.case(global_step == zero_var):
+ fluid.layers.assign(input=one_var, output=lr)
+ with switch.default():
+ fluid.layers.assign(input=two_var, output=lr)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ res = exe.run(fluid.default_main_program(), feed={}, fetch_list=[lr])
+ print(res) # [array([1.], dtype=float32)]
+ """
+
+ def __init__(self, name=None):
+ self.helper = LayerHelper('switch', name=name)
+ self.inside_scope = False
+ self.pre_not_conditions = []
+
+ def case(self, condition):
+ if not self.inside_scope:
+ raise ValueError("case should be called inside with")
+
+ check_variable_and_dtype(
+ condition,
+ 'condition',
+ ['bool'],
+ 'the member function case of fluid.layers.Switch',
+ )
+
+ if len(self.pre_not_conditions) == 0:
+ cond_block = ConditionalBlock([condition], is_scalar_condition=True)
+ not_cond = logical_not(x=condition)
+ self.pre_not_conditions.append(not_cond)
+ else:
+ pre_cond_num = len(self.pre_not_conditions)
+ pre_not_cond = self.pre_not_conditions[pre_cond_num - 1]
+ new_not_cond = logical_and(
+ x=pre_not_cond, y=logical_not(x=condition)
+ )
+ self.pre_not_conditions.append(new_not_cond)
+ cond_block = ConditionalBlock(
+ [logical_and(x=pre_not_cond, y=condition)],
+ is_scalar_condition=True,
+ )
+
+ return ConditionalBlockGuard(cond_block)
+
+ def default(self):
+ pre_cond_num = len(self.pre_not_conditions)
+ if pre_cond_num == 0:
+ raise ValueError("there should be at least one condition")
+ cond_block = ConditionalBlock(
+ [self.pre_not_conditions[pre_cond_num - 1]],
+ is_scalar_condition=True,
+ )
+ return ConditionalBlockGuard(cond_block)
+
+ def __enter__(self):
+ """
+ set flag that now is inside switch.block {}
+ :return:
+ """
+ self.inside_scope = True
+ return self
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.inside_scope = False
+ if exc_type is not None:
+ return False # re-raise exception
+
+ return True
+
+
+class IfElseBlockGuard(object):
+ def __init__(self, is_true, ifelse):
+ if not isinstance(ifelse, IfElse):
+ raise TypeError("ifelse must be an instance of IfElse class")
+
+ if ifelse.status != IfElse.OUT_IF_ELSE_BLOCKS:
+ raise ValueError("You cannot invoke IfElse.block() inside a block")
+
+ self.is_true = is_true
+ self.ie = ifelse
+ if is_true:
+ self.cond_block = ifelse.conditional_true_block
+ else:
+ self.cond_block = ifelse.conditional_false_block
+
+ if not isinstance(self.cond_block, ConditionalBlock):
+ raise TypeError("Unexpected situation")
+
+ self.cond_block = self.cond_block.block()
+
+ def __enter__(self):
+ self.ie.status = (
+ IfElse.IN_IF_ELSE_TRUE_BLOCKS
+ if self.is_true
+ else IfElse.IN_IF_ELSE_FALSE_BLOCKS
+ )
+ self.cond_block.__enter__()
+
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ if not self.cond_block.__exit__(exc_type, exc_val, exc_tb):
+ # re-raise inside exception
+ return False
+ if len(self.ie.output_table[1 if self.is_true else 0]) == 0:
+ raise ValueError("Must set output inside block")
+ self.ie.status = IfElse.OUT_IF_ELSE_BLOCKS
+
+
+class IfElse(object):
+ """
+ :api_attr: Static Graph
+
+ This class is used to implement IfElse branch control function. IfElse contains two blocks, true_block and false_block. IfElse will put data satisfying True or False conditions into different blocks to run.
+
+ Cond is a 2-D Tensor with shape [N, 1] and data type bool, representing the execution conditions of the corresponding part of the input data.
+
+ Note:
+ A new OP :ref:`api_fluid_layers_cond` is highly recommended instead of ``IfElse``. if the shape of parameter ``cond`` is [1].
+ OP :ref:`api_fluid_layers_cond` is easier to use and is called with less code but does the same thing as ``IfElse`` .
+
+ IfElse OP is different from other OPs in usage, which may cause some users confusion. Here is a simple example to illustrate this OP.
+
+ .. code-block:: python
+
+ # The following code completes the function: subtract 10 from the data greater than 0 in x, add 10 to the data less than 0 in x, and sum all the data.
+ import numpy as np
+ import paddle.fluid as fluid
+
+ x = fluid.layers.data(name='x', shape=[4, 1], dtype='float32', append_batch_size=False)
+ y = fluid.layers.data(name='y', shape=[4, 1], dtype='float32', append_batch_size=False)
+
+ x_d = np.array([[3], [1], [-2], [-3]]).astype(np.float32)
+ y_d = np.zeros((4, 1)).astype(np.float32)
+
+ # Compare the size of x, y pairs of elements, output cond, cond is shape [4, 1], data type bool 2-D tensor.
+ # Based on the input data x_d, y_d, it can be inferred that the data in cond are [[true], [true], [false], [false]].
+ cond = fluid.layers.greater_than(x, y)
+ # Unlike other common OPs, ie below returned by the OP is an IfElse OP object
+ ie = fluid.layers.IfElse(cond)
+
+ with ie.true_block():
+ # In this block, according to cond condition, the data corresponding to true dimension in X is obtained and subtracted by 10.
+ out_1 = ie.input(x)
+ out_1 = out_1 - 10
+ ie.output(out_1)
+ with ie.false_block():
+ # In this block, according to cond condition, get the data of the corresponding condition in X as false dimension, and add 10
+ out_1 = ie.input(x)
+ out_1 = out_1 + 10
+ ie.output(out_1)
+
+ # According to cond condition, the data processed in the two blocks are merged. The output here is output, the type is List, and the element type in List is Variable.
+ output = ie() # [array([[-7.], [-9.], [ 8.], [ 7.]], dtype=float32)]
+
+ # Get the first Variable in the output List and add all elements.
+ out = fluid.layers.reduce_sum(output[0])
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ res = exe.run(fluid.default_main_program(), feed={"x":x_d, "y":y_d}, fetch_list=[out])
+ print(res)
+ # [array([-1.], dtype=float32)]
+
+ Args:
+ cond (Variable): cond is a 2-D Tensor with shape [N, 1] and data type bool, representing the corresponding execution conditions of N input data. The data type is bool.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Unlike other common OPs, the OP call returns an IfElse OP object (e.g. ie in the example), which branches the input data by calling the internal functions of the object ``true_block ()``, ``false_block ()``, ``input ()``, ``output ()``, and integrates the data processed by different branches as the overall output by calling the internal ``call ()`` function. The output type is a list, and the type of each element in the list is Variable.
+
+ Internal Functions:
+ The block is constructed by calling the ``with ie. true_block()`` function in the object, and the computational logic under condition true is put into the block. If no corresponding block is constructed, the input data in the corresponding conditional dimension is unchanged.
+
+ The block is constructed by calling the ``with ie. false_block()`` function in the object, and the computational logic under condition false is put into the block. If no corresponding block is constructed, the input data in the corresponding conditional dimension is unchanged.
+
+ ``Out = ie. input (x)`` will take out the data of the corresponding conditional dimension in X and put it into out, supporting the internal processing of multiple inputs in block.
+
+ ``ie. output (out)`` writes the result to the output of the corresponding condition.
+
+ There is a ``call ()`` function inside the object, that is, by calling ``output = ie ()``, all the outputs inside the block of False are fused as the whole output, the output type is a list, and the type of each element in the list is Variable.
+
+ """
+
+ OUT_IF_ELSE_BLOCKS = 0
+ IN_IF_ELSE_TRUE_BLOCKS = 1
+ IN_IF_ELSE_FALSE_BLOCKS = 2
+
+ def __init__(self, cond, name=None):
+ check_type(cond, "cond", Variable, "fluid.layers.IfElse")
+ check_type(name, "name", (str, type(None)), "fluid.layers.IfElse")
+ self.helper = LayerHelper('ifelse', name=name)
+ self.cond = cond
+ self.input_table = {}
+ self.status = IfElse.OUT_IF_ELSE_BLOCKS
+ self.conditional_true_block = ConditionalBlock(inputs=[self.cond])
+ self.conditional_false_block = ConditionalBlock(inputs=[self.cond])
+ self.output_table = ([], []) # (true_outs, false_outs)
+
+ def input(self, x):
+ if self.status == IfElse.OUT_IF_ELSE_BLOCKS:
+ raise ValueError("input must in true/false blocks")
+ if id(x) not in self.input_table:
+ parent_block = self._parent_block()
+ out_true = parent_block.create_var(
+ name=unique_name.generate_with_ignorable_key(
+ 'ifelse_input' + self.helper.name
+ ),
+ dtype=x.dtype,
+ )
+
+ out_false = parent_block.create_var(
+ name=unique_name.generate_with_ignorable_key(
+ 'ifelse_input' + self.helper.name
+ ),
+ dtype=x.dtype,
+ )
+ parent_block.append_op(
+ type='split_lod_tensor',
+ inputs={
+ 'X': x,
+ 'Mask': self.cond,
+ },
+ outputs={'OutTrue': out_true, 'OutFalse': out_false},
+ attrs={'level': 0},
+ )
+ self.input_table[id(x)] = (out_true, out_false)
+ else:
+ out_true, out_false = self.input_table[id(x)]
+
+ if self.status == IfElse.IN_IF_ELSE_TRUE_BLOCKS:
+ return out_true
+ else:
+ return out_false
+
+ def _parent_block(self):
+ current_block = self.helper.main_program.current_block()
+ return self.helper.main_program.block(current_block.parent_idx)
+
+ def true_block(self):
+ return IfElseBlockGuard(True, self)
+
+ def false_block(self):
+ return IfElseBlockGuard(False, self)
+
+ def output(self, *outs):
+ if self.status == self.OUT_IF_ELSE_BLOCKS:
+ raise ValueError("output can only be invoked in the sub-block")
+
+ out_table = self.output_table[
+ 1 if self.status == self.IN_IF_ELSE_TRUE_BLOCKS else 0
+ ]
+ parent_block = self._parent_block()
+ for each_out in outs:
+ check_type(
+ each_out, "each output", Variable, "fluid.layers.IfElse.output"
+ )
+ # create outside tensor
+ outside_out = parent_block.create_var(
+ name=unique_name.generate_with_ignorable_key(
+ "_".join([self.helper.name, 'output'])
+ ),
+ dtype=each_out.dtype,
+ )
+ out_table.append(outside_out)
+
+ # assign local var to outside
+ assign(input=each_out, output=outside_out)
+
+ def __call__(self):
+ if self.status != self.OUT_IF_ELSE_BLOCKS:
+ raise ValueError("IfElse::__call__ must be out of sub-block")
+ false_len, true_len = list(map(len, self.output_table))
+ if false_len == 0 and true_len == 0:
+ raise ValueError(
+ "Must invoke true_block/false_block before " "__call__"
+ )
+ elif false_len != true_len and false_len != 0 and true_len != 0:
+ raise ValueError("The output side must be same")
+ elif false_len == 0 or true_len == 0:
+ return self.output_table[0 if false_len != 0 else 1]
+
+ # else none of false_len/true_len is zero
+ # merge together
+ rlist = []
+ for false_var, true_var in zip(*self.output_table):
+ rlist.append(
+ merge_lod_tensor(
+ in_true=true_var,
+ in_false=false_var,
+ mask=self.cond,
+ x=self.cond,
+ level=0,
+ )
+ )
+ return rlist
+
+
+class DynamicRNN(object):
+ """
+ :api_attr: Static Graph
+
+ **Note: the input of this class should be LoDTensor which holds the
+ information of variable-length sequences. If the input is fixed-length Tensor,
+ please use StaticRNN (fluid.layers.** :ref:`api_fluid_layers_StaticRNN` **) for
+ better performance.**
+
+ DynamicRNN can process a minibatch of variable-length sequences.
+ The length of each sample can be different and is recorded in LoD.
+ In DynamicRNN, an input sequence will be unfolded into time steps and users
+ can define how to process each time step in :code:`block()` .
+ The total number of time steps is determined by the longest sequence.
+ DynamicRNN will not pad all sequences to the same length, instead it will
+ sort the sequences internally by the sequence length in descending order.
+ The input sequences will be shrank because only sequences of which the
+ length is larger than the time step will participate the remaining calculation.
+
+ If defined :code:`drnn = DynamicRNN()`, then users can call :code:`drnn()`
+ to obtain the result sequences. It is a LoDTensor gained by merging all
+ time steps's output. When RNN's input sequence x meets :code:`x.lod_level == 1`,
+ the output LoDTensor will have the same LoD with x. The result of :code:`drnn()`
+ includes RNN's outputs of all time steps, users can call
+ :ref:`api_fluid_layers_sequence_last_step` to extract the data of the last time step.
+
+ Warning:
+ Currently it is not supported to set :code:`is_sparse = True` of any
+ layers defined within DynamicRNN's :code:`block` function.
+
+ Args:
+ name (str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
+ encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1)
+ decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32')
+
+ drnn = fluid.layers.DynamicRNN()
+ with drnn.block():
+ # Set sentence as RNN's input, each time step processes a word from the sentence
+ current_word = drnn.step_input(sentence)
+ # Set encode_proj as RNN's static input
+ encoder_word = drnn.static_input(encoder_proj)
+ # Initialize memory with boot_memory, which need reorder according to RNN's input sequences
+ memory = drnn.memory(init=decoder_boot, need_reorder=True)
+ fc_1 = fluid.layers.fc(input=encoder_word, size=30)
+ fc_2 = fluid.layers.fc(input=current_word, size=30)
+ decoder_inputs = fc_1 + fc_2
+ hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30)
+ # Update memory with hidden
+ drnn.update_memory(ex_mem=memory, new_mem=hidden)
+ out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax')
+ # Set hidden and out as RNN's outputs
+ drnn.output(hidden, out)
+
+ # Get RNN's result
+ hidden, out = drnn()
+ # Get RNN's result of the last time step
+ last = fluid.layers.sequence_last_step(out)
+ """
+
+ BEFORE_RNN = 0
+ IN_RNN = 1
+ AFTER_RNN = 2
+
+ def __init__(self, name=None):
+ self.helper = LayerHelper('dynamic_rnn', name=name)
+ self.status = DynamicRNN.BEFORE_RNN
+ self.lod_rank_table = None
+ self.max_seq_len = None
+ self.step_idx = None
+ self.zero_idx = None
+ self.mem_dict = dict()
+ self.output_array = []
+ self.outputs = []
+ self.cond = self.helper.create_variable_for_type_inference(dtype='bool')
+ self.cond.stop_gradient = False
+ self.while_op = While(self.cond)
+ self.input_array = []
+ self.mem_link = []
+
+ def step_input(self, x, level=0):
+ r"""
+ This function is used to set sequence x as DynamicRNN's input.
+ The maximum sequence length in x determines the number of time steps
+ the RNN unit will be executed. DynamicRNN can take multiple inputs.
+ When all inputs' :code:`lod_level` are 1, all inputs should hold the
+ same LoD. When :code:`x.lod_level >= 2` , the input sequence will be
+ unfold along specified level, and the slice of each time step is a
+ LoDTensor whose lod_level is :code:`x.lod_level - level - 1` .
+ In this case, the specified LoD level of multiple inputs should be the same.
+
+ - Case 1:
+
+ .. code-block:: text
+
+ # input, where Si is slice data of shape [1, N]
+ level = 0
+ x.lod = [[2, 1, 3]]
+ x.shape = [6, N]
+ x.data = [[S0],
+ [S0],
+ [S1],
+ [S2],
+ [S2],
+ [S2]]
+
+ # output
+ # step 0, time step data of 3 sequences
+ out.lod = [[]]
+ out.shape = [3, N]
+ out.data = [[S2],
+ [S0],
+ [S1]]
+
+ # step 1, time step data of 2 sequences
+ out.lod = [[]]
+ out.shape = [2, N]
+ out.data = [[S2],
+ [S0]]
+
+ # step 2, time step data of 1 sequences
+ out.lod = [[]]
+ out.shape = [1, N]
+ out.data = [[S2]]
+
+
+ Args:
+ x (Variable): The input LoDTensor which holds information of a
+ minibatch of variable-length sequences and should meet :code:`x.lod_level >= 1` .
+ When RNN has multiple inputs, the first dimension should match
+ across all inputs, but other shape components may differ.
+ Optional data types are: bool, float16, float32, float64, int8, int16, int32, int64, uint8.
+ level (int, optional): The level of lod used to split steps.
+ It should be in range :math:`[0, x.lod\_level)` . The default value is 0.
+
+ Returns:
+ Variable: The current time step in the input sequence. If there are :code:`num_sequences` \
+ sequences in x whose length is larger than :code:`step_idx` , the returned Variable \
+ will only hold the :code:`step_idx` -th time step of those `num_sequences` sequences. \
+ The data type is the same as input. If :code:`x.lod_level == 1` , the return value is \
+ a Tensor of shape :math:`\{num\_sequences, x.shape[1], ...\}` , or it will \
+ be a variable-length LoDTensor.
+
+ Raises:
+ ValueError: When :code:`step_input()` is called outside :code:`block()` .
+ TypeError: When x is not a Variable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ sentence = fluid.data(name='sentence', shape=[None, 1], dtype='int64', lod_level=1)
+ embedding = fluid.layers.embedding(input=sentence, size=[65536, 32], is_sparse=True)
+
+ drnn = fluid.layers.DynamicRNN()
+ with drnn.block():
+ # Set embedding as RNN's input, each time step processes a word from the sentence
+ word = drnn.step_input(embedding)
+ # Initialize memory to a Tensor whose value is 0, shape=[batch_size, 200],
+ # where batch_size is the number of sequences in embedding.
+ memory = drnn.memory(shape=[200])
+ hidden = fluid.layers.fc(input=[word, memory], size=200, act='relu')
+ # Update memory to hidden
+ drnn.update_memory(ex_mem=memory, new_mem=hidden)
+ # Set hidden as RNN's output
+ drnn.output(hidden)
+
+ # Get RNN's result
+ rnn_output = drnn()
+ """
+ self._assert_in_rnn_block_("step_input")
+ check_type(x, 'x', Variable, 'fluid.layers.DynamicRNN.step_input()')
+ parent_block = self._parent_block_()
+ if self.lod_rank_table is None:
+ self.lod_rank_table = parent_block.create_var(
+ name=unique_name.generate('lod_rank_table'),
+ type=core.VarDesc.VarType.LOD_RANK_TABLE,
+ )
+ self.lod_rank_table.stop_gradient = True
+ parent_block.append_op(
+ type='lod_rank_table',
+ inputs={"X": x},
+ outputs={"Out": self.lod_rank_table},
+ attrs={"level": level},
+ )
+ self.max_seq_len = parent_block.create_var(
+ name=unique_name.generate('dynamic_rnn_max_seq_len'),
+ dtype='int64',
+ )
+ self.max_seq_len.stop_gradient = False
+ parent_block.append_op(
+ type='max_sequence_len',
+ inputs={'RankTable': self.lod_rank_table},
+ outputs={"Out": self.max_seq_len},
+ )
+ self.cond.stop_gradient = True
+ parent_block.append_op(
+ type='less_than',
+ inputs={'X': self.step_idx, 'Y': self.max_seq_len},
+ outputs={'Out': self.cond},
+ attrs={'force_cpu': True},
+ )
+
+ input_array = parent_block.create_var(
+ name=unique_name.generate('dynamic_rnn_input_array'),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=x.dtype,
+ )
+ self.input_array.append((input_array, x.dtype))
+ parent_block.append_op(
+ type='lod_tensor_to_array',
+ inputs={'X': x, 'RankTable': self.lod_rank_table},
+ outputs={'Out': input_array},
+ )
+ return array_read(array=input_array, i=self.step_idx)
+
+ def static_input(self, x):
+ r"""
+ This function is used to set x as DynamicRNN's static input. It is optional.
+
+ - Case 1, set static input with LoD
+
+ .. code-block:: text
+
+ # RNN's input is the same as the case listed in step_input
+ # static input, where Si is slice data of shape [1, M]
+ x.lod = [[3, 1, 2]]
+ x.shape = [6, M]
+ x.data = [[S0],
+ [S0],
+ [S0],
+ [S1],
+ [S2],
+ [S2]]
+
+ # step 0, batch data corresponding to the 3 input sequences
+ out.lod = [[2, 3, 1]]
+ out.shape = [6, M]
+ out.data = [[S2],
+ [S2],
+ [S0],
+ [S0],
+ [S0],
+ [S1]]
+
+ # step 1, batch data corresponding to the 2 input sequences
+ out.lod = [[2, 3]]
+ out.shape = [5, M]
+ out.data = [[S2],
+ [S2],
+ [S0],
+ [S0],
+ [S0]]
+
+ # step 2, batch data corresponding to the 1 input sequences
+ out.lod = [[2]]
+ out.shape = [2, M]
+ out.data = [[S2],
+ [S2]]
+
+
+ - Case 2, set static input without LoD
+
+ .. code-block:: text
+
+ # RNN's input is the same as the case listed in step_input
+ # static input, where Si is slice data of shape [1, M]
+ x.lod = [[]]
+ x.shape = [3, M]
+ x.data = [[S0],
+ [S1],
+ [S2]]
+
+ # step 0, batch data corresponding to the 3 input sequences
+ out.lod = [[]]
+ out.shape = [3, M]
+ out.data = [[S2],
+ [S0],
+ [S1]]
+
+ # step 1, batch data corresponding to the 2 input sequences
+ out.lod = [[]]
+ out.shape = [2, M]
+ out.data = [[S2],
+ [S0]]
+
+ # step 2, batch data corresponding to the 1 input sequences
+ out.lod = [[]]
+ out.shape = [1, M]
+ out.data = [[S2]]
+
+
+ Args:
+ x (Variable): The static input LoDTensor which should hold the same number of sequences
+ as RNN's input (the input LoDTensor set by :code:`step_input()` ). If the LoD is None,
+ the input x will be treated as a minibatch with :code:`x.shape[0]` sequences of length 1.
+ Optional data types are: bool, float16, float32, float64, int8, int16, int32, int64, uint8.
+
+ Returns:
+ Variable: The input LoDTensor after sorted and shrank. If there are :code:`num_sequences` \
+ sequences in RNN's input LoDTensor whose length is larger than :code:`step_idx` , \
+ the static input Tensor will be sorted to the same order as RNN's input and \
+ will only retain data corresponding to those :code:`num_sequences` sequences. \
+ The data type is the same as input. If :code:`x.lod == None` , the return value is \
+ a Tensor of shape :math:`\{num\_sequences, x.shape[1], ...\}` , or it will \
+ be a variable-length LoDTensor.
+
+ Raises:
+ ValueError: When :code:`static_input()` is called outside :code:`block()` .
+ TypeError: When x is not a Variable.
+ RuntimeError: When :code:`static_input()` is called before :code:`step_input()` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
+ encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1)
+ decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32')
+
+ drnn = fluid.layers.DynamicRNN()
+ with drnn.block():
+ # Set sentence as RNN's input, each time step processes a word from the sentence
+ current_word = drnn.step_input(sentence)
+ # Set encode_proj as RNN's static input
+ encoder_word = drnn.static_input(encoder_proj)
+ # Initialize memory with boot_memory, which need reorder according to RNN's input sequences
+ memory = drnn.memory(init=decoder_boot, need_reorder=True)
+ fc_1 = fluid.layers.fc(input=encoder_word, size=30)
+ fc_2 = fluid.layers.fc(input=current_word, size=30)
+ decoder_inputs = fc_1 + fc_2
+ hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30)
+ # Update memory with hidden
+ drnn.update_memory(ex_mem=memory, new_mem=hidden)
+ out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax')
+ # Set out as RNN's output
+ drnn.output(out)
+
+ # Get RNN's result
+ rnn_output = drnn()
+ """
+ self._assert_in_rnn_block_("static_input")
+ check_type(x, 'x', Variable, 'fluid.layers.DynamicRNN.static_input()')
+ if self.lod_rank_table is None:
+ raise RuntimeError(
+ "static_input() must be called after step_input()."
+ )
+ parent_block = self._parent_block_()
+ x_reordered = parent_block.create_var(
+ name=unique_name.generate("dynamic_rnn_static_input_reordered"),
+ type=core.VarDesc.VarType.LOD_TENSOR,
+ dtype=x.dtype,
+ )
+ parent_block.append_op(
+ type='reorder_lod_tensor_by_rank',
+ inputs={'X': [x], 'RankTable': [self.lod_rank_table]},
+ outputs={'Out': [x_reordered]},
+ )
+ return shrink_memory(x_reordered, self.step_idx, self.lod_rank_table)
+
+ @signature_safe_contextmanager
+ def block(self):
+ """
+ The function is used to list the operations executed during
+ each time step in RNN. The operation list will be executed :code:`max_sequence_len`
+ times (where :code:`max_sequence_len` is the maximum length of RNN's input sequences).
+
+ Raises:
+ ValueError: When :code:`block()` is called multi-times.
+ """
+ if self.status != DynamicRNN.BEFORE_RNN:
+ raise ValueError("rnn.block() can only be invoke once")
+ self.step_idx = fill_constant(
+ shape=[1], dtype='int64', value=0, force_cpu=True
+ )
+ self.step_idx.stop_gradient = False
+ self.status = DynamicRNN.IN_RNN
+ with self.while_op.block():
+ yield
+ increment(x=self.step_idx, value=1.0, in_place=True)
+
+ for new_mem, mem_array in self.mem_link:
+ array_write(x=new_mem, i=self.step_idx, array=mem_array)
+
+ less_than(
+ x=self.step_idx,
+ y=self.max_seq_len,
+ force_cpu=True,
+ cond=self.cond,
+ )
+
+ self.status = DynamicRNN.AFTER_RNN
+ for each_array in self.output_array:
+ self.outputs.append(
+ array_to_lod_tensor(x=each_array, table=self.lod_rank_table)
+ )
+
+ def __call__(self, *args, **kwargs):
+ """
+ This function is used to get the output sequences of DynamicRNN.
+
+ Args:
+ None
+
+ Returns:
+ Variable or Variable list: RNN's output sequences.
+
+ Raises:
+ ValueError: When :code:`__call__()` is called before :code:`block()` .
+ """
+ if self.status != DynamicRNN.AFTER_RNN:
+ raise ValueError(
+ (
+ "Output of the dynamic RNN can only be visited "
+ "outside the rnn block."
+ )
+ )
+ if len(self.outputs) == 1:
+ return self.outputs[0]
+ else:
+ return self.outputs
+
+ def memory(
+ self,
+ init=None,
+ shape=None,
+ value=0.0,
+ need_reorder=False,
+ dtype='float32',
+ ):
+ r"""
+ Create a memory Variable for DynamicRNN to deliver data cross time steps.
+ It can be initialized by an existing Tensor or a constant Tensor of given
+ dtype and shape.
+
+ Args:
+ init (Variable, optional): LoDTensor used to initialize the memory.
+ If init is not None, it should hold the same number of sequences
+ as RNN's input (the input LoDTensor set by :code:`step_input()` )
+ and the memory will be initialized to it. If init's LoD is None,
+ it will be treated as a minibatch with :code:`init.shape[0]` sequences
+ of length 1. The default value is None.
+ shape (list|tuple, optional): When init is None, it is used to specify
+ the memory's shape. Note that the shape does not include the batch_size.
+ If setting shape to :math:`\{D_1, D_2, ...\}` , the shape of memory Tensor
+ will be :math:`\{batch\_size, D_1, D_2, ...\}` , where batch_size is
+ determined by RNN's input sequences. The default value is None.
+ value (float, optional): When init is None, it is used as initialized value
+ of memory. The default value is 0.0.
+ need_reorder (bool, optional): When init is not None, it determines whether
+ the memory needs to reorder like the RNN's input sequences. It should be
+ set to True when the initialized memory depends on the order of input samples.
+ The default value is False.
+ dtype (str|numpy.dtype, optional): When init is None, it is used to set the
+ data type of memory. The default value is "float32". Optional data types
+ are: "float32", "float64", "int32", "int64".
+
+ Returns:
+ Variable: The memory LoDTensor after shrank. If there are :code:`num_sequences` \
+ sequences in RNN's input LoDTensor whose length is larger than :code:`step_idx` , \
+ the memory Tensor also need to be shrank and will only retain data \
+ corresponding to those :code:`num_sequences` sequences.
+
+ Raises:
+ ValueError: When :code:`memory()` is called outside :code:`block()` .
+ TypeError: When init is set and is not a Variable.
+ ValueError: When :code:`memory()` is called before :code:`step_input()` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
+ boot_memory = fluid.data(name='boot', shape=[None, 10], dtype='float32')
+
+ drnn = fluid.layers.DynamicRNN()
+ with drnn.block():
+ # Set sentence as RNN's input, each time step processes a word from the sentence
+ word = drnn.step_input(sentence)
+ # Initialize memory with boot_memory, which need reorder according to RNN's input sequences
+ memory = drnn.memory(init=boot_memory, need_reorder=True)
+ hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
+ # Update memory with hidden
+ drnn.update_memory(ex_mem=memory, new_mem=hidden)
+ # Set hidden as RNN's output
+ drnn.output(hidden)
+
+ # Get RNN's result
+ rnn_output = drnn()
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
+
+ drnn = fluid.layers.DynamicRNN()
+ with drnn.block():
+ # Set sentence as RNN's input, each time step processes a word from the sentence
+ word = drnn.step_input(sentence)
+ # Initialize memory to a Tensor whose value is 0, shape=[batch_size, 10],
+ # where batch_size is the number of sequences in sentence.
+ memory = drnn.memory(shape=[10], dtype='float32', value=0)
+ hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
+ # Update memory with hidden
+ drnn.update_memory(ex_mem=memory, new_mem=hidden)
+ # Set hidden as RNN's output
+ drnn.output(hidden)
+
+ # Get RNN's result
+ rnn_output = drnn()
+ """
+ self._assert_in_rnn_block_('memory')
+ self._init_zero_idx_()
+ if shape is not None:
+ check_type(
+ shape,
+ 'shape',
+ (list, tuple),
+ 'fluid.layers.DynamicRNN.memory()',
+ )
+ if init is not None:
+ check_type(
+ init, 'init', Variable, 'fluid.layers.DynamicRNN.memory()'
+ )
+ parent_block = self._parent_block_()
+ init_tensor = init
+ if need_reorder == True:
+ if self.lod_rank_table is None:
+ raise ValueError(
+ 'If set need_reorder to True, make sure step_input be '
+ 'invoked before '
+ 'memory(init=init, need_reordered=True, ...).'
+ )
+ init_reordered = parent_block.create_var(
+ name=unique_name.generate('dynamic_rnn_mem_init_reordered'),
+ type=core.VarDesc.VarType.LOD_TENSOR,
+ dtype=init.dtype,
+ )
+ parent_block.append_op(
+ type='reorder_lod_tensor_by_rank',
+ inputs={
+ 'X': [init_tensor],
+ 'RankTable': [self.lod_rank_table],
+ },
+ outputs={'Out': [init_reordered]},
+ )
+ init_tensor = init_reordered
+ mem_array = parent_block.create_var(
+ name=unique_name.generate('dynamic_rnn_mem_array'),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=init.dtype,
+ )
+ parent_block.append_op(
+ type='write_to_array',
+ inputs={'X': init_tensor, 'I': self.zero_idx},
+ outputs={'Out': mem_array},
+ )
+ retv = array_read(array=mem_array, i=self.step_idx)
+ retv = shrink_memory(
+ x=retv, i=self.step_idx, table=self.lod_rank_table
+ )
+ self.mem_dict[retv.name] = mem_array
+ return retv
+ else:
+ if len(self.input_array) == 0:
+ raise ValueError(
+ "step_input should be invoked before memory(shape=..., value=...)"
+ )
+ parent_block = self._parent_block_()
+ init = parent_block.create_var(
+ name=unique_name.generate('mem_init'), dtype=dtype
+ )
+ arr, dtype = self.input_array[0]
+ in0 = parent_block.create_var(
+ name=unique_name.generate('in0'), dtype=dtype
+ )
+ parent_block.append_op(
+ type='read_from_array',
+ inputs={'X': [arr], 'I': [self.zero_idx]},
+ outputs={'Out': [in0]},
+ )
+ parent_block.append_op(
+ type='fill_constant_batch_size_like',
+ inputs={'Input': [in0]},
+ outputs={'Out': [init]},
+ attrs={
+ 'shape': [-1] + shape,
+ 'value': float(value),
+ 'dtype': init.dtype,
+ },
+ )
+ return self.memory(init=init)
+
+ def update_memory(self, ex_mem, new_mem):
+ """
+ Update the memory which need to be delivered across time steps.
+
+ Args:
+ ex_mem (Variable): The memory data of previous time step.
+ new_mem (Variable): The new memory data produced in current time step.
+ The shape and data type of ex_mem and new_mem should be the same.
+
+ Returns:
+ None
+
+ Raises:
+ ValueError: When :code:`update_memory()` is called outside :code:`block()` .
+ TypeError: When :code:`ex_mem` or :code:`new_mem` is not a Variable.
+ ValueError: When :code:`ex_mem` is defined by :code:`memory()` .
+ ValueError: When :code:`update_memory()` is called before :code:`step_input()` .
+ """
+ self._assert_in_rnn_block_('update_memory')
+ check_type(
+ ex_mem,
+ 'ex_mem',
+ Variable,
+ 'fluid.layers.DynamicRNN.update_memory()',
+ )
+ check_type(
+ new_mem,
+ 'new_mem',
+ Variable,
+ 'fluid.layers.DynamicRNN.update_memory()',
+ )
+
+ mem_array = self.mem_dict.get(ex_mem.name, None)
+ if mem_array is None:
+ raise ValueError("Please invoke memory before update_memory")
+ if self.lod_rank_table is None:
+ raise ValueError("Please invoke step_input before update_memory")
+
+ self.mem_link.append((new_mem, mem_array))
+
+ def output(self, *outputs):
+ """
+ This function is used to set :code:`outputs` as RNN's output.
+
+ Args:
+ *outputs (Variable ...): The output Tensor. DynamicRNN can mark multiple
+ Variables as its output.
+
+ Returns:
+ None
+
+ Raises:
+ ValueError: When :code:`output()` is called outside :code:`block()` .
+ """
+ self._assert_in_rnn_block_('output')
+ parent_block = self._parent_block_()
+ for each in outputs:
+ check_type(
+ each, "outputs", Variable, "fluid.layers.DynamicRNN.output"
+ )
+ outside_array = parent_block.create_var(
+ name=unique_name.generate_with_ignorable_key(
+ "_".join([self.helper.name, "output_array", each.name])
+ ),
+ type=core.VarDesc.VarType.LOD_TENSOR_ARRAY,
+ dtype=each.dtype,
+ )
+ array_write(x=each, i=self.step_idx, array=outside_array)
+ self.output_array.append(outside_array)
+
+ def _init_zero_idx_(self):
+ if self.zero_idx is None:
+ parent_block = self._parent_block_()
+ self.zero_idx = parent_block.create_var(
+ name=unique_name.generate('zero_idx'), dtype='int64'
+ )
+ parent_block.append_op(
+ type='fill_constant',
+ inputs={},
+ outputs={'Out': [self.zero_idx]},
+ attrs={
+ 'shape': [1],
+ 'dtype': self.zero_idx.dtype,
+ 'value': float(0),
+ 'force_cpu': True,
+ },
+ )
+
+ def _parent_block_(self):
+ prog = self.helper.main_program
+ parent_idx = prog.current_block().parent_idx
+ assert parent_idx >= 0
+ parent_block = prog.block(parent_idx)
+
+ return parent_block
+
+ def _assert_in_rnn_block_(self, method):
+ if self.status != DynamicRNN.IN_RNN:
+ raise ValueError(
+ "{0} can only be invoked inside rnn block.".format(method)
+ )
+
+
+def switch_case(branch_index, branch_fns, default=None, name=None):
+ '''
+ :api_attr: Static Graph
+
+ This operator is like a C++ switch/case statement.
+
+ Args:
+ branch_index(Tensor): A Tensor with shape [1] to specify which branch to execute. The data type is ``int32``, ``int64`` or ``uint8``.
+ branch_fns(dict|list|tuple): If it's a list or tuple, the elements in it could be pairs of (int, callable) or simple callables whose actual index will be used as the index of callable. If it's a dict, its key is a python integer and the value is a callable. All callables return the same structure of Tensors.
+ default(callable, optional): Callable that returns a structure of Tensors.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor|list(Tensor): Tensors returned by the callable specified by ``branch_index`` in ``branch_fns``,
+ or Tensors returned by ``default`` if ``default`` is not None and no index matches in ``branch_fns``,
+ or Tensors returned by the callable with the max index in ``branch_fns`` if ``default`` is None and no index matches in ``branch_fns``.
+
+ Raises:
+ TypeError: If the type of ``branch_index`` is not Tensor.
+ TypeError: If the data type of ``branch_index`` is not ``int32``, ``int64`` or ``uint8``.
+ TypeError: If the type of ``branch_fns`` is not dict, list or tuple.
+ TypeError: If the elements of ``branch_fns`` is not 2-tuple.
+ TypeError: If the first element of 2-tuple in ``branch_fns`` is not integer.
+ ValueError: If the first element of 2-tuple in ``branch_fns`` is not unique.
+ TypeError: If the second element of 2-tuple in ``branch_fns`` is not callable.
+ TypeError: If ``default`` is not None but it is not callable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+
+ def fn_1():
+ return paddle.full(shape=[1, 2], dtype='float32', fill_value=1)
+
+ def fn_2():
+ return paddle.full(shape=[2, 2], dtype='int32', fill_value=2)
+
+ def fn_3():
+ return paddle.full(shape=[3], dtype='int32', fill_value=3)
+
+ main_program = paddle.static.default_startup_program()
+ startup_program = paddle.static.default_main_program()
+ with paddle.static.program_guard(main_program, startup_program):
+ index_1 = paddle.full(shape=[1], dtype='int32', fill_value=1)
+ index_2 = paddle.full(shape=[1], dtype='int32', fill_value=2)
+
+ out_1 = paddle.static.nn.switch_case(
+ branch_index=index_1,
+ branch_fns={1: fn_1, 2: fn_2},
+ default=fn_3)
+
+ out_2 = paddle.static.nn.switch_case(
+ branch_index=index_2,
+ branch_fns=[(1, fn_1), (2, fn_2)],
+ default=fn_3)
+
+ # Argument default is None and no index matches. fn_3 will be called because of the max index 7.
+ out_3 = paddle.static.nn.switch_case(
+ branch_index=index_2,
+ branch_fns=[(0, fn_1), (4, fn_2), (7, fn_3)])
+
+ exe = paddle.static.Executor(paddle.CPUPlace())
+ res_1, res_2, res_3 = exe.run(main_program, fetch_list=[out_1, out_2, out_3])
+ print(res_1) # [[1. 1.]]
+ print(res_2) # [[2 2] [2 2]]
+ print(res_3) # [3 3 3]
+ '''
+ helper = LayerHelper('switch_case', **locals())
+
+ def _check_args(branch_index, branch_fns, default):
+
+ check_variable_and_dtype(
+ branch_index,
+ 'branch_index',
+ ['uint8', 'int32', 'int64'],
+ 'switch_case',
+ )
+
+ if convert_dtype(branch_index.dtype) != "int64":
+ branch_index = cast(branch_index, "int64")
+
+ check_type(branch_fns, 'branch_fns', (list, tuple, dict), 'switch_case')
+
+ branch_fns = (
+ branch_fns.items() if isinstance(branch_fns, dict) else branch_fns
+ )
+
+ branch_fns = (
+ list(enumerate(branch_fns))
+ if all(callable(fn) for fn in branch_fns)
+ else branch_fns
+ )
+
+ keys_of_fns = []
+ for index_fn_pair in branch_fns:
+ if not isinstance(index_fn_pair, tuple):
+ raise TypeError(
+ _error_message(
+ "The elements' type",
+ "branch_fns",
+ "switch_case",
+ tuple,
+ type(branch_fns),
+ )
+ )
+
+ if len(index_fn_pair) != 2:
+ raise TypeError(
+ _error_message(
+ "The tuple's size",
+ "branch_fns",
+ "switch_case",
+ "2",
+ str(len(index_fn_pair)) + "-tuple",
+ )
+ )
+
+ key, fn = index_fn_pair
+
+ if not isinstance(key, int):
+ raise TypeError(
+ _error_message(
+ "The key's type",
+ "branch_fns",
+ "switch_case",
+ int,
+ type(key),
+ )
+ )
+
+ if key in keys_of_fns:
+ raise ValueError(
+ "The key in 'branch_fns' must be unique, but '{}' appears more than once.".format(
+ key
+ )
+ )
+ else:
+ keys_of_fns.append(key)
+
+ if not callable(fn):
+ raise TypeError(
+ _error_message(
+ "The type of function for key {}".format(key),
+ "branch_fns",
+ "switch_case",
+ "callable",
+ type(fn),
+ )
+ )
+
+ if default is None:
+ default = sorted(branch_fns)[-1][1]
+ branch_fns = sorted(branch_fns)[:-1]
+ elif not callable(default):
+ raise TypeError("The default in Op(case) must be callable.")
+
+ pred_fn_pairs = []
+ for index, fn in branch_fns:
+ new_index = fill_constant(shape=[1], dtype="int64", value=index)
+ pred = equal(branch_index, new_index)
+ pred_fn_pairs.append((pred, fn))
+
+ return pred_fn_pairs, default
+
+ pred_fn_pairs, default = _check_args(branch_index, branch_fns, default)
+ false_fn = default
+ for pred, true_fn in pred_fn_pairs:
+ false_fn = partial(cond, pred=pred, true_fn=true_fn, false_fn=false_fn)
+
+ final_fn = false_fn
+ return final_fn()
+
+
+@templatedoc()
+def reorder_lod_tensor_by_rank(x, rank_table):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}.
+ rank_table(${rank_table_type}): ${rank_table_comment}.
+
+ Returns:
+ out(${out_type}): ${out_comment}.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data_desc = (['input', [9], 0], ['ref', [5], 1])
+ data = fluid.layers.data(name=data_desc[0][0], shape=data_desc[0][1])
+ rank_data = fluid.layers.data(name=data_desc[1][0], shape=data_desc[1][1])
+ table = fluid.layers.control_flow.lod_rank_table(rank_data)
+ new_data = fluid.layers.reorder_lod_tensor_by_rank(
+ x=data, rank_table=table)
+
+ """
+
+ check_type(x, 'x', (Variable), 'reorder_lod_tensor_by_rank')
+ check_type(
+ rank_table, 'rank_table', (Variable), 'reorder_lod_tensor_by_rank'
+ )
+ if rank_table.type != core.VarDesc.VarType.LOD_RANK_TABLE:
+ raise TypeError("The type of rank_table should be LOD_RANK_TABLE.")
+
+ helper = LayerHelper('reorder_lod_tensor_by_rank', **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='reorder_lod_tensor_by_rank',
+ inputs={'X': [x], 'RankTable': [rank_table]},
+ outputs={'Out': [out]},
+ )
+ return out
+
+
+def is_empty(x, name=None):
+ """
+
+ Test whether a Tensor is empty.
+
+ Args:
+ x (Tensor): The Tensor to be tested.
+ name (str, optional): The default value is ``None`` . Normally users
+ don't have to set this parameter. For more information,
+ please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor: A bool scalar Tensor. True if 'x' is an empty Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ input = paddle.rand(shape=[4, 32, 32], dtype='float32')
+ res = paddle.is_empty(x=input)
+ print("res:", res)
+ # ('res:', Tensor: eager_tmp_1
+ # - place: CPUPlace
+ # - shape: [1]
+ # - layout: NCHW
+ # - dtype: bool
+ # - data: [0])
+
+ """
+ if in_dygraph_mode():
+ return _C_ops.is_empty(x)
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.is_empty(x)
+
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64'], 'is_empty'
+ )
+ check_type(name, "name", (str, type(None)), "is_empty")
+
+ helper = LayerHelper("is_empty", **locals())
+ cond = helper.create_variable_for_type_inference(dtype='bool')
+ cond.stop_gradient = True
+
+ helper.append_op(
+ type='is_empty', inputs={'X': [x]}, outputs={'Out': [cond]}
+ )
+ return cond
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/detection.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..8766e3982d673e4a8a88331934ed81231ee550ca
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/detection.py
@@ -0,0 +1,3877 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserve.
+#
+# 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.
+"""
+All layers just related to the detection neural network.
+"""
+
+from __future__ import print_function
+
+import paddle
+
+from .layer_function_generator import generate_layer_fn
+from .layer_function_generator import autodoc, templatedoc
+from ..layer_helper import LayerHelper
+from ..framework import Variable, _non_static_mode, static_only, in_dygraph_mode
+from .. import core
+from .loss import softmax_with_cross_entropy
+from . import tensor
+from . import nn
+from . import ops
+from ... import compat as cpt
+from ..data_feeder import check_variable_and_dtype, check_type, check_dtype
+import math
+import six
+import numpy as np
+from functools import reduce
+from ..data_feeder import convert_dtype, check_variable_and_dtype, check_type, check_dtype
+from paddle.utils import deprecated
+from paddle import _C_ops, _legacy_C_ops
+from ..framework import in_dygraph_mode
+
+__all__ = [
+ 'prior_box',
+ 'density_prior_box',
+ 'multi_box_head',
+ 'bipartite_match',
+ 'target_assign',
+ 'detection_output',
+ 'ssd_loss',
+ 'rpn_target_assign',
+ 'retinanet_target_assign',
+ 'sigmoid_focal_loss',
+ 'anchor_generator',
+ 'roi_perspective_transform',
+ 'generate_proposal_labels',
+ 'generate_proposals',
+ 'generate_mask_labels',
+ 'iou_similarity',
+ 'box_coder',
+ 'polygon_box_transform',
+ 'yolov3_loss',
+ 'yolo_box',
+ 'box_clip',
+ 'multiclass_nms',
+ 'locality_aware_nms',
+ 'matrix_nms',
+ 'retinanet_detection_output',
+ 'distribute_fpn_proposals',
+ 'box_decoder_and_assign',
+ 'collect_fpn_proposals',
+]
+
+
+def retinanet_target_assign(bbox_pred,
+ cls_logits,
+ anchor_box,
+ anchor_var,
+ gt_boxes,
+ gt_labels,
+ is_crowd,
+ im_info,
+ num_classes=1,
+ positive_overlap=0.5,
+ negative_overlap=0.4):
+ r"""
+ **Target Assign Layer for the detector RetinaNet.**
+
+ This OP finds out positive and negative samples from all anchors
+ for training the detector `RetinaNet `_ ,
+ and assigns target labels for classification along with target locations for
+ regression to each sample, then takes out the part belonging to positive and
+ negative samples from category prediction( :attr:`cls_logits`) and location
+ prediction( :attr:`bbox_pred`) which belong to all anchors.
+
+ The searching principles for positive and negative samples are as followed:
+
+ 1. Anchors are assigned to ground-truth boxes when it has the highest IoU
+ overlap with a ground-truth box.
+
+ 2. Anchors are assigned to ground-truth boxes when it has an IoU overlap
+ higher than :attr:`positive_overlap` with any ground-truth box.
+
+ 3. Anchors are assigned to background when its IoU overlap is lower than
+ :attr:`negative_overlap` for all ground-truth boxes.
+
+ 4. Anchors which do not meet the above conditions do not participate in
+ the training process.
+
+ Retinanet predicts a :math:`C`-vector for classification and a 4-vector for box
+ regression for each anchor, hence the target label for each positive(or negative)
+ sample is a :math:`C`-vector and the target locations for each positive sample
+ is a 4-vector. As for a positive sample, if the category of its assigned
+ ground-truth box is class :math:`i`, the corresponding entry in its length
+ :math:`C` label vector is set to 1 and all other entries is set to 0, its box
+ regression targets are computed as the offset between itself and its assigned
+ ground-truth box. As for a negative sample, all entries in its length :math:`C`
+ label vector are set to 0 and box regression targets are omitted because
+ negative samples do not participate in the training process of location
+ regression.
+
+ After the assignment, the part belonging to positive and negative samples is
+ taken out from category prediction( :attr:`cls_logits` ), and the part
+ belonging to positive samples is taken out from location
+ prediction( :attr:`bbox_pred` ).
+
+ Args:
+ bbox_pred(Variable): A 3-D Tensor with shape :math:`[N, M, 4]` represents
+ the predicted locations of all anchors. :math:`N` is the batch size( the
+ number of images in a mini-batch), :math:`M` is the number of all anchors
+ of one image, and each anchor has 4 coordinate values. The data type of
+ :attr:`bbox_pred` is float32 or float64.
+ cls_logits(Variable): A 3-D Tensor with shape :math:`[N, M, C]` represents
+ the predicted categories of all anchors. :math:`N` is the batch size,
+ :math:`M` is the number of all anchors of one image, and :math:`C` is
+ the number of categories (**Notice: excluding background**). The data type
+ of :attr:`cls_logits` is float32 or float64.
+ anchor_box(Variable): A 2-D Tensor with shape :math:`[M, 4]` represents
+ the locations of all anchors. :math:`M` is the number of all anchors of
+ one image, each anchor is represented as :math:`[xmin, ymin, xmax, ymax]`,
+ :math:`[xmin, ymin]` is the left top coordinate of the anchor box,
+ :math:`[xmax, ymax]` is the right bottom coordinate of the anchor box.
+ The data type of :attr:`anchor_box` is float32 or float64. Please refer
+ to the OP :ref:`api_fluid_layers_anchor_generator`
+ for the generation of :attr:`anchor_box`.
+ anchor_var(Variable): A 2-D Tensor with shape :math:`[M,4]` represents the expanded
+ factors of anchor locations used in loss function. :math:`M` is number of
+ all anchors of one image, each anchor possesses a 4-vector expanded factor.
+ The data type of :attr:`anchor_var` is float32 or float64. Please refer
+ to the OP :ref:`api_fluid_layers_anchor_generator`
+ for the generation of :attr:`anchor_var`.
+ gt_boxes(Variable): A 1-level 2-D LoDTensor with shape :math:`[G, 4]` represents
+ locations of all ground-truth boxes. :math:`G` is the total number of
+ all ground-truth boxes in a mini-batch, and each ground-truth box has 4
+ coordinate values. The data type of :attr:`gt_boxes` is float32 or
+ float64.
+ gt_labels(variable): A 1-level 2-D LoDTensor with shape :math:`[G, 1]` represents
+ categories of all ground-truth boxes, and the values are in the range of
+ :math:`[1, C]`. :math:`G` is the total number of all ground-truth boxes
+ in a mini-batch, and each ground-truth box has one category. The data type
+ of :attr:`gt_labels` is int32.
+ is_crowd(Variable): A 1-level 1-D LoDTensor with shape :math:`[G]` which
+ indicates whether a ground-truth box is a crowd. If the value is 1, the
+ corresponding box is a crowd, it is ignored during training. :math:`G` is
+ the total number of all ground-truth boxes in a mini-batch. The data type
+ of :attr:`is_crowd` is int32.
+ im_info(Variable): A 2-D Tensor with shape [N, 3] represents the size
+ information of input images. :math:`N` is the batch size, the size
+ information of each image is a 3-vector which are the height and width
+ of the network input along with the factor scaling the origin image to
+ the network input. The data type of :attr:`im_info` is float32.
+ num_classes(int32): The number of categories for classification, the default
+ value is 1.
+ positive_overlap(float32): Minimum overlap required between an anchor
+ and ground-truth box for the anchor to be a positive sample, the default
+ value is 0.5.
+ negative_overlap(float32): Maximum overlap allowed between an anchor
+ and ground-truth box for the anchor to be a negative sample, the default
+ value is 0.4. :attr:`negative_overlap` should be less than or equal to
+ :attr:`positive_overlap`, if not, the actual value of
+ :attr:`positive_overlap` is :attr:`negative_overlap`.
+
+ Returns:
+ A tuple with 6 Variables:
+
+ **predict_scores** (Variable): A 2-D Tensor with shape :math:`[F+B, C]` represents
+ category prediction belonging to positive and negative samples. :math:`F`
+ is the number of positive samples in a mini-batch, :math:`B` is the number
+ of negative samples, and :math:`C` is the number of categories
+ (**Notice: excluding background**). The data type of :attr:`predict_scores`
+ is float32 or float64.
+
+ **predict_location** (Variable): A 2-D Tensor with shape :math:`[F, 4]` represents
+ location prediction belonging to positive samples. :math:`F` is the number
+ of positive samples. :math:`F` is the number of positive samples, and each
+ sample has 4 coordinate values. The data type of :attr:`predict_location`
+ is float32 or float64.
+
+ **target_label** (Variable): A 2-D Tensor with shape :math:`[F+B, 1]` represents
+ target labels for classification belonging to positive and negative
+ samples. :math:`F` is the number of positive samples, :math:`B` is the
+ number of negative, and each sample has one target category. The data type
+ of :attr:`target_label` is int32.
+
+ **target_bbox** (Variable): A 2-D Tensor with shape :math:`[F, 4]` represents
+ target locations for box regression belonging to positive samples.
+ :math:`F` is the number of positive samples, and each sample has 4
+ coordinate values. The data type of :attr:`target_bbox` is float32 or
+ float64.
+
+ **bbox_inside_weight** (Variable): A 2-D Tensor with shape :math:`[F, 4]`
+ represents whether a positive sample is fake positive, if a positive
+ sample is false positive, the corresponding entries in
+ :attr:`bbox_inside_weight` are set 0, otherwise 1. :math:`F` is the number
+ of total positive samples in a mini-batch, and each sample has 4
+ coordinate values. The data type of :attr:`bbox_inside_weight` is float32
+ or float64.
+
+ **fg_num** (Variable): A 2-D Tensor with shape :math:`[N, 1]` represents the number
+ of positive samples. :math:`N` is the batch size. **Notice: The number
+ of positive samples is used as the denominator of later loss function,
+ to avoid the condition that the denominator is zero, this OP has added 1
+ to the actual number of positive samples of each image.** The data type of
+ :attr:`fg_num` is int32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ bbox_pred = fluid.data(name='bbox_pred', shape=[1, 100, 4],
+ dtype='float32')
+ cls_logits = fluid.data(name='cls_logits', shape=[1, 100, 10],
+ dtype='float32')
+ anchor_box = fluid.data(name='anchor_box', shape=[100, 4],
+ dtype='float32')
+ anchor_var = fluid.data(name='anchor_var', shape=[100, 4],
+ dtype='float32')
+ gt_boxes = fluid.data(name='gt_boxes', shape=[10, 4],
+ dtype='float32')
+ gt_labels = fluid.data(name='gt_labels', shape=[10, 1],
+ dtype='int32')
+ is_crowd = fluid.data(name='is_crowd', shape=[1],
+ dtype='int32')
+ im_info = fluid.data(name='im_info', shape=[1, 3],
+ dtype='float32')
+ score_pred, loc_pred, score_target, loc_target, bbox_inside_weight, fg_num = \\
+ fluid.layers.retinanet_target_assign(bbox_pred, cls_logits, anchor_box,
+ anchor_var, gt_boxes, gt_labels, is_crowd, im_info, 10)
+
+ """
+
+ check_variable_and_dtype(bbox_pred, 'bbox_pred', ['float32', 'float64'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(cls_logits, 'cls_logits', ['float32', 'float64'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(anchor_box, 'anchor_box', ['float32', 'float64'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(anchor_var, 'anchor_var', ['float32', 'float64'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(gt_boxes, 'gt_boxes', ['float32', 'float64'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(gt_labels, 'gt_labels', ['int32'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(is_crowd, 'is_crowd', ['int32'],
+ 'retinanet_target_assign')
+ check_variable_and_dtype(im_info, 'im_info', ['float32', 'float64'],
+ 'retinanet_target_assign')
+
+ helper = LayerHelper('retinanet_target_assign', **locals())
+ # Assign target label to anchors
+ loc_index = helper.create_variable_for_type_inference(dtype='int32')
+ score_index = helper.create_variable_for_type_inference(dtype='int32')
+ target_label = helper.create_variable_for_type_inference(dtype='int32')
+ target_bbox = helper.create_variable_for_type_inference(
+ dtype=anchor_box.dtype)
+ bbox_inside_weight = helper.create_variable_for_type_inference(
+ dtype=anchor_box.dtype)
+ fg_num = helper.create_variable_for_type_inference(dtype='int32')
+ helper.append_op(type="retinanet_target_assign",
+ inputs={
+ 'Anchor': anchor_box,
+ 'GtBoxes': gt_boxes,
+ 'GtLabels': gt_labels,
+ 'IsCrowd': is_crowd,
+ 'ImInfo': im_info
+ },
+ outputs={
+ 'LocationIndex': loc_index,
+ 'ScoreIndex': score_index,
+ 'TargetLabel': target_label,
+ 'TargetBBox': target_bbox,
+ 'BBoxInsideWeight': bbox_inside_weight,
+ 'ForegroundNumber': fg_num
+ },
+ attrs={
+ 'positive_overlap': positive_overlap,
+ 'negative_overlap': negative_overlap
+ })
+
+ loc_index.stop_gradient = True
+ score_index.stop_gradient = True
+ target_label.stop_gradient = True
+ target_bbox.stop_gradient = True
+ bbox_inside_weight.stop_gradient = True
+ fg_num.stop_gradient = True
+
+ cls_logits = nn.reshape(x=cls_logits, shape=(-1, num_classes))
+ bbox_pred = nn.reshape(x=bbox_pred, shape=(-1, 4))
+ predicted_cls_logits = nn.gather(cls_logits, score_index)
+ predicted_bbox_pred = nn.gather(bbox_pred, loc_index)
+
+ return predicted_cls_logits, predicted_bbox_pred, target_label, target_bbox, bbox_inside_weight, fg_num
+
+
+def rpn_target_assign(bbox_pred,
+ cls_logits,
+ anchor_box,
+ anchor_var,
+ gt_boxes,
+ is_crowd,
+ im_info,
+ rpn_batch_size_per_im=256,
+ rpn_straddle_thresh=0.0,
+ rpn_fg_fraction=0.5,
+ rpn_positive_overlap=0.7,
+ rpn_negative_overlap=0.3,
+ use_random=True):
+ """
+ **Target Assign Layer for region proposal network (RPN) in Faster-RCNN detection.**
+
+ This layer can be, for given the Intersection-over-Union (IoU) overlap
+ between anchors and ground truth boxes, to assign classification and
+ regression targets to each each anchor, these target labels are used for
+ train RPN. The classification targets is a binary class label (of being
+ an object or not). Following the paper of Faster-RCNN, the positive labels
+ are two kinds of anchors: (i) the anchor/anchors with the highest IoU
+ overlap with a ground-truth box, or (ii) an anchor that has an IoU overlap
+ higher than rpn_positive_overlap(0.7) with any ground-truth box. Note
+ that a single ground-truth box may assign positive labels to multiple
+ anchors. A non-positive anchor is when its IoU ratio is lower than
+ rpn_negative_overlap (0.3) for all ground-truth boxes. Anchors that are
+ neither positive nor negative do not contribute to the training objective.
+ The regression targets are the encoded ground-truth boxes associated with
+ the positive anchors.
+
+ Args:
+ bbox_pred(Variable): A 3-D Tensor with shape [N, M, 4] represents the
+ predicted locations of M bounding bboxes. N is the batch size,
+ and each bounding box has four coordinate values and the layout
+ is [xmin, ymin, xmax, ymax]. The data type can be float32 or float64.
+ cls_logits(Variable): A 3-D Tensor with shape [N, M, 1] represents the
+ predicted confidence predictions. N is the batch size, 1 is the
+ frontground and background sigmoid, M is number of bounding boxes.
+ The data type can be float32 or float64.
+ anchor_box(Variable): A 2-D Tensor with shape [M, 4] holds M boxes,
+ each box is represented as [xmin, ymin, xmax, ymax],
+ [xmin, ymin] is the left top coordinate of the anchor box,
+ if the input is image feature map, they are close to the origin
+ of the coordinate system. [xmax, ymax] is the right bottom
+ coordinate of the anchor box. The data type can be float32 or float64.
+ anchor_var(Variable): A 2-D Tensor with shape [M,4] holds expanded
+ variances of anchors. The data type can be float32 or float64.
+ gt_boxes (Variable): The ground-truth bounding boxes (bboxes) are a 2D
+ LoDTensor with shape [Ng, 4], Ng is the total number of ground-truth
+ bboxes of mini-batch input. The data type can be float32 or float64.
+ is_crowd (Variable): A 1-D LoDTensor which indicates groud-truth is crowd.
+ The data type must be int32.
+ im_info (Variable): A 2-D LoDTensor with shape [N, 3]. N is the batch size,
+ 3 is the height, width and scale.
+ rpn_batch_size_per_im(int): Total number of RPN examples per image.
+ The data type must be int32.
+ rpn_straddle_thresh(float): Remove RPN anchors that go outside the image
+ by straddle_thresh pixels. The data type must be float32.
+ rpn_fg_fraction(float): Target fraction of RoI minibatch that is labeled
+ foreground (i.e. class > 0), 0-th class is background. The data type must be float32.
+ rpn_positive_overlap(float): Minimum overlap required between an anchor
+ and ground-truth box for the (anchor, gt box) pair to be a positive
+ example. The data type must be float32.
+ rpn_negative_overlap(float): Maximum overlap allowed between an anchor
+ and ground-truth box for the (anchor, gt box) pair to be a negative
+ examples. The data type must be float32.
+
+ Returns:
+ tuple:
+ A tuple(predicted_scores, predicted_location, target_label,
+ target_bbox, bbox_inside_weight) is returned. The predicted_scores
+ and predicted_location is the predicted result of the RPN.
+ The target_label and target_bbox is the ground truth,
+ respectively. The predicted_location is a 2D Tensor with shape
+ [F, 4], and the shape of target_bbox is same as the shape of
+ the predicted_location, F is the number of the foreground
+ anchors. The predicted_scores is a 2D Tensor with shape
+ [F + B, 1], and the shape of target_label is same as the shape
+ of the predicted_scores, B is the number of the background
+ anchors, the F and B is depends on the input of this operator.
+ Bbox_inside_weight represents whether the predicted loc is fake_fg
+ or not and the shape is [F, 4].
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ bbox_pred = fluid.data(name='bbox_pred', shape=[None, 4], dtype='float32')
+ cls_logits = fluid.data(name='cls_logits', shape=[None, 1], dtype='float32')
+ anchor_box = fluid.data(name='anchor_box', shape=[None, 4], dtype='float32')
+ anchor_var = fluid.data(name='anchor_var', shape=[None, 4], dtype='float32')
+ gt_boxes = fluid.data(name='gt_boxes', shape=[None, 4], dtype='float32')
+ is_crowd = fluid.data(name='is_crowd', shape=[None], dtype='float32')
+ im_info = fluid.data(name='im_infoss', shape=[None, 3], dtype='float32')
+ loc, score, loc_target, score_target, inside_weight = fluid.layers.rpn_target_assign(
+ bbox_pred, cls_logits, anchor_box, anchor_var, gt_boxes, is_crowd, im_info)
+
+ """
+
+ helper = LayerHelper('rpn_target_assign', **locals())
+
+ check_variable_and_dtype(bbox_pred, 'bbox_pred', ['float32', 'float64'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(cls_logits, 'cls_logits', ['float32', 'float64'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(anchor_box, 'anchor_box', ['float32', 'float64'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(anchor_var, 'anchor_var', ['float32', 'float64'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(gt_boxes, 'gt_boxes', ['float32', 'float64'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(is_crowd, 'is_crowd', ['int32'],
+ 'rpn_target_assign')
+ check_variable_and_dtype(im_info, 'im_info', ['float32', 'float64'],
+ 'rpn_target_assign')
+
+ # Assign target label to anchors
+ loc_index = helper.create_variable_for_type_inference(dtype='int32')
+ score_index = helper.create_variable_for_type_inference(dtype='int32')
+ target_label = helper.create_variable_for_type_inference(dtype='int32')
+ target_bbox = helper.create_variable_for_type_inference(
+ dtype=anchor_box.dtype)
+ bbox_inside_weight = helper.create_variable_for_type_inference(
+ dtype=anchor_box.dtype)
+ helper.append_op(type="rpn_target_assign",
+ inputs={
+ 'Anchor': anchor_box,
+ 'GtBoxes': gt_boxes,
+ 'IsCrowd': is_crowd,
+ 'ImInfo': im_info
+ },
+ outputs={
+ 'LocationIndex': loc_index,
+ 'ScoreIndex': score_index,
+ 'TargetLabel': target_label,
+ 'TargetBBox': target_bbox,
+ 'BBoxInsideWeight': bbox_inside_weight
+ },
+ attrs={
+ 'rpn_batch_size_per_im': rpn_batch_size_per_im,
+ 'rpn_straddle_thresh': rpn_straddle_thresh,
+ 'rpn_positive_overlap': rpn_positive_overlap,
+ 'rpn_negative_overlap': rpn_negative_overlap,
+ 'rpn_fg_fraction': rpn_fg_fraction,
+ 'use_random': use_random
+ })
+
+ loc_index.stop_gradient = True
+ score_index.stop_gradient = True
+ target_label.stop_gradient = True
+ target_bbox.stop_gradient = True
+ bbox_inside_weight.stop_gradient = True
+
+ cls_logits = nn.reshape(x=cls_logits, shape=(-1, 1))
+ bbox_pred = nn.reshape(x=bbox_pred, shape=(-1, 4))
+ predicted_cls_logits = nn.gather(cls_logits, score_index)
+ predicted_bbox_pred = nn.gather(bbox_pred, loc_index)
+
+ return predicted_cls_logits, predicted_bbox_pred, target_label, target_bbox, bbox_inside_weight
+
+
+def sigmoid_focal_loss(x, label, fg_num, gamma=2.0, alpha=0.25):
+ r"""
+ :alias_main: paddle.nn.functional.sigmoid_focal_loss
+ :alias: paddle.nn.functional.sigmoid_focal_loss,paddle.nn.functional.loss.sigmoid_focal_loss
+ :old_api: paddle.fluid.layers.sigmoid_focal_loss
+
+ **Sigmoid Focal Loss Operator.**
+
+ `Focal Loss `_ is used to address the foreground-background
+ class imbalance existed on the training phase of many computer vision tasks. This OP computes
+ the sigmoid value for each element in the input tensor :attr:`x`, after which focal loss is
+ measured between the sigmoid value and target label.
+
+ The focal loss is given as followed:
+
+ .. math::
+
+ \\mathop{loss_{i,\\,j}}\\limits_{i\\in\\mathbb{[0,\\,N-1]},\\,j\\in\\mathbb{[0,\\,C-1]}}=\\left\\{
+ \\begin{array}{rcl}
+ - \\frac{1}{fg\_num} * \\alpha * {(1 - \\sigma(x_{i,\\,j}))}^{\\gamma} * \\log(\\sigma(x_{i,\\,j})) & & {(j +1) = label_{i,\\,0}} \\\\
+ - \\frac{1}{fg\_num} * (1 - \\alpha) * {\sigma(x_{i,\\,j})}^{ \\gamma} * \\log(1 - \\sigma(x_{i,\\,j})) & & {(j +1)!= label_{i,\\,0}}
+ \\end{array} \\right.
+
+
+ We know that
+
+ .. math::
+ \\sigma(x_j) = \\frac{1}{1 + \\exp(-x_j)}
+
+
+ Args:
+ x(Variable): A 2-D tensor with shape :math:`[N, C]` represents the predicted categories of
+ all samples. :math:`N` is the number of all samples responsible for optimization in
+ a mini-batch, for example, samples are anchor boxes for object detection and :math:`N`
+ is the total number of positive and negative samples in a mini-batch; Samples are images
+ for image classification and :math:`N` is the number of images in a mini-batch. :math:`C`
+ is the number of classes (**Notice: excluding background**). The data type of :attr:`x` is
+ float32 or float64.
+ label(Variable): A 2-D tensor with shape :math:`[N, 1]` represents the target labels for
+ classification. :math:`N` is the number of all samples responsible for optimization in a
+ mini-batch, each sample has one target category. The values for positive samples are in the
+ range of :math:`[1, C]`, and the values for negative samples are 0. The data type of :attr:`label`
+ is int32.
+ fg_num(Variable): A 1-D tensor with shape [1] represents the number of positive samples in a
+ mini-batch, which should be obtained before this OP. The data type of :attr:`fg_num` is int32.
+ gamma(int|float): Hyper-parameter to balance the easy and hard examples. Default value is
+ set to 2.0.
+ alpha(int|float): Hyper-parameter to balance the positive and negative example. Default value
+ is set to 0.25.
+
+ Returns:
+ Variable(the data type is float32 or float64):
+ A 2-D tensor with shape :math:`[N, C]`, which is the focal loss of each element in the input
+ tensor :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+
+ num_classes = 10 # exclude background
+ image_width = 16
+ image_height = 16
+ batch_size = 32
+ max_iter = 20
+
+
+ def gen_train_data():
+ x_data = np.random.uniform(0, 255, (batch_size, 3, image_height,
+ image_width)).astype('float64')
+ label_data = np.random.randint(0, num_classes,
+ (batch_size, 1)).astype('int32')
+ return {"x": x_data, "label": label_data}
+
+
+ def get_focal_loss(pred, label, fg_num, num_classes):
+ pred = fluid.layers.reshape(pred, [-1, num_classes])
+ label = fluid.layers.reshape(label, [-1, 1])
+ label.stop_gradient = True
+ loss = fluid.layers.sigmoid_focal_loss(
+ pred, label, fg_num, gamma=2.0, alpha=0.25)
+ loss = fluid.layers.reduce_sum(loss)
+ return loss
+
+
+ def build_model(mode='train'):
+ x = fluid.data(name="x", shape=[-1, 3, -1, -1], dtype='float64')
+ output = fluid.layers.pool2d(input=x, pool_type='avg', global_pooling=True)
+ output = fluid.layers.fc(
+ input=output,
+ size=num_classes,
+ # Notice: size is set to be the number of target classes (excluding backgorund)
+ # because sigmoid activation will be done in the sigmoid_focal_loss op.
+ act=None)
+ if mode == 'train':
+ label = fluid.data(name="label", shape=[-1, 1], dtype='int32')
+ # Obtain the fg_num needed by the sigmoid_focal_loss op:
+ # 0 in label represents background, >=1 in label represents foreground,
+ # find the elements in label which are greater or equal than 1, then
+ # computed the numbers of these elements.
+ data = fluid.layers.fill_constant(shape=[1], value=1, dtype='int32')
+ fg_label = fluid.layers.greater_equal(label, data)
+ fg_label = fluid.layers.cast(fg_label, dtype='int32')
+ fg_num = fluid.layers.reduce_sum(fg_label)
+ fg_num.stop_gradient = True
+ avg_loss = get_focal_loss(output, label, fg_num, num_classes)
+ return avg_loss
+ else:
+ # During evaluating or testing phase,
+ # output of the final fc layer should be connected to a sigmoid layer.
+ pred = fluid.layers.sigmoid(output)
+ return pred
+
+
+ loss = build_model('train')
+ moment_optimizer = fluid.optimizer.MomentumOptimizer(
+ learning_rate=0.001, momentum=0.9)
+ moment_optimizer.minimize(loss)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for i in range(max_iter):
+ outs = exe.run(feed=gen_train_data(), fetch_list=[loss.name])
+ print(outs)
+ """
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'],
+ 'sigmoid_focal_loss')
+ check_variable_and_dtype(label, 'label', ['int32'], 'sigmoid_focal_loss')
+ check_variable_and_dtype(fg_num, 'fg_num', ['int32'], 'sigmoid_focal_loss')
+
+ helper = LayerHelper("sigmoid_focal_loss", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(type="sigmoid_focal_loss",
+ inputs={
+ "X": x,
+ "Label": label,
+ "FgNum": fg_num
+ },
+ attrs={
+ "gamma": gamma,
+ 'alpha': alpha
+ },
+ outputs={"Out": out})
+ return out
+
+
+def detection_output(loc,
+ scores,
+ prior_box,
+ prior_box_var,
+ background_label=0,
+ nms_threshold=0.3,
+ nms_top_k=400,
+ keep_top_k=200,
+ score_threshold=0.01,
+ nms_eta=1.0,
+ return_index=False):
+ """
+
+ Given the regression locations, classification confidences and prior boxes,
+ calculate the detection outputs by performing following steps:
+
+ 1. Decode input bounding box predictions according to the prior boxes and
+ regression locations.
+ 2. Get the final detection results by applying multi-class non maximum
+ suppression (NMS).
+
+ Please note, this operation doesn't clip the final output bounding boxes
+ to the image window.
+
+ Args:
+ loc(Variable): A 3-D Tensor with shape [N, M, 4] represents the
+ predicted locations of M bounding bboxes. Data type should be
+ float32 or float64. N is the batch size,
+ and each bounding box has four coordinate values and the layout
+ is [xmin, ymin, xmax, ymax].
+ scores(Variable): A 3-D Tensor with shape [N, M, C] represents the
+ predicted confidence predictions. Data type should be float32
+ or float64. N is the batch size, C is the
+ class number, M is number of bounding boxes.
+ prior_box(Variable): A 2-D Tensor with shape [M, 4] holds M boxes,
+ each box is represented as [xmin, ymin, xmax, ymax]. Data type
+ should be float32 or float64.
+ prior_box_var(Variable): A 2-D Tensor with shape [M, 4] holds M group
+ of variance. Data type should be float32 or float64.
+ background_label(int): The index of background label,
+ the background label will be ignored. If set to -1, then all
+ categories will be considered. Default: 0.
+ nms_threshold(float): The threshold to be used in NMS. Default: 0.3.
+ nms_top_k(int): Maximum number of detections to be kept according
+ to the confidences after filtering detections based on
+ score_threshold and before NMS. Default: 400.
+ keep_top_k(int): Number of total bboxes to be kept per image after
+ NMS step. -1 means keeping all bboxes after NMS step. Default: 200.
+ score_threshold(float): Threshold to filter out bounding boxes with
+ low confidence score. If not provided, consider all boxes.
+ Default: 0.01.
+ nms_eta(float): The parameter for adaptive NMS. It works only when the
+ value is less than 1.0. Default: 1.0.
+ return_index(bool): Whether return selected index. Default: False
+
+ Returns:
+
+ A tuple with two Variables: (Out, Index) if return_index is True,
+ otherwise, a tuple with one Variable(Out) is returned.
+
+ Out (Variable): The detection outputs is a LoDTensor with shape [No, 6].
+ Data type is the same as input (loc). Each row has six values:
+ [label, confidence, xmin, ymin, xmax, ymax]. `No` is
+ the total number of detections in this mini-batch. For each instance,
+ the offsets in first dimension are called LoD, the offset number is
+ N + 1, N is the batch size. The i-th image has `LoD[i + 1] - LoD[i]`
+ detected results, if it is 0, the i-th image has no detected results.
+
+ Index (Variable): Only return when return_index is True. A 2-D LoDTensor
+ with shape [No, 1] represents the selected index which type is Integer.
+ The index is the absolute value cross batches. No is the same number
+ as Out. If the index is used to gather other attribute such as age,
+ one needs to reshape the input(N, M, 1) to (N * M, 1) as first, where
+ N is the batch size and M is the number of boxes.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+
+ pb = fluid.data(name='prior_box', shape=[10, 4], dtype='float32')
+ pbv = fluid.data(name='prior_box_var', shape=[10, 4], dtype='float32')
+ loc = fluid.data(name='target_box', shape=[2, 21, 4], dtype='float32')
+ scores = fluid.data(name='scores', shape=[2, 21, 10], dtype='float32')
+ nmsed_outs, index = fluid.layers.detection_output(scores=scores,
+ loc=loc,
+ prior_box=pb,
+ prior_box_var=pbv,
+ return_index=True)
+ """
+ helper = LayerHelper("detection_output", **locals())
+ decoded_box = box_coder(prior_box=prior_box,
+ prior_box_var=prior_box_var,
+ target_box=loc,
+ code_type='decode_center_size')
+ scores = nn.softmax(input=scores)
+ scores = nn.transpose(scores, perm=[0, 2, 1])
+ scores.stop_gradient = True
+ nmsed_outs = helper.create_variable_for_type_inference(
+ dtype=decoded_box.dtype)
+ if return_index:
+ index = helper.create_variable_for_type_inference(dtype='int')
+ helper.append_op(type="multiclass_nms2",
+ inputs={
+ 'Scores': scores,
+ 'BBoxes': decoded_box
+ },
+ outputs={
+ 'Out': nmsed_outs,
+ 'Index': index
+ },
+ attrs={
+ 'background_label': 0,
+ 'nms_threshold': nms_threshold,
+ 'nms_top_k': nms_top_k,
+ 'keep_top_k': keep_top_k,
+ 'score_threshold': score_threshold,
+ 'nms_eta': 1.0,
+ })
+ index.stop_gradient = True
+ else:
+ helper.append_op(type="multiclass_nms",
+ inputs={
+ 'Scores': scores,
+ 'BBoxes': decoded_box
+ },
+ outputs={'Out': nmsed_outs},
+ attrs={
+ 'background_label': 0,
+ 'nms_threshold': nms_threshold,
+ 'nms_top_k': nms_top_k,
+ 'keep_top_k': keep_top_k,
+ 'score_threshold': score_threshold,
+ 'nms_eta': 1.0,
+ })
+ nmsed_outs.stop_gradient = True
+ if return_index:
+ return nmsed_outs, index
+ return nmsed_outs
+
+
+@templatedoc()
+def iou_similarity(x, y, box_normalized=True, name=None):
+ """
+ :alias_main: paddle.nn.functional.iou_similarity
+ :alias: paddle.nn.functional.iou_similarity,paddle.nn.functional.loss.iou_similarity
+ :old_api: paddle.fluid.layers.iou_similarity
+
+ ${comment}
+
+ Args:
+ x (Variable): ${x_comment}.The data type is float32 or float64.
+ y (Variable): ${y_comment}.The data type is float32 or float64.
+ box_normalized(bool): Whether treat the priorbox as a normalized box.
+ Set true by default.
+ Returns:
+ Variable: ${out_comment}.The data type is same with x.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+
+ use_gpu = False
+ place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ x = fluid.data(name='x', shape=[None, 4], dtype='float32')
+ y = fluid.data(name='y', shape=[None, 4], dtype='float32')
+ iou = fluid.layers.iou_similarity(x=x, y=y)
+
+ exe.run(fluid.default_startup_program())
+ test_program = fluid.default_main_program().clone(for_test=True)
+
+ [out_iou] = exe.run(test_program,
+ fetch_list=iou,
+ feed={'x': np.array([[0.5, 0.5, 2.0, 2.0],
+ [0., 0., 1.0, 1.0]]).astype('float32'),
+ 'y': np.array([[1.0, 1.0, 2.5, 2.5]]).astype('float32')})
+ # out_iou is [[0.2857143],
+ # [0. ]] with shape: [2, 1]
+ """
+ helper = LayerHelper("iou_similarity", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(type="iou_similarity",
+ inputs={
+ "X": x,
+ "Y": y
+ },
+ attrs={"box_normalized": box_normalized},
+ outputs={"Out": out})
+ return out
+
+
+@templatedoc()
+def box_coder(prior_box,
+ prior_box_var,
+ target_box,
+ code_type="encode_center_size",
+ box_normalized=True,
+ name=None,
+ axis=0):
+ r"""
+
+ **Box Coder Layer**
+
+ Encode/Decode the target bounding box with the priorbox information.
+
+ The Encoding schema described below:
+
+ .. math::
+
+ ox = (tx - px) / pw / pxv
+
+ oy = (ty - py) / ph / pyv
+
+ ow = \log(\abs(tw / pw)) / pwv
+
+ oh = \log(\abs(th / ph)) / phv
+
+ The Decoding schema described below:
+
+ .. math::
+
+ ox = (pw * pxv * tx * + px) - tw / 2
+
+ oy = (ph * pyv * ty * + py) - th / 2
+
+ ow = \exp(pwv * tw) * pw + tw / 2
+
+ oh = \exp(phv * th) * ph + th / 2
+
+ where `tx`, `ty`, `tw`, `th` denote the target box's center coordinates,
+ width and height respectively. Similarly, `px`, `py`, `pw`, `ph` denote
+ the priorbox's (anchor) center coordinates, width and height. `pxv`,
+ `pyv`, `pwv`, `phv` denote the variance of the priorbox and `ox`, `oy`,
+ `ow`, `oh` denote the encoded/decoded coordinates, width and height.
+
+ During Box Decoding, two modes for broadcast are supported. Say target
+ box has shape [N, M, 4], and the shape of prior box can be [N, 4] or
+ [M, 4]. Then prior box will broadcast to target box along the
+ assigned axis.
+
+ Args:
+ prior_box(Variable): Box list prior_box is a 2-D Tensor with shape
+ [M, 4] holds M boxes and data type is float32 or float64. Each box
+ is represented as [xmin, ymin, xmax, ymax], [xmin, ymin] is the
+ left top coordinate of the anchor box, if the input is image feature
+ map, they are close to the origin of the coordinate system.
+ [xmax, ymax] is the right bottom coordinate of the anchor box.
+ prior_box_var(List|Variable|None): prior_box_var supports three types
+ of input. One is variable with shape [M, 4] which holds M group and
+ data type is float32 or float64. The second is list consist of
+ 4 elements shared by all boxes and data type is float32 or float64.
+ Other is None and not involved in calculation.
+ target_box(Variable): This input can be a 2-D LoDTensor with shape
+ [N, 4] when code_type is 'encode_center_size'. This input also can
+ be a 3-D Tensor with shape [N, M, 4] when code_type is
+ 'decode_center_size'. Each box is represented as
+ [xmin, ymin, xmax, ymax]. The data type is float32 or float64.
+ This tensor can contain LoD information to represent a batch of inputs.
+ code_type(str): The code type used with the target box. It can be
+ `encode_center_size` or `decode_center_size`. `encode_center_size`
+ by default.
+ box_normalized(bool): Whether treat the priorbox as a normalized box.
+ Set true by default.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ axis(int): Which axis in PriorBox to broadcast for box decode,
+ for example, if axis is 0 and TargetBox has shape [N, M, 4] and
+ PriorBox has shape [M, 4], then PriorBox will broadcast to [N, M, 4]
+ for decoding. It is only valid when code type is
+ `decode_center_size`. Set 0 by default.
+
+ Returns:
+ Variable:
+
+ output_box(Variable): When code_type is 'encode_center_size', the
+ output tensor of box_coder_op with shape [N, M, 4] representing the
+ result of N target boxes encoded with M Prior boxes and variances.
+ When code_type is 'decode_center_size', N represents the batch size
+ and M represents the number of decoded boxes.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # For encode
+ prior_box_encode = fluid.data(name='prior_box_encode',
+ shape=[512, 4],
+ dtype='float32')
+ target_box_encode = fluid.data(name='target_box_encode',
+ shape=[81, 4],
+ dtype='float32')
+ output_encode = fluid.layers.box_coder(prior_box=prior_box_encode,
+ prior_box_var=[0.1,0.1,0.2,0.2],
+ target_box=target_box_encode,
+ code_type="encode_center_size")
+ # For decode
+ prior_box_decode = fluid.data(name='prior_box_decode',
+ shape=[512, 4],
+ dtype='float32')
+ target_box_decode = fluid.data(name='target_box_decode',
+ shape=[512, 81, 4],
+ dtype='float32')
+ output_decode = fluid.layers.box_coder(prior_box=prior_box_decode,
+ prior_box_var=[0.1,0.1,0.2,0.2],
+ target_box=target_box_decode,
+ code_type="decode_center_size",
+ box_normalized=False,
+ axis=1)
+ """
+ return paddle.vision.ops.box_coder(prior_box=prior_box,
+ prior_box_var=prior_box_var,
+ target_box=target_box,
+ code_type=code_type,
+ box_normalized=box_normalized,
+ axis=axis,
+ name=name)
+
+
+@templatedoc()
+def polygon_box_transform(input, name=None):
+ """
+ ${comment}
+
+ Args:
+ input(Variable): The input with shape [batch_size, geometry_channels, height, width].
+ A Tensor with type float32, float64.
+ name(str, Optional): For details, please refer to :ref:`api_guide_Name`.
+ Generally, no setting is required. Default: None.
+
+ Returns:
+ Variable: The output with the same shape as input. A Tensor with type float32, float64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ input = fluid.data(name='input', shape=[4, 10, 5, 5], dtype='float32')
+ out = fluid.layers.polygon_box_transform(input)
+ """
+ check_variable_and_dtype(input, "input", ['float32', 'float64'],
+ 'polygon_box_transform')
+ helper = LayerHelper("polygon_box_transform", **locals())
+ output = helper.create_variable_for_type_inference(dtype=input.dtype)
+
+ helper.append_op(type="polygon_box_transform",
+ inputs={"Input": input},
+ attrs={},
+ outputs={"Output": output})
+ return output
+
+
+@deprecated(since="2.0.0", update_to="paddle.vision.ops.yolo_loss")
+@templatedoc(op_type="yolov3_loss")
+def yolov3_loss(x,
+ gt_box,
+ gt_label,
+ anchors,
+ anchor_mask,
+ class_num,
+ ignore_thresh,
+ downsample_ratio,
+ gt_score=None,
+ use_label_smooth=True,
+ name=None,
+ scale_x_y=1.):
+ """
+
+ ${comment}
+
+ Args:
+ x (Variable): ${x_comment}The data type is float32 or float64.
+ gt_box (Variable): groud truth boxes, should be in shape of [N, B, 4],
+ in the third dimension, x, y, w, h should be stored.
+ x,y is the center coordinate of boxes, w, h are the
+ width and height, x, y, w, h should be divided by
+ input image height to scale to [0, 1].
+ N is the batch number and B is the max box number in
+ an image.The data type is float32 or float64.
+ gt_label (Variable): class id of ground truth boxes, should be in shape
+ of [N, B].The data type is int32.
+ anchors (list|tuple): ${anchors_comment}
+ anchor_mask (list|tuple): ${anchor_mask_comment}
+ class_num (int): ${class_num_comment}
+ ignore_thresh (float): ${ignore_thresh_comment}
+ downsample_ratio (int): ${downsample_ratio_comment}
+ name (string): The default value is None. Normally there is no need
+ for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`
+ gt_score (Variable): mixup score of ground truth boxes, should be in shape
+ of [N, B]. Default None.
+ use_label_smooth (bool): ${use_label_smooth_comment}
+ scale_x_y (float): ${scale_x_y_comment}
+
+ Returns:
+ Variable: A 1-D tensor with shape [N], the value of yolov3 loss
+
+ Raises:
+ TypeError: Input x of yolov3_loss must be Variable
+ TypeError: Input gtbox of yolov3_loss must be Variable
+ TypeError: Input gtlabel of yolov3_loss must be Variable
+ TypeError: Input gtscore of yolov3_loss must be None or Variable
+ TypeError: Attr anchors of yolov3_loss must be list or tuple
+ TypeError: Attr class_num of yolov3_loss must be an integer
+ TypeError: Attr ignore_thresh of yolov3_loss must be a float number
+ TypeError: Attr use_label_smooth of yolov3_loss must be a bool value
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ x = fluid.data(name='x', shape=[None, 255, 13, 13], dtype='float32')
+ gt_box = fluid.data(name='gt_box', shape=[None, 6, 4], dtype='float32')
+ gt_label = fluid.data(name='gt_label', shape=[None, 6], dtype='int32')
+ gt_score = fluid.data(name='gt_score', shape=[None, 6], dtype='float32')
+ anchors = [10, 13, 16, 30, 33, 23, 30, 61, 62, 45, 59, 119, 116, 90, 156, 198, 373, 326]
+ anchor_mask = [0, 1, 2]
+ loss = fluid.layers.yolov3_loss(x=x, gt_box=gt_box, gt_label=gt_label,
+ gt_score=gt_score, anchors=anchors,
+ anchor_mask=anchor_mask, class_num=80,
+ ignore_thresh=0.7, downsample_ratio=32)
+ """
+
+ if not isinstance(x, Variable):
+ raise TypeError("Input x of yolov3_loss must be Variable")
+ if not isinstance(gt_box, Variable):
+ raise TypeError("Input gtbox of yolov3_loss must be Variable")
+ if not isinstance(gt_label, Variable):
+ raise TypeError("Input gtlabel of yolov3_loss must be Variable")
+ if gt_score is not None and not isinstance(gt_score, Variable):
+ raise TypeError("Input gtscore of yolov3_loss must be Variable")
+ if not isinstance(anchors, list) and not isinstance(anchors, tuple):
+ raise TypeError("Attr anchors of yolov3_loss must be list or tuple")
+ if not isinstance(anchor_mask, list) and not isinstance(anchor_mask, tuple):
+ raise TypeError("Attr anchor_mask of yolov3_loss must be list or tuple")
+ if not isinstance(class_num, int):
+ raise TypeError("Attr class_num of yolov3_loss must be an integer")
+ if not isinstance(ignore_thresh, float):
+ raise TypeError(
+ "Attr ignore_thresh of yolov3_loss must be a float number")
+ if not isinstance(use_label_smooth, bool):
+ raise TypeError(
+ "Attr use_label_smooth of yolov3_loss must be a bool value")
+
+ if _non_static_mode():
+ attrs = ("anchors", anchors, "anchor_mask", anchor_mask, "class_num",
+ class_num, "ignore_thresh", ignore_thresh, "downsample_ratio",
+ downsample_ratio, "use_label_smooth", use_label_smooth,
+ "scale_x_y", scale_x_y)
+ loss, _, _ = _legacy_C_ops.yolov3_loss(x, gt_box, gt_label, gt_score,
+ *attrs)
+ return loss
+
+ helper = LayerHelper('yolov3_loss', **locals())
+ loss = helper.create_variable_for_type_inference(dtype=x.dtype)
+ objectness_mask = helper.create_variable_for_type_inference(dtype='int32')
+ gt_match_mask = helper.create_variable_for_type_inference(dtype='int32')
+
+ inputs = {
+ "X": x,
+ "GTBox": gt_box,
+ "GTLabel": gt_label,
+ }
+ if gt_score is not None:
+ inputs["GTScore"] = gt_score
+
+ attrs = {
+ "anchors": anchors,
+ "anchor_mask": anchor_mask,
+ "class_num": class_num,
+ "ignore_thresh": ignore_thresh,
+ "downsample_ratio": downsample_ratio,
+ "use_label_smooth": use_label_smooth,
+ "scale_x_y": scale_x_y,
+ }
+
+ helper.append_op(type='yolov3_loss',
+ inputs=inputs,
+ outputs={
+ 'Loss': loss,
+ 'ObjectnessMask': objectness_mask,
+ 'GTMatchMask': gt_match_mask
+ },
+ attrs=attrs)
+ return loss
+
+
+@deprecated(since="2.0.0", update_to="paddle.vision.ops.yolo_box")
+@templatedoc(op_type="yolo_box")
+def yolo_box(x,
+ img_size,
+ anchors,
+ class_num,
+ conf_thresh,
+ downsample_ratio,
+ clip_bbox=True,
+ name=None,
+ scale_x_y=1.,
+ iou_aware=False,
+ iou_aware_factor=0.5):
+ """
+
+ ${comment}
+
+ Args:
+ x (Variable): ${x_comment} The data type is float32 or float64.
+ img_size (Variable): ${img_size_comment} The data type is int32.
+ anchors (list|tuple): ${anchors_comment}
+ class_num (int): ${class_num_comment}
+ conf_thresh (float): ${conf_thresh_comment}
+ downsample_ratio (int): ${downsample_ratio_comment}
+ clip_bbox (bool): ${clip_bbox_comment}
+ scale_x_y (float): ${scale_x_y_comment}
+ name (string): The default value is None. Normally there is no need
+ for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`
+ iou_aware (bool): ${iou_aware_comment}
+ iou_aware_factor (float): ${iou_aware_factor_comment}
+
+ Returns:
+ Variable: A 3-D tensor with shape [N, M, 4], the coordinates of boxes,
+ and a 3-D tensor with shape [N, M, :attr:`class_num`], the classification
+ scores of boxes.
+
+ Raises:
+ TypeError: Input x of yolov_box must be Variable
+ TypeError: Attr anchors of yolo box must be list or tuple
+ TypeError: Attr class_num of yolo box must be an integer
+ TypeError: Attr conf_thresh of yolo box must be a float number
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ x = fluid.data(name='x', shape=[None, 255, 13, 13], dtype='float32')
+ img_size = fluid.data(name='img_size',shape=[None, 2],dtype='int64')
+ anchors = [10, 13, 16, 30, 33, 23]
+ boxes,scores = fluid.layers.yolo_box(x=x, img_size=img_size, class_num=80, anchors=anchors,
+ conf_thresh=0.01, downsample_ratio=32)
+ """
+ helper = LayerHelper('yolo_box', **locals())
+
+ if not isinstance(x, Variable):
+ raise TypeError("Input x of yolo_box must be Variable")
+ if not isinstance(img_size, Variable):
+ raise TypeError("Input img_size of yolo_box must be Variable")
+ if not isinstance(anchors, list) and not isinstance(anchors, tuple):
+ raise TypeError("Attr anchors of yolo_box must be list or tuple")
+ if not isinstance(class_num, int):
+ raise TypeError("Attr class_num of yolo_box must be an integer")
+ if not isinstance(conf_thresh, float):
+ raise TypeError("Attr ignore_thresh of yolo_box must be a float number")
+
+ boxes = helper.create_variable_for_type_inference(dtype=x.dtype)
+ scores = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ attrs = {
+ "anchors": anchors,
+ "class_num": class_num,
+ "conf_thresh": conf_thresh,
+ "downsample_ratio": downsample_ratio,
+ "clip_bbox": clip_bbox,
+ "scale_x_y": scale_x_y,
+ "iou_aware": iou_aware,
+ "iou_aware_factor": iou_aware_factor
+ }
+
+ helper.append_op(type='yolo_box',
+ inputs={
+ "X": x,
+ "ImgSize": img_size,
+ },
+ outputs={
+ 'Boxes': boxes,
+ 'Scores': scores,
+ },
+ attrs=attrs)
+ return boxes, scores
+
+
+@templatedoc()
+def detection_map(detect_res,
+ label,
+ class_num,
+ background_label=0,
+ overlap_threshold=0.3,
+ evaluate_difficult=True,
+ has_state=None,
+ input_states=None,
+ out_states=None,
+ ap_version='integral'):
+ """
+ ${comment}
+
+ Args:
+ detect_res: ${detect_res_comment}
+ label: ${label_comment}
+ class_num: ${class_num_comment}
+ background_label: ${background_label_comment}
+ overlap_threshold: ${overlap_threshold_comment}
+ evaluate_difficult: ${evaluate_difficult_comment}
+ has_state: ${has_state_comment}
+ input_states: (tuple|None) If not None, It contains 3 elements:
+ (1) pos_count ${pos_count_comment}.
+ (2) true_pos ${true_pos_comment}.
+ (3) false_pos ${false_pos_comment}.
+ out_states: (tuple|None) If not None, it contains 3 elements.
+ (1) accum_pos_count ${accum_pos_count_comment}.
+ (2) accum_true_pos ${accum_true_pos_comment}.
+ (3) accum_false_pos ${accum_false_pos_comment}.
+ ap_version: ${ap_type_comment}
+
+ Returns:
+ ${map_comment}
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ from fluid.layers import detection
+ detect_res = fluid.data(
+ name='detect_res',
+ shape=[10, 6],
+ dtype='float32')
+ label = fluid.data(
+ name='label',
+ shape=[10, 6],
+ dtype='float32')
+
+ map_out = detection.detection_map(detect_res, label, 21)
+ """
+ helper = LayerHelper("detection_map", **locals())
+
+ def __create_var(type):
+ return helper.create_variable_for_type_inference(dtype=type)
+
+ map_out = __create_var('float32')
+ accum_pos_count_out = out_states[
+ 0] if out_states is not None else __create_var('int32')
+ accum_true_pos_out = out_states[
+ 1] if out_states is not None else __create_var('float32')
+ accum_false_pos_out = out_states[
+ 2] if out_states is not None else __create_var('float32')
+
+ pos_count = input_states[0] if input_states is not None else None
+ true_pos = input_states[1] if input_states is not None else None
+ false_pos = input_states[2] if input_states is not None else None
+
+ helper.append_op(type="detection_map",
+ inputs={
+ 'Label': label,
+ 'DetectRes': detect_res,
+ 'HasState': has_state,
+ 'PosCount': pos_count,
+ 'TruePos': true_pos,
+ 'FalsePos': false_pos
+ },
+ outputs={
+ 'MAP': map_out,
+ 'AccumPosCount': accum_pos_count_out,
+ 'AccumTruePos': accum_true_pos_out,
+ 'AccumFalsePos': accum_false_pos_out
+ },
+ attrs={
+ 'overlap_threshold': overlap_threshold,
+ 'evaluate_difficult': evaluate_difficult,
+ 'ap_type': ap_version,
+ 'class_num': class_num,
+ })
+ return map_out
+
+
+def bipartite_match(dist_matrix,
+ match_type=None,
+ dist_threshold=None,
+ name=None):
+ """
+
+ This operator implements a greedy bipartite matching algorithm, which is
+ used to obtain the matching with the maximum distance based on the input
+ distance matrix. For input 2D matrix, the bipartite matching algorithm can
+ find the matched column for each row (matched means the largest distance),
+ also can find the matched row for each column. And this operator only
+ calculate matched indices from column to row. For each instance,
+ the number of matched indices is the column number of the input distance
+ matrix. **The OP only supports CPU**.
+
+ There are two outputs, matched indices and distance.
+ A simple description, this algorithm matched the best (maximum distance)
+ row entity to the column entity and the matched indices are not duplicated
+ in each row of ColToRowMatchIndices. If the column entity is not matched
+ any row entity, set -1 in ColToRowMatchIndices.
+
+ NOTE: the input DistMat can be LoDTensor (with LoD) or Tensor.
+ If LoDTensor with LoD, the height of ColToRowMatchIndices is batch size.
+ If Tensor, the height of ColToRowMatchIndices is 1.
+
+ NOTE: This API is a very low level API. It is used by :code:`ssd_loss`
+ layer. Please consider to use :code:`ssd_loss` instead.
+
+ Args:
+ dist_matrix(Variable): This input is a 2-D LoDTensor with shape
+ [K, M]. The data type is float32 or float64. It is pair-wise
+ distance matrix between the entities represented by each row and
+ each column. For example, assumed one entity is A with shape [K],
+ another entity is B with shape [M]. The dist_matrix[i][j] is the
+ distance between A[i] and B[j]. The bigger the distance is, the
+ better matching the pairs are. NOTE: This tensor can contain LoD
+ information to represent a batch of inputs. One instance of this
+ batch can contain different numbers of entities.
+ match_type(str, optional): The type of matching method, should be
+ 'bipartite' or 'per_prediction'. None ('bipartite') by default.
+ dist_threshold(float32, optional): If `match_type` is 'per_prediction',
+ this threshold is to determine the extra matching bboxes based
+ on the maximum distance, 0.5 by default.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tuple:
+
+ matched_indices(Variable): A 2-D Tensor with shape [N, M]. The data
+ type is int32. N is the batch size. If match_indices[i][j] is -1, it
+ means B[j] does not match any entity in i-th instance.
+ Otherwise, it means B[j] is matched to row
+ match_indices[i][j] in i-th instance. The row number of
+ i-th instance is saved in match_indices[i][j].
+
+ matched_distance(Variable): A 2-D Tensor with shape [N, M]. The data
+ type is float32. N is batch size. If match_indices[i][j] is -1,
+ match_distance[i][j] is also -1.0. Otherwise, assumed
+ match_distance[i][j] = d, and the row offsets of each instance
+ are called LoD. Then match_distance[i][j] =
+ dist_matrix[d+LoD[i]][j].
+
+ Examples:
+
+ >>> import paddle.fluid as fluid
+ >>> x = fluid.data(name='x', shape=[None, 4], dtype='float32')
+ >>> y = fluid.data(name='y', shape=[None, 4], dtype='float32')
+ >>> iou = fluid.layers.iou_similarity(x=x, y=y)
+ >>> matched_indices, matched_dist = fluid.layers.bipartite_match(iou)
+ """
+ helper = LayerHelper('bipartite_match', **locals())
+ match_indices = helper.create_variable_for_type_inference(dtype='int32')
+ match_distance = helper.create_variable_for_type_inference(
+ dtype=dist_matrix.dtype)
+ helper.append_op(type='bipartite_match',
+ inputs={'DistMat': dist_matrix},
+ attrs={
+ 'match_type': match_type,
+ 'dist_threshold': dist_threshold,
+ },
+ outputs={
+ 'ColToRowMatchIndices': match_indices,
+ 'ColToRowMatchDist': match_distance
+ })
+ return match_indices, match_distance
+
+
+def target_assign(input,
+ matched_indices,
+ negative_indices=None,
+ mismatch_value=None,
+ name=None):
+ """
+
+ This operator can be, for given the target bounding boxes or labels,
+ to assign classification and regression targets to each prediction as well as
+ weights to prediction. The weights is used to specify which prediction would
+ not contribute to training loss.
+
+ For each instance, the output `out` and`out_weight` are assigned based on
+ `match_indices` and `negative_indices`.
+ Assumed that the row offset for each instance in `input` is called lod,
+ this operator assigns classification/regression targets by performing the
+ following steps:
+
+ 1. Assigning all outputs based on `match_indices`:
+
+ .. code-block:: text
+
+ If id = match_indices[i][j] > 0,
+
+ out[i][j][0 : K] = X[lod[i] + id][j % P][0 : K]
+ out_weight[i][j] = 1.
+
+ Otherwise,
+
+ out[j][j][0 : K] = {mismatch_value, mismatch_value, ...}
+ out_weight[i][j] = 0.
+
+ 2. Assigning outputs based on `neg_indices` if `neg_indices` is provided:
+
+ Assumed that i-th instance in `neg_indices` is called `neg_indice`,
+ for i-th instance:
+
+ .. code-block:: text
+
+ for id in neg_indice:
+ out[i][id][0 : K] = {mismatch_value, mismatch_value, ...}
+ out_weight[i][id] = 1.0
+
+ Args:
+ input (Variable): This input is a 3D LoDTensor with shape [M, P, K].
+ Data type should be int32 or float32.
+ matched_indices (Variable): The input matched indices
+ is 2D Tenosr with shape [N, P], If MatchIndices[i][j] is -1,
+ the j-th entity of column is not matched to any entity of row in
+ i-th instance.
+ negative_indices (Variable, optional): The input negative example indices
+ are an optional input with shape [Neg, 1] and int32 type, where Neg is
+ the total number of negative example indices.
+ mismatch_value (float32, optional): Fill this value to the mismatched
+ location.
+ name (string): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer
+ to :ref:`api_guide_Name`.
+
+ Returns:
+ tuple: A tuple(out, out_weight) is returned.
+
+ out (Variable): a 3D Tensor with shape [N, P, K] and same data type
+ with `input`, N and P is the same as they are in `matched_indices`,
+ K is the same as it in input of X.
+
+ out_weight (Variable): the weight for output with the shape of [N, P, 1].
+ Data type is float32.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ x = fluid.data(
+ name='x',
+ shape=[4, 20, 4],
+ dtype='float',
+ lod_level=1)
+ matched_id = fluid.data(
+ name='indices',
+ shape=[8, 20],
+ dtype='int32')
+ trg, trg_weight = fluid.layers.target_assign(
+ x,
+ matched_id,
+ mismatch_value=0)
+ """
+ helper = LayerHelper('target_assign', **locals())
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ out_weight = helper.create_variable_for_type_inference(dtype='float32')
+ helper.append_op(type='target_assign',
+ inputs={
+ 'X': input,
+ 'MatchIndices': matched_indices,
+ 'NegIndices': negative_indices
+ },
+ outputs={
+ 'Out': out,
+ 'OutWeight': out_weight
+ },
+ attrs={'mismatch_value': mismatch_value})
+ return out, out_weight
+
+
+def ssd_loss(location,
+ confidence,
+ gt_box,
+ gt_label,
+ prior_box,
+ prior_box_var=None,
+ background_label=0,
+ overlap_threshold=0.5,
+ neg_pos_ratio=3.0,
+ neg_overlap=0.5,
+ loc_loss_weight=1.0,
+ conf_loss_weight=1.0,
+ match_type='per_prediction',
+ mining_type='max_negative',
+ normalize=True,
+ sample_size=None):
+ r"""
+ :alias_main: paddle.nn.functional.ssd_loss
+ :alias: paddle.nn.functional.ssd_loss,paddle.nn.functional.loss.ssd_loss
+ :old_api: paddle.fluid.layers.ssd_loss
+
+ **Multi-box loss layer for object detection algorithm of SSD**
+
+ This layer is to compute detection loss for SSD given the location offset
+ predictions, confidence predictions, prior boxes and ground-truth bounding
+ boxes and labels, and the type of hard example mining. The returned loss
+ is a weighted sum of the localization loss (or regression loss) and
+ confidence loss (or classification loss) by performing the following steps:
+
+ 1. Find matched bounding box by bipartite matching algorithm.
+
+ 1.1 Compute IOU similarity between ground-truth boxes and prior boxes.
+
+ 1.2 Compute matched bounding box by bipartite matching algorithm.
+
+ 2. Compute confidence for mining hard examples
+
+ 2.1. Get the target label based on matched indices.
+
+ 2.2. Compute confidence loss.
+
+ 3. Apply hard example mining to get the negative example indices and update
+ the matched indices.
+
+ 4. Assign classification and regression targets
+
+ 4.1. Encoded bbox according to the prior boxes.
+
+ 4.2. Assign regression targets.
+
+ 4.3. Assign classification targets.
+
+ 5. Compute the overall objective loss.
+
+ 5.1 Compute confidence loss.
+
+ 5.2 Compute localization loss.
+
+ 5.3 Compute the overall weighted loss.
+
+ Args:
+ location (Variable): The location predictions are a 3D Tensor with
+ shape [N, Np, 4], N is the batch size, Np is total number of
+ predictions for each instance. 4 is the number of coordinate values,
+ the layout is [xmin, ymin, xmax, ymax].The data type is float32 or
+ float64.
+ confidence (Variable): The confidence predictions are a 3D Tensor
+ with shape [N, Np, C], N and Np are the same as they are in
+ `location`, C is the class number.The data type is float32 or
+ float64.
+ gt_box (Variable): The ground-truth bounding boxes (bboxes) are a 2D
+ LoDTensor with shape [Ng, 4], Ng is the total number of ground-truth
+ bboxes of mini-batch input.The data type is float32 or float64.
+ gt_label (Variable): The ground-truth labels are a 2D LoDTensor
+ with shape [Ng, 1].Ng is the total number of ground-truth bboxes of
+ mini-batch input, 1 is the number of class. The data type is float32
+ or float64.
+ prior_box (Variable): The prior boxes are a 2D Tensor with shape [Np, 4].
+ Np and 4 are the same as they are in `location`. The data type is
+ float32 or float64.
+ prior_box_var (Variable): The variance of prior boxes are a 2D Tensor
+ with shape [Np, 4]. Np and 4 are the same as they are in `prior_box`
+ background_label (int): The index of background label, 0 by default.
+ overlap_threshold (float): If match_type is 'per_prediction', use
+ 'overlap_threshold' to determine the extra matching bboxes when finding \
+ matched boxes. 0.5 by default.
+ neg_pos_ratio (float): The ratio of the negative boxes to the positive
+ boxes, used only when mining_type is 'max_negative', 3.0 by default.
+ neg_overlap (float): The negative overlap upper bound for the unmatched
+ predictions. Use only when mining_type is 'max_negative',
+ 0.5 by default.
+ loc_loss_weight (float): Weight for localization loss, 1.0 by default.
+ conf_loss_weight (float): Weight for confidence loss, 1.0 by default.
+ match_type (str): The type of matching method during training, should
+ be 'bipartite' or 'per_prediction', 'per_prediction' by default.
+ mining_type (str): The hard example mining type, should be 'hard_example'
+ or 'max_negative', now only support `max_negative`.
+ normalize (bool): Whether to normalize the SSD loss by the total number
+ of output locations, True by default.
+ sample_size (int): The max sample size of negative box, used only when
+ mining_type is 'hard_example'.
+
+ Returns:
+ Variable(Tensor): The weighted sum of the localization loss and confidence loss, \
+ with shape [N * Np, 1], N and Np are the same as they are in
+ `location`.The data type is float32 or float64.
+
+ Raises:
+ ValueError: If mining_type is 'hard_example', now only support mining \
+ type of `max_negative`.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ pb = fluid.data(
+ name='prior_box',
+ shape=[10, 4],
+ dtype='float32')
+ pbv = fluid.data(
+ name='prior_box_var',
+ shape=[10, 4],
+ dtype='float32')
+ loc = fluid.data(name='target_box', shape=[10, 4], dtype='float32')
+ scores = fluid.data(name='scores', shape=[10, 21], dtype='float32')
+ gt_box = fluid.data(
+ name='gt_box', shape=[4], lod_level=1, dtype='float32')
+ gt_label = fluid.data(
+ name='gt_label', shape=[1], lod_level=1, dtype='float32')
+ loss = fluid.layers.ssd_loss(loc, scores, gt_box, gt_label, pb, pbv)
+ """
+
+ helper = LayerHelper('ssd_loss', **locals())
+ if mining_type != 'max_negative':
+ raise ValueError("Only support mining_type == max_negative now.")
+
+ num, num_prior, num_class = confidence.shape
+ conf_shape = nn.shape(confidence)
+
+ def __reshape_to_2d(var):
+ return nn.flatten(x=var, axis=2)
+
+ # 1. Find matched bounding box by prior box.
+ # 1.1 Compute IOU similarity between ground-truth boxes and prior boxes.
+ iou = iou_similarity(x=gt_box, y=prior_box)
+ # 1.2 Compute matched bounding box by bipartite matching algorithm.
+ matched_indices, matched_dist = bipartite_match(iou, match_type,
+ overlap_threshold)
+
+ # 2. Compute confidence for mining hard examples
+ # 2.1. Get the target label based on matched indices
+ gt_label = nn.reshape(x=gt_label,
+ shape=(len(gt_label.shape) - 1) * (0, ) + (-1, 1))
+ gt_label.stop_gradient = True
+ target_label, _ = target_assign(gt_label,
+ matched_indices,
+ mismatch_value=background_label)
+ # 2.2. Compute confidence loss.
+ # Reshape confidence to 2D tensor.
+ confidence = __reshape_to_2d(confidence)
+ target_label = tensor.cast(x=target_label, dtype='int64')
+ target_label = __reshape_to_2d(target_label)
+ target_label.stop_gradient = True
+ conf_loss = softmax_with_cross_entropy(confidence, target_label)
+ # 3. Mining hard examples
+ actual_shape = nn.slice(conf_shape, axes=[0], starts=[0], ends=[2])
+ actual_shape.stop_gradient = True
+ # shape=(-1, 0) is set for compile-time, the correct shape is set by
+ # actual_shape in runtime.
+ conf_loss = nn.reshape(x=conf_loss,
+ shape=(-1, 0),
+ actual_shape=actual_shape)
+ conf_loss.stop_gradient = True
+ neg_indices = helper.create_variable_for_type_inference(dtype='int32')
+ dtype = matched_indices.dtype
+ updated_matched_indices = helper.create_variable_for_type_inference(
+ dtype=dtype)
+ helper.append_op(type='mine_hard_examples',
+ inputs={
+ 'ClsLoss': conf_loss,
+ 'LocLoss': None,
+ 'MatchIndices': matched_indices,
+ 'MatchDist': matched_dist,
+ },
+ outputs={
+ 'NegIndices': neg_indices,
+ 'UpdatedMatchIndices': updated_matched_indices
+ },
+ attrs={
+ 'neg_pos_ratio': neg_pos_ratio,
+ 'neg_dist_threshold': neg_overlap,
+ 'mining_type': mining_type,
+ 'sample_size': sample_size,
+ })
+
+ # 4. Assign classification and regression targets
+ # 4.1. Encoded bbox according to the prior boxes.
+ encoded_bbox = box_coder(prior_box=prior_box,
+ prior_box_var=prior_box_var,
+ target_box=gt_box,
+ code_type='encode_center_size')
+ # 4.2. Assign regression targets
+ target_bbox, target_loc_weight = target_assign(
+ encoded_bbox, updated_matched_indices, mismatch_value=background_label)
+ # 4.3. Assign classification targets
+ target_label, target_conf_weight = target_assign(
+ gt_label,
+ updated_matched_indices,
+ negative_indices=neg_indices,
+ mismatch_value=background_label)
+
+ # 5. Compute loss.
+ # 5.1 Compute confidence loss.
+ target_label = __reshape_to_2d(target_label)
+ target_label = tensor.cast(x=target_label, dtype='int64')
+
+ conf_loss = softmax_with_cross_entropy(confidence, target_label)
+ target_conf_weight = __reshape_to_2d(target_conf_weight)
+ conf_loss = conf_loss * target_conf_weight
+
+ # the target_label and target_conf_weight do not have gradient.
+ target_label.stop_gradient = True
+ target_conf_weight.stop_gradient = True
+
+ # 5.2 Compute regression loss.
+ location = __reshape_to_2d(location)
+ target_bbox = __reshape_to_2d(target_bbox)
+
+ loc_loss = nn.smooth_l1(location, target_bbox)
+ target_loc_weight = __reshape_to_2d(target_loc_weight)
+ loc_loss = loc_loss * target_loc_weight
+
+ # the target_bbox and target_loc_weight do not have gradient.
+ target_bbox.stop_gradient = True
+ target_loc_weight.stop_gradient = True
+
+ # 5.3 Compute overall weighted loss.
+ loss = conf_loss_weight * conf_loss + loc_loss_weight * loc_loss
+ # reshape to [N, Np], N is the batch size and Np is the prior box number.
+ # shape=(-1, 0) is set for compile-time, the correct shape is set by
+ # actual_shape in runtime.
+ loss = nn.reshape(x=loss, shape=(-1, 0), actual_shape=actual_shape)
+ loss = nn.reduce_sum(loss, dim=1, keep_dim=True)
+ if normalize:
+ normalizer = nn.reduce_sum(target_loc_weight)
+ loss = loss / normalizer
+
+ return loss
+
+
+def prior_box(
+ input,
+ image,
+ min_sizes,
+ max_sizes=None,
+ aspect_ratios=[1.],
+ variance=[0.1, 0.1, 0.2, 0.2],
+ flip=False,
+ clip=False,
+ steps=[0.0, 0.0],
+ offset=0.5,
+ name=None,
+ min_max_aspect_ratios_order=False,
+):
+ """
+
+ This op generates prior boxes for SSD(Single Shot MultiBox Detector) algorithm.
+ Each position of the input produce N prior boxes, N is determined by
+ the count of min_sizes, max_sizes and aspect_ratios, The size of the
+ box is in range(min_size, max_size) interval, which is generated in
+ sequence according to the aspect_ratios.
+
+ Parameters:
+ input(Variable): 4-D tensor(NCHW), the data type should be float32 or float64.
+ image(Variable): 4-D tensor(NCHW), the input image data of PriorBoxOp,
+ the data type should be float32 or float64.
+ min_sizes(list|tuple|float): the min sizes of generated prior boxes.
+ max_sizes(list|tuple|None): the max sizes of generated prior boxes.
+ Default: None.
+ aspect_ratios(list|tuple|float): the aspect ratios of generated
+ prior boxes. Default: [1.].
+ variance(list|tuple): the variances to be encoded in prior boxes.
+ Default:[0.1, 0.1, 0.2, 0.2].
+ flip(bool): Whether to flip aspect ratios. Default:False.
+ clip(bool): Whether to clip out-of-boundary boxes. Default: False.
+ step(list|tuple): Prior boxes step across width and height, If
+ step[0] equals to 0.0 or step[1] equals to 0.0, the prior boxes step across
+ height or weight of the input will be automatically calculated.
+ Default: [0., 0.]
+ offset(float): Prior boxes center offset. Default: 0.5
+ min_max_aspect_ratios_order(bool): If set True, the output prior box is
+ in order of [min, max, aspect_ratios], which is consistent with
+ Caffe. Please note, this order affects the weights order of
+ convolution layer followed by and does not affect the final
+ detection results. Default: False.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Tuple: A tuple with two Variable (boxes, variances)
+
+ boxes(Variable): the output prior boxes of PriorBox.
+ 4-D tensor, the layout is [H, W, num_priors, 4].
+ H is the height of input, W is the width of input,
+ num_priors is the total box count of each position of input.
+
+ variances(Variable): the expanded variances of PriorBox.
+ 4-D tensor, the layput is [H, W, num_priors, 4].
+ H is the height of input, W is the width of input
+ num_priors is the total box count of each position of input
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+ input = fluid.data(name="input", shape=[None,3,6,9])
+ image = fluid.data(name="image", shape=[None,3,9,12])
+ box, var = fluid.layers.prior_box(
+ input=input,
+ image=image,
+ min_sizes=[100.],
+ clip=True,
+ flip=True)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ # prepare a batch of data
+ input_data = np.random.rand(1,3,6,9).astype("float32")
+ image_data = np.random.rand(1,3,9,12).astype("float32")
+
+ box_out, var_out = exe.run(fluid.default_main_program(),
+ feed={"input":input_data,"image":image_data},
+ fetch_list=[box,var],
+ return_numpy=True)
+
+ # print(box_out.shape)
+ # (6, 9, 1, 4)
+ # print(var_out.shape)
+ # (6, 9, 1, 4)
+
+ # imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ image = dg.to_variable(image_data)
+ box, var = fluid.layers.prior_box(
+ input=input,
+ image=image,
+ min_sizes=[100.],
+ clip=True,
+ flip=True)
+ # print(box.shape)
+ # [6L, 9L, 1L, 4L]
+ # print(var.shape)
+ # [6L, 9L, 1L, 4L]
+
+ """
+ return paddle.vision.ops.prior_box(
+ input=input,
+ image=image,
+ min_sizes=min_sizes,
+ max_sizes=max_sizes,
+ aspect_ratios=aspect_ratios,
+ variance=variance,
+ flip=flip,
+ clip=clip,
+ steps=steps,
+ offset=offset,
+ min_max_aspect_ratios_order=min_max_aspect_ratios_order,
+ name=name)
+
+
+def density_prior_box(input,
+ image,
+ densities=None,
+ fixed_sizes=None,
+ fixed_ratios=None,
+ variance=[0.1, 0.1, 0.2, 0.2],
+ clip=False,
+ steps=[0.0, 0.0],
+ offset=0.5,
+ flatten_to_2d=False,
+ name=None):
+ r"""
+
+ This op generates density prior boxes for SSD(Single Shot MultiBox Detector)
+ algorithm. Each position of the input produce N prior boxes, N is
+ determined by the count of densities, fixed_sizes and fixed_ratios.
+ Boxes center at grid points around each input position is generated by
+ this operator, and the grid points is determined by densities and
+ the count of density prior box is determined by fixed_sizes and fixed_ratios.
+ Obviously, the number of fixed_sizes is equal to the number of densities.
+
+ For densities_i in densities:
+
+ .. math::
+
+ N\_density_prior\_box = SUM(N\_fixed\_ratios * densities\_i^2)
+
+ N_density_prior_box is the number of density_prior_box and N_fixed_ratios is the number of fixed_ratios.
+
+ Parameters:
+ input(Variable): 4-D tensor(NCHW), the data type should be float32 of float64.
+ image(Variable): 4-D tensor(NCHW), the input image data of PriorBoxOp, the data type should be float32 or float64.
+ the layout is NCHW.
+ densities(list|tuple|None): The densities of generated density prior
+ boxes, this attribute should be a list or tuple of integers.
+ Default: None.
+ fixed_sizes(list|tuple|None): The fixed sizes of generated density
+ prior boxes, this attribute should a list or tuple of same
+ length with :attr:`densities`. Default: None.
+ fixed_ratios(list|tuple|None): The fixed ratios of generated density
+ prior boxes, if this attribute is not set and :attr:`densities`
+ and :attr:`fix_sizes` is set, :attr:`aspect_ratios` will be used
+ to generate density prior boxes.
+ variance(list|tuple): The variances to be encoded in density prior boxes.
+ Default:[0.1, 0.1, 0.2, 0.2].
+ clip(bool): Whether to clip out of boundary boxes. Default: False.
+ step(list|tuple): Prior boxes step across width and height, If
+ step[0] equals 0.0 or step[1] equals 0.0, the density prior boxes step across
+ height or weight of the input will be automatically calculated.
+ Default: [0., 0.]
+ offset(float): Prior boxes center offset. Default: 0.5
+ flatten_to_2d(bool): Whether to flatten output prior boxes and variance
+ to 2D shape, the second dim is 4. Default: False.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Tuple: A tuple with two Variable (boxes, variances)
+
+ boxes: the output density prior boxes of PriorBox.
+ 4-D tensor, the layout is [H, W, num_priors, 4] when flatten_to_2d is False.
+ 2-D tensor, the layout is [H * W * num_priors, 4] when flatten_to_2d is True.
+ H is the height of input, W is the width of input, and num_priors is the total box count of each position of input.
+
+ variances: the expanded variances of PriorBox.
+ 4-D tensor, the layout is [H, W, num_priors, 4] when flatten_to_2d is False.
+ 2-D tensor, the layout is [H * W * num_priors, 4] when flatten_to_2d is True.
+ H is the height of input, W is the width of input, and num_priors is the total box count of each position of input.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ #declarative mode
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ input = fluid.data(name="input", shape=[None,3,6,9])
+ image = fluid.data(name="image", shape=[None,3,9,12])
+ box, var = fluid.layers.density_prior_box(
+ input=input,
+ image=image,
+ densities=[4, 2, 1],
+ fixed_sizes=[32.0, 64.0, 128.0],
+ fixed_ratios=[1.],
+ clip=True,
+ flatten_to_2d=True)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ # prepare a batch of data
+ input_data = np.random.rand(1,3,6,9).astype("float32")
+ image_data = np.random.rand(1,3,9,12).astype("float32")
+
+ box_out, var_out = exe.run(
+ fluid.default_main_program(),
+ feed={"input":input_data,
+ "image":image_data},
+ fetch_list=[box,var],
+ return_numpy=True)
+
+ # print(box_out.shape)
+ # (1134, 4)
+ # print(var_out.shape)
+ # (1134, 4)
+
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ image = dg.to_variable(image_data)
+ box, var = fluid.layers.density_prior_box(
+ input=input,
+ image=image,
+ densities=[4, 2, 1],
+ fixed_sizes=[32.0, 64.0, 128.0],
+ fixed_ratios=[1.],
+ clip=True)
+
+ # print(box.shape)
+ # [6L, 9L, 21L, 4L]
+ # print(var.shape)
+ # [6L, 9L, 21L, 4L]
+
+ """
+ helper = LayerHelper("density_prior_box", **locals())
+ dtype = helper.input_dtype()
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'density_prior_box')
+
+ def _is_list_or_tuple_(data):
+ return (isinstance(data, list) or isinstance(data, tuple))
+
+ check_type(densities, 'densities', (list, tuple), 'density_prior_box')
+ check_type(fixed_sizes, 'fixed_sizes', (list, tuple), 'density_prior_box')
+ check_type(fixed_ratios, 'fixed_ratios', (list, tuple), 'density_prior_box')
+ if len(densities) != len(fixed_sizes):
+ raise ValueError('densities and fixed_sizes length should be euqal.')
+
+ if not (_is_list_or_tuple_(steps) and len(steps) == 2):
+ raise ValueError('steps should be a list or tuple ',
+ 'with length 2, (step_width, step_height).')
+
+ densities = list(map(int, densities))
+ fixed_sizes = list(map(float, fixed_sizes))
+ fixed_ratios = list(map(float, fixed_ratios))
+ steps = list(map(float, steps))
+
+ attrs = {
+ 'variances': variance,
+ 'clip': clip,
+ 'step_w': steps[0],
+ 'step_h': steps[1],
+ 'offset': offset,
+ 'densities': densities,
+ 'fixed_sizes': fixed_sizes,
+ 'fixed_ratios': fixed_ratios,
+ 'flatten_to_2d': flatten_to_2d,
+ }
+ box = helper.create_variable_for_type_inference(dtype)
+ var = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="density_prior_box",
+ inputs={
+ "Input": input,
+ "Image": image
+ },
+ outputs={
+ "Boxes": box,
+ "Variances": var
+ },
+ attrs=attrs,
+ )
+ box.stop_gradient = True
+ var.stop_gradient = True
+ return box, var
+
+
+@static_only
+def multi_box_head(inputs,
+ image,
+ base_size,
+ num_classes,
+ aspect_ratios,
+ min_ratio=None,
+ max_ratio=None,
+ min_sizes=None,
+ max_sizes=None,
+ steps=None,
+ step_w=None,
+ step_h=None,
+ offset=0.5,
+ variance=[0.1, 0.1, 0.2, 0.2],
+ flip=True,
+ clip=False,
+ kernel_size=1,
+ pad=0,
+ stride=1,
+ name=None,
+ min_max_aspect_ratios_order=False):
+ """
+ :api_attr: Static Graph
+
+ Base on SSD ((Single Shot MultiBox Detector) algorithm, generate prior boxes,
+ regression location and classification confidence on multiple input feature
+ maps, then output the concatenate results. The details of this algorithm,
+ please refer the section 2.2 of SSD paper `SSD: Single Shot MultiBox Detector
+ `_ .
+
+ Args:
+ inputs (list(Variable)|tuple(Variable)): The list of input variables,
+ the format of all Variables are 4-D Tensor, layout is NCHW.
+ Data type should be float32 or float64.
+ image (Variable): The input image, layout is NCHW. Data type should be
+ the same as inputs.
+ base_size(int): the base_size is input image size. When len(inputs) > 2
+ and `min_size` and `max_size` are None, the `min_size` and `max_size`
+ are calculated by `baze_size`, 'min_ratio' and `max_ratio`. The
+ formula is as follows:
+
+ .. code-block:: text
+
+ min_sizes = []
+ max_sizes = []
+ step = int(math.floor(((max_ratio - min_ratio)) / (num_layer - 2)))
+ for ratio in six.moves.range(min_ratio, max_ratio + 1, step):
+ min_sizes.append(base_size * ratio / 100.)
+ max_sizes.append(base_size * (ratio + step) / 100.)
+ min_sizes = [base_size * .10] + min_sizes
+ max_sizes = [base_size * .20] + max_sizes
+
+ num_classes(int): The number of classes.
+ aspect_ratios(list(float) | tuple(float)): the aspect ratios of generated
+ prior boxes. The length of input and aspect_ratios must be equal.
+ min_ratio(int): the min ratio of generated prior boxes.
+ max_ratio(int): the max ratio of generated prior boxes.
+ min_sizes(list|tuple|None): If `len(inputs) <=2`,
+ min_sizes must be set up, and the length of min_sizes
+ should equal to the length of inputs. Default: None.
+ max_sizes(list|tuple|None): If `len(inputs) <=2`,
+ max_sizes must be set up, and the length of min_sizes
+ should equal to the length of inputs. Default: None.
+ steps(list|tuple): If step_w and step_h are the same,
+ step_w and step_h can be replaced by steps.
+ step_w(list|tuple): Prior boxes step
+ across width. If step_w[i] == 0.0, the prior boxes step
+ across width of the inputs[i] will be automatically
+ calculated. Default: None.
+ step_h(list|tuple): Prior boxes step across height, If
+ step_h[i] == 0.0, the prior boxes step across height of
+ the inputs[i] will be automatically calculated. Default: None.
+ offset(float): Prior boxes center offset. Default: 0.5
+ variance(list|tuple): the variances to be encoded in prior boxes.
+ Default:[0.1, 0.1, 0.2, 0.2].
+ flip(bool): Whether to flip aspect ratios. Default:False.
+ clip(bool): Whether to clip out-of-boundary boxes. Default: False.
+ kernel_size(int): The kernel size of conv2d. Default: 1.
+ pad(int|list|tuple): The padding of conv2d. Default:0.
+ stride(int|list|tuple): The stride of conv2d. Default:1,
+ name(str): The default value is None. Normally there is no need
+ for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+ min_max_aspect_ratios_order(bool): If set True, the output prior box is
+ in order of [min, max, aspect_ratios], which is consistent with
+ Caffe. Please note, this order affects the weights order of
+ convolution layer followed by and does not affect the final
+ detection results. Default: False.
+
+ Returns:
+ tuple: A tuple with four Variables. (mbox_loc, mbox_conf, boxes, variances)
+
+ mbox_loc (Variable): The predicted boxes' location of the inputs. The
+ layout is [N, num_priors, 4], where N is batch size, ``num_priors``
+ is the number of prior boxes. Data type is the same as input.
+
+ mbox_conf (Variable): The predicted boxes' confidence of the inputs.
+ The layout is [N, num_priors, C], where ``N`` and ``num_priors``
+ has the same meaning as above. C is the number of Classes.
+ Data type is the same as input.
+
+ boxes (Variable): the output prior boxes. The layout is [num_priors, 4].
+ The meaning of num_priors is the same as above.
+ Data type is the same as input.
+
+ variances (Variable): the expanded variances for prior boxes.
+ The layout is [num_priors, 4]. Data type is the same as input.
+
+ Examples 1: set min_ratio and max_ratio:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ images = paddle.static.data(name='data', shape=[None, 3, 300, 300], dtype='float32')
+ conv1 = paddle.static.data(name='conv1', shape=[None, 512, 19, 19], dtype='float32')
+ conv2 = paddle.static.data(name='conv2', shape=[None, 1024, 10, 10], dtype='float32')
+ conv3 = paddle.static.data(name='conv3', shape=[None, 512, 5, 5], dtype='float32')
+ conv4 = paddle.static.data(name='conv4', shape=[None, 256, 3, 3], dtype='float32')
+ conv5 = paddle.static.data(name='conv5', shape=[None, 256, 2, 2], dtype='float32')
+ conv6 = paddle.static.data(name='conv6', shape=[None, 128, 1, 1], dtype='float32')
+
+ mbox_locs, mbox_confs, box, var = paddle.static.nn.multi_box_head(
+ inputs=[conv1, conv2, conv3, conv4, conv5, conv6],
+ image=images,
+ num_classes=21,
+ min_ratio=20,
+ max_ratio=90,
+ aspect_ratios=[[2.], [2., 3.], [2., 3.], [2., 3.], [2.], [2.]],
+ base_size=300,
+ offset=0.5,
+ flip=True,
+ clip=True)
+
+ Examples 2: set min_sizes and max_sizes:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ images = paddle.static.data(name='data', shape=[None, 3, 300, 300], dtype='float32')
+ conv1 = paddle.static.data(name='conv1', shape=[None, 512, 19, 19], dtype='float32')
+ conv2 = paddle.static.data(name='conv2', shape=[None, 1024, 10, 10], dtype='float32')
+ conv3 = paddle.static.data(name='conv3', shape=[None, 512, 5, 5], dtype='float32')
+ conv4 = paddle.static.data(name='conv4', shape=[None, 256, 3, 3], dtype='float32')
+ conv5 = paddle.static.data(name='conv5', shape=[None, 256, 2, 2], dtype='float32')
+ conv6 = paddle.static.data(name='conv6', shape=[None, 128, 1, 1], dtype='float32')
+
+ mbox_locs, mbox_confs, box, var = paddle.static.nn.multi_box_head(
+ inputs=[conv1, conv2, conv3, conv4, conv5, conv6],
+ image=images,
+ num_classes=21,
+ min_sizes=[60.0, 105.0, 150.0, 195.0, 240.0, 285.0],
+ max_sizes=[[], 150.0, 195.0, 240.0, 285.0, 300.0],
+ aspect_ratios=[[2.], [2., 3.], [2., 3.], [2., 3.], [2.], [2.]],
+ base_size=300,
+ offset=0.5,
+ flip=True,
+ clip=True)
+
+ """
+
+ def _reshape_with_axis_(input, axis=1):
+ out = nn.flatten(x=input, axis=axis)
+ return out
+
+ def _is_list_or_tuple_(data):
+ return (isinstance(data, list) or isinstance(data, tuple))
+
+ def _is_list_or_tuple_and_equal(data, length, err_info):
+ if not (_is_list_or_tuple_(data) and len(data) == length):
+ raise ValueError(err_info)
+
+ if not _is_list_or_tuple_(inputs):
+ raise ValueError('inputs should be a list or tuple.')
+
+ num_layer = len(inputs)
+
+ if num_layer <= 2:
+ assert min_sizes is not None and max_sizes is not None
+ assert len(min_sizes) == num_layer and len(max_sizes) == num_layer
+ elif min_sizes is None and max_sizes is None:
+ min_sizes = []
+ max_sizes = []
+ step = int(math.floor(((max_ratio - min_ratio)) / (num_layer - 2)))
+ for ratio in six.moves.range(min_ratio, max_ratio + 1, step):
+ min_sizes.append(base_size * ratio / 100.)
+ max_sizes.append(base_size * (ratio + step) / 100.)
+ min_sizes = [base_size * .10] + min_sizes
+ max_sizes = [base_size * .20] + max_sizes
+
+ if aspect_ratios:
+ _is_list_or_tuple_and_equal(
+ aspect_ratios, num_layer,
+ 'aspect_ratios should be list or tuple, and the length of inputs '
+ 'and aspect_ratios should be the same.')
+ if step_h is not None:
+ _is_list_or_tuple_and_equal(
+ step_h, num_layer,
+ 'step_h should be list or tuple, and the length of inputs and '
+ 'step_h should be the same.')
+ if step_w is not None:
+ _is_list_or_tuple_and_equal(
+ step_w, num_layer,
+ 'step_w should be list or tuple, and the length of inputs and '
+ 'step_w should be the same.')
+ if steps is not None:
+ _is_list_or_tuple_and_equal(
+ steps, num_layer,
+ 'steps should be list or tuple, and the length of inputs and '
+ 'step_w should be the same.')
+ step_w = steps
+ step_h = steps
+
+ mbox_locs = []
+ mbox_confs = []
+ box_results = []
+ var_results = []
+ for i, input in enumerate(inputs):
+ min_size = min_sizes[i]
+ max_size = max_sizes[i]
+
+ if not _is_list_or_tuple_(min_size):
+ min_size = [min_size]
+ if not _is_list_or_tuple_(max_size):
+ max_size = [max_size]
+
+ aspect_ratio = []
+ if aspect_ratios is not None:
+ aspect_ratio = aspect_ratios[i]
+ if not _is_list_or_tuple_(aspect_ratio):
+ aspect_ratio = [aspect_ratio]
+ step = [step_w[i] if step_w else 0.0, step_h[i] if step_w else 0.0]
+
+ box, var = prior_box(input, image, min_size, max_size, aspect_ratio,
+ variance, flip, clip, step, offset, None,
+ min_max_aspect_ratios_order)
+
+ box_results.append(box)
+ var_results.append(var)
+
+ num_boxes = box.shape[2]
+
+ # get loc
+ num_loc_output = num_boxes * 4
+ mbox_loc = nn.conv2d(input=input,
+ num_filters=num_loc_output,
+ filter_size=kernel_size,
+ padding=pad,
+ stride=stride)
+
+ mbox_loc = nn.transpose(mbox_loc, perm=[0, 2, 3, 1])
+ mbox_loc_flatten = nn.flatten(mbox_loc, axis=1)
+ mbox_locs.append(mbox_loc_flatten)
+
+ # get conf
+ num_conf_output = num_boxes * num_classes
+ conf_loc = nn.conv2d(input=input,
+ num_filters=num_conf_output,
+ filter_size=kernel_size,
+ padding=pad,
+ stride=stride)
+ conf_loc = nn.transpose(conf_loc, perm=[0, 2, 3, 1])
+ conf_loc_flatten = nn.flatten(conf_loc, axis=1)
+ mbox_confs.append(conf_loc_flatten)
+
+ if len(box_results) == 1:
+ box = box_results[0]
+ var = var_results[0]
+ mbox_locs_concat = mbox_locs[0]
+ mbox_confs_concat = mbox_confs[0]
+ else:
+ reshaped_boxes = []
+ reshaped_vars = []
+ for i in range(len(box_results)):
+ reshaped_boxes.append(_reshape_with_axis_(box_results[i], axis=3))
+ reshaped_vars.append(_reshape_with_axis_(var_results[i], axis=3))
+
+ box = tensor.concat(reshaped_boxes)
+ var = tensor.concat(reshaped_vars)
+ mbox_locs_concat = tensor.concat(mbox_locs, axis=1)
+ mbox_locs_concat = nn.reshape(mbox_locs_concat, shape=[0, -1, 4])
+ mbox_confs_concat = tensor.concat(mbox_confs, axis=1)
+ mbox_confs_concat = nn.reshape(mbox_confs_concat,
+ shape=[0, -1, num_classes])
+
+ box.stop_gradient = True
+ var.stop_gradient = True
+ return mbox_locs_concat, mbox_confs_concat, box, var
+
+
+def anchor_generator(input,
+ anchor_sizes=None,
+ aspect_ratios=None,
+ variance=[0.1, 0.1, 0.2, 0.2],
+ stride=None,
+ offset=0.5,
+ name=None):
+ """
+
+ **Anchor generator operator**
+
+ Generate anchors for Faster RCNN algorithm.
+ Each position of the input produce N anchors, N =
+ size(anchor_sizes) * size(aspect_ratios). The order of generated anchors
+ is firstly aspect_ratios loop then anchor_sizes loop.
+
+ Args:
+ input(Variable): 4-D Tensor with shape [N,C,H,W]. The input feature map.
+ anchor_sizes(float32|list|tuple, optional): The anchor sizes of generated
+ anchors, given in absolute pixels e.g. [64., 128., 256., 512.].
+ For instance, the anchor size of 64 means the area of this anchor
+ equals to 64**2. None by default.
+ aspect_ratios(float32|list|tuple, optional): The height / width ratios
+ of generated anchors, e.g. [0.5, 1.0, 2.0]. None by default.
+ variance(list|tuple, optional): The variances to be used in box
+ regression deltas. The data type is float32, [0.1, 0.1, 0.2, 0.2] by
+ default.
+ stride(list|tuple, optional): The anchors stride across width and height.
+ The data type is float32. e.g. [16.0, 16.0]. None by default.
+ offset(float32, optional): Prior boxes center offset. 0.5 by default.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and None
+ by default.
+
+ Returns:
+ Tuple:
+
+ Anchors(Variable): The output anchors with a layout of [H, W, num_anchors, 4].
+ H is the height of input, W is the width of input,
+ num_anchors is the box count of each position.
+ Each anchor is in (xmin, ymin, xmax, ymax) format an unnormalized.
+
+ Variances(Variable): The expanded variances of anchors
+ with a layout of [H, W, num_priors, 4].
+ H is the height of input, W is the width of input
+ num_anchors is the box count of each position.
+ Each variance is in (xcenter, ycenter, w, h) format.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ conv1 = fluid.data(name='conv1', shape=[None, 48, 16, 16], dtype='float32')
+ anchor, var = fluid.layers.anchor_generator(
+ input=conv1,
+ anchor_sizes=[64, 128, 256, 512],
+ aspect_ratios=[0.5, 1.0, 2.0],
+ variance=[0.1, 0.1, 0.2, 0.2],
+ stride=[16.0, 16.0],
+ offset=0.5)
+ """
+ helper = LayerHelper("anchor_generator", **locals())
+ dtype = helper.input_dtype()
+
+ def _is_list_or_tuple_(data):
+ return (isinstance(data, list) or isinstance(data, tuple))
+
+ if not _is_list_or_tuple_(anchor_sizes):
+ anchor_sizes = [anchor_sizes]
+ if not _is_list_or_tuple_(aspect_ratios):
+ aspect_ratios = [aspect_ratios]
+ if not (_is_list_or_tuple_(stride) and len(stride) == 2):
+ raise ValueError('stride should be a list or tuple ',
+ 'with length 2, (stride_width, stride_height).')
+
+ anchor_sizes = list(map(float, anchor_sizes))
+ aspect_ratios = list(map(float, aspect_ratios))
+ stride = list(map(float, stride))
+
+ attrs = {
+ 'anchor_sizes': anchor_sizes,
+ 'aspect_ratios': aspect_ratios,
+ 'variances': variance,
+ 'stride': stride,
+ 'offset': offset
+ }
+
+ anchor = helper.create_variable_for_type_inference(dtype)
+ var = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="anchor_generator",
+ inputs={"Input": input},
+ outputs={
+ "Anchors": anchor,
+ "Variances": var
+ },
+ attrs=attrs,
+ )
+ anchor.stop_gradient = True
+ var.stop_gradient = True
+ return anchor, var
+
+
+def roi_perspective_transform(input,
+ rois,
+ transformed_height,
+ transformed_width,
+ spatial_scale=1.0,
+ name=None):
+ """
+ **The** `rois` **of this op should be a LoDTensor.**
+
+ ROI perspective transform op applies perspective transform to map each roi into an
+ rectangular region. Perspective transform is a type of transformation in linear algebra.
+
+ Parameters:
+ input (Variable): 4-D Tensor, input of ROIPerspectiveTransformOp. The format of
+ input tensor is NCHW. Where N is batch size, C is the
+ number of input channels, H is the height of the feature,
+ and W is the width of the feature. The data type is float32.
+ rois (Variable): 2-D LoDTensor, ROIs (Regions of Interest) to be transformed.
+ It should be a 2-D LoDTensor of shape (num_rois, 8). Given as
+ [[x1, y1, x2, y2, x3, y3, x4, y4], ...], (x1, y1) is the
+ top left coordinates, and (x2, y2) is the top right
+ coordinates, and (x3, y3) is the bottom right coordinates,
+ and (x4, y4) is the bottom left coordinates. The data type is the
+ same as `input`
+ transformed_height (int): The height of transformed output.
+ transformed_width (int): The width of transformed output.
+ spatial_scale (float): Spatial scale factor to scale ROI coords. Default: 1.0
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ A tuple with three Variables. (out, mask, transform_matrix)
+
+ out: The output of ROIPerspectiveTransformOp which is a 4-D tensor with shape
+ (num_rois, channels, transformed_h, transformed_w). The data type is the same as `input`
+
+ mask: The mask of ROIPerspectiveTransformOp which is a 4-D tensor with shape
+ (num_rois, 1, transformed_h, transformed_w). The data type is int32
+
+ transform_matrix: The transform matrix of ROIPerspectiveTransformOp which is
+ a 2-D tensor with shape (num_rois, 9). The data type is the same as `input`
+
+ Return Type:
+ tuple
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ x = fluid.data(name='x', shape=[100, 256, 28, 28], dtype='float32')
+ rois = fluid.data(name='rois', shape=[None, 8], lod_level=1, dtype='float32')
+ out, mask, transform_matrix = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0)
+ """
+ check_variable_and_dtype(input, 'input', ['float32'],
+ 'roi_perspective_transform')
+ check_variable_and_dtype(rois, 'rois', ['float32'],
+ 'roi_perspective_transform')
+ check_type(transformed_height, 'transformed_height', int,
+ 'roi_perspective_transform')
+ check_type(transformed_width, 'transformed_width', int,
+ 'roi_perspective_transform')
+ check_type(spatial_scale, 'spatial_scale', float,
+ 'roi_perspective_transform')
+
+ helper = LayerHelper('roi_perspective_transform', **locals())
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ mask = helper.create_variable_for_type_inference(dtype="int32")
+ transform_matrix = helper.create_variable_for_type_inference(dtype)
+ out2in_idx = helper.create_variable_for_type_inference(dtype="int32")
+ out2in_w = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type="roi_perspective_transform",
+ inputs={
+ "X": input,
+ "ROIs": rois
+ },
+ outputs={
+ "Out": out,
+ "Out2InIdx": out2in_idx,
+ "Out2InWeights": out2in_w,
+ "Mask": mask,
+ "TransformMatrix": transform_matrix
+ },
+ attrs={
+ "transformed_height": transformed_height,
+ "transformed_width": transformed_width,
+ "spatial_scale": spatial_scale
+ })
+ return out, mask, transform_matrix
+
+
+def generate_proposal_labels(rpn_rois,
+ gt_classes,
+ is_crowd,
+ gt_boxes,
+ im_info,
+ batch_size_per_im=256,
+ fg_fraction=0.25,
+ fg_thresh=0.25,
+ bg_thresh_hi=0.5,
+ bg_thresh_lo=0.0,
+ bbox_reg_weights=[0.1, 0.1, 0.2, 0.2],
+ class_nums=None,
+ use_random=True,
+ is_cls_agnostic=False,
+ is_cascade_rcnn=False,
+ max_overlap=None,
+ return_max_overlap=False):
+ """
+
+ **Generate Proposal Labels of Faster-RCNN**
+
+ This operator can be, for given the GenerateProposalOp output bounding boxes and groundtruth,
+ to sample foreground boxes and background boxes, and compute loss target.
+
+ RpnRois is the output boxes of RPN and was processed by generate_proposal_op, these boxes
+ were combined with groundtruth boxes and sampled according to batch_size_per_im and fg_fraction,
+ If an instance with a groundtruth overlap greater than fg_thresh, then it was considered as a foreground sample.
+ If an instance with a groundtruth overlap greater than bg_thresh_lo and lower than bg_thresh_hi,
+ then it was considered as a background sample.
+ After all foreground and background boxes are chosen (so called Rois),
+ then we apply random sampling to make sure
+ the number of foreground boxes is no more than batch_size_per_im * fg_fraction.
+
+ For each box in Rois, we assign the classification (class label) and regression targets (box label) to it.
+ Finally BboxInsideWeights and BboxOutsideWeights are used to specify whether it would contribute to training loss.
+
+ Args:
+ rpn_rois(Variable): A 2-D LoDTensor with shape [N, 4]. N is the number of the GenerateProposalOp's output, each element is a bounding box with [xmin, ymin, xmax, ymax] format. The data type can be float32 or float64.
+ gt_classes(Variable): A 2-D LoDTensor with shape [M, 1]. M is the number of groundtruth, each element is a class label of groundtruth. The data type must be int32.
+ is_crowd(Variable): A 2-D LoDTensor with shape [M, 1]. M is the number of groundtruth, each element is a flag indicates whether a groundtruth is crowd. The data type must be int32.
+ gt_boxes(Variable): A 2-D LoDTensor with shape [M, 4]. M is the number of groundtruth, each element is a bounding box with [xmin, ymin, xmax, ymax] format.
+ im_info(Variable): A 2-D LoDTensor with shape [B, 3]. B is the number of input images, each element consists of im_height, im_width, im_scale.
+
+ batch_size_per_im(int): Batch size of rois per images. The data type must be int32.
+ fg_fraction(float): Foreground fraction in total batch_size_per_im. The data type must be float32.
+ fg_thresh(float): Overlap threshold which is used to chose foreground sample. The data type must be float32.
+ bg_thresh_hi(float): Overlap threshold upper bound which is used to chose background sample. The data type must be float32.
+ bg_thresh_lo(float): Overlap threshold lower bound which is used to chose background sample. The data type must be float32.
+ bbox_reg_weights(list|tuple): Box regression weights. The data type must be float32.
+ class_nums(int): Class number. The data type must be int32.
+ use_random(bool): Use random sampling to choose foreground and background boxes.
+ is_cls_agnostic(bool): bbox regression use class agnostic simply which only represent fg and bg boxes.
+ is_cascade_rcnn(bool): it will filter some bbox crossing the image's boundary when setting True.
+ max_overlap(Variable): Maximum overlap between each proposal box and ground-truth.
+ return_max_overlap(bool): Whether return the maximum overlap between each sampled RoI and ground-truth.
+
+ Returns:
+ tuple:
+ A tuple with format``(rois, labels_int32, bbox_targets, bbox_inside_weights, bbox_outside_weights, max_overlap)``.
+
+ - **rois**: 2-D LoDTensor with shape ``[batch_size_per_im * batch_size, 4]``. The data type is the same as ``rpn_rois``.
+ - **labels_int32**: 2-D LoDTensor with shape ``[batch_size_per_im * batch_size, 1]``. The data type must be int32.
+ - **bbox_targets**: 2-D LoDTensor with shape ``[batch_size_per_im * batch_size, 4 * class_num]``. The regression targets of all RoIs. The data type is the same as ``rpn_rois``.
+ - **bbox_inside_weights**: 2-D LoDTensor with shape ``[batch_size_per_im * batch_size, 4 * class_num]``. The weights of foreground boxes' regression loss. The data type is the same as ``rpn_rois``.
+ - **bbox_outside_weights**: 2-D LoDTensor with shape ``[batch_size_per_im * batch_size, 4 * class_num]``. The weights of regression loss. The data type is the same as ``rpn_rois``.
+ - **max_overlap**: 1-D LoDTensor with shape ``[P]``. P is the number of output ``rois``. The maximum overlap between each sampled RoI and ground-truth.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ rpn_rois = fluid.data(name='rpn_rois', shape=[None, 4], dtype='float32')
+ gt_classes = fluid.data(name='gt_classes', shape=[None, 1], dtype='int32')
+ is_crowd = fluid.data(name='is_crowd', shape=[None, 1], dtype='int32')
+ gt_boxes = fluid.data(name='gt_boxes', shape=[None, 4], dtype='float32')
+ im_info = fluid.data(name='im_info', shape=[None, 3], dtype='float32')
+ rois, labels, bbox, inside_weights, outside_weights = fluid.layers.generate_proposal_labels(
+ rpn_rois, gt_classes, is_crowd, gt_boxes, im_info,
+ class_nums=10)
+
+ """
+
+ helper = LayerHelper('generate_proposal_labels', **locals())
+
+ check_variable_and_dtype(rpn_rois, 'rpn_rois', ['float32', 'float64'],
+ 'generate_proposal_labels')
+ check_variable_and_dtype(gt_classes, 'gt_classes', ['int32'],
+ 'generate_proposal_labels')
+ check_variable_and_dtype(is_crowd, 'is_crowd', ['int32'],
+ 'generate_proposal_labels')
+ if is_cascade_rcnn:
+ assert max_overlap is not None, "Input max_overlap of generate_proposal_labels should not be None if is_cascade_rcnn is True"
+
+ rois = helper.create_variable_for_type_inference(dtype=rpn_rois.dtype)
+ labels_int32 = helper.create_variable_for_type_inference(
+ dtype=gt_classes.dtype)
+ bbox_targets = helper.create_variable_for_type_inference(
+ dtype=rpn_rois.dtype)
+ bbox_inside_weights = helper.create_variable_for_type_inference(
+ dtype=rpn_rois.dtype)
+ bbox_outside_weights = helper.create_variable_for_type_inference(
+ dtype=rpn_rois.dtype)
+ max_overlap_with_gt = helper.create_variable_for_type_inference(
+ dtype=rpn_rois.dtype)
+
+ inputs = {
+ 'RpnRois': rpn_rois,
+ 'GtClasses': gt_classes,
+ 'IsCrowd': is_crowd,
+ 'GtBoxes': gt_boxes,
+ 'ImInfo': im_info,
+ }
+ if max_overlap is not None:
+ inputs['MaxOverlap'] = max_overlap
+ helper.append_op(type="generate_proposal_labels",
+ inputs=inputs,
+ outputs={
+ 'Rois': rois,
+ 'LabelsInt32': labels_int32,
+ 'BboxTargets': bbox_targets,
+ 'BboxInsideWeights': bbox_inside_weights,
+ 'BboxOutsideWeights': bbox_outside_weights,
+ 'MaxOverlapWithGT': max_overlap_with_gt
+ },
+ attrs={
+ 'batch_size_per_im': batch_size_per_im,
+ 'fg_fraction': fg_fraction,
+ 'fg_thresh': fg_thresh,
+ 'bg_thresh_hi': bg_thresh_hi,
+ 'bg_thresh_lo': bg_thresh_lo,
+ 'bbox_reg_weights': bbox_reg_weights,
+ 'class_nums': class_nums,
+ 'use_random': use_random,
+ 'is_cls_agnostic': is_cls_agnostic,
+ 'is_cascade_rcnn': is_cascade_rcnn
+ })
+
+ rois.stop_gradient = True
+ labels_int32.stop_gradient = True
+ bbox_targets.stop_gradient = True
+ bbox_inside_weights.stop_gradient = True
+ bbox_outside_weights.stop_gradient = True
+ max_overlap_with_gt.stop_gradient = True
+
+ if return_max_overlap:
+ return rois, labels_int32, bbox_targets, bbox_inside_weights, bbox_outside_weights, max_overlap_with_gt
+ return rois, labels_int32, bbox_targets, bbox_inside_weights, bbox_outside_weights
+
+
+def generate_mask_labels(im_info, gt_classes, is_crowd, gt_segms, rois,
+ labels_int32, num_classes, resolution):
+ r"""
+
+ **Generate Mask Labels for Mask-RCNN**
+
+ This operator can be, for given the RoIs and corresponding labels,
+ to sample foreground RoIs. This mask branch also has
+ a :math: `K \\times M^{2}` dimensional output targets for each foreground
+ RoI, which encodes K binary masks of resolution M x M, one for each of the
+ K classes. This mask targets are used to compute loss of mask branch.
+
+ Please note, the data format of groud-truth segmentation, assumed the
+ segmentations are as follows. The first instance has two gt objects.
+ The second instance has one gt object, this object has two gt segmentations.
+
+ .. code-block:: python
+
+ #[
+ # [[[229.14, 370.9, 229.14, 370.9, ...]],
+ # [[343.7, 139.85, 349.01, 138.46, ...]]], # 0-th instance
+ # [[[500.0, 390.62, ...],[115.48, 187.86, ...]]] # 1-th instance
+ #]
+
+ batch_masks = []
+ for semgs in batch_semgs:
+ gt_masks = []
+ for semg in semgs:
+ gt_segm = []
+ for polys in semg:
+ gt_segm.append(np.array(polys).reshape(-1, 2))
+ gt_masks.append(gt_segm)
+ batch_masks.append(gt_masks)
+
+
+ place = fluid.CPUPlace()
+ feeder = fluid.DataFeeder(place=place, feed_list=feeds)
+ feeder.feed(batch_masks)
+
+ Args:
+ im_info (Variable): A 2-D Tensor with shape [N, 3] and float32
+ data type. N is the batch size, each element is
+ [height, width, scale] of image. Image scale is
+ target_size / original_size, target_size is the size after resize,
+ original_size is the original image size.
+ gt_classes (Variable): A 2-D LoDTensor with shape [M, 1]. Data type
+ should be int. M is the total number of ground-truth, each
+ element is a class label.
+ is_crowd (Variable): A 2-D LoDTensor with same shape and same data type
+ as gt_classes, each element is a flag indicating whether a
+ groundtruth is crowd.
+ gt_segms (Variable): This input is a 2D LoDTensor with shape [S, 2] and
+ float32 data type, it's LoD level is 3.
+ Usually users do not needs to understand LoD,
+ The users should return correct data format in reader.
+ The LoD[0] represents the ground-truth objects number of
+ each instance. LoD[1] represents the segmentation counts of each
+ objects. LoD[2] represents the polygons number of each segmentation.
+ S the total number of polygons coordinate points. Each element is
+ (x, y) coordinate points.
+ rois (Variable): A 2-D LoDTensor with shape [R, 4] and float32 data type
+ float32. R is the total number of RoIs, each element is a bounding
+ box with (xmin, ymin, xmax, ymax) format in the range of original image.
+ labels_int32 (Variable): A 2-D LoDTensor in shape of [R, 1] with type
+ of int32. R is the same as it in `rois`. Each element represents
+ a class label of a RoI.
+ num_classes (int): Class number.
+ resolution (int): Resolution of mask predictions.
+
+ Returns:
+ mask_rois (Variable): A 2D LoDTensor with shape [P, 4] and same data
+ type as `rois`. P is the total number of sampled RoIs. Each element
+ is a bounding box with [xmin, ymin, xmax, ymax] format in range of
+ original image size.
+
+ mask_rois_has_mask_int32 (Variable): A 2D LoDTensor with shape [P, 1]
+ and int data type, each element represents the output mask RoI
+ index with regard to input RoIs.
+
+ mask_int32 (Variable): A 2D LoDTensor with shape [P, K * M * M] and int
+ data type, K is the classes number and M is the resolution of mask
+ predictions. Each element represents the binary mask targets.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ im_info = fluid.data(name="im_info", shape=[None, 3],
+ dtype="float32")
+ gt_classes = fluid.data(name="gt_classes", shape=[None, 1],
+ dtype="float32", lod_level=1)
+ is_crowd = fluid.data(name="is_crowd", shape=[None, 1],
+ dtype="float32", lod_level=1)
+ gt_masks = fluid.data(name="gt_masks", shape=[None, 2],
+ dtype="float32", lod_level=3)
+ # rois, roi_labels can be the output of
+ # fluid.layers.generate_proposal_labels.
+ rois = fluid.data(name="rois", shape=[None, 4],
+ dtype="float32", lod_level=1)
+ roi_labels = fluid.data(name="roi_labels", shape=[None, 1],
+ dtype="int32", lod_level=1)
+ mask_rois, mask_index, mask_int32 = fluid.layers.generate_mask_labels(
+ im_info=im_info,
+ gt_classes=gt_classes,
+ is_crowd=is_crowd,
+ gt_segms=gt_masks,
+ rois=rois,
+ labels_int32=roi_labels,
+ num_classes=81,
+ resolution=14)
+ """
+
+ helper = LayerHelper('generate_mask_labels', **locals())
+
+ mask_rois = helper.create_variable_for_type_inference(dtype=rois.dtype)
+ roi_has_mask_int32 = helper.create_variable_for_type_inference(
+ dtype=gt_classes.dtype)
+ mask_int32 = helper.create_variable_for_type_inference(
+ dtype=gt_classes.dtype)
+
+ helper.append_op(type="generate_mask_labels",
+ inputs={
+ 'ImInfo': im_info,
+ 'GtClasses': gt_classes,
+ 'IsCrowd': is_crowd,
+ 'GtSegms': gt_segms,
+ 'Rois': rois,
+ 'LabelsInt32': labels_int32
+ },
+ outputs={
+ 'MaskRois': mask_rois,
+ 'RoiHasMaskInt32': roi_has_mask_int32,
+ 'MaskInt32': mask_int32
+ },
+ attrs={
+ 'num_classes': num_classes,
+ 'resolution': resolution
+ })
+
+ mask_rois.stop_gradient = True
+ roi_has_mask_int32.stop_gradient = True
+ mask_int32.stop_gradient = True
+
+ return mask_rois, roi_has_mask_int32, mask_int32
+
+
+def generate_proposals(scores,
+ bbox_deltas,
+ im_info,
+ anchors,
+ variances,
+ pre_nms_top_n=6000,
+ post_nms_top_n=1000,
+ nms_thresh=0.5,
+ min_size=0.1,
+ eta=1.0,
+ return_rois_num=False,
+ name=None):
+ """
+
+ **Generate proposal Faster-RCNN**
+
+ This operation proposes RoIs according to each box with their
+ probability to be a foreground object and
+ the box can be calculated by anchors. Bbox_deltais and scores
+ to be an object are the output of RPN. Final proposals
+ could be used to train detection net.
+
+ For generating proposals, this operation performs following steps:
+
+ 1. Transposes and resizes scores and bbox_deltas in size of
+ (H*W*A, 1) and (H*W*A, 4)
+ 2. Calculate box locations as proposals candidates.
+ 3. Clip boxes to image
+ 4. Remove predicted boxes with small area.
+ 5. Apply NMS to get final proposals as output.
+
+ Args:
+ scores(Variable): A 4-D Tensor with shape [N, A, H, W] represents
+ the probability for each box to be an object.
+ N is batch size, A is number of anchors, H and W are height and
+ width of the feature map. The data type must be float32.
+ bbox_deltas(Variable): A 4-D Tensor with shape [N, 4*A, H, W]
+ represents the difference between predicted box location and
+ anchor location. The data type must be float32.
+ im_info(Variable): A 2-D Tensor with shape [N, 3] represents origin
+ image information for N batch. Height and width are the input sizes
+ and scale is the ratio of network input size and original size.
+ The data type can be float32 or float64.
+ anchors(Variable): A 4-D Tensor represents the anchors with a layout
+ of [H, W, A, 4]. H and W are height and width of the feature map,
+ num_anchors is the box count of each position. Each anchor is
+ in (xmin, ymin, xmax, ymax) format an unnormalized. The data type must be float32.
+ variances(Variable): A 4-D Tensor. The expanded variances of anchors with a layout of
+ [H, W, num_priors, 4]. Each variance is in
+ (xcenter, ycenter, w, h) format. The data type must be float32.
+ pre_nms_top_n(float): Number of total bboxes to be kept per
+ image before NMS. The data type must be float32. `6000` by default.
+ post_nms_top_n(float): Number of total bboxes to be kept per
+ image after NMS. The data type must be float32. `1000` by default.
+ nms_thresh(float): Threshold in NMS. The data type must be float32. `0.5` by default.
+ min_size(float): Remove predicted boxes with either height or
+ width < min_size. The data type must be float32. `0.1` by default.
+ eta(float): Apply in adaptive NMS, if adaptive `threshold > 0.5`,
+ `adaptive_threshold = adaptive_threshold * eta` in each iteration.
+ return_rois_num(bool): When setting True, it will return a 1D Tensor with shape [N, ] that includes Rois's
+ num of each image in one batch. The N is the image's num. For example, the tensor has values [4,5] that represents
+ the first image has 4 Rois, the second image has 5 Rois. It only used in rcnn model.
+ 'False' by default.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ tuple:
+ A tuple with format ``(rpn_rois, rpn_roi_probs)``.
+
+ - **rpn_rois**: The generated RoIs. 2-D Tensor with shape ``[N, 4]`` while ``N`` is the number of RoIs. The data type is the same as ``scores``.
+ - **rpn_roi_probs**: The scores of generated RoIs. 2-D Tensor with shape ``[N, 1]`` while ``N`` is the number of RoIs. The data type is the same as ``scores``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ scores = fluid.data(name='scores', shape=[None, 4, 5, 5], dtype='float32')
+ bbox_deltas = fluid.data(name='bbox_deltas', shape=[None, 16, 5, 5], dtype='float32')
+ im_info = fluid.data(name='im_info', shape=[None, 3], dtype='float32')
+ anchors = fluid.data(name='anchors', shape=[None, 5, 4, 4], dtype='float32')
+ variances = fluid.data(name='variances', shape=[None, 5, 10, 4], dtype='float32')
+ rois, roi_probs = fluid.layers.generate_proposals(scores, bbox_deltas,
+ im_info, anchors, variances)
+
+ """
+ return paddle.vision.ops.generate_proposals(scores=scores,
+ bbox_deltas=bbox_deltas,
+ img_size=im_info[:2],
+ anchors=anchors,
+ variances=variances,
+ pre_nms_top_n=pre_nms_top_n,
+ post_nms_top_n=post_nms_top_n,
+ nms_thresh=nms_thresh,
+ min_size=min_size,
+ eta=eta,
+ return_rois_num=return_rois_num,
+ name=name)
+
+
+def box_clip(input, im_info, name=None):
+ """
+
+ Clip the box into the size given by im_info
+ For each input box, The formula is given as follows:
+
+ .. code-block:: text
+
+ xmin = max(min(xmin, im_w - 1), 0)
+ ymin = max(min(ymin, im_h - 1), 0)
+ xmax = max(min(xmax, im_w - 1), 0)
+ ymax = max(min(ymax, im_h - 1), 0)
+
+ where im_w and im_h are computed from im_info:
+
+ .. code-block:: text
+
+ im_h = round(height / scale)
+ im_w = round(weight / scale)
+
+ Args:
+ input(Variable): The input Tensor with shape :math:`[N_1, N_2, ..., N_k, 4]`,
+ the last dimension is 4 and data type is float32 or float64.
+ im_info(Variable): The 2-D Tensor with shape [N, 3] with layout
+ (height, width, scale) representing the information of image.
+ Height and width are the input sizes and scale is the ratio of network input
+ size and original size. The data type is float32 or float64.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable:
+
+ output(Variable): The clipped tensor with data type float32 or float64.
+ The shape is same as input.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ boxes = fluid.data(
+ name='boxes', shape=[None, 8, 4], dtype='float32', lod_level=1)
+ im_info = fluid.data(name='im_info', shape=[-1 ,3])
+ out = fluid.layers.box_clip(
+ input=boxes, im_info=im_info)
+ """
+
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'box_clip')
+ check_variable_and_dtype(im_info, 'im_info', ['float32', 'float64'],
+ 'box_clip')
+
+ helper = LayerHelper("box_clip", **locals())
+ output = helper.create_variable_for_type_inference(dtype=input.dtype)
+ inputs = {"Input": input, "ImInfo": im_info}
+ helper.append_op(type="box_clip", inputs=inputs, outputs={"Output": output})
+
+ return output
+
+
+def retinanet_detection_output(bboxes,
+ scores,
+ anchors,
+ im_info,
+ score_threshold=0.05,
+ nms_top_k=1000,
+ keep_top_k=100,
+ nms_threshold=0.3,
+ nms_eta=1.0):
+ """
+ **Detection Output Layer for the detector RetinaNet.**
+
+ In the detector `RetinaNet `_ , many
+ `FPN `_ levels output the category
+ and location predictions, this OP is to get the detection results by
+ performing following steps:
+
+ 1. For each FPN level, decode box predictions according to the anchor
+ boxes from at most :attr:`nms_top_k` top-scoring predictions after
+ thresholding detector confidence at :attr:`score_threshold`.
+ 2. Merge top predictions from all levels and apply multi-class non
+ maximum suppression (NMS) on them to get the final detections.
+
+ Args:
+ bboxes(List): A list of Tensors from multiple FPN levels represents
+ the location prediction for all anchor boxes. Each element is
+ a 3-D Tensor with shape :math:`[N, Mi, 4]`, :math:`N` is the
+ batch size, :math:`Mi` is the number of bounding boxes from
+ :math:`i`-th FPN level and each bounding box has four coordinate
+ values and the layout is [xmin, ymin, xmax, ymax]. The data type
+ of each element is float32 or float64.
+ scores(List): A list of Tensors from multiple FPN levels represents
+ the category prediction for all anchor boxes. Each element is a
+ 3-D Tensor with shape :math:`[N, Mi, C]`, :math:`N` is the batch
+ size, :math:`C` is the class number (**excluding background**),
+ :math:`Mi` is the number of bounding boxes from :math:`i`-th FPN
+ level. The data type of each element is float32 or float64.
+ anchors(List): A list of Tensors from multiple FPN levels represents
+ the locations of all anchor boxes. Each element is a 2-D Tensor
+ with shape :math:`[Mi, 4]`, :math:`Mi` is the number of bounding
+ boxes from :math:`i`-th FPN level, and each bounding box has four
+ coordinate values and the layout is [xmin, ymin, xmax, ymax].
+ The data type of each element is float32 or float64.
+ im_info(Variable): A 2-D Tensor with shape :math:`[N, 3]` represents the size
+ information of input images. :math:`N` is the batch size, the size
+ information of each image is a 3-vector which are the height and width
+ of the network input along with the factor scaling the origin image to
+ the network input. The data type of :attr:`im_info` is float32.
+ score_threshold(float): Threshold to filter out bounding boxes
+ with a confidence score before NMS, default value is set to 0.05.
+ nms_top_k(int): Maximum number of detections per FPN layer to be
+ kept according to the confidences before NMS, default value is set to
+ 1000.
+ keep_top_k(int): Number of total bounding boxes to be kept per image after
+ NMS step. Default value is set to 100, -1 means keeping all bounding
+ boxes after NMS step.
+ nms_threshold(float): The Intersection-over-Union(IoU) threshold used to
+ filter out boxes in NMS.
+ nms_eta(float): The parameter for adjusting :attr:`nms_threshold` in NMS.
+ Default value is set to 1., which represents the value of
+ :attr:`nms_threshold` keep the same in NMS. If :attr:`nms_eta` is set
+ to be lower than 1. and the value of :attr:`nms_threshold` is set to
+ be higher than 0.5, everytime a bounding box is filtered out,
+ the adjustment for :attr:`nms_threshold` like :attr:`nms_threshold`
+ = :attr:`nms_threshold` * :attr:`nms_eta` will not be stopped until
+ the actual value of :attr:`nms_threshold` is lower than or equal to
+ 0.5.
+
+ **Notice**: In some cases where the image sizes are very small, it's possible
+ that there is no detection if :attr:`score_threshold` are used at all
+ levels. Hence, this OP do not filter out anchors from the highest FPN level
+ before NMS. And the last element in :attr:`bboxes`:, :attr:`scores` and
+ :attr:`anchors` is required to be from the highest FPN level.
+
+ Returns:
+ Variable(The data type is float32 or float64):
+ The detection output is a 1-level LoDTensor with shape :math:`[No, 6]`.
+ Each row has six values: [label, confidence, xmin, ymin, xmax, ymax].
+ :math:`No` is the total number of detections in this mini-batch.
+ The :math:`i`-th image has `LoD[i + 1] - LoD[i]` detected
+ results, if `LoD[i + 1] - LoD[i]` is 0, the :math:`i`-th image
+ has no detected results. If all images have no detected results,
+ LoD will be set to 0, and the output tensor is empty (None).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ bboxes_low = fluid.data(
+ name='bboxes_low', shape=[1, 44, 4], dtype='float32')
+ bboxes_high = fluid.data(
+ name='bboxes_high', shape=[1, 11, 4], dtype='float32')
+ scores_low = fluid.data(
+ name='scores_low', shape=[1, 44, 10], dtype='float32')
+ scores_high = fluid.data(
+ name='scores_high', shape=[1, 11, 10], dtype='float32')
+ anchors_low = fluid.data(
+ name='anchors_low', shape=[44, 4], dtype='float32')
+ anchors_high = fluid.data(
+ name='anchors_high', shape=[11, 4], dtype='float32')
+ im_info = fluid.data(
+ name="im_info", shape=[1, 3], dtype='float32')
+ nmsed_outs = fluid.layers.retinanet_detection_output(
+ bboxes=[bboxes_low, bboxes_high],
+ scores=[scores_low, scores_high],
+ anchors=[anchors_low, anchors_high],
+ im_info=im_info,
+ score_threshold=0.05,
+ nms_top_k=1000,
+ keep_top_k=100,
+ nms_threshold=0.45,
+ nms_eta=1.0)
+ """
+
+ check_type(bboxes, 'bboxes', (list), 'retinanet_detection_output')
+ for i, bbox in enumerate(bboxes):
+ check_variable_and_dtype(bbox, 'bbox{}'.format(i),
+ ['float32', 'float64'],
+ 'retinanet_detection_output')
+ check_type(scores, 'scores', (list), 'retinanet_detection_output')
+ for i, score in enumerate(scores):
+ check_variable_and_dtype(score, 'score{}'.format(i),
+ ['float32', 'float64'],
+ 'retinanet_detection_output')
+ check_type(anchors, 'anchors', (list), 'retinanet_detection_output')
+ for i, anchor in enumerate(anchors):
+ check_variable_and_dtype(anchor, 'anchor{}'.format(i),
+ ['float32', 'float64'],
+ 'retinanet_detection_output')
+ check_variable_and_dtype(im_info, 'im_info', ['float32', 'float64'],
+ 'retinanet_detection_output')
+
+ helper = LayerHelper('retinanet_detection_output', **locals())
+ output = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype('scores'))
+ helper.append_op(type="retinanet_detection_output",
+ inputs={
+ 'BBoxes': bboxes,
+ 'Scores': scores,
+ 'Anchors': anchors,
+ 'ImInfo': im_info
+ },
+ attrs={
+ 'score_threshold': score_threshold,
+ 'nms_top_k': nms_top_k,
+ 'nms_threshold': nms_threshold,
+ 'keep_top_k': keep_top_k,
+ 'nms_eta': 1.,
+ },
+ outputs={'Out': output})
+ output.stop_gradient = True
+ return output
+
+
+def multiclass_nms(bboxes,
+ scores,
+ score_threshold,
+ nms_top_k,
+ keep_top_k,
+ nms_threshold=0.3,
+ normalized=True,
+ nms_eta=1.,
+ background_label=0,
+ name=None):
+ """
+
+ **Multiclass NMS**
+
+ This operator is to do multi-class non maximum suppression (NMS) on
+ boxes and scores.
+
+ In the NMS step, this operator greedily selects a subset of detection bounding
+ boxes that have high scores larger than score_threshold, if providing this
+ threshold, then selects the largest nms_top_k confidences scores if nms_top_k
+ is larger than -1. Then this operator pruns away boxes that have high IOU
+ (intersection over union) overlap with already selected boxes by adaptive
+ threshold NMS based on parameters of nms_threshold and nms_eta.
+ Aftern NMS step, at most keep_top_k number of total bboxes are to be kept
+ per image if keep_top_k is larger than -1.
+
+ See below for an example:
+
+ .. code-block:: text
+
+ if:
+ box1.data = (2.0, 3.0, 7.0, 5.0) format is (xmin, ymin, xmax, ymax)
+ box1.scores = (0.7, 0.2, 0.4) which is (label0.score=0.7, label1.score=0.2, label2.cores=0.4)
+
+ box2.data = (3.0, 4.0, 8.0, 5.0)
+ box2.score = (0.3, 0.3, 0.1)
+
+ nms_threshold = 0.3
+ background_label = 0
+ score_threshold = 0
+
+
+ Then:
+ iou = 4/11 > 0.3
+ out.data = [[1, 0.3, 3.0, 4.0, 8.0, 5.0],
+ [2, 0.4, 2.0, 3.0, 7.0, 5.0]]
+
+ Out format is (label, confidence, xmin, ymin, xmax, ymax)
+ Args:
+ bboxes (Variable): Two types of bboxes are supported:
+ 1. (Tensor) A 3-D Tensor with shape
+ [N, M, 4 or 8 16 24 32] represents the
+ predicted locations of M bounding bboxes,
+ N is the batch size. Each bounding box has four
+ coordinate values and the layout is
+ [xmin, ymin, xmax, ymax], when box size equals to 4.
+ The data type is float32 or float64.
+ 2. (LoDTensor) A 3-D Tensor with shape [M, C, 4]
+ M is the number of bounding boxes, C is the
+ class number. The data type is float32 or float64.
+ scores (Variable): Two types of scores are supported:
+ 1. (Tensor) A 3-D Tensor with shape [N, C, M]
+ represents the predicted confidence predictions.
+ N is the batch size, C is the class number, M is
+ number of bounding boxes. For each category there
+ are total M scores which corresponding M bounding
+ boxes. Please note, M is equal to the 2nd dimension
+ of BBoxes.The data type is float32 or float64.
+ 2. (LoDTensor) A 2-D LoDTensor with shape [M, C].
+ M is the number of bbox, C is the class number.
+ In this case, input BBoxes should be the second
+ case with shape [M, C, 4].The data type is float32 or float64.
+ background_label (int): The index of background label, the background
+ label will be ignored. If set to -1, then all
+ categories will be considered. Default: 0
+ score_threshold (float): Threshold to filter out bounding boxes with
+ low confidence score. If not provided,
+ consider all boxes.
+ nms_top_k (int): Maximum number of detections to be kept according to
+ the confidences after the filtering detections based
+ on score_threshold.
+ nms_threshold (float): The threshold to be used in NMS. Default: 0.3
+ nms_eta (float): The threshold to be used in NMS. Default: 1.0
+ keep_top_k (int): Number of total bboxes to be kept per image after NMS
+ step. -1 means keeping all bboxes after NMS step.
+ normalized (bool): Whether detections are normalized. Default: True
+ name(str): Name of the multiclass nms op. Default: None.
+
+ Returns:
+ Variable: A 2-D LoDTensor with shape [No, 6] represents the detections.
+ Each row has 6 values: [label, confidence, xmin, ymin, xmax, ymax]
+ or A 2-D LoDTensor with shape [No, 10] represents the detections.
+ Each row has 10 values:
+ [label, confidence, x1, y1, x2, y2, x3, y3, x4, y4]. No is the
+ total number of detections. If there is no detected boxes for all
+ images, lod will be set to {1} and Out only contains one value
+ which is -1.
+ (After version 1.3, when no boxes detected, the lod is changed
+ from {0} to {1})
+
+
+ Examples:
+ .. code-block:: python
+
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ boxes = fluid.data(name='bboxes', shape=[None,81, 4],
+ dtype='float32', lod_level=1)
+ scores = fluid.data(name='scores', shape=[None,81],
+ dtype='float32', lod_level=1)
+ out = fluid.layers.multiclass_nms(bboxes=boxes,
+ scores=scores,
+ background_label=0,
+ score_threshold=0.5,
+ nms_top_k=400,
+ nms_threshold=0.3,
+ keep_top_k=200,
+ normalized=False)
+ """
+ check_variable_and_dtype(bboxes, 'BBoxes', ['float32', 'float64'],
+ 'multiclass_nms')
+ check_variable_and_dtype(scores, 'Scores', ['float32', 'float64'],
+ 'multiclass_nms')
+ check_type(score_threshold, 'score_threshold', float, 'multicalss_nms')
+ check_type(nms_top_k, 'nums_top_k', int, 'multiclass_nms')
+ check_type(keep_top_k, 'keep_top_k', int, 'mutliclass_nms')
+ check_type(nms_threshold, 'nms_threshold', float, 'multiclass_nms')
+ check_type(normalized, 'normalized', bool, 'multiclass_nms')
+ check_type(nms_eta, 'nms_eta', float, 'multiclass_nms')
+ check_type(background_label, 'background_label', int, 'multiclass_nms')
+
+ helper = LayerHelper('multiclass_nms', **locals())
+ output = helper.create_variable_for_type_inference(dtype=bboxes.dtype)
+ helper.append_op(type="multiclass_nms",
+ inputs={
+ 'BBoxes': bboxes,
+ 'Scores': scores
+ },
+ attrs={
+ 'background_label': background_label,
+ 'score_threshold': score_threshold,
+ 'nms_top_k': nms_top_k,
+ 'nms_threshold': nms_threshold,
+ 'nms_eta': nms_eta,
+ 'keep_top_k': keep_top_k,
+ 'normalized': normalized
+ },
+ outputs={'Out': output})
+ output.stop_gradient = True
+
+ return output
+
+
+def locality_aware_nms(bboxes,
+ scores,
+ score_threshold,
+ nms_top_k,
+ keep_top_k,
+ nms_threshold=0.3,
+ normalized=True,
+ nms_eta=1.,
+ background_label=-1,
+ name=None):
+ """
+ **Local Aware NMS**
+
+ `Local Aware NMS `_ is to do locality-aware non maximum
+ suppression (LANMS) on boxes and scores.
+
+ Firstly, this operator merge box and score according their IOU
+ (intersection over union). In the NMS step, this operator greedily selects a
+ subset of detection bounding boxes that have high scores larger than score_threshold,
+ if providing this threshold, then selects the largest nms_top_k confidences scores
+ if nms_top_k is larger than -1. Then this operator pruns away boxes that have high
+ IOU overlap with already selected boxes by adaptive threshold NMS based on parameters
+ of nms_threshold and nms_eta.
+
+ Aftern NMS step, at most keep_top_k number of total bboxes are to be kept
+ per image if keep_top_k is larger than -1.
+
+ Args:
+ bboxes (Variable): A 3-D Tensor with shape [N, M, 4 or 8 16 24 32]
+ represents the predicted locations of M bounding
+ bboxes, N is the batch size. Each bounding box
+ has four coordinate values and the layout is
+ [xmin, ymin, xmax, ymax], when box size equals to 4.
+ The data type is float32 or float64.
+ scores (Variable): A 3-D Tensor with shape [N, C, M] represents the
+ predicted confidence predictions. N is the batch
+ size, C is the class number, M is number of bounding
+ boxes. Now only support 1 class. For each category
+ there are total M scores which corresponding M bounding
+ boxes. Please note, M is equal to the 2nd dimension of
+ BBoxes. The data type is float32 or float64.
+ background_label (int): The index of background label, the background
+ label will be ignored. If set to -1, then all
+ categories will be considered. Default: -1
+ score_threshold (float): Threshold to filter out bounding boxes with
+ low confidence score. If not provided,
+ consider all boxes.
+ nms_top_k (int): Maximum number of detections to be kept according to
+ the confidences after the filtering detections based
+ on score_threshold.
+ keep_top_k (int): Number of total bboxes to be kept per image after NMS
+ step. -1 means keeping all bboxes after NMS step.
+ nms_threshold (float): The threshold to be used in NMS. Default: 0.3
+ nms_eta (float): The threshold to be used in NMS. Default: 1.0
+ normalized (bool): Whether detections are normalized. Default: True
+ name(str): Name of the locality aware nms op, please refer to :ref:`api_guide_Name` .
+ Default: None.
+
+ Returns:
+ Variable: A 2-D LoDTensor with shape [No, 6] represents the detections.
+ Each row has 6 values: [label, confidence, xmin, ymin, xmax, ymax]
+ or A 2-D LoDTensor with shape [No, 10] represents the detections.
+ Each row has 10 values:
+ [label, confidence, x1, y1, x2, y2, x3, y3, x4, y4]. No is the
+ total number of detections. If there is no detected boxes for all
+ images, lod will be set to {1} and Out only contains one value
+ which is -1.
+ (After version 1.3, when no boxes detected, the lod is changed
+ from {0} to {1}). The data type is float32 or float64.
+
+
+ Examples:
+ .. code-block:: python
+
+
+ import paddle.fluid as fluid
+ boxes = fluid.data(name='bboxes', shape=[None, 81, 8],
+ dtype='float32')
+ scores = fluid.data(name='scores', shape=[None, 1, 81],
+ dtype='float32')
+ out = fluid.layers.locality_aware_nms(bboxes=boxes,
+ scores=scores,
+ score_threshold=0.5,
+ nms_top_k=400,
+ nms_threshold=0.3,
+ keep_top_k=200,
+ normalized=False)
+ """
+ check_variable_and_dtype(bboxes, 'bboxes', ['float32', 'float64'],
+ 'locality_aware_nms')
+ check_variable_and_dtype(scores, 'scores', ['float32', 'float64'],
+ 'locality_aware_nms')
+ check_type(background_label, 'background_label', int, 'locality_aware_nms')
+ check_type(score_threshold, 'score_threshold', float, 'locality_aware_nms')
+ check_type(nms_top_k, 'nms_top_k', int, 'locality_aware_nms')
+ check_type(nms_eta, 'nms_eta', float, 'locality_aware_nms')
+ check_type(nms_threshold, 'nms_threshold', float, 'locality_aware_nms')
+ check_type(keep_top_k, 'keep_top_k', int, 'locality_aware_nms')
+ check_type(normalized, 'normalized', bool, 'locality_aware_nms')
+
+ shape = scores.shape
+ assert len(shape) == 3, "dim size of scores must be 3"
+ assert shape[
+ 1] == 1, "locality_aware_nms only support one class, Tensor score shape must be [N, 1, M]"
+
+ helper = LayerHelper('locality_aware_nms', **locals())
+
+ output = helper.create_variable_for_type_inference(dtype=bboxes.dtype)
+ out = {'Out': output}
+
+ helper.append_op(type="locality_aware_nms",
+ inputs={
+ 'BBoxes': bboxes,
+ 'Scores': scores
+ },
+ attrs={
+ 'background_label': background_label,
+ 'score_threshold': score_threshold,
+ 'nms_top_k': nms_top_k,
+ 'nms_threshold': nms_threshold,
+ 'nms_eta': nms_eta,
+ 'keep_top_k': keep_top_k,
+ 'nms_eta': nms_eta,
+ 'normalized': normalized
+ },
+ outputs={'Out': output})
+ output.stop_gradient = True
+
+ return output
+
+
+def matrix_nms(bboxes,
+ scores,
+ score_threshold,
+ post_threshold,
+ nms_top_k,
+ keep_top_k,
+ use_gaussian=False,
+ gaussian_sigma=2.,
+ background_label=0,
+ normalized=True,
+ return_index=False,
+ name=None):
+ """
+ **Matrix NMS**
+
+ This operator does matrix non maximum suppression (NMS).
+
+ First selects a subset of candidate bounding boxes that have higher scores
+ than score_threshold (if provided), then the top k candidate is selected if
+ nms_top_k is larger than -1. Score of the remaining candidate are then
+ decayed according to the Matrix NMS scheme.
+ Aftern NMS step, at most keep_top_k number of total bboxes are to be kept
+ per image if keep_top_k is larger than -1.
+
+ Args:
+ bboxes (Variable): A 3-D Tensor with shape [N, M, 4] represents the
+ predicted locations of M bounding bboxes,
+ N is the batch size. Each bounding box has four
+ coordinate values and the layout is
+ [xmin, ymin, xmax, ymax], when box size equals to 4.
+ The data type is float32 or float64.
+ scores (Variable): A 3-D Tensor with shape [N, C, M]
+ represents the predicted confidence predictions.
+ N is the batch size, C is the class number, M is
+ number of bounding boxes. For each category there
+ are total M scores which corresponding M bounding
+ boxes. Please note, M is equal to the 2nd dimension
+ of BBoxes. The data type is float32 or float64.
+ score_threshold (float): Threshold to filter out bounding boxes with
+ low confidence score.
+ post_threshold (float): Threshold to filter out bounding boxes with
+ low confidence score AFTER decaying.
+ nms_top_k (int): Maximum number of detections to be kept according to
+ the confidences after the filtering detections based
+ on score_threshold.
+ keep_top_k (int): Number of total bboxes to be kept per image after NMS
+ step. -1 means keeping all bboxes after NMS step.
+ use_gaussian (bool): Use Gaussian as the decay function. Default: False
+ gaussian_sigma (float): Sigma for Gaussian decay function. Default: 2.0
+ background_label (int): The index of background label, the background
+ label will be ignored. If set to -1, then all
+ categories will be considered. Default: 0
+ normalized (bool): Whether detections are normalized. Default: True
+ return_index(bool): Whether return selected index. Default: False
+ name(str): Name of the matrix nms op. Default: None.
+
+ Returns:
+ A tuple with two Variables: (Out, Index) if return_index is True,
+ otherwise, one Variable(Out) is returned.
+
+ Out (Variable): A 2-D LoDTensor with shape [No, 6] containing the
+ detection results.
+ Each row has 6 values: [label, confidence, xmin, ymin, xmax, ymax]
+ (After version 1.3, when no boxes detected, the lod is changed
+ from {0} to {1})
+
+ Index (Variable): A 2-D LoDTensor with shape [No, 1] containing the
+ selected indices, which are absolute values cross batches.
+
+ Examples:
+ .. code-block:: python
+
+
+ import paddle.fluid as fluid
+ boxes = fluid.data(name='bboxes', shape=[None,81, 4],
+ dtype='float32', lod_level=1)
+ scores = fluid.data(name='scores', shape=[None,81],
+ dtype='float32', lod_level=1)
+ out = fluid.layers.matrix_nms(bboxes=boxes,
+ scores=scores,
+ background_label=0,
+ score_threshold=0.5,
+ post_threshold=0.1,
+ nms_top_k=400,
+ keep_top_k=200,
+ normalized=False)
+ """
+ if in_dygraph_mode():
+ attrs = (score_threshold, nms_top_k, keep_top_k, post_threshold,
+ use_gaussian, gaussian_sigma, background_label, normalized)
+
+ out, index = _C_ops.matrix_nms(bboxes, scores, *attrs)
+ if return_index:
+ return out, index
+ else:
+ return out
+
+ check_variable_and_dtype(bboxes, 'BBoxes', ['float32', 'float64'],
+ 'matrix_nms')
+ check_variable_and_dtype(scores, 'Scores', ['float32', 'float64'],
+ 'matrix_nms')
+ check_type(score_threshold, 'score_threshold', float, 'matrix_nms')
+ check_type(post_threshold, 'post_threshold', float, 'matrix_nms')
+ check_type(nms_top_k, 'nums_top_k', int, 'matrix_nms')
+ check_type(keep_top_k, 'keep_top_k', int, 'matrix_nms')
+ check_type(normalized, 'normalized', bool, 'matrix_nms')
+ check_type(use_gaussian, 'use_gaussian', bool, 'matrix_nms')
+ check_type(gaussian_sigma, 'gaussian_sigma', float, 'matrix_nms')
+ check_type(background_label, 'background_label', int, 'matrix_nms')
+
+ helper = LayerHelper('matrix_nms', **locals())
+ output = helper.create_variable_for_type_inference(dtype=bboxes.dtype)
+ index = helper.create_variable_for_type_inference(dtype='int')
+ helper.append_op(type="matrix_nms",
+ inputs={
+ 'BBoxes': bboxes,
+ 'Scores': scores
+ },
+ attrs={
+ 'score_threshold': score_threshold,
+ 'post_threshold': post_threshold,
+ 'nms_top_k': nms_top_k,
+ 'keep_top_k': keep_top_k,
+ 'use_gaussian': use_gaussian,
+ 'gaussian_sigma': gaussian_sigma,
+ 'background_label': background_label,
+ 'normalized': normalized
+ },
+ outputs={
+ 'Out': output,
+ 'Index': index
+ })
+ output.stop_gradient = True
+
+ if return_index:
+ return output, index
+ else:
+ return output
+
+
+def distribute_fpn_proposals(fpn_rois,
+ min_level,
+ max_level,
+ refer_level,
+ refer_scale,
+ rois_num=None,
+ name=None):
+ r"""
+
+ **This op only takes LoDTensor as input.** In Feature Pyramid Networks
+ (FPN) models, it is needed to distribute all proposals into different FPN
+ level, with respect to scale of the proposals, the referring scale and the
+ referring level. Besides, to restore the order of proposals, we return an
+ array which indicates the original index of rois in current proposals.
+ To compute FPN level for each roi, the formula is given as follows:
+
+ .. math::
+
+ roi\_scale &= \sqrt{BBoxArea(fpn\_roi)}
+
+ level = floor(&\log(\\frac{roi\_scale}{refer\_scale}) + refer\_level)
+
+ where BBoxArea is a function to compute the area of each roi.
+
+ Args:
+
+ fpn_rois(Variable): 2-D Tensor with shape [N, 4] and data type is
+ float32 or float64. The input fpn_rois.
+ min_level(int32): The lowest level of FPN layer where the proposals come
+ from.
+ max_level(int32): The highest level of FPN layer where the proposals
+ come from.
+ refer_level(int32): The referring level of FPN layer with specified scale.
+ refer_scale(int32): The referring scale of FPN layer with specified level.
+ rois_num(Tensor): 1-D Tensor contains the number of RoIs in each image.
+ The shape is [B] and data type is int32. B is the number of images.
+ If it is not None then return a list of 1-D Tensor. Each element
+ is the output RoIs' number of each image on the corresponding level
+ and the shape is [B]. None by default.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tuple:
+
+ multi_rois(List) : A list of 2-D LoDTensor with shape [M, 4]
+ and data type of float32 and float64. The length is
+ max_level-min_level+1. The proposals in each FPN level.
+
+ restore_ind(Variable): A 2-D Tensor with shape [N, 1], N is
+ the number of total rois. The data type is int32. It is
+ used to restore the order of fpn_rois.
+
+ rois_num_per_level(List): A list of 1-D Tensor and each Tensor is
+ the RoIs' number in each image on the corresponding level. The shape
+ is [B] and data type of int32. B is the number of images
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ fpn_rois = fluid.data(
+ name='data', shape=[None, 4], dtype='float32', lod_level=1)
+ multi_rois, restore_ind = fluid.layers.distribute_fpn_proposals(
+ fpn_rois=fpn_rois,
+ min_level=2,
+ max_level=5,
+ refer_level=4,
+ refer_scale=224)
+ """
+ return paddle.vision.ops.distribute_fpn_proposals(fpn_rois=fpn_rois,
+ min_level=min_level,
+ max_level=max_level,
+ refer_level=refer_level,
+ refer_scale=refer_scale,
+ rois_num=rois_num,
+ name=name)
+
+
+@templatedoc()
+def box_decoder_and_assign(prior_box,
+ prior_box_var,
+ target_box,
+ box_score,
+ box_clip,
+ name=None):
+ """
+
+ ${comment}
+ Args:
+ prior_box(${prior_box_type}): ${prior_box_comment}
+ prior_box_var(${prior_box_var_type}): ${prior_box_var_comment}
+ target_box(${target_box_type}): ${target_box_comment}
+ box_score(${box_score_type}): ${box_score_comment}
+ box_clip(${box_clip_type}): ${box_clip_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tuple:
+
+ decode_box(${decode_box_type}): ${decode_box_comment}
+
+ output_assign_box(${output_assign_box_type}): ${output_assign_box_comment}
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ pb = fluid.data(
+ name='prior_box', shape=[None, 4], dtype='float32')
+ pbv = fluid.data(
+ name='prior_box_var', shape=[4], dtype='float32')
+ loc = fluid.data(
+ name='target_box', shape=[None, 4*81], dtype='float32')
+ scores = fluid.data(
+ name='scores', shape=[None, 81], dtype='float32')
+ decoded_box, output_assign_box = fluid.layers.box_decoder_and_assign(
+ pb, pbv, loc, scores, 4.135)
+
+ """
+ check_variable_and_dtype(prior_box, 'prior_box', ['float32', 'float64'],
+ 'box_decoder_and_assign')
+ check_variable_and_dtype(target_box, 'target_box', ['float32', 'float64'],
+ 'box_decoder_and_assign')
+ check_variable_and_dtype(box_score, 'box_score', ['float32', 'float64'],
+ 'box_decoder_and_assign')
+ helper = LayerHelper("box_decoder_and_assign", **locals())
+
+ decoded_box = helper.create_variable_for_type_inference(
+ dtype=prior_box.dtype)
+ output_assign_box = helper.create_variable_for_type_inference(
+ dtype=prior_box.dtype)
+
+ helper.append_op(type="box_decoder_and_assign",
+ inputs={
+ "PriorBox": prior_box,
+ "PriorBoxVar": prior_box_var,
+ "TargetBox": target_box,
+ "BoxScore": box_score
+ },
+ attrs={"box_clip": box_clip},
+ outputs={
+ "DecodeBox": decoded_box,
+ "OutputAssignBox": output_assign_box
+ })
+ return decoded_box, output_assign_box
+
+
+def collect_fpn_proposals(multi_rois,
+ multi_scores,
+ min_level,
+ max_level,
+ post_nms_top_n,
+ rois_num_per_level=None,
+ name=None):
+ """
+
+ **This OP only supports LoDTensor as input**. Concat multi-level RoIs
+ (Region of Interest) and select N RoIs with respect to multi_scores.
+ This operation performs the following steps:
+
+ 1. Choose num_level RoIs and scores as input: num_level = max_level - min_level
+ 2. Concat multi-level RoIs and scores
+ 3. Sort scores and select post_nms_top_n scores
+ 4. Gather RoIs by selected indices from scores
+ 5. Re-sort RoIs by corresponding batch_id
+
+ Args:
+ multi_rois(list): List of RoIs to collect. Element in list is 2-D
+ LoDTensor with shape [N, 4] and data type is float32 or float64,
+ N is the number of RoIs.
+ multi_scores(list): List of scores of RoIs to collect. Element in list
+ is 2-D LoDTensor with shape [N, 1] and data type is float32 or
+ float64, N is the number of RoIs.
+ min_level(int): The lowest level of FPN layer to collect
+ max_level(int): The highest level of FPN layer to collect
+ post_nms_top_n(int): The number of selected RoIs
+ rois_num_per_level(list, optional): The List of RoIs' numbers.
+ Each element is 1-D Tensor which contains the RoIs' number of each
+ image on each level and the shape is [B] and data type is
+ int32, B is the number of images. If it is not None then return
+ a 1-D Tensor contains the output RoIs' number of each image and
+ the shape is [B]. Default: None
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable:
+
+ fpn_rois(Variable): 2-D LoDTensor with shape [N, 4] and data type is
+ float32 or float64. Selected RoIs.
+
+ rois_num(Tensor): 1-D Tensor contains the RoIs's number of each
+ image. The shape is [B] and data type is int32. B is the number of
+ images.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ multi_rois = []
+ multi_scores = []
+ for i in range(4):
+ multi_rois.append(fluid.data(
+ name='roi_'+str(i), shape=[None, 4], dtype='float32', lod_level=1))
+ for i in range(4):
+ multi_scores.append(fluid.data(
+ name='score_'+str(i), shape=[None, 1], dtype='float32', lod_level=1))
+
+ fpn_rois = fluid.layers.collect_fpn_proposals(
+ multi_rois=multi_rois,
+ multi_scores=multi_scores,
+ min_level=2,
+ max_level=5,
+ post_nms_top_n=2000)
+ """
+ num_lvl = max_level - min_level + 1
+ input_rois = multi_rois[:num_lvl]
+ input_scores = multi_scores[:num_lvl]
+
+ if _non_static_mode():
+ assert rois_num_per_level is not None, "rois_num_per_level should not be None in dygraph mode."
+ attrs = ('post_nms_topN', post_nms_top_n)
+ output_rois, rois_num = _legacy_C_ops.collect_fpn_proposals(
+ input_rois, input_scores, rois_num_per_level, *attrs)
+
+ check_type(multi_rois, 'multi_rois', list, 'collect_fpn_proposals')
+ check_type(multi_scores, 'multi_scores', list, 'collect_fpn_proposals')
+ helper = LayerHelper('collect_fpn_proposals', **locals())
+ dtype = helper.input_dtype('multi_rois')
+ check_dtype(dtype, 'multi_rois', ['float32', 'float64'],
+ 'collect_fpn_proposals')
+ output_rois = helper.create_variable_for_type_inference(dtype)
+ output_rois.stop_gradient = True
+
+ inputs = {
+ 'MultiLevelRois': input_rois,
+ 'MultiLevelScores': input_scores,
+ }
+ outputs = {'FpnRois': output_rois}
+ if rois_num_per_level is not None:
+ inputs['MultiLevelRoIsNum'] = rois_num_per_level
+ rois_num = helper.create_variable_for_type_inference(dtype='int32')
+ rois_num.stop_gradient = True
+ outputs['RoisNum'] = rois_num
+ helper.append_op(type='collect_fpn_proposals',
+ inputs=inputs,
+ outputs=outputs,
+ attrs={'post_nms_topN': post_nms_top_n})
+ if rois_num_per_level is not None:
+ return output_rois, rois_num
+ return output_rois
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/device.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/device.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4b967a8509e47acb4b480f14eeecd26653a28b9
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/device.py
@@ -0,0 +1,44 @@
+# Copyright (c) 2018 PaddlePaddle 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.
+"""
+All util layers.
+"""
+
+from __future__ import print_function
+
+from .layer_function_generator import autodoc
+from ..framework import unique_name
+from ..layer_helper import LayerHelper
+from paddle.utils import deprecated
+
+__all__ = []
+
+
+@deprecated(since='0.15.0', update_to="paddle.fluid.ParallelExecutor")
+@autodoc()
+def get_places(device_count=None, device_type=None):
+ helper = LayerHelper('get_places', **locals())
+ out_places = helper.create_variable(
+ name=unique_name.generate_with_ignorable_key(helper.name + ".out"))
+ attrs = dict()
+ if device_count is not None:
+ attrs['device_count'] = int(device_count)
+ if device_type is not None:
+ attrs['device_type'] = str(device_type)
+
+ helper.append_op(type='get_places',
+ outputs={"Out": [out_places]},
+ attrs=attrs)
+
+ return out_places
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/distributions.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/distributions.py
new file mode 100644
index 0000000000000000000000000000000000000000..757ba0dc8855fb4dd1c2c0e25e7d754789fffab0
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/distributions.py
@@ -0,0 +1,666 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from . import control_flow
+from . import tensor
+from . import ops
+from . import nn
+import math
+import numpy as np
+import warnings
+
+from ..data_feeder import convert_dtype, check_variable_and_dtype, check_type, check_dtype
+
+__all__ = ['Uniform', 'Normal', 'Categorical', 'MultivariateNormalDiag']
+
+
+class Distribution(object):
+ """
+ Distribution is the abstract base class for probability distributions.
+ """
+
+ def sample(self):
+ """Sampling from the distribution."""
+ raise NotImplementedError
+
+ def entropy(self):
+ """The entropy of the distribution."""
+ raise NotImplementedError
+
+ def kl_divergence(self, other):
+ """The KL-divergence between self distributions and other."""
+ raise NotImplementedError
+
+ def log_prob(self, value):
+ """Log probability density/mass function."""
+ raise NotImplementedError
+
+ def _validate_args(self, *args):
+ """
+ Argument validation for distribution args
+ Args:
+ value (float, list, numpy.ndarray, Variable)
+ Raises
+ ValueError: if one argument is Variable, all arguments should be Variable
+ """
+ is_variable = False
+ is_number = False
+ for arg in args:
+ if isinstance(arg, tensor.Variable):
+ is_variable = True
+ else:
+ is_number = True
+
+ if is_variable and is_number:
+ raise ValueError(
+ 'if one argument is Variable, all arguments should be Variable')
+
+ return is_variable
+
+ def _to_variable(self, *args):
+ """
+ Argument convert args to Variable
+
+ Args:
+ value (float, list, numpy.ndarray, Variable)
+ Returns:
+ Variable of args.
+ """
+ numpy_args = []
+ variable_args = []
+ tmp = 0.
+
+ for arg in args:
+ valid_arg = False
+ for cls in [float, list, np.ndarray, tensor.Variable]:
+ if isinstance(arg, cls):
+ valid_arg = True
+ break
+ assert valid_arg, "type of input args must be float, list, numpy.ndarray or Variable."
+ if isinstance(arg, float):
+ arg = np.zeros(1) + arg
+ arg_np = np.array(arg)
+ arg_dtype = arg_np.dtype
+ if str(arg_dtype) not in ['float32']:
+ warnings.warn(
+ "data type of argument only support float32, your argument will be convert to float32."
+ )
+ arg_np = arg_np.astype('float32')
+ tmp = tmp + arg_np
+ numpy_args.append(arg_np)
+
+ dtype = tmp.dtype
+ for arg in numpy_args:
+ arg_broadcasted, _ = np.broadcast_arrays(arg, tmp)
+ arg_variable = tensor.create_tensor(dtype=dtype)
+ tensor.assign(arg_broadcasted, arg_variable)
+ variable_args.append(arg_variable)
+
+ return tuple(variable_args)
+
+
+class Uniform(Distribution):
+ r"""Uniform distribution with `low` and `high` parameters.
+
+ Mathematical Details
+
+ The probability density function (pdf) is,
+
+ .. math::
+
+ pdf(x; a, b) = \\frac{1}{Z}, \ a <=x = 0
+ parent_block = prog.block(parent_idx)
+ return parent_block
+
+ def complete_op(self):
+ from ..incubate.fleet.parameter_server.mode import DistributedMode
+
+ main_program = self.helper.main_program
+ current_block = main_program.current_block()
+ parent_block = self.parent_block()
+
+ parent_block.append_op(
+ type='listen_and_serv',
+ inputs={"X": self.inputs},
+ outputs={},
+ attrs={
+ 'endpoint': self.endpoint,
+ 'Fanin': self.fan_in,
+ 'optimize_blocks':
+ [current_block
+ ], # did not support multiple optimize blocks in layers
+ 'distributed_mode':
+ DistributedMode.SYNC, # did not support async now in layers
+ 'grad_to_block_id': [""]
+ })
+
+
+def Send(endpoints, send_vars, dummy_output=None, sync=True):
+ """
+ Send variables to the server side, and get vars from server
+ side when server have finished running server side program.
+
+ Args:
+ endpoints (str): comma separated IP:PORT pairs in the order
+ of send_vars to send
+ send_vars (list): variables to send to server
+ sync (bool): whether to wait the request finish
+
+ """
+ assert (type(send_vars) == list)
+
+ if dummy_output is None:
+ dummy_output = []
+ elif isinstance(dummy_output, Variable):
+ dummy_output = [dummy_output]
+
+ assert (type(dummy_output) == list)
+
+ epmap = endpoints.split(",")
+ endpoints = list(set(epmap))
+
+ helper = LayerHelper("Send", **locals())
+ rpc_op_role_name = core.op_proto_and_checker_maker.kOpRoleAttrName()
+
+ helper.append_op(type="send",
+ inputs={"X": send_vars},
+ outputs={"Out": dummy_output},
+ attrs={
+ "endpoints":
+ endpoints,
+ "epmap":
+ epmap,
+ rpc_op_role_name:
+ core.op_proto_and_checker_maker.OpRole.RPC
+ })
+ if sync:
+ helper.append_op(type="send_barrier",
+ inputs={"X": dummy_output},
+ outputs={"Out": []},
+ attrs={"endpoints": endpoints})
+
+
+def Recv(endpoints, get_vars, dummy_input=None, sync=True):
+ """
+ Receive variables from server side
+
+ Args:
+ endpoints (str): comma separated IP:PORT pairs in the order
+ of send_vars to send
+ get_vars (list): vars to get from server after send completes.
+ sync (bool): whether to wait the request finish
+
+ Returns:
+ list: list of received variables
+ """
+ assert (type(get_vars) == list)
+
+ if dummy_input is None:
+ dummy_input = []
+ elif isinstance(dummy_input, Variable):
+ dummy_input = [dummy_input]
+
+ assert (type(dummy_input) == list)
+
+ epmap = endpoints.split(",")
+ endpoints = list(set(epmap))
+
+ helper = LayerHelper("Recv", **locals())
+ helper.append_op(type="recv",
+ inputs={"X": dummy_input},
+ outputs={"Out": get_vars},
+ attrs={
+ "endpoints": endpoints,
+ "epmap": epmap
+ })
+ if sync:
+ helper.append_op(type="fetch_barrier",
+ outputs={"Out": get_vars},
+ attrs={"endpoints": endpoints})
+ return get_vars
+
+
+def monkey_patch_reader_methods(reader):
+
+ def __get_reader__():
+ scope = global_scope()
+ var = scope.find_var(reader.name)
+ return var.get_reader()
+
+ def reset():
+ return __get_reader__().reset()
+
+ reader.reset = reset
+ reader.stop_gradient = True
+ reader.persistable = True
+ return reader
+
+
+def _copy_reader_var_(block, var):
+ new_var = block.create_var(name=var.name, type=core.VarDesc.VarType.READER)
+ new_var.desc.set_shapes(var.desc.shapes())
+ new_var.desc.set_dtypes(var.desc.dtypes())
+ new_var.desc.set_lod_levels(var.desc.lod_levels())
+ new_var.persistable = True
+ return new_var
+
+
+def _copy_reader_create_op_(block, op):
+ input_param_names = op.input_names
+ new_input_map = {}
+ for param_name in input_param_names:
+ new_input_map[param_name] = []
+ arg_names = op.input(param_name)
+ for arg_name in arg_names:
+ new_input_map[param_name].append(block.var(arg_name))
+
+ output_param_names = op.output_names
+ new_output_map = {}
+ for param_name in output_param_names:
+ new_output_map[param_name] = []
+ arg_names = op.output(param_name)
+ for arg_name in arg_names:
+ new_output_map[param_name].append(block.var(arg_name))
+
+ new_op = block.append_op(type=op.type,
+ inputs=new_input_map,
+ outputs=new_output_map,
+ attrs=op.all_attrs())
+ return new_op
+
+
+def _py_reader(capacity,
+ shapes,
+ dtypes,
+ lod_levels=None,
+ name=None,
+ use_double_buffer=True,
+ feed_list=None):
+ if feed_list is not None:
+ if not isinstance(feed_list, list):
+ raise TypeError("feed_list should be a list of Variable"
+ " instead of " + str(type(feed_list)))
+ lod_levels = []
+ dtypes = []
+ shape_concat = []
+ ranks = []
+ shapes = []
+ need_check_feed = []
+
+ for feed_data in feed_list:
+ dtypes.append(feed_data.dtype)
+ shape_concat.extend(feed_data.shape)
+ ranks.append(len(feed_data.shape))
+ shapes.append(feed_data.shape)
+ lod_levels.append(feed_data.lod_level)
+ need_check_feed.append(int(feed_data.desc.need_check_feed()))
+ else:
+ dtypes = [convert_np_dtype_to_dtype_(dt) for dt in dtypes]
+ need_check_feed = [0 for dt in dtypes]
+ shape_concat = []
+ ranks = []
+
+ for shape in shapes:
+ shape_concat.extend(shape)
+ ranks.append(len(shape))
+
+ if lod_levels is None:
+ lod_levels = [0] * len(shapes)
+ dtype_int = [int(t) for t in dtypes]
+ if name is None:
+ queue_name = unique_name('lod_tensor_blocking_queue')
+ reader_name = unique_name('create_py_reader')
+ double_buffer_name = unique_name('double_buffer')
+ else:
+ queue_name = "_".join([name, "queue"])
+ reader_name = "_".join([name, "reader"])
+ double_buffer_name = "_".join([name, "double_buffer"])
+
+ var = global_scope().var(queue_name)
+ feed_queue = core.init_lod_tensor_blocking_queue(var, capacity, False)
+
+ startup_blk = default_startup_program().current_block()
+ startup_var = startup_blk.create_var(name=reader_name)
+ startup_blk.append_op(type='create_py_reader',
+ inputs={'blocking_queue': [queue_name]},
+ outputs={'Out': [startup_var]},
+ attrs={
+ 'shape_concat': shape_concat,
+ 'lod_levels': lod_levels,
+ 'dtypes': dtype_int,
+ 'need_check_feed': need_check_feed,
+ 'ranks': ranks
+ })
+
+ startup_var.desc.set_dtypes(dtypes)
+ startup_var.persistable = True
+
+ main_prog_var = _copy_reader_var_(default_main_program().current_block(),
+ startup_var)
+
+ reader = monkey_patch_reader_methods(main_prog_var)
+ if use_double_buffer:
+ double_buffer_reader = double_buffer(reader, name=double_buffer_name)
+ # we return a double buffer reader. However, the reset method comes from
+ # py_reader.
+ double_buffer_reader.reset = reader.reset
+ reader = double_buffer_reader
+
+ # monkey patch py_reader special methods
+ reader.queue = feed_queue
+ current_reset_method = reader.reset
+ reader.thread = None
+ reader.tensor_provider = None
+ reader.exited = False
+
+ def start_provide_thread(func):
+
+ def __provider_thread__(legacy_expected_place):
+ try:
+ # See _DataLoaderIterSingleProcess._thread_loop() for why set expected place here.
+ _set_expected_place(legacy_expected_place)
+
+ for tensors in func():
+ array = core.LoDTensorArray()
+ for item in tensors:
+ if not isinstance(item, core.LoDTensor):
+ tmp = core.LoDTensor()
+ tmp.set(item, core.CPUPlace())
+ item = tmp
+
+ array.append(item)
+
+ if reader.exited:
+ break
+ feed_queue.push(array)
+ if reader.exited:
+ break
+ feed_queue.close()
+ except Exception as ex:
+ feed_queue.kill()
+ logging.warn('Your decorated reader has raised an exception!')
+ six.reraise(*sys.exc_info())
+
+ reader.thread = threading.Thread(target=__provider_thread__,
+ args=(_current_expected_place(), ))
+ reader.thread.daemon = True
+ reader.thread.start()
+
+ def __set_tensor_provider__(func):
+ reader.tensor_provider = func
+
+ def __set_paddle_reader__(paddle_reader):
+ with program_guard(Program(), Program()):
+ actual_feed_list = feed_list
+ if actual_feed_list is None:
+ actual_feed_list = []
+ counter = 0
+ for dtype, shape, lod_level in zip(dtypes, shapes, lod_levels):
+ name = str(counter)
+ actual_feed_list.append(
+ data(name=name,
+ dtype=dtype,
+ shape=shape,
+ lod_level=lod_level))
+ counter += 1
+
+ data_names = [feed_data.name for feed_data in actual_feed_list]
+ feeder = DataFeeder(feed_list=actual_feed_list,
+ place=core.CPUPlace())
+ paddle_reader = feeder.decorate_reader(paddle_reader,
+ multi_devices=False)
+
+ def __tensor_provider__():
+ for slots in paddle_reader():
+ yield [slots[data_name] for data_name in data_names]
+
+ __set_tensor_provider__(__tensor_provider__)
+
+ def __reset__():
+ current_reset_method()
+ if reader.thread is not None and reader.tensor_provider is not None:
+ reader.exited = True
+ reader.thread.join()
+ reader.exited = False
+
+ def __start__():
+ start_provide_thread(reader.tensor_provider)
+
+ reader.reset = __reset__
+ reader.decorate_tensor_provider = __set_tensor_provider__
+ reader.decorate_paddle_reader = __set_paddle_reader__
+
+ reader.decorate_batch_generator = __set_tensor_provider__
+ reader.decorate_sample_list_generator = __set_paddle_reader__
+ reader.start = __start__
+
+ return reader
+
+
+def py_reader(capacity,
+ shapes,
+ dtypes,
+ lod_levels=None,
+ name=None,
+ use_double_buffer=True):
+ """
+ :api_attr: Static Graph
+
+ Create a Python reader for data feeding in Python
+
+ This operator returns a Reader Variable.
+ The Reader provides :code:`decorate_paddle_reader()` and
+ :code:`decorate_tensor_provider()` to set a Python generator as the data
+ source and feed the data from the data source to the Reader Variable.
+ When :code:`Executor::Run()` is invoked in C++ side, the data from the
+ generator would be read automatically. Unlike :code:`DataFeeder.feed()`,
+ the data reading process and :code:`Executor::Run()` process can run in
+ parallel using :code:`py_reader`. The :code:`start()` method of the Reader
+ should be called when each pass begins, while the :code:`reset()` method
+ should be called when the pass ends and :code:`fluid.core.EOFException` raises.
+
+ Note:
+ :code:`Program.clone()` method cannot clone :code:`py_reader`. You can
+ refer to :ref:`api_fluid_Program` for more details.
+
+ The :code:`read_file` call needs to be in the program block of :code:`py_reader`.
+ You can refer to :ref:`api_fluid_layers_read_file` for more details.
+
+ Args:
+ capacity(int): The buffer capacity maintained by :code:`py_reader`.
+ shapes(list|tuple): List of tuples which declaring data shapes. shapes[i]
+ represents the i-th data shape.
+ dtypes(list|tuple): List of strings which declaring data type. Supported dtype:
+ bool, float16, float32, float64, int8, int16, int32, int64, uint8.
+ lod_levels(list|tuple): List of ints which declaring data lod_level.
+ name(basestring): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+ use_double_buffer(bool): Whether use double buffer or not. The double buffer is
+ for pre-reading the data of the next batch and copy the data asynchronously
+ from CPU to GPU. Default is True.
+
+ Returns:
+ A Reader from which we can get feeding data.
+
+ Return Type:
+ Variable
+
+ Examples:
+ 1. The basic usage of :code:`py_reader` is as follows:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.dataset.mnist as mnist
+
+ def network(image, label):
+ # user defined network, here a softmax regession example
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ reader = fluid.layers.py_reader(capacity=64,
+ shapes=[(-1, 1, 28, 28), (-1, 1)],
+ dtypes=['float32', 'int64'])
+ reader.decorate_paddle_reader(
+ paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),
+ buf_size=1000))
+
+ img, label = fluid.layers.read_file(reader)
+ loss = network(img, label)
+
+ fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
+ exe = fluid.ParallelExecutor(use_cuda=True)
+ for epoch_id in range(10):
+ reader.start()
+ try:
+ while True:
+ exe.run(fetch_list=[loss.name])
+ except fluid.core.EOFException:
+ reader.reset()
+
+ fluid.io.save_inference_model(dirname='./model',
+ feeded_var_names=[img.name, label.name],
+ target_vars=[loss],
+ executor=fluid.Executor(fluid.CUDAPlace(0)))
+
+ 2. When training and testing are both performed, two different
+ :code:`py_reader` should be created with different names, e.g.:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.dataset.mnist as mnist
+
+ def network(reader):
+ img, label = fluid.layers.read_file(reader)
+ # User defined network. Here a simple regression as example
+ predict = fluid.layers.fc(input=img, size=10, act='softmax')
+ loss = fluid.layers.cross_entropy(input=predict, label=label)
+ return fluid.layers.mean(loss)
+
+ # Create train_main_prog and train_startup_prog
+ train_main_prog = fluid.Program()
+ train_startup_prog = fluid.Program()
+ with fluid.program_guard(train_main_prog, train_startup_prog):
+ # Use fluid.unique_name.guard() to share parameters with test program
+ with fluid.unique_name.guard():
+ train_reader = fluid.layers.py_reader(capacity=64,
+ shapes=[(-1, 1, 28, 28),
+ (-1, 1)],
+ dtypes=['float32', 'int64'],
+ name='train_reader')
+ train_reader.decorate_paddle_reader(
+ paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),
+ buf_size=500))
+ train_loss = network(train_reader) # some network definition
+ adam = fluid.optimizer.Adam(learning_rate=0.01)
+ adam.minimize(train_loss)
+
+ # Create test_main_prog and test_startup_prog
+ test_main_prog = fluid.Program()
+ test_startup_prog = fluid.Program()
+ with fluid.program_guard(test_main_prog, test_startup_prog):
+ # Use fluid.unique_name.guard() to share parameters with train program
+ with fluid.unique_name.guard():
+ test_reader = fluid.layers.py_reader(capacity=32,
+ shapes=[(-1, 1, 28, 28), (-1, 1)],
+ dtypes=['float32', 'int64'],
+ name='test_reader')
+ test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
+ test_loss = network(test_reader)
+
+ fluid.Executor(fluid.CUDAPlace(0)).run(train_startup_prog)
+ fluid.Executor(fluid.CUDAPlace(0)).run(test_startup_prog)
+
+ train_exe = fluid.ParallelExecutor(use_cuda=True,
+ loss_name=train_loss.name,
+ main_program=train_main_prog)
+ test_exe = fluid.ParallelExecutor(use_cuda=True,
+ loss_name=test_loss.name,
+ main_program=test_main_prog)
+ for epoch_id in range(10):
+ train_reader.start()
+ try:
+ while True:
+ train_exe.run(fetch_list=[train_loss.name])
+ except fluid.core.EOFException:
+ train_reader.reset()
+
+ test_reader.start()
+ try:
+ while True:
+ test_exe.run(fetch_list=[test_loss.name])
+ except fluid.core.EOFException:
+ test_reader.reset()
+ """
+ logging.warn(
+ 'paddle.fluid.layers.py_reader() may be deprecated in the near future. '
+ 'Please use paddle.fluid.io.DataLoader.from_generator() instead.')
+ return _py_reader(capacity=capacity,
+ shapes=shapes,
+ dtypes=dtypes,
+ lod_levels=lod_levels,
+ name=name,
+ use_double_buffer=use_double_buffer)
+
+
+def create_py_reader_by_data(capacity,
+ feed_list,
+ name=None,
+ use_double_buffer=True):
+ """
+ :api_attr: Static Graph
+
+ The OP creates a Python reader for data feeding in Python, it is similar
+ to :ref:`api_fluid_layers_py_reader` except that it can read data from
+ the list of feed variables.
+
+ Parameters:
+ capacity (int): The buffer capacity maintained by :code:`py_reader`. Its unit
+ is batch number. Set larger :attr:`capacity` if the reader is fast.
+ feed_list (list(Variable)): The feed variables, are usually created by
+ :code:`fluid.data()`.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`. Default: None.
+ use_double_buffer (bool, optional): Whether use double buffer. If it's True,
+ the OP would prefetch next batch data asynchronously. Default: True.
+
+ Returns:
+ Reader: A Reader for data feeding. The data types of read data are the same as the data types of variables of :attr:`feed_list`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.dataset.mnist as mnist
+
+ def network(img, label):
+ # User defined network. Here a simple regression as example
+ predict = fluid.layers.fc(input=img, size=10, act='softmax')
+ loss = fluid.layers.cross_entropy(input=predict, label=label)
+ return fluid.layers.mean(loss)
+
+ MEMORY_OPT = False
+ USE_CUDA = False
+
+ image = fluid.data(name='image', shape=[None, 1, 28, 28], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ reader = fluid.layers.create_py_reader_by_data(capacity=64,
+ feed_list=[image, label])
+ reader.decorate_paddle_reader(
+ paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
+ img, label = fluid.layers.read_file(reader)
+ loss = network(img, label) # The definition of custom network and the loss function
+
+ place = fluid.CUDAPlace(0) if USE_CUDA else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ build_strategy = fluid.BuildStrategy()
+ build_strategy.memory_optimize = True if MEMORY_OPT else False
+ exec_strategy = fluid.ExecutionStrategy()
+ compiled_prog = fluid.compiler.CompiledProgram(
+ fluid.default_main_program()).with_data_parallel(
+ loss_name=loss.name,
+ build_strategy=build_strategy,
+ exec_strategy=exec_strategy)
+
+ for epoch_id in range(2):
+ reader.start()
+ try:
+ while True:
+ exe.run(compiled_prog, fetch_list=[loss.name])
+ except fluid.core.EOFException:
+ reader.reset()
+ """
+ logging.warn(
+ 'paddle.fluid.layers.create_py_reader_by_data() may be deprecated in the near future. '
+ 'Please use paddle.fluid.io.DataLoader.from_generator() instead.')
+ return _py_reader(capacity=capacity,
+ shapes=None,
+ dtypes=None,
+ lod_levels=None,
+ name=name,
+ use_double_buffer=use_double_buffer,
+ feed_list=feed_list)
+
+
+def __create_shared_decorated_reader__(op_type, reader, attrs):
+ var_name = unique_name(op_type)
+ startup_blk = default_startup_program().current_block()
+ startup_var = startup_blk.create_var(name=var_name)
+ startop_op = startup_blk.append_op(type=op_type,
+ inputs={'UnderlyingReader': reader},
+ outputs={'Out': [startup_var]},
+ attrs=attrs)
+ startup_var.persistable = True
+ main_prog_block = default_main_program().current_block()
+ main_prog_var = _copy_reader_var_(main_prog_block, startup_var)
+ _copy_reader_create_op_(main_prog_block, startop_op)
+ return monkey_patch_reader_methods(main_prog_var)
+
+
+def __create_unshared_decorated_reader__(op_type, reader, attrs, name=None):
+ new_reader_name = name if name is not None else unique_name(op_type)
+ main_blk = default_main_program().current_block()
+ new_reader = main_blk.create_var(name=new_reader_name)
+ main_blk.append_op(type=op_type,
+ inputs={'UnderlyingReader': reader},
+ outputs={'Out': [new_reader]},
+ attrs=attrs)
+ return monkey_patch_reader_methods(new_reader)
+
+
+def double_buffer(reader, place=None, name=None):
+ """
+ Wrap a double buffer reader. The class Reader contains DecoratedReader and FileReader. Moreover, the DecoratedReader is inherited by CustomReader and BufferedReader. This function is related to BufferedReader. The data will copy to target place with a double buffer queue. If the target place is None, the place that executor perform on will be used.
+
+
+ Args:
+ reader (Variable): The Reader Variable need to be wrapped.
+ place (Place|str, optional): The place of target data, such as CPU, GPU, and if use GPU, it's necessary to point out which card is involved. Default is the sample place of executor perform.
+ if ``place`` is string, It can be ``cpu``, ``gpu:x``, where ``x`` is the ndex of the GPUs.
+ name (str, optional): Variable name. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Returns:
+ Variable(Reader): wrapped reader with double buffer.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ reader = fluid.layers.py_reader(capacity=64,
+ shapes=[(-1, 1, 28, 28), (-1, 1)],
+ dtypes=['float32', 'int64'],
+ use_double_buffer=False)
+ reader = fluid.layers.double_buffer(reader)
+ image, label = fluid.layers.read_file(reader)
+ """
+ attrs = dict()
+ if place is not None:
+ attrs['place'] = str(_get_paddle_place(place)).upper()
+
+ return __create_unshared_decorated_reader__('create_double_buffer_reader',
+ reader,
+ attrs,
+ name=name)
+
+
+def read_file(reader):
+ """
+ :api_attr: Static Graph
+
+ Execute the given reader and get data via it.
+
+ A reader is also a Variable. It can be a raw reader generated by
+ `fluid.layers.open_files()` or a decorated one generated by
+ `fluid.layers.double_buffer()` .
+
+ Args:
+
+ reader(Variable): The reader to execute.
+
+ Returns:
+ Tuple[Variable]: Data read from the given reader.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ reader = fluid.layers.py_reader(capacity=64,
+ shapes=[(-1, 1, 28, 28), (-1, 1)],
+ dtypes=['float32', 'int64'])
+ image, label = fluid.layers.read_file(reader)
+ """
+ helper = LayerHelper('read_file')
+ out = [
+ helper.create_variable_for_type_inference(stop_gradient=True,
+ dtype='float32')
+ for _ in range(len(reader.desc.shapes()))
+ ]
+ helper.append_op(type='read',
+ inputs={'Reader': [reader]},
+ outputs={'Out': out})
+ if len(out) == 1:
+ return out[0]
+ else:
+ return out
+
+
+def load(out, file_path, load_as_fp16=None):
+ """
+ Load operator will load a LoDTensor / SelectedRows variable from disk file.
+
+ Args:
+ out(Variable): The LoDTensor / SelectedRows need to be loaded..
+
+ file_path(STRING): Variable will be loaded from "file_path".
+
+ load_as_fp16(BOOLEAN): If true, the tensor will be first loaded and then converted to float16 data type. Otherwise, the tensor will be directly loaded without data type conversion. Default is false..
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ tmp_tensor = fluid.layers.create_tensor(dtype='float32')
+ fluid.layers.load(tmp_tensor, "./tmp_tensor.bin")
+ """
+ helper = LayerHelper("load", **locals())
+ attrs = {"file_path": file_path}
+ if load_as_fp16 is not None:
+ attrs['load_as_fp16'] = load_as_fp16
+ helper.append_op(type="load", inputs={}, outputs={"Out": out}, attrs=attrs)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/layer_function_generator.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/layer_function_generator.py
new file mode 100644
index 0000000000000000000000000000000000000000..65ce37157c2bcc5150a7951f27c0ce5427d93719
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/layer_function_generator.py
@@ -0,0 +1,402 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import re
+import functools
+import warnings
+import string
+
+from six.moves import cStringIO
+from ..proto import framework_pb2
+from ..framework import OpProtoHolder, Variable, core, convert_np_dtype_to_dtype_, _non_static_mode, in_dygraph_mode, _in_legacy_dygraph
+from ..layer_helper import LayerHelper
+from ..data_feeder import check_variable_and_dtype
+from paddle.fluid.framework import in_dygraph_mode, _in_legacy_dygraph
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'generate_layer_fn', 'generate_activation_fn', 'generate_inplace_fn',
+ 'autodoc', 'templatedoc'
+]
+
+
+def _convert_(name):
+ """
+ Formatting.
+
+ Args:
+ name: The name/alias
+
+ This function takes in a name and converts it to a standard format of
+ group1_group2. Where as per the regular expression, group1 can have
+ alphabets and numbers and group2 has capital alphabets.
+
+ """
+ s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+ return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+
+def _type_to_str_(tp):
+ return framework_pb2.AttrType.Name(tp)
+
+
+_two_dollar_pattern_ = re.compile(r"\$\$([^\$]+)\$\$")
+_single_dollar_pattern_ = re.compile(r"\$([^\$]+)\$")
+_two_bang_pattern_ = re.compile(r"!!([^!]+)!!")
+
+
+def escape_math(text):
+ #return _two_bang_pattern_.sub(
+ # r'$$\1$$',
+ # _single_dollar_pattern_.sub(r':math:\n`\1`',
+ # _two_dollar_pattern_.sub(r"!!\1!!", text)))
+ return _two_dollar_pattern_.sub(r':math:`\1`', text)
+
+
+def _generate_doc_string_(op_proto,
+ additional_args_lines=None,
+ skip_attrs_set=None):
+ """
+ Generate docstring by OpProto
+
+ Args:
+ op_proto (framework_pb2.OpProto): a protobuf message typed OpProto
+
+ Returns:
+ str: the document string
+ """
+
+ if not isinstance(op_proto, framework_pb2.OpProto):
+ raise TypeError("OpProto should be `framework_pb2.OpProto`")
+
+ buf = cStringIO()
+ buf.write(escape_math(op_proto.comment))
+ buf.write('\nArgs:\n')
+ for each_input in op_proto.inputs:
+ line_begin = ' {0}'.format(_convert_(each_input.name))
+ buf.write(line_begin)
+ buf.write(" (Tensor): ")
+ buf.write(escape_math(each_input.comment))
+ if each_input.duplicable:
+ buf.write(" Duplicatable.")
+ if each_input.dispensable:
+ buf.write(" Optional.")
+ buf.write('\n')
+
+ skip_attrs = OpProtoHolder.generated_op_attr_names()
+ # attr use_mkldnn and is_test also should not be visible to users.
+ skip_attrs.add("use_mkldnn")
+ skip_attrs.add("is_test")
+ skip_attrs.add("use_cudnn")
+
+ if skip_attrs_set:
+ for t in skip_attrs_set:
+ skip_attrs.add(t)
+
+ for each_attr in op_proto.attrs:
+ if each_attr.name in skip_attrs:
+ continue
+ buf.write(' ')
+ buf.write(each_attr.name)
+ buf.write(' (')
+ buf.write(_type_to_str_(each_attr.type))
+ buf.write('): ')
+ buf.write(escape_math(each_attr.comment))
+ buf.write('\n')
+
+ if additional_args_lines is not None:
+ for line in additional_args_lines:
+ line = line.strip()
+ buf.write(' ')
+ buf.write(line)
+ buf.write('\n')
+
+ if len(op_proto.outputs) != 0:
+ buf.write('\nReturns:\n')
+ buf.write(' ')
+ for each_opt in op_proto.outputs:
+ if not each_opt.intermediate:
+ break
+ buf.write(_convert_(each_opt.name))
+ buf.write(' (Tensor): ')
+ buf.write(escape_math(each_opt.comment))
+
+ return buf.getvalue()
+
+
+def generate_layer_fn(op_type):
+ """Register the Python layer for an Operator.
+
+ Args:
+ op_type: The name of the operator to be created.
+
+ This function takes in the operator type (sigmoid, mean , average etc) and
+ creates the operator functionality.
+
+ """
+ op_proto = OpProtoHolder.instance().get_op_proto(op_type)
+ not_intermediate_outputs = \
+ [output for output in op_proto.outputs if not output.intermediate]
+ intermediate_outputs = \
+ [output for output in op_proto.outputs if output.intermediate]
+
+ if len(not_intermediate_outputs) != 1:
+ raise ValueError("Only one non intermediate output operator can be",
+ "automatically generated. {0}".format(op_type))
+
+ if not_intermediate_outputs[0].duplicable:
+ raise ValueError(
+ "Only non duplicable op can be automatically generated.")
+
+ for output in intermediate_outputs:
+ if output.duplicable:
+ raise ValueError("The op can be automatically generated only when ",
+ "all intermediate ops are not duplicable.")
+
+ o_name = not_intermediate_outputs[0].name
+ intermediate_output_names = [output.name for output in intermediate_outputs]
+
+ def infer_and_check_dtype(op_proto, *args, **kwargs):
+ """
+ This function performs the sanity check for dtype and
+ instance type.
+ """
+ dtype = None
+ for ipt in op_proto.inputs:
+ name = _convert_(ipt.name)
+ val = kwargs.pop(name, [])
+ if not isinstance(val, list) and not isinstance(val, tuple):
+ val = [val]
+ if len(val) == 0:
+ if len(args) == 0:
+ continue
+ val = [args[0]]
+ args = args[1:]
+
+ for each in val:
+ if not isinstance(each, Variable):
+ raise ValueError(
+ "input of {0} must be variable".format(op_type))
+
+ if dtype is None:
+ dtype = each.dtype
+ elif dtype != each.dtype:
+ raise ValueError(
+ "operator {0} must input same dtype. {1} vs {2}".format(
+ op_type, dtype, each.dtype))
+
+ if dtype is None:
+ arg_dtype = kwargs.get("dtype")
+ if arg_dtype:
+ if not isinstance(arg_dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(arg_dtype)
+ else:
+ dtype = arg_dtype
+ else:
+ dtype = core.VarDesc.VarType.FP32
+ return dtype
+
+ def func(*args, **kwargs):
+ helper = LayerHelper(op_type, **kwargs)
+
+ dtype = infer_and_check_dtype(op_proto, *args, **kwargs)
+
+ inputs = dict()
+ for ipt in op_proto.inputs:
+ name = _convert_(ipt.name)
+ val = kwargs.pop(name, [])
+ if not isinstance(val, list) and not isinstance(val, tuple):
+ val = [val]
+ if len(val) == 0 and len(args) != 0:
+ val = args[0]
+ args = args[1:]
+ inputs[ipt.name] = val
+
+ outputs = dict()
+ out = kwargs.pop(_convert_(o_name), [])
+ if out:
+ out_var = out[0] if (isinstance(out, list)
+ or isinstance(out, tuple)) else out
+ else:
+ out_var = helper.create_variable_for_type_inference(dtype=dtype)
+ outputs[o_name] = [out_var]
+ for name in intermediate_output_names:
+ outputs[name] = [
+ helper.create_variable_for_type_inference(dtype=dtype)
+ ]
+ helper.append_op(type=op_type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=kwargs)
+ return helper.append_activation(out_var)
+
+ func.__name__ = op_type
+ func.__doc__ = _generate_doc_string_(op_proto)
+ return func
+
+
+def generate_activation_fn(op_type):
+ """Register the Python layer for an Operator without Attribute.
+
+ Args:
+ op_type: The name of the operator to be created.
+
+ This function takes in the operator type (sigmoid, exp , tanh etc) and
+ creates the operator functionality.
+
+ """
+ op_proto = OpProtoHolder.instance().get_op_proto(op_type)
+
+ def func(x, name=None):
+ if in_dygraph_mode() and hasattr(_C_ops, op_type):
+ op = getattr(_C_ops, op_type)
+ return op(x)
+ # TODO(dev): Because some ops' yaml has not been migrated.
+ # Replace it with _in_legacy_dygraph while all yaml work is done.
+ if _non_static_mode():
+ op = getattr(_legacy_C_ops, op_type)
+ return op(x)
+
+ if op_type not in ["abs", "exp", "square"]:
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
+ op_type)
+ else:
+ # abs exp square ops support dtype(int32, int64, float16, float32, float64)
+ check_variable_and_dtype(x, 'x', [
+ 'int32', 'int64', 'float16', 'float32', 'float64', 'complex64',
+ 'complex128'
+ ], op_type)
+
+ helper = LayerHelper(op_type, **locals())
+
+ output = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(type=op_type, inputs={"X": x}, outputs={"Out": output})
+ return output
+
+ func.__name__ = op_type
+ func.__doc__ = _generate_doc_string_(
+ op_proto,
+ additional_args_lines=[
+ "name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`."
+ ])
+ return func
+
+
+def generate_inplace_fn(inplace_op_type):
+ """Register the Python layer for an Inplace Operator without Attribute.
+
+ Args:
+ inplace_op_type: The name of the inplace operator to be created.
+
+ This function takes in the inplace operator type (exp_ , ceil_ etc) and
+ creates the operator functionality.
+ """
+ origin_op_type = inplace_op_type[:-1]
+
+ def func(x, name=None):
+ if _non_static_mode():
+ op = getattr(_legacy_C_ops, inplace_op_type)
+ return op(x)
+ warnings.warn(
+ "In static mode, {}() is the same as {}() and does not perform inplace operation."
+ .format(inplace_op_type, origin_op_type))
+ return generate_activation_fn(origin_op_type)(x, name)
+
+ func.__name__ = inplace_op_type
+ func.__doc__ = """
+Inplace version of ``{0}`` API, the output Tensor will be inplaced with input ``x``.
+Please refer to :ref:`api_fluid_layers_{1}`.
+""".format(origin_op_type, origin_op_type)
+
+ return func
+
+
+def autodoc(comment=""):
+
+ def __impl__(func):
+ func.__doc__ = _generate_doc_string_(
+ OpProtoHolder.instance().get_op_proto(func.__name__)) + comment
+ return func
+
+ return __impl__
+
+
+def templatedoc(op_type=None):
+ """
+ Decorator of layer function. It will use the docstring from the layer
+ function as the template. The template arguments are:
+
+ * ${comment}: The operator comment written in CPP.
+ * ${{name}_comment}: The comment of ${name} written with AddAttr, AddOutput,
+ and AddInput. The ${name} is Python snake style. i.e., xxx_xxx.
+ * ${{name}_type}: The type of ${name}.
+
+ Returns:
+ Decorated function.
+ """
+
+ def trim_ending_dot(msg):
+ return msg.rstrip('.')
+
+ def __impl__(func):
+ if op_type is None:
+ op_type_name = func.__name__
+ else:
+ op_type_name = op_type
+ op_proto = OpProtoHolder.instance().get_op_proto(op_type_name)
+ tmpl = string.Template(func.__doc__)
+
+ comment_lines = op_proto.comment.split("\n")
+ comment = ""
+ for line in comment_lines:
+ line = line.strip()
+ if len(line) != 0:
+ comment += escape_math(line)
+ comment += " "
+ elif len(comment) != 0:
+ comment += "\n \n "
+
+ args = {"comment": trim_ending_dot(comment)}
+ for each_input in op_proto.inputs:
+ input_name = _convert_(each_input.name)
+ args["{0}_comment".format(input_name)] = trim_ending_dot(
+ each_input.comment)
+ args["{0}_type".format(input_name)] = "Variable"
+ for each_attr in op_proto.attrs:
+ input_name = _convert_(each_attr.name)
+ args["{0}_comment".format(input_name)] = trim_ending_dot(
+ each_attr.comment)
+ args["{0}_type".format(input_name)] = _type_to_str_(each_attr.type)
+
+ for each_opt in op_proto.outputs:
+ output_name = _convert_(each_opt.name)
+ args["{0}_comment".format(output_name)] = trim_ending_dot(
+ each_opt.comment)
+ args["{0}_type".format(output_name)] = "Variable"
+ func.__doc__ = tmpl.substitute(args)
+ return func
+
+ return __impl__
+
+
+def add_sample_code(func, sample_code):
+ """
+ Append sample code for dynamically generated functions.
+
+ Args:
+ func: The function of the function to be append sample code to.
+ sample_code: sample code session in rst format.
+ """
+ func.__doc__ = func.__doc__ + sample_code
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/learning_rate_scheduler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/learning_rate_scheduler.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1a65633e60e25a1fd58dd4dd2d593a519ba838e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/learning_rate_scheduler.py
@@ -0,0 +1,578 @@
+# Copyright (c) 2016 PaddlePaddle 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.
+"""
+When training a model, it's often useful to decay the
+learning rate during training process, this is called
+learning_rate_decay. There are many strategies to do
+this, this module will provide some classical method.
+User can also implement their own learning_rate_decay
+strategy according to this module.
+"""
+
+from __future__ import print_function
+
+import math
+import numbers
+
+from . import control_flow
+from . import nn
+from . import ops
+from . import tensor
+from ..framework import default_main_program, Parameter, unique_name, name_scope
+from ..framework import Variable
+from ..framework import _non_static_mode
+from ..dygraph import learning_rate_scheduler as imperate_lr
+from ..data_feeder import check_variable_and_dtype, check_type
+
+__all__ = [
+ 'exponential_decay', 'natural_exp_decay', 'inverse_time_decay',
+ 'polynomial_decay', 'piecewise_decay', 'noam_decay', 'cosine_decay',
+ 'linear_lr_warmup'
+]
+
+
+def _decay_step_counter(begin=0):
+ # the first global step is zero in learning rate decay
+ global_step = nn.autoincreased_step_counter(
+ counter_name='@LR_DECAY_COUNTER@', begin=begin, step=1)
+ global_step = tensor.cast(global_step, 'float32')
+ return global_step
+
+
+def noam_decay(d_model, warmup_steps, learning_rate=1.0):
+ """
+
+ Noam decay method. The numpy implementation of noam decay as follows.
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ # set hyper parameters
+ base_lr = 0.01
+ d_model = 2
+ current_steps = 20
+ warmup_steps = 200
+ # compute
+ lr_value = base_lr * np.power(d_model, -0.5) * np.min([
+ np.power(current_steps, -0.5),
+ np.power(warmup_steps, -1.5) * current_steps])
+
+ Please reference `attention is all you need
+ `_.
+
+ Args:
+ d_model(Variable): The dimensionality of input and output of model.
+
+ warmup_steps(Variable): A super parameter.
+
+ learning_rate(Variable|float|int): The initial learning rate. If the type
+ is Variable, it's a tensor with shape [1], the data type can be
+ float32 or float64. It also can be set to python int number. Default 1.0
+
+ Returns:
+ The decayed learning rate.
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ warmup_steps = 100
+ learning_rate = 0.01
+ lr = fluid.layers.learning_rate_scheduler.noam_decay(
+ 1/(warmup_steps *(learning_rate ** 2)),
+ warmup_steps,
+ learning_rate)
+ """
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.NoamDecay(d_model,
+ warmup_steps,
+ learning_rate=learning_rate)
+ return decay
+ else:
+ global_step = _decay_step_counter(1)
+
+ a = global_step**-0.5
+ b = (warmup_steps**-1.5) * global_step
+ lr_value = learning_rate * (d_model**-0.5) * nn.elementwise_min(
+ a, b)
+
+ return lr_value
+
+
+def exponential_decay(learning_rate, decay_steps, decay_rate, staircase=False):
+ """
+
+ Applies exponential decay to the learning rate.
+
+ When training a model, it is often recommended to lower the learning rate as the
+ training progresses. By using this function, the learning rate will be decayed by
+ 'decay_rate' every 'decay_steps' steps.
+
+ Decayed learning rate calculates as follows:
+
+ >>> if staircase == True:
+ >>> decayed_learning_rate = learning_rate * decay_rate ^ floor(global_step / decay_steps)
+ >>> else:
+ >>> decayed_learning_rate = learning_rate * decay_rate ^ (global_step / decay_steps)
+
+ Args:
+ learning_rate(Variable|float): The initial learning rate. It should be a Variable
+ or a float
+ decay_steps(int): The learning rate decay steps. See the decay computation above.
+ decay_rate(float): The learning rate decay rate. See the decay computation above.
+ staircase(bool): If True, decay the learning rate at discrete intervals, which
+ means the learning rate will be decayed by `decay_rate` every
+ `decay_steps`. If False, learning rate will be decayed continuously
+ and following the formula above. Default: False
+
+ Returns:
+ Variable: The decayed learning rate. The data type is float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ base_lr = 0.1
+ sgd_optimizer = fluid.optimizer.SGD(
+ learning_rate=fluid.layers.exponential_decay(
+ learning_rate=base_lr,
+ decay_steps=10000,
+ decay_rate=0.5,
+ staircase=True))
+
+ """
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.ExponentialDecay(learning_rate, decay_steps,
+ decay_rate, staircase)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ div_res = global_step / decay_steps
+ if staircase:
+ div_res = ops.floor(div_res)
+ decayed_lr = learning_rate * (decay_rate**div_res)
+
+ return decayed_lr
+
+
+def natural_exp_decay(learning_rate, decay_steps, decay_rate, staircase=False):
+ """
+
+Applies natural exponential decay to the initial learning rate.
+
+ When training a model, it is often recommended to lower the learning rate as the
+ training progresses. By using this function, the learning rate will be decayed by
+ natural exponential power 'decay_rate' every 'decay_steps' steps.
+
+ Decayed learning rate calculates as follows:
+
+ >>> if not staircase:
+ >>> decayed_learning_rate = learning_rate * exp(- decay_rate * (global_step / decay_steps))
+ >>> else:
+ >>> decayed_learning_rate = learning_rate * exp(- decay_rate * floor(global_step / decay_steps))
+
+ Args:
+ learning_rate(Variable|float): The initial learning rate. It should be a Variable
+ or a float
+ decay_steps(int): The learning rate decay steps. See the decay computation above.
+ decay_rate(float): The learning rate decay rate. See the decay computation above.
+ staircase(bool): If True, decay the learning rate at discrete intervals, which
+ means the learning rate will be decayed by natural exponential power
+ `decay_rate` every `decay_steps`. If False, learning rate will be
+ decayed continuously and following the formula above. Default: False
+
+ Returns:
+ The decayed learning rate. The data type is float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ base_lr = 0.1
+ sgd_optimizer = fluid.optimizer.SGD(
+ learning_rate=fluid.layers.natural_exp_decay(
+ learning_rate=base_lr,
+ decay_steps=10000,
+ decay_rate=0.5,
+ staircase=True))
+
+ """
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.NaturalExpDecay(learning_rate, decay_steps,
+ decay_rate, staircase)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ div_res = global_step / decay_steps
+ if staircase:
+ div_res = ops.floor(div_res)
+ decayed_lr = learning_rate * ops.exp(-1 * decay_rate * div_res)
+
+ return decayed_lr
+
+
+def inverse_time_decay(learning_rate, decay_steps, decay_rate, staircase=False):
+ """
+
+ Applies inverse time decay to the initial learning rate.
+
+ When training a model, it is often recommended to lower the learning rate as the
+ training progresses. By using this function, an inverse decay function will be
+ applied to the initial learning rate.
+
+ Decayed learning rate calculates as follows:
+
+ >>> if staircase == True:
+ >>> decayed_learning_rate = learning_rate / (1 + decay_rate * floor(global_step / decay_step))
+ >>> else:
+ >>> decayed_learning_rate = learning_rate / (1 + decay_rate * global_step / decay_step)
+
+ Args:
+ learning_rate(Variable|float): The initial learning rate. It should be a Variable
+ or a float
+ decay_steps(int): The learning rate decay steps. See the decay computation above.
+ decay_rate(float): The learning rate decay rate. See the decay computation above.
+ staircase(bool): If True, decay the learning rate at discrete intervals, which
+ means the learning rate will be decayed by `decay_rate` times
+ every `decay_steps`. If False, learning rate will be decayed
+ continuously and following the formula above. Default: False
+
+ Returns:
+ Variable: The decayed learning rate. The data type is float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ base_lr = 0.1
+ sgd_optimizer = fluid.optimizer.SGD(
+ learning_rate=fluid.layers.inverse_time_decay(
+ learning_rate=base_lr,
+ decay_steps=10000,
+ decay_rate=0.5,
+ staircase=True))
+ """
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.InverseTimeDecay(learning_rate, decay_steps,
+ decay_rate, staircase)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ div_res = global_step / decay_steps
+ if staircase:
+ div_res = ops.floor(div_res)
+
+ decayed_lr = learning_rate / (1 + decay_rate * div_res)
+
+ return decayed_lr
+
+
+def polynomial_decay(learning_rate,
+ decay_steps,
+ end_learning_rate=0.0001,
+ power=1.0,
+ cycle=False):
+ """
+ Applies polynomial decay to the initial learning rate.
+
+ .. code-block:: text
+
+ if cycle:
+ decay_steps = decay_steps * ceil(global_step / decay_steps)
+ else:
+ global_step = min(global_step, decay_steps)
+ decayed_learning_rate = (learning_rate - end_learning_rate) *
+ (1 - global_step / decay_steps) ^ power + end_learning_rate
+
+ Args:
+ learning_rate(Variable|float32): A scalar float32 value or a Variable. This
+ will be the initial learning rate during training.
+ decay_steps(int32): A Python `int32` number.
+ end_learning_rate(float): A Python `float` number.
+ power(float): A Python `float` number.
+ cycle(bool): If set true, decay the learning rate every decay_steps.
+
+ Returns:
+ Variable: The decayed learning rate
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ start_lr = 0.01
+ total_step = 5000
+ end_lr = 0
+ lr = fluid.layers.polynomial_decay(
+ start_lr, total_step, end_lr, power=1)
+
+ """
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.PolynomialDecay(learning_rate, decay_steps,
+ end_learning_rate, power, cycle)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ if cycle:
+ div_res = ops.ceil(global_step / decay_steps)
+ zero_var = tensor.fill_constant(shape=[1],
+ dtype='float32',
+ value=0.0)
+ one_var = tensor.fill_constant(shape=[1],
+ dtype='float32',
+ value=1.0)
+
+ with control_flow.Switch() as switch:
+ with switch.case(global_step == zero_var):
+ tensor.assign(input=one_var, output=div_res)
+ decay_steps = decay_steps * div_res
+ else:
+ decay_steps_var = tensor.fill_constant(shape=[1],
+ dtype='float32',
+ value=float(decay_steps))
+ global_step = nn.elementwise_min(x=global_step,
+ y=decay_steps_var)
+
+ decayed_lr = (learning_rate - end_learning_rate) * \
+ ((1 - global_step / decay_steps) ** power) + end_learning_rate
+ return decayed_lr
+
+
+def piecewise_decay(boundaries, values):
+ """
+
+Applies piecewise decay to the initial learning rate.
+
+ The algorithm can be described as the code below.
+
+ .. code-block:: text
+
+ boundaries = [10000, 20000]
+ values = [1.0, 0.5, 0.1]
+ if step < 10000:
+ learning_rate = 1.0
+ elif 10000 <= step < 20000:
+ learning_rate = 0.5
+ else:
+ learning_rate = 0.1
+ Args:
+ boundaries: A list of steps numbers.
+ values: A list of learning rate values that will be picked during
+ different step boundaries.
+
+ Returns:
+ The decayed learning rate.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ boundaries = [10000, 20000]
+ values = [1.0, 0.5, 0.1]
+ optimizer = fluid.optimizer.Momentum(
+ momentum=0.9,
+ learning_rate=fluid.layers.piecewise_decay(boundaries=boundaries, values=values),
+ regularization=fluid.regularizer.L2Decay(1e-4))
+
+
+ """
+ with default_main_program()._lr_schedule_guard():
+ if len(values) - len(boundaries) != 1:
+ raise ValueError("len(values) - len(boundaries) should be 1")
+
+ if _non_static_mode():
+ decay = imperate_lr.PiecewiseDecay(boundaries, values, 0)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ lr = tensor.create_global_var(shape=[1],
+ value=0.0,
+ dtype='float32',
+ persistable=True,
+ name="learning_rate")
+
+ with control_flow.Switch() as switch:
+ for i in range(len(boundaries)):
+ boundary_val = tensor.fill_constant(shape=[1],
+ dtype='float32',
+ value=float(
+ boundaries[i]),
+ force_cpu=True)
+ with switch.case(global_step < boundary_val):
+ tensor.fill_constant(shape=[1],
+ dtype="float32",
+ value=float(values[i]),
+ out=lr)
+ with switch.default():
+ tensor.fill_constant(shape=[1],
+ dtype="float32",
+ value=float(values[len(values) - 1]),
+ out=lr)
+
+ return lr
+
+
+def cosine_decay(learning_rate, step_each_epoch, epochs):
+ r"""
+
+ Applies cosine decay to the learning rate.
+
+ when training a model, it is often recommended to lower the learning rate as the
+ training progresses. By using this function, the learning rate will be decayed by
+ following cosine decay strategy.
+
+ .. math::
+
+ decayed\_lr = learning\_rate * 0.5 * (math.cos * (epoch * \\frac{math.pi}{epochs} ) + 1)
+
+ Args:
+ learning_rate(Variable|float): The initial learning rate.
+ step_each_epoch(int): the number of steps in an epoch.
+ epochs(int): the number of epochs.
+
+ Returns:
+ Variable: The decayed learning rate.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ base_lr = 0.1
+ lr = fluid.layers.cosine_decay(
+ learning_rate = base_lr, step_each_epoch=10000, epochs=120)
+ """
+ check_type(learning_rate, 'learning_rate', (float, tensor.Variable),
+ 'cosine_decay')
+
+ with default_main_program()._lr_schedule_guard():
+ if _non_static_mode():
+ decay = imperate_lr.CosineDecay(learning_rate, step_each_epoch,
+ epochs)
+ return decay
+ else:
+ global_step = _decay_step_counter()
+
+ cur_epoch = ops.floor(global_step / step_each_epoch)
+ decayed_lr = learning_rate * 0.5 * (
+ ops.cos(cur_epoch * math.pi / epochs) + 1)
+ return decayed_lr
+
+
+def linear_lr_warmup(learning_rate, warmup_steps, start_lr, end_lr):
+ """
+
+ This operator use the linear learning rate warm up strategy to adjust the learning rate preliminarily before the normal learning rate scheduling.
+ For more information, please refer to `Bag of Tricks for Image Classification with Convolutional Neural Networks `_
+
+ When global_step < warmup_steps, learning rate is updated as:
+
+ .. code-block:: text
+
+ linear_step = end_lr - start_lr
+ lr = start_lr + linear_step * (global_step / warmup_steps)
+
+ where start_lr is the initial learning rate, and end_lr is the final learning rate;
+
+ When global_step >= warmup_steps, learning rate is updated as:
+
+ .. code-block:: text
+
+ lr = learning_rate
+
+ where lr is the learning_rate after warm-up.
+
+ Args:
+ learning_rate (Variable|float): Learning_rate after warm-up, it could be 1D-Tensor or single value with the data type of float32.
+ warmup_steps (int): Steps for warm up.
+ start_lr (float): Initial learning rate of warm up.
+ end_lr (float): Final learning rate of warm up.
+
+ Returns:
+ Variable: Warm-up learning rate with the same data type as learning_rate.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ boundaries = [100, 200]
+ lr_steps = [0.1, 0.01, 0.001]
+ learning_rate = fluid.layers.piecewise_decay(boundaries, lr_steps) #case1, 1D-Tensor
+ #learning_rate = 0.1 #case2, single-value
+ warmup_steps = 50
+ start_lr = 1. / 3.
+ end_lr = 0.1
+ decayed_lr = fluid.layers.linear_lr_warmup(learning_rate,
+ warmup_steps, start_lr, end_lr)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ out, = exe.run(fetch_list=[decayed_lr.name])
+ print(out)
+ # case1: [0.33333334]
+ # case2: [0.33333334]
+ """
+ dtype = 'float32'
+ if isinstance(learning_rate, Variable):
+ dtype = learning_rate.dtype
+
+ linear_step = float(end_lr) - float(start_lr)
+ with default_main_program()._lr_schedule_guard():
+
+ if _non_static_mode():
+ lr = imperate_lr.LinearLrWarmup(learning_rate, warmup_steps,
+ start_lr, end_lr)
+ return lr
+ else:
+ lr = tensor.create_global_var(shape=[1],
+ value=0.0,
+ dtype=dtype,
+ persistable=True,
+ name="learning_rate_warmup")
+
+ global_step = _decay_step_counter()
+
+ with control_flow.Switch() as switch:
+ with switch.case(global_step < warmup_steps):
+ decayed_lr = start_lr + linear_step * (global_step /
+ float(warmup_steps))
+ tensor.assign(decayed_lr, lr)
+ with switch.default():
+ if not isinstance(learning_rate, Variable):
+ learning_rate = tensor.fill_constant(
+ shape=[1], dtype=dtype, value=float(learning_rate))
+ tensor.assign(learning_rate, lr)
+ return lr
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/loss.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..20c198388a9b43a40feedf67dabbe06a8baf08d8
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/loss.py
@@ -0,0 +1,1749 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import numpy as np
+from functools import partial, reduce
+import paddle
+from paddle.utils import deprecated
+from . import nn
+from .layer_function_generator import templatedoc
+from ..layer_helper import LayerHelper
+from ..framework import Variable, _non_static_mode, static_only, _in_legacy_dygraph, in_dygraph_mode
+from .. import core
+from ..data_feeder import check_variable_and_dtype, check_type
+from ..param_attr import ParamAttr
+from ..initializer import NumpyArrayInitializer, Constant
+from .. import core
+import warnings
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'center_loss',
+ 'bpr_loss',
+ 'cross_entropy',
+ 'square_error_cost',
+ 'edit_distance',
+ 'warpctc',
+ 'nce',
+ 'hsigmoid',
+ 'sampled_softmax_with_cross_entropy',
+ 'softmax_with_cross_entropy',
+ 'rank_loss',
+ 'margin_rank_loss',
+ 'sigmoid_cross_entropy_with_logits',
+ 'teacher_student_sigmoid_loss',
+ 'huber_loss',
+ 'kldiv_loss',
+ 'npair_loss',
+ 'mse_loss',
+]
+
+kIgnoreIndex = -100
+
+
+def center_loss(input,
+ label,
+ num_classes,
+ alpha,
+ param_attr,
+ update_center=True):
+ r"""
+ :api_attr: Static Graph
+
+ **Center loss Cost layer**
+
+ This OP accepts input (deep features,the output of the last hidden layer)
+ and target label and return the center loss cost. The average of the
+ distances of each sample in the mini-batch from the center of the
+ corresponding category is calculated as the center loss.
+
+ For deep features, :math:`X`, and target labels, :math:`Y`, the equation is:
+
+ .. math::
+
+ Out = \\frac{1}{2}(X - Y)^2
+
+ Args:
+ input (Variable): a 2-D tensor with shape[N x M]. Its dtype should be float32 or float64.
+ label (Variable): the groud truth which is a 2-D tensor
+ with shape[N x 1],where N is the batch size. Its dtype should be int32.
+ num_classes (int): the number of classification categories.
+ alpha (float|Variable): learning rate of centers.
+ param_attr (ParamAttr): Attribute initializer of centers.
+ update_center (bool): whether to update value of center.
+
+ Returns:
+ Variable: 2-D tensor with shape [N * 1]
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ input = fluid.data(name='x',shape=[20,30],dtype='float32')
+ label = fluid.data(name='y',shape=[20,1],dtype='int64')
+ num_classes = 1000
+ alpha = 0.01
+ param_attr = fluid.initializer.Xavier(uniform=False)
+ center_loss=fluid.layers.center_loss(input=input,
+ label=label,
+ num_classes=1000,
+ alpha=alpha,
+ param_attr=fluid.initializer.Xavier(uniform=False),
+ update_center=True)
+ """
+ helper = LayerHelper('center_loss', **locals())
+ dtype = helper.input_dtype()
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'center_loss')
+ check_variable_and_dtype(label, 'label', ['int32', 'int64'], 'center_loss')
+
+ centers_shape = [num_classes, input.shape[1]]
+ centers_param = helper.create_parameter(attr=param_attr,
+ shape=centers_shape,
+ dtype=dtype)
+ centers_param.stop_gradient = True
+
+ if isinstance(alpha, Variable):
+ alpha_param = alpha
+ check_variable_and_dtype(alpha, 'alpha', ['float32', 'float64'],
+ 'center_loss')
+ else:
+ assert isinstance(alpha, float)
+ alpha_param = helper.create_variable(
+ name="centerloss_alpha",
+ shape=[1],
+ dtype="float32",
+ type=core.VarDesc.VarType.LOD_TENSOR,
+ persistable=True,
+ stop_gradient=True,
+ initializer=Constant(alpha))
+
+ centersdiff = helper.create_variable_for_type_inference(dtype=input.dtype)
+ loss = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(type='center_loss',
+ inputs={
+ 'X': [input],
+ 'Label': [label],
+ 'Centers': [centers_param],
+ 'CenterUpdateRate': [alpha_param]
+ },
+ outputs={
+ 'SampleCenterDiff': [centersdiff],
+ 'Loss': [loss],
+ 'CentersOut': [centers_param]
+ },
+ attrs={
+ 'cluster_num': num_classes,
+ 'need_update': update_center
+ })
+ return loss
+
+
+def bpr_loss(input, label, name=None):
+ r"""
+
+ **Bayesian Personalized Ranking Loss Operator**
+
+ This operator belongs to pairwise ranking loss. Label is the desired item.
+ The loss at a given point in one session is defined as:
+
+ .. math::
+ Y[i] = 1/(N[i] - 1) * \sum_j{\log(\sigma(X[i, Label[i]]-X[i, j]))}
+
+ Learn more details by reading paper .
+
+ Args:
+ input (Variable|list): a 2-D tensor with shape [N x D], where N is the
+ batch size and D is the number of positive classes and negative classes
+ This input is not probability but logits.
+ label (Variable|list): the ground truth which is a 2-D tensor. `label`
+ is a tensor with shape [N x 1].
+ name (str|None): A name for this layer(optional). If set None, the
+ layer will be named automatically. Default: None.
+ Returns:
+ A 2-D tensor with shape [N x 1], the bpr loss.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+
+ neg_size = 10
+ label = fluid.data(
+ name="label", shape=[3, 1], dtype="int64")
+ predict = fluid.data(
+ name="predict", shape=[3, neg_size + 1], dtype="float32")
+ cost = fluid.layers.bpr_loss(input=predict, label=label)
+ """
+ helper = LayerHelper('bpr_loss', **locals())
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'],
+ 'bpr_loss')
+ helper.append_op(type='bpr_loss',
+ inputs={
+ 'X': [input],
+ 'Label': [label]
+ },
+ outputs={'Y': [out]})
+ return out
+
+
+def cross_entropy(input, label, soft_label=False, ignore_index=kIgnoreIndex):
+ r"""
+ :alias_main: paddle.nn.functional.cross_entropy
+ :alias: paddle.nn.functional.cross_entropy,paddle.nn.functional.loss.cross_entropy
+ :old_api: paddle.fluid.layers.cross_entropy
+
+ This operator computes the cross entropy between input and label. It
+ supports both hard-label and and soft-label cross entropy computation.
+
+ 1. Hard-label cross entropy: if soft_label=False, :math:`label[i_1, i_2, ..., i_k]`
+ is the hard label of each sample.
+
+ .. math::
+
+ output[i_1, i_2, ..., i_k]=-log(input[i_1, i_2, ..., i_k, j]), label[i_1, i_2, ..., i_k] = j, j != ignore\_index
+
+ 2. Soft-label cross entropy: if soft_label=True, :math:`label[i_1, i_2, ..., i_k, j]`
+ is the soft label of each sample corresponding to the j-th class.
+
+ .. math::
+
+ output[i_1, i_2, ..., i_k]= -\sum_{j}label[i_1,i_2,...,i_k,j]*log(input[i_1, i_2, ..., i_k,j])
+
+ Args:
+ input (Variable): a multidimensional Tensor with shape
+ :math:`[N_1, N_2, ..., N_k, D]`, where the last dimension D is
+ the class number. The data type should be float32 or float64.
+ label (Variable): label value corresponding to input. If
+ soft_label=False, the dimension of label should be :math:`[N_1, N_2, ..., N_k]`
+ or :math:`[N_1, N_2, ..., N_k, 1]` , and its data type should be int64,
+ and the value must be inside [0, D). If soft_label=True, the shape,
+ data type of label should be the same with input, and the sum of
+ soft label value of each sample should be 1.
+ soft_label (bool): indicate whether label is soft. Default False, meaning that
+ the label is hard. If soft_label=True, the label is soft.
+ ignore_index (int): specify an ignorable label value. The ignored label would be
+ omitted when computing. If it is a negative integer, no label would
+ be ignored. Only valid when soft_label=False. Default -100.
+
+ Returns:
+ A Variable holding Tensor representing the cross entropy, whose data type is the same with input.
+ If soft_label=False, the shape of output is the same with label.
+ If soft_label=True, the shape of output is :math:`[N_1, N_2, ..., N_k, 1]` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ class_num = 7
+ x = fluid.data(name='x', shape=[None, 3, 10], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ predict = fluid.layers.fc(input=x, size=class_num, act='softmax')
+ cost = fluid.layers.cross_entropy(input=predict, label=label)
+ """
+ if not soft_label:
+ return cross_entropy2(input, label, ignore_index)
+
+ if _non_static_mode():
+ return _legacy_C_ops.cross_entropy(input, label, "soft_label",
+ soft_label, "ignore_index",
+ ignore_index)
+
+ inputs = {'X': [input], 'Label': [label]}
+ attrs = {"soft_label": soft_label, "ignore_index": ignore_index}
+
+ check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'],
+ 'cross_entropy')
+ helper = LayerHelper('cross_entropy', **locals())
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(type='cross_entropy',
+ inputs=inputs,
+ outputs={'Y': [out]},
+ attrs=attrs)
+ return out
+
+
+def cross_entropy2(input, label, ignore_index=kIgnoreIndex):
+ if _non_static_mode():
+ loss, _, _ = _legacy_C_ops.cross_entropy2(input, label, 'ignore_index',
+ ignore_index)
+ return loss
+
+ inputs = {'X': [input], 'Label': [label]}
+ attrs = {'ignore_index': ignore_index}
+ check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'],
+ 'cross_entropy2')
+ helper = LayerHelper('cross_entropy2', **locals())
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ xshape = helper.create_variable_for_type_inference(dtype=input.dtype)
+ match_x = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(type='cross_entropy2',
+ inputs=inputs,
+ outputs={
+ 'Y': [out],
+ 'MatchX': [match_x],
+ 'XShape': [xshape]
+ },
+ attrs=attrs)
+ return out
+
+
+def square_error_cost(input, label):
+ r"""
+
+ Accept input predictions and target label and returns the
+ squared error cost.
+
+ For predictions label, and target label, the equation is:
+
+ .. math::
+
+ Out = (input - label)^2
+
+ Parameters:
+ input (Tensor): Input tensor, the data type should be float32.
+ label (Tensor): Label tensor, the data type should be float32.
+
+ Returns:
+ Tensor, The tensor storing the element-wise squared
+ error difference between input and label.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ input = paddle.to_tensor([1.1, 1.9])
+ label = paddle.to_tensor([1.0, 2.0])
+ output = paddle.nn.functional.square_error_cost(input, label)
+ print(output)
+ # [0.01, 0.01]
+
+ """
+ return paddle.nn.functional.square_error_cost(input, label)
+
+
+def edit_distance(input,
+ label,
+ normalized=True,
+ ignored_tokens=None,
+ input_length=None,
+ label_length=None):
+ """
+ This op computes the edit distances, also called Levenshtein distance, between a batch of
+ hypothesis strings and their references. It measures how dissimilar two strings are by counting
+ the minimum number of operations to transform one string into another.
+ The operations include insertion, deletion, and substitution.
+
+ For example, given hypothesis string A = "kitten" and reference
+ B = "sitting", A will be transformed into B
+ at least after two substitutions and one insertion:
+
+ "kitten" -> "sitten" -> "sittin" -> "sitting"
+
+ So the edit distance between A and B is 3.
+
+ The input is a Tensor, the input_length and label_length should be supported.
+
+ The `batch_size` of labels should be same as `input`.
+
+ The output include the edit distance value between every pair of input and related label, and the number of sequence.
+ If Attr(normalized) is true,
+ the edit distance value will be divided by the length of label.
+
+ Parameters:
+ input(Tensor): The input tensor, its rank should be equal to 2 and its data type should be int64.
+ label(Tensor): The label tensor, its rank should be equal to 2 and its data type should be int64.
+ normalized(bool, default True): Indicated whether to normalize the edit distance.
+ ignored_tokens(list, default None): Tokens that will be removed before
+ calculating edit distance.
+ input_length(Tensor): The length for each sequence in `input` if it's of Tensor type, it should have shape `(batch_size, )` and its data type should be int64.
+ label_length(Tensor): The length for each sequence in `label` if it's of Tensor type, it should have shape `(batch_size, )` and its data type should be int64.
+ NOTE: To be avoid unexpected result, the value of every elements in input_length and label_length should be equal to the value of the second dimension of input and label. For example, The input: [[1,2,3,4],[5,6,7,8],[9,10,11,12]], the shape of input is [3,4] and the input_length should be [4,4,4]
+ NOTE: This Api is different from fluid.metrics.EditDistance
+
+ Returns:
+ Tuple:
+
+ distance(Tensor): edit distance result, its data type is float32, and its shape is (batch_size, 1).
+ sequence_num(Tensor): sequence number, its data type is float32, and its shape is (1,).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ input = paddle.to_tensor([[1,2,3],[4,5,6],[4,4,4],[1,1,1]], dtype='int64')
+ label = paddle.to_tensor([[1,3,4,1],[4,5,8,1],[7,7,7,1],[1,1,1,1]], dtype='int64')
+ input_len = paddle.to_tensor([3,3,3,3], dtype='int64')
+ label_len = paddle.to_tensor([4,4,4,4], dtype='int64')
+
+ distance, sequence_num = F.loss.edit_distance(input=input, label=label, input_length=input_len, label_length=label_len, normalized=False)
+
+ # print(distance)
+ # [[3.]
+ # [2.]
+ # [4.]
+ # [1.]]
+ # if set normalized to True
+ # [[0.75]
+ # [0.5 ]
+ # [1. ]
+ # [0.25]
+ #
+ # print(sequence_num)
+ # [4]
+
+ """
+ return paddle.nn.functional.loss.edit_distance(input, label, normalized,
+ ignored_tokens, input_length,
+ label_length)
+
+
+def warpctc(input,
+ label,
+ blank=0,
+ norm_by_times=False,
+ input_length=None,
+ label_length=None):
+ """
+ An operator integrating the open source Warp-CTC library
+ (https://github.com/baidu-research/warp-ctc)
+ to compute Connectionist Temporal Classification (CTC) loss.
+ It can be aliased as softmax with CTC, since a native softmax activation is
+ interated to the Warp-CTC library to normalize values for each row of the
+ input tensor.
+
+ Args:
+ input (Variable): The unscaled probabilities of variable-length sequences,
+ which is a 2-D Tensor with LoD information, or a 3-D Tensor without Lod
+ information. When it is a 2-D LodTensor, its shape is
+ `[Lp, num_classes + 1]`, where `Lp` is the sum of all input
+ sequences' length and `num_classes` is the true number of classes.
+ (not including the blank label). When it is a 3-D Tensor, its shape
+ is `[max_logit_length, batch_size, num_classes + 1]`,
+ where `max_logit_length` is the longest length of
+ input logit sequence. The data type should be float32 or float64.
+ label (Variable): The ground truth of variable-length sequence,
+ which must be a 2-D Tensor with LoD information or a 3-D Tensor without
+ LoD information, needs to be consistent with the coressponding input.
+ When it is a 2-D LoDTensor, its shape is `[Lg, 1]`, where `Lg` is the sum
+ of all labels' length. When it is a 3-D Tensor, its shape is
+ `[batch_size, max_label_length]`, where `max_label_length` is the longest
+ length of label sequence. Data type must be int32.
+ blank (int, default 0): The blank label index of Connectionist
+ Temporal Classification (CTC) loss, which is in the
+ half-opened interval `[0, num_classes + 1)`. The data type must be int32.
+ norm_by_times(bool, default false): Whether to normalize the gradients
+ by the number of time-step, which is also the sequence's length.
+ There is no need to normalize the gradients if warpctc layer was
+ followed by a mean_op.
+ input_length(Variable): The length for each input sequence if it is
+ of Tensor type, it should have shape `[batch_size]` and dtype int64.
+ label_length(Variable): The length for each label sequence if it is
+ of Tensor type, it should have shape `[batch_size]` and dtype int64.
+
+ Returns:
+ Variable: The Connectionist Temporal Classification (CTC) loss,
+ which is a 2-D Tensor with the shape `[batch_size, 1]`.
+ The date type is the same as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ # using LoDTensor
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ # lengths of logit sequences
+ seq_lens = [2,6]
+ # lengths of label sequences
+ label_lens = [2,3]
+ # class num
+ class_num = 5
+
+ paddle.enable_static()
+ logits = fluid.data(name='logits',shape=[None, class_num+1],
+ dtype='float32',lod_level=1)
+ label = fluid.data(name='label', shape=[None, 1],
+ dtype='int32', lod_level=1)
+ cost = fluid.layers.warpctc(input=logits, label=label)
+ place = fluid.CPUPlace()
+ x = fluid.create_lod_tensor(
+ np.random.rand(np.sum(seq_lens), class_num+1).astype("float32"),
+ [seq_lens], place)
+ y = fluid.create_lod_tensor(
+ np.random.randint(0, class_num, [np.sum(label_lens), 1]).astype("int32"),
+ [label_lens], place)
+ exe = fluid.Executor(place)
+ output= exe.run(fluid.default_main_program(),
+ feed={"logits": x,"label": y},
+ fetch_list=[cost.name])
+ print(output)
+
+ .. code-block:: python
+
+ # using Tensor
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ # length of the longest logit sequence
+ max_seq_length = 5
+ #length of the longest label sequence
+ max_label_length = 3
+ # number of logit sequences
+ batch_size = 16
+ # class num
+ class_num = 5
+ paddle.enable_static()
+ logits = fluid.data(name='logits',
+ shape=[max_seq_length, batch_size, class_num+1],
+ dtype='float32')
+ logits_length = fluid.data(name='logits_length', shape=[None],
+ dtype='int64')
+ label = fluid.data(name='label', shape=[batch_size, max_label_length],
+ dtype='int32')
+ label_length = fluid.data(name='labels_length', shape=[None],
+ dtype='int64')
+ cost = fluid.layers.warpctc(input=logits, label=label,
+ input_length=logits_length,
+ label_length=label_length)
+ place = fluid.CPUPlace()
+ x = np.random.rand(max_seq_length, batch_size, class_num+1).astype("float32")
+ y = np.random.randint(0, class_num, [batch_size, max_label_length]).astype("int32")
+ exe = fluid.Executor(place)
+ output= exe.run(fluid.default_main_program(),
+ feed={"logits": x,
+ "label": y,
+ "logits_length": np.array([max_seq_length]*batch_size).astype("int64"),
+ "labels_length": np.array([max_label_length]*batch_size).astype("int64")},
+ fetch_list=[cost.name])
+ print(output)
+ """
+ if in_dygraph_mode():
+ if input_length is None or label_length is None:
+ raise ValueError(
+ "input_length and label_length must not be None in dygraph mode!"
+ )
+ loss_out = _C_ops.warpctc(input, label, input_length, label_length,
+ blank, norm_by_times)
+ return loss_out
+ if _non_static_mode():
+ if input_length is None or label_length is None:
+ raise ValueError(
+ "input_length and label_length must not be None in dygraph mode!"
+ )
+ grad, loss_out = _legacy_C_ops.warpctc(
+ input,
+ label,
+ input_length,
+ label_length,
+ 'blank',
+ blank,
+ 'norm_by_times',
+ norm_by_times,
+ )
+ return loss_out
+ helper = LayerHelper('warpctc', **locals())
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], "warpctc")
+ check_variable_and_dtype(label, 'label', ['int32'], "warpctc")
+ this_inputs = {'Logits': [input], 'Label': [label]}
+ if input_length is not None and label_length is not None:
+ check_variable_and_dtype(input_length, 'LogitsLength', ['int64'],
+ "warpctc")
+ check_variable_and_dtype(label_length, 'LabelLength', ['int64'],
+ "warpctc")
+ this_inputs['LogitsLength'] = [input_length]
+ this_inputs['LabelLength'] = [label_length]
+
+ loss_out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ grad_out = helper.create_variable_for_type_inference(dtype=input.dtype)
+
+ helper.append_op(type='warpctc',
+ inputs=this_inputs,
+ outputs={
+ 'WarpCTCGrad': [grad_out],
+ 'Loss': [loss_out]
+ },
+ attrs={
+ 'blank': blank,
+ 'norm_by_times': norm_by_times,
+ })
+ return loss_out
+
+
+# FIXME(wuyi): let docstring_checker.py understand @autodoc.
+# For now, the comments in c++ use types like Tensor, but in python side
+# the type is often "Variable", and arguments may vary.
+@static_only
+@templatedoc(op_type="nce")
+def nce(input,
+ label,
+ num_total_classes,
+ sample_weight=None,
+ param_attr=None,
+ bias_attr=None,
+ num_neg_samples=None,
+ name=None,
+ sampler="uniform",
+ custom_dist=None,
+ seed=0,
+ is_sparse=False):
+ """
+ :api_attr: Static Graph
+
+ ${comment}
+
+ Args:
+ input (Tensor): Input tensor, 2-D tensor with shape [batch_size, dim],
+ and data type is float32 or float64.
+ label (Tensor): Input label, 2-D tensor with shape [batch_size, num_true_class],
+ and data type is int64.
+ num_total_classes (int):${num_total_classes_comment}.
+ sample_weight (Tensor|None): A Tensor of shape [batch_size, 1]
+ storing a weight for each sample. The default weight for each
+ sample is 1.0.
+ param_attr (ParamAttr|None): To specify the weight parameter attribute.
+ Default: None, which means the default weight parameter property is
+ used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr|None): To specify the bias parameter attribute.
+ Default: None, which means the default bias parameter property is
+ used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ num_neg_samples (int): ${num_neg_samples_comment}.
+ name(str|None): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+ sampler (str, optional): The sampler used to sample class from negative classes.
+ It can be 'uniform', 'log_uniform' or 'custom_dist'.
+ default: 'uniform'.
+ custom_dist (nd.array|None): A numpy ndarray with size=num_total_classes.
+ It is used when sampler is set to 'custom_dist'.
+ custom_dist[i] is the probability of i-th class to be sampled.
+ default: None.
+ seed (int, optional): The seed used in sampler. Default 0, means no random seed.
+ is_sparse(bool, optional): The flag indicating whether to use sparse update,
+ the weight@GRAD and bias@GRAD will be changed to SelectedRows. Default False.
+
+ Returns:
+ Tensor: The output nce loss.
+
+ Examples:
+ .. code-block:: python
+
+
+ import paddle
+ import numpy as np
+
+ paddle.enable_static()
+
+ window_size = 5
+ words = []
+ for i in range(window_size):
+ words.append(paddle.static.data(
+ name='word_{0}'.format(i), shape=[-1, 1], dtype='int64'))
+
+ dict_size = 10000
+ label_word = int(window_size / 2) + 1
+
+ embs = []
+ for i in range(window_size):
+ if i == label_word:
+ continue
+
+ emb = paddle.static.nn.embedding(input=words[i], size=[dict_size, 32],
+ param_attr='embed', is_sparse=True)
+ embs.append(emb)
+
+ embs = paddle.concat(x=embs, axis=1)
+ loss = paddle.static.nn.nce(input=embs, label=words[label_word],
+ num_total_classes=dict_size, param_attr='nce.w_0',
+ bias_attr='nce.b_0')
+
+ #or use custom distribution
+ dist = np.array([0.05,0.5,0.1,0.3,0.05])
+ loss = paddle.static.nn.nce(input=embs, label=words[label_word],
+ num_total_classes=5, param_attr='nce.w_1',
+ bias_attr='nce.b_1',
+ num_neg_samples=3,
+ sampler="custom_dist",
+ custom_dist=dist)
+ """
+ helper = LayerHelper('nce', **locals())
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'nce')
+ check_variable_and_dtype(label, 'label', ['int64'], 'nce')
+
+ dim = input.shape[1]
+ num_true_class = label.shape[1]
+ w = helper.create_parameter(attr=helper.param_attr,
+ shape=[num_total_classes, dim],
+ is_bias=False,
+ dtype=input.dtype)
+ inputs = {}
+ if helper.bias_attr:
+ b = helper.create_parameter(attr=helper.bias_attr,
+ shape=[num_total_classes, 1],
+ is_bias=True,
+ dtype=input.dtype)
+ inputs['Bias'] = b
+ cost = helper.create_variable_for_type_inference(dtype=input.dtype)
+ sample_logits = helper.create_variable_for_type_inference(dtype=input.dtype)
+ sample_labels = helper.create_variable_for_type_inference(dtype=label.dtype)
+
+ inputs['Input'] = input
+ inputs['Label'] = label
+ inputs['Weight'] = w
+ inputs['SampleWeight'] = sample_weight if sample_weight is not None else []
+
+ if sampler == "uniform":
+ sampler = 0
+ elif sampler == "log_uniform":
+ sampler = 1
+ elif sampler == "custom_dist":
+ assert custom_dist is not None
+
+ custom_dist_len = num_total_classes
+ alias_probs_ = [0] * custom_dist_len
+ alias_ = [0] * custom_dist_len
+ bigs = []
+ littles = []
+ for i in range(custom_dist_len):
+ normal_prob = custom_dist[i] * custom_dist_len
+ if normal_prob - 1.0 > 0:
+ bigs.append((i, normal_prob))
+ elif 1.0 - normal_prob > 0:
+ littles.append((i, normal_prob))
+ else:
+ alias_probs_[i] = normal_prob
+ alias_[i] = -1
+
+ while len(bigs) and len(littles):
+ big = bigs.pop(0)
+ little = littles.pop(0)
+
+ big_idx = big[0]
+ big_prob = big[1]
+
+ alias_probs_[little[0]] = little[1]
+ alias_[little[0]] = big_idx
+ big_left = big[1] + little[1] - 1
+ if big_left - 1.0 > 0:
+ bigs.append((big_idx, big_left))
+ elif 1.0 - big_left > 0:
+ littles.append((big_idx, big_left))
+ else:
+ alias_probs_[big_idx] = big_left
+ alias_[big_idx] = -1
+
+ if len(bigs):
+ big = bigs.pop(0)
+ alias_probs_[big[0]] = 1.0
+ alias_[big[0]] = -1
+ if len(littles):
+ little = littles.pop(0)
+ alias_probs_[little[0]] = 1.0
+ alias_[little[0]] = -1
+
+ def _init_by_numpy_array(numpy_array):
+ ret = helper.create_parameter(
+ attr=ParamAttr(),
+ shape=numpy_array.shape,
+ dtype=numpy_array.dtype,
+ default_initializer=NumpyArrayInitializer(numpy_array))
+ ret.stop_gradient = True
+ return ret
+
+ inputs['CustomDistProbs'] = _init_by_numpy_array(
+ np.array(custom_dist).astype('float32'))
+ inputs['CustomDistAlias'] = _init_by_numpy_array(
+ np.array(alias_).astype('int32'))
+ inputs['CustomDistAliasProbs'] = _init_by_numpy_array(
+ np.array(alias_probs_).astype('float32'))
+ sampler = 2
+ else:
+ raise Exception("Unsupported sampler type.")
+
+ if num_neg_samples is None:
+ num_neg_samples = 10
+ else:
+ num_neg_samples = int(num_neg_samples)
+
+ remote_prefetch = is_sparse
+ print(
+ "With sparse mode, if your models has only small parameter prefetch may cause speed down"
+ )
+
+ attrs = {
+ 'num_total_classes': int(num_total_classes),
+ 'num_neg_samples': num_neg_samples,
+ 'seed': seed,
+ 'sampler': sampler,
+ 'is_sparse': is_sparse,
+ 'remote_prefetch': remote_prefetch
+ }
+
+ helper.append_op(type='nce',
+ inputs=inputs,
+ outputs={
+ 'Cost': cost,
+ 'SampleLogits': sample_logits,
+ 'SampleLabels': sample_labels
+ },
+ attrs=attrs)
+ return cost / (num_neg_samples + 1)
+
+
+def hsigmoid(input,
+ label,
+ num_classes,
+ param_attr=None,
+ bias_attr=None,
+ name=None,
+ path_table=None,
+ path_code=None,
+ is_custom=False,
+ is_sparse=False):
+ """
+ :api_attr: Static Graph
+
+ The hierarchical sigmoid organizes the classes into a complete binary tree to reduce the computational complexity
+ and speed up the model training, especially the training of language model.
+ Each leaf node of the complete binary tree represents a class(word) and each non-leaf node acts as a binary classifier.
+ For each class(word), there's a unique path from root to itself, hsigmoid calculate the cost for each non-leaf node on
+ the path, and sum them to get a total cost.
+ Comparing to softmax, the OP can reduce the computational complexity from :math:`O(N)` to :math:`O(logN)`, where :math:`N`
+ represents the number of classes or the size of word dict.
+
+ The OP supports default tree and custom tree. For the default tree, you can refer to `Hierarchical Probabilistic Neural
+ Network Language Model `. For the custom
+ tree, you need to set :attr:`is_custom` to True, and do the following steps (take the language model as an example):
+
+ 1. Using a custom word dict to build a binary tree, each leaf node should be an word in the word dict.
+ 2. Creating a dict map word_id -> path that from the word to the root node, we call it path_table.
+ 3. Creating a dict map word_id -> code of path that from the word to the root node, we call it path_code.
+ Code means the label of each binary classifier, 1 indicate true, 0 indicate false.
+ 4. Now, each word should has its path and code along the path, you can pass a batch of path and code related
+ to the same batch of inputs.
+
+ Parameters:
+ input (Variable): A tensor with the shape [N, D], where N is the size of mini-batch,
+ and D is the feature size. Its data type supports float32 and float64.
+ label (Variable): A tensor contains the labels of training data. Its shape is [N, 1]
+ and data type is int64.
+ num_classes (int): The number of classes or the size of word dict, must be greater than 2.
+ If the default tree is used (:attr:`is_custom` is set to False), :attr:`num_classes`
+ should not be None. If the custom tree is used (:attr:`is_custom` is set to True),
+ :attr:`num_classes` should be the number of non-leaf nodes, which indicates the num of
+ classes using by the binary classifier.
+ param_attr (ParamAttr, optional): The parameter attribute for the learnable parameters/weights
+ of hsigmoid. If it is set to None or one attribute of ParamAttr, hsigmoid will create a
+ ParamAttr as param_attr. If the Initializer of the param_attr is not set, the parameter is
+ initialized with Xavier. Default: None.
+ bias_attr (ParamAttr|bool, optional): The parameter attribute for the bias of hsigmoid. If it
+ is set to False, no bias will be added. If it is set to None or one attribute of ParamAttr,
+ hsigmoid will create a ParamAttr as bias_attr. If the Initializer of the bias_attr is not
+ set, the bias is initialized zero. Default: None.
+ name (str, optional): Normally there is no need for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`. Default: None.
+ path_table (Variable, optional): A tensor that stores each batch of samples' path from leaf to root
+ node, its shape is [N, L] and data type is int64, where L is the length of path. For each sample i,
+ path_table[i] is a np.array like structure and each element in this array is the indexes in parent
+ nodes' weight matrix. Default: None.
+ path_code (Variable, optional): A tensor that stores each batch of samples' code of path from leaf
+ to root node, its shape is [N, L] and data type is int64, which is the same as :attr:`path_table`.
+ Each code of path is consisted with the code of nodes from leaf to root node. Default: None.
+ is_custom (bool, optional): Whether use custom binary tree. If it's True, :attr:`path_table`,
+ :attr:`path_code` and :attr:`num_classes` should be set, otherwise :attr:`num_classes` should
+ be set. Default: False.
+ is_sparse (bool, optional): Whether use sparse updating instead of dense updating, if it's True, the
+ gradient of W and input will be sparse. Default: False.
+
+ Returns:
+ Variable: A tensor with the cost of hierarchical sigmoid, its shape is [N, 1] and data type is the same as :attr:`input`.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.fill_constant(shape=[4, 3], value=0.9, dtype='float32')
+ # x = [[0.9, 0.9, 0.9], [0.9, 0.9, 0.9], [0.9, 0.9, 0.9], [0.9, 0.9, 0.9]]
+ y = fluid.layers.fill_constant(
+ shape=[4, 1], value=1, dtype='int64')
+ # y = [[1], [1], [1], [1]]
+ out = fluid.layers.hsigmoid(input=x, label=y, num_classes=2, param_attr=fluid.initializer.Constant(
+ value=0.05), bias_attr=fluid.initializer.Constant(value=.0))
+ # out = [[0.62792355], [0.62792355], [0.62792355], [0.62792355]]
+ """
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'hsigmoid')
+ check_variable_and_dtype(label, 'label', ['int64'], 'hsigmoid')
+
+ helper = LayerHelper('hierarchical_sigmoid', **locals())
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ pre_out = helper.create_variable_for_type_inference(dtype)
+ dim = input.shape[1]
+ if ((num_classes is None) or (num_classes < 2)) and (not is_custom):
+ raise ValueError(
+ "num_classes must not be less than 2 with default tree")
+
+ if (not is_custom) and (is_sparse):
+ print("Sparse mode should not be used without custom tree")
+ is_sparse = False
+
+ if (not is_custom) and ((path_table is not None) or
+ (path_code is not None)):
+ raise ValueError(
+ "only num_classes should be passed without custom tree")
+
+ if (is_custom) and (path_code is None):
+ raise ValueError("path_code should not be None with custom tree")
+ elif (is_custom) and (path_table is None):
+ raise ValueError("path_table should not be None with custom tree")
+ elif (is_custom) and (num_classes is None):
+ raise ValueError("num_classes should not be None with custom tree")
+ else:
+ pass
+
+ weights = None
+ remote_prefetch = is_sparse
+ print(
+ "With sparse mode, if your models has only small parameter prefetch may cause speed down"
+ )
+ if not is_custom:
+ weights = helper.create_parameter(attr=helper.param_attr,
+ shape=[num_classes - 1, dim],
+ is_bias=False,
+ dtype=input.dtype)
+ else:
+ weights = helper.create_parameter(attr=helper.param_attr,
+ shape=[num_classes, dim],
+ is_bias=False,
+ dtype=input.dtype)
+ inputs = {
+ "X": input,
+ "W": weights,
+ "PathTable": path_table,
+ "PathCode": path_code,
+ "Label": label
+ }
+ if helper.bias_attr:
+ if not is_custom:
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=[num_classes - 1, 1],
+ is_bias=True,
+ dtype=input.dtype)
+ inputs['Bias'] = bias
+ else:
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=[num_classes, 1],
+ is_bias=True,
+ dtype=input.dtype)
+ inputs['Bias'] = bias
+ helper.append_op(type="hierarchical_sigmoid",
+ inputs=inputs,
+ outputs={
+ "Out": out,
+ "PreOut": pre_out,
+ "W_Out": weights
+ },
+ attrs={
+ "num_classes": num_classes,
+ "is_sparse": is_sparse,
+ "remote_prefetch": remote_prefetch
+ })
+ return out
+
+
+def sampled_softmax_with_cross_entropy(logits,
+ label,
+ num_samples,
+ num_true=1,
+ remove_accidental_hits=True,
+ use_customized_samples=False,
+ customized_samples=None,
+ customized_probabilities=None,
+ seed=0):
+ """
+ **Sampled Softmax With Cross Entropy Operator.**
+
+ Cross entropy loss with sampled softmax is used as the output layer for
+ larger output classes extensively. This operator samples a number of samples
+ for all examples, and computes the softmax normalized values for each
+ row of the sampled tensor, after which cross-entropy loss is computed.
+
+ Because this operator performs a softmax on logits internally, it expects
+ unscaled logits. This operator should not be used with the output of
+ softmax operator since that would produce incorrect results.
+
+ For examples with T true labels (T >= 1), we assume that each true label has
+ a probability of 1/T. For each sample, S samples are generated using a
+ log uniform distribution. True labels are concatenated with these samples to
+ form T + S samples for each example. So, assume the shape of logits is
+ [N x K], the shape for samples is [N x (T+S)]. For each sampled label, a
+ probability is calculated, which corresponds to the Q(y|x) in
+ [Jean et al., 2014](http://arxiv.org/abs/1412.2007).
+
+ Logits are sampled according to the sampled labels. Then if
+ remove_accidental_hits is True, if a sample[i, j] accidentally hits true
+ labels, then the corresponding sampled_logits[i, j] is minus by 1e20 to
+ make its softmax result close to zero. Then sampled logits are subtracted by
+ logQ(y|x), these sampled logits and re-indexed labels are used to compute
+ a softmax with cross entropy.
+
+ Args:
+ logits (Variable): The unscaled log probabilities, which is a 2-D tensor
+ with shape [N x K]. N is the batch_size, and K is the class number.
+ label (Variable): The ground truth which is a 2-D tensor. Label is a
+ Tensor with shape [N x T], where T is the number of true
+ labels per example.
+ num_samples (int): The number for each example, num_samples should be
+ less than the number of class.
+ num_true(int): The number of target classes per training example.
+ remove_accidental_hits (bool): A flag indicating whether to remove
+ accidental hits when sampling. If True and if a sample[i, j]
+ accidentally hits true labels, then the corresponding
+ sampled_logits[i, j] is minus by 1e20 to make its softmax result
+ close to zero. Default is True.
+ use_customized_samples (bool): Whether to use custom samples and probabities to sample
+ logits.
+ customized_samples (Variable): User defined samples, which is a 2-D tensor
+ with shape [N, T + S]. S is the num_samples, and T is the number of true
+ labels per example.
+ customized_probabilities (Variable): User defined probabilities of samples,
+ a 2-D tensor which has the same shape with customized_samples.
+ seed (int): The random seed for generating random number, which is used
+ in the process of sampling. Default is 0.
+
+ Returns:
+ Variable: Return the cross entropy loss which is a 2-D tensor with shape
+ [N x 1].
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ input = fluid.layers.data(name='data', shape=[256], dtype='float32')
+ label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+ fc = fluid.layers.fc(input=input, size=100)
+ out = fluid.layers.sampled_softmax_with_cross_entropy(
+ logits=fc, label=label, num_samples=25)
+ """
+ if _non_static_mode():
+ sample_logits_attrs = ('use_customized_samples', use_customized_samples,
+ 'uniq', True, 'remove_accidental_hits',
+ remove_accidental_hits, 'num_samples',
+ num_samples, 'seed', seed)
+ _, _, _, _, sampled_logits_out, sampled_label_out = _legacy_C_ops.sample_logits(
+ logits, label, *sample_logits_attrs)
+ depth = num_samples + 1
+ sampled_softlabel_out = _legacy_C_ops.one_hot(sampled_label_out,
+ 'depth', depth)
+
+ softmax_with_cross_entropy_attrs = ('soft_label', True,
+ 'numeric_stable_mode', False)
+
+ _, loss = _legacy_C_ops.softmax_with_cross_entropy(
+ sampled_logits_out, sampled_softlabel_out,
+ *softmax_with_cross_entropy_attrs)
+ return loss / num_true
+
+ helper = LayerHelper('sample_logits', **locals())
+ samples = customized_samples if use_customized_samples else helper.create_variable_for_type_inference(
+ dtype='int64')
+ probabilities = customized_probabilities if use_customized_samples else helper.create_variable_for_type_inference(
+ dtype=logits.dtype)
+ sampled_logits \
+ = helper.create_variable_for_type_inference(dtype=logits.dtype)
+ sampled_label = helper.create_variable_for_type_inference(dtype='int64')
+ sampled_softlabel = helper.create_variable_for_type_inference(
+ dtype=logits.dtype)
+ logits_dim = helper.create_variable_for_type_inference(dtype=logits.dtype)
+ labels_dim = helper.create_variable_for_type_inference(dtype=label.type)
+
+ helper.append_op(type='sample_logits',
+ inputs={
+ 'Logits': logits,
+ 'Labels': label,
+ 'CustomizedSamples': customized_samples,
+ 'CustomizedProbabilities': customized_probabilities
+ },
+ outputs={
+ 'Samples': samples,
+ 'Probabilities': probabilities,
+ 'SampledLabels': sampled_label,
+ 'SampledLogits': sampled_logits,
+ 'LogitsDim': logits_dim,
+ 'LabelsDim': labels_dim
+ },
+ attrs={
+ 'use_customized_samples': use_customized_samples,
+ 'uniq': True,
+ 'remove_accidental_hits': remove_accidental_hits,
+ 'num_samples': num_samples,
+ 'seed': seed
+ })
+ loss = helper.create_variable_for_type_inference(dtype=logits.dtype)
+ softmax = helper.create_variable_for_type_inference(dtype=logits.dtype)
+ helper.append_op(type='one_hot',
+ inputs={'X': sampled_label},
+ attrs={'depth': num_samples + 1},
+ outputs={'Out': sampled_softlabel})
+
+ helper.append_op(type='softmax_with_cross_entropy',
+ inputs={
+ 'Logits': sampled_logits,
+ 'Label': sampled_softlabel
+ },
+ outputs={
+ 'Softmax': softmax,
+ 'Loss': loss
+ },
+ attrs={
+ 'soft_label': True,
+ 'ignore_index': False,
+ 'numeric_stable_mode': False
+ })
+ return loss / num_true
+
+
+def softmax_with_cross_entropy(logits,
+ label,
+ soft_label=False,
+ ignore_index=kIgnoreIndex,
+ numeric_stable_mode=True,
+ return_softmax=False,
+ axis=-1):
+ r"""
+
+ This operator implements the cross entropy loss function with softmax. This function
+ combines the calculation of the softmax operation and the cross entropy loss function
+ to provide a more numerically stable gradient.
+
+ Because this operator performs a softmax on logits internally, it expects
+ unscaled logits. This operator should not be used with the output of
+ softmax operator since that would produce incorrect results.
+
+ When the attribute :attr:`soft_label` is set :attr:`False`, this operators
+ expects mutually exclusive hard labels, each sample in a batch is in exactly
+ one class with a probability of 1.0. Each sample in the batch will have a
+ single label.
+
+ The equation is as follows:
+
+ 1) Hard label (one-hot label, so every sample has exactly one class)
+
+ .. math::
+
+ loss_j = -\\text{logits}_{label_j} +
+ \\log\\left(\\sum_{i=0}^{K}\\exp(\\text{logits}_i)\\right), j = 1,..., K
+
+ 2) Soft label (each sample can have a distribution over all classes)
+
+ .. math::
+
+ loss_j = -\\sum_{i=0}^{K}\\text{label}_i
+ \\left(\\text{logits}_i - \\log\\left(\\sum_{i=0}^{K}
+ \\exp(\\text{logits}_i)\\right)\\right), j = 1,...,K
+
+ 3) If :attr:`numeric_stable_mode` is :attr:`True`, softmax is calculated first by:
+
+ .. math::
+
+ max_j &= \\max_{i=0}^{K}{\\text{logits}_i}
+
+ log\\_max\\_sum_j &= \\log\\sum_{i=0}^{K}\\exp(logits_i - max_j)
+
+ softmax_j &= \\exp(logits_j - max_j - {log\\_max\\_sum}_j)
+
+ and then cross entropy loss is calculated by softmax and label.
+
+ Args:
+ logits (Tensor): A multi-dimension ``Tensor`` , and the data type is float32 or float64. The input tensor of unscaled log probabilities.
+ label (Tensor): The ground truth ``Tensor`` , data type is the same
+ as the ``logits`` . If :attr:`soft_label` is set to :attr:`True`,
+ Label is a ``Tensor`` in the same shape with :attr:`logits`.
+ If :attr:`soft_label` is set to :attr:`True`, Label is a ``Tensor``
+ in the same shape with :attr:`logits` expect shape in dimension :attr:`axis` as 1.
+ soft_label (bool, optional): A flag to indicate whether to interpretant the given
+ labels as soft labels. Default False.
+ ignore_index (int, optional): Specifies a target value that is ignored and does
+ not contribute to the input gradient. Only valid
+ if :attr:`soft_label` is set to :attr:`False`.
+ Default: kIgnoreIndex(-100).
+ numeric_stable_mode (bool, optional): A flag to indicate whether to use a more
+ numerically stable algorithm. Only valid
+ when :attr:`soft_label` is :attr:`False`
+ and GPU is used. When :attr:`soft_label`
+ is :attr:`True` or CPU is used, the
+ algorithm is always numerically stable.
+ Note that the speed may be slower when use
+ stable algorithm. Default: True.
+ return_softmax (bool, optional): A flag indicating whether to return the softmax
+ along with the cross entropy loss. Default: False.
+ axis (int, optional): The index of dimension to perform softmax calculations. It
+ should be in range :math:`[-1, rank - 1]`, while :math:`rank`
+ is the rank of input :attr:`logits`. Default: -1.
+
+ Returns:
+ ``Tensor`` or Tuple of two ``Tensor`` : Return the cross entropy loss if \
+ `return_softmax` is False, otherwise the tuple \
+ (loss, softmax), softmax is in the same shape \
+ with input logits and cross entropy loss is in \
+ the same shape with input logits except shape \
+ in dimension :attr:`axis` as 1.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ data = np.random.rand(128).astype("float32")
+ label = np.random.rand(1).astype("int64")
+ data = paddle.to_tensor(data)
+ label = paddle.to_tensor(label)
+ linear = paddle.nn.Linear(128, 100)
+ x = linear(data)
+ out = paddle.nn.functional.softmax_with_cross_entropy(logits=x, label=label)
+ print(out)
+ """
+ return paddle.nn.functional.loss.fluid_softmax_with_cross_entropy(
+ logits, label, soft_label, ignore_index, numeric_stable_mode,
+ return_softmax, axis)
+
+
+def identity_loss(x, reduction="none"):
+ r"""Marks a tensor as being part of the loss calculation for IPU.
+
+ This operator is used to handle on the (final) loss of a model so that
+ it is used as the start of backpropagation.
+
+ When `reduction` is `none`, return raw `Out`.
+
+ When `reduction` is `mean`, return
+
+ .. math::
+ Out = MEAN(Out)
+
+ When `reduction` is `sum`, return
+
+ .. math::
+ Out = SUM(Out)
+
+ Parameters:
+ x (Variable): The input tensor. The shapes is [N, *], where N is batch size and `*` means any number of
+ additional dimensions. It's data type should be float32, float64 on CPU and float16, float32 on IPU.
+ reduction(str|int, optional): Reduce the loss output. Supported string values are: 'sum', 'mean', 'none'
+ the corresponding int values are 0, 1, 2 respectively. The default value is "none".
+
+ Returns:
+ Variable: The loss ``Tensor`` with the specified reduction applied.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ loss = fluid.data(name="loss", shape=[-1, 1], dtype="float32")
+ out = paddle.incubate.identity_loss(loss, reduction=1)
+ """
+ if isinstance(reduction, str):
+ reduction = {"sum": 0, "mean": 1, "none": 2}.get(reduction.lower())
+ if reduction is None:
+ raise Exception("Unsupported reduction type.")
+
+ if _non_static_mode():
+ return _legacy_C_ops.identity_loss(x, "reduction", reduction)
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], "identity_loss")
+ attrs = {'reduction': reduction}
+ helper = LayerHelper('identity_loss', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type="identity_loss",
+ inputs={"X": x},
+ outputs={"Out": out},
+ attrs=attrs)
+ return out
+
+
+def rank_loss(label, left, right, name=None):
+ r"""
+
+ This operator implements the sort loss layer in the RankNet model. RankNet is a pairwise ranking model
+ with a training sample consisting of a pair of documents (A and B), The label (P)
+ indicates whether A is ranked higher than B or not. Please refer to more details:
+ `RankNet `_
+
+ Rank loss layer takes three inputs: left ( :math:`o_i` ), right ( :math:`o_j` ) and
+ label ( :math:`P_{i,j}` ). The inputs respectively represent RankNet's output scores
+ for documents A and B and the value of label P. Rank loss layer takes batch inputs
+ with size batch_size (batch_size >= 1), P = {0, 1} or {0, 0.5, 1},
+ where 0.5 means that there is no information about the rank of the input pair.
+ The following equation computes rank loss C_{i,j} from the inputs:
+
+ .. math::
+ C_{i,j} &= -\\tilde{P_{ij}} * o_{i,j} + \log(1 + e^{o_{i,j}}) \\\\
+ .. math::
+ o_{i,j} &= o_i - o_j \\\\
+ .. math::
+ \\tilde{P_{i,j}} &= \\left \{0, 0.5, 1 \\right \} \ or \ \\left \{0, 1 \\right \}
+
+ Parameters:
+ label (Variable): 2-D ``Tensor`` with the shape of :math:`[batch,1]`, the data type is float32, batch indicates the size of the data. Indicats whether A ranked higher than B or not.
+ left (Variable): 2-D ``Tensor`` with the shape of :math:`[batch,1]`, the data type is float32. RankNet's output score for doc A.
+ right (Variable): 2-D ``Tensor`` with the shape of :math:`[batch,1]`, the data type is float32. RankNet's output score for doc B.
+ name(str|None): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: ``Tensor`` indicating the output value of the sort loss layer, the data type is float32, and the return value's shape is :math:`[batch,1]` .
+
+ Raises:
+ ValueError: Any of label, left, and right is not a ``Variable`` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ label = fluid.data(name="label", shape=[-1, 1], dtype="float32")
+ left = fluid.data(name="left", shape=[-1, 1], dtype="float32")
+ right = fluid.data(name="right", shape=[-1, 1], dtype="float32")
+ out = fluid.layers.rank_loss(label, left, right)
+
+ """
+ helper = LayerHelper('rank_loss', **locals())
+ check_variable_and_dtype(label, 'label', ['float32'], "rank_loss")
+ check_variable_and_dtype(left, 'left', ['float32'], "rank_loss")
+ check_variable_and_dtype(right, 'right', ['float32'], "rank_loss")
+
+ out = helper.create_variable_for_type_inference("float32")
+
+ helper.append_op(type='rank_loss',
+ inputs={
+ "Label": label,
+ "Left": left,
+ "Right": right
+ },
+ outputs={'Out': out})
+ return out
+
+
+def margin_rank_loss(label, left, right, margin=0.1, name=None):
+ r"""
+ Margin Ranking Loss Layer for ranking problem,
+ which compares left score and right score passed in.
+ The ranking loss can be defined as following equation:
+
+ .. math::
+
+ rank\_loss = max(0, -label * (left - right) + margin)
+
+ Args:
+ label (Variable): Indicates whether the left is ranked higher than the right or not.
+ Data type is float32.
+ left (Variable): Ranking score for left. Data type float32.
+ right (Variable): Ranking score for right. Data type float32.
+ margin (float): Indicates the given margin.
+ name(str|None): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+
+ Returns:
+ Variable: The ranking loss.
+
+ Raises:
+ ValueError: Any of label, left, and right is not a Variable.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ label = fluid.data(name="label", shape=[-1, 1], dtype="float32")
+ left = fluid.data(name="left", shape=[-1, 1], dtype="float32")
+ right = fluid.data(name="right", shape=[-1, 1], dtype="float32")
+ out = fluid.layers.margin_rank_loss(label, left, right)
+ """
+ helper = LayerHelper('margin_rank_loss', **locals())
+ check_variable_and_dtype(label, 'label', ['float32'], 'margin_rank_loss')
+ check_variable_and_dtype(label, 'left', ['float32'], 'margin_rank_loss')
+ check_variable_and_dtype(label, 'right', ['float32'], 'margin_rank_loss')
+ out = helper.create_variable_for_type_inference(left.dtype)
+ act = helper.create_variable_for_type_inference(left.dtype)
+ helper.append_op(type='margin_rank_loss',
+ inputs={
+ "Label": label,
+ "X1": left,
+ "X2": right
+ },
+ outputs={
+ 'Out': out,
+ 'Activated': act
+ },
+ attrs={'margin': margin})
+ return out
+
+
+@templatedoc()
+def sigmoid_cross_entropy_with_logits(x,
+ label,
+ ignore_index=kIgnoreIndex,
+ name=None,
+ normalize=False):
+ """
+
+ ${comment}
+
+ Args:
+ x(Tensor): a 2-D tensor with shape N x D, where N is the batch size and
+ D is the number of classes. This input is a tensor of logits computed
+ by the previous operator. Logits are unscaled log probabilities given
+ as log(p/(1-p)) The data type should be float32 or float64.
+ label (Tensor): a 2-D tensor of the same type and shape as X.
+ This input is a tensor of probabalistic labels for each logit.
+ ignore_index(int): Specifies a target value that is ignored and
+ does not contribute to the input gradient.
+ name(str|None): The default value is None. Normally there is
+ no need for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`
+ normalize(bool): If true, divide the output by the number of
+ targets != ignore_index.
+
+ Returns:
+ out(Tensor): ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+
+ import paddle
+
+ input = paddle.rand(shape=[10], dtype='float32')
+ label = paddle.rand(shape=[10], dtype='float32')
+ loss = paddle.fluid.layers.sigmoid_cross_entropy_with_logits(input, label,
+ ignore_index=-1, normalize=True)
+ print(loss)
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.sigmoid_cross_entropy_with_logits(x, label, normalize,
+ int(ignore_index))
+ check_variable_and_dtype(x, 'input', ['float16', 'float32', 'float64'],
+ 'sigmoid_cross_entropy_with_logits')
+
+ helper = LayerHelper("sigmoid_cross_entropy_with_logits", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(type="sigmoid_cross_entropy_with_logits",
+ inputs={
+ "X": x,
+ "Label": label
+ },
+ attrs={
+ "ignore_index": ignore_index,
+ 'normalize': normalize
+ },
+ outputs={"Out": out})
+ return out
+
+
+def teacher_student_sigmoid_loss(input,
+ label,
+ soft_max_up_bound=15.0,
+ soft_max_lower_bound=-15.0):
+ """
+
+ **Teacher Student Log Loss Layer**
+
+ This layer accepts input predictions and target label and returns the
+ teacher_student loss. Z is click or not, z' is value of teacher loss, label = {-2, -1, [0, 2]}
+ when z' is not exist, clk = 0 : label = -2; when z' is not exist, clk = 1 : label = -1;
+ when z' is exist , clk = 0 : label = 0 + z'; when z' is exist , clk = 1 : label = 1 + z'
+
+ .. math::
+ loss = max(x, 0) - x * z + log(1 + exp(-abs(x))) + max(x, 0) - x * z' + log(1 + exp(-abs(x)))
+
+ Args:
+ input (Variable|list): a 2-D tensor with shape [N x 1], where N is the
+ batch size. This input is a probability computed
+ by the previous operator.
+ label (Variable|list): the ground truth which is a 2-D tensor with
+ shape [N x 1], where N is the batch size.
+ soft_max_up_bound (float): if input > soft_max_up_bound, will be bound
+ soft_max_lower_bound (float): if input < soft_max_lower_bound, will be bound
+
+ Returns:
+ Variable: A 2-D tensor with shape [N x 1], the teacher_student_sigmoid_loss.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ batch_size = 64
+ label = fluid.data(
+ name="label", shape=[batch_size, 1], dtype="int64")
+ similarity = fluid.data(
+ name="similarity", shape=[batch_size, 1], dtype="float32")
+ cost = fluid.layers.teacher_student_sigmoid_loss(input=similarity, label=label)
+
+ """
+ check_variable_and_dtype(input, "input",
+ ['float32', 'float64', 'int32', 'int64'],
+ 'teacher_student_sigmoid_loss')
+ check_variable_and_dtype(label, "label",
+ ['float32', 'float64', 'int32', 'int64'],
+ 'teacher_student_sigmoid_loss')
+
+ helper = LayerHelper('teacher_student_sigmoid_loss', **locals())
+ out = helper.create_variable(dtype=input.dtype)
+ helper.append_op(
+ type='teacher_student_sigmoid_loss',
+ inputs={'X': [input],
+ 'Label': [label]},
+ outputs={'Y': [out]},
+ attrs={"soft_max_lower_bound": float(soft_max_lower_bound), \
+ "soft_max_up_bound": float(soft_max_up_bound)})
+ return out
+
+
+def huber_loss(input, label, delta):
+ r"""
+ This operator computes the Huber loss between input and label.
+ Huber loss is commonly used in regression tasks. Compared to square_error_cost, Huber loss is more robust and less sensitivity to outliers.
+
+ When the absolute difference between input and label is greater than delta, the linear error is calculated:
+
+ .. math::
+ huber\_loss = delta * (label - input) - 0.5 * delta * delta
+
+ When the absolute difference between input and label is greater than delta, the square error is calculated:
+
+ .. math::
+ huber\_loss = 0.5 * (label - input) * (label - input)
+
+
+ Args:
+ input (Variable): Predicted data, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32.
+ label (Variable): Ground truth label, 2D-Tensor with the shape of [batch_size, 1]. The data type should be float32.
+ delta (float): The threshold for Huber loss, which is used to control the balance between the linear error and square error. The data type should be float32.
+
+ Returns:
+ Variable: The huber loss, a tensor with the same shape and data type as input.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ DATATYPE='float32'
+ input_data = np.array([[1.],[2.],[3.],[4.]]).astype(DATATYPE)
+ label_data = np.array([[3.],[3.],[4.],[4.]]).astype(DATATYPE)
+
+ x = fluid.data(name='input', shape=[None, 1], dtype=DATATYPE)
+ y = fluid.data(name='label', shape=[None, 1], dtype=DATATYPE)
+ loss = fluid.layers.huber_loss(input=x, label=y, delta=1.0)
+
+ place = fluid.CPUPlace()
+ #place = fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+ HuberLoss, = exe.run(feed={'input':input_data ,'label':label_data}, fetch_list=[loss.name])
+ print(HuberLoss) #[[1.5], [0.5], [0.5], [0. ]], dtype=float32
+ """
+ if in_dygraph_mode():
+ out, residual = _C_ops.huber_loss(input, label, delta)
+ return out
+
+ helper = LayerHelper('huber_loss', **locals())
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'huber_loss')
+ check_variable_and_dtype(label, 'label', ['float32', 'float64'],
+ 'huber_loss')
+ residual = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(type='huber_loss',
+ inputs={
+ 'X': input,
+ 'Y': label
+ },
+ outputs={
+ 'Out': out,
+ 'Residual': residual
+ },
+ attrs={'delta': delta})
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.kl_div")
+@templatedoc()
+def kldiv_loss(x, target, reduction='mean', name=None):
+ """
+
+ ${comment}
+
+ Args:
+ x (Tensor): ${x_comment}
+ target (Tensor): ${target_comment}
+ reduction (Tensor): ${reduction_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor: The KL divergence loss. The data type is same as input tensor
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ x = paddle.rand(shape=[3,4,2,2], dtype='float32')
+ target = paddle.rand(shape=[3,4,2,2], dtype='float32')
+
+ # 'batchmean' reduction, loss shape will be [1]
+ loss = fluid.layers.kldiv_loss(x=x, target=target, reduction='batchmean')
+ print(loss.shape) # shape=[1]
+
+ # 'mean' reduction, loss shape will be [1]
+ loss = fluid.layers.kldiv_loss(x=x, target=target, reduction='mean')
+ print(loss.shape) # shape=[1]
+
+ # 'sum' reduction, loss shape will be [1]
+ loss = fluid.layers.kldiv_loss(x=x, target=target, reduction='sum')
+ print(loss.shape) # shape=[1]
+
+ # 'none' reduction, loss shape is same with X shape
+ loss = fluid.layers.kldiv_loss(x=x, target=target, reduction='none')
+ print(loss.shape) # shape=[3, 4, 2, 2]
+
+ """
+ helper = LayerHelper('kldiv_loss', **locals())
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'kldiv_loss')
+ check_variable_and_dtype(target, 'target', ['float32', 'float64'],
+ 'kldiv_loss')
+ check_type(reduction, 'reduction', str, 'kldiv_loss')
+ loss = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(type='kldiv_loss',
+ inputs={
+ 'X': x,
+ 'Target': target
+ },
+ outputs={'Loss': loss},
+ attrs={'reduction': reduction})
+ return loss
+
+
+from .ops import square
+from .control_flow import equal
+
+
+def npair_loss(anchor, positive, labels, l2_reg=0.002):
+ """
+
+ Npair loss requires paired data. Npair loss has two parts: the first part is L2
+ regularizer on the embedding vector; the second part is cross entropy loss which
+ takes the similarity matrix of anchor and positive as logits.
+
+ For more information, please refer to:
+ `Improved Deep Metric Learning with Multi class N pair Loss Objective `_
+
+ Args:
+ anchor(Tensor): embedding vector for the anchor image. shape=[batch_size, embedding_dims],
+ the data type is float32 or float64.
+ positive(Tensor): embedding vector for the positive image. shape=[batch_size, embedding_dims],
+ the data type is float32 or float64.
+ labels(Tensor): 1-D tensor. shape=[batch_size], the data type is float32 or float64 or int64.
+ l2_reg(float32): L2 regularization term on embedding vector, default: 0.002.
+
+
+ Returns:
+ A Tensor representing the npair loss, the data type is the same as anchor, the shape is [1].
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ DATATYPE = "float32"
+
+ anchor = paddle.rand(shape=(18, 6), dtype=DATATYPE)
+ positive = paddle.rand(shape=(18, 6), dtype=DATATYPE)
+ labels = paddle.rand(shape=(18,), dtype=DATATYPE)
+
+ npair_loss = paddle.nn.functional.npair_loss(anchor, positive, labels, l2_reg = 0.002)
+ print(npair_loss)
+
+ """
+ return paddle.nn.functional.npair_loss(anchor, positive, labels, l2_reg)
+
+
+def mse_loss(input, label):
+ """
+
+ This op accepts input predications and target label and returns the mean square error.
+
+ The loss can be described as:
+
+ .. math::
+
+ Out = MEAN((input - label)^2)
+
+ Parameters:
+ input (Tensor): Input tensor, the data type should be float32.
+ label (Tensor): Label tensor, the data type should be float32.
+
+ Returns:
+ Tensor: The tensor storing the mean square error difference of input and label.
+
+ Return type: Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ input = paddle.to_tensor([1.1, 1.9])
+ label = paddle.to_tensor([1.0, 2.0])
+ output = paddle.fluid.layers.mse_loss(input, label)
+ print(output.numpy())
+ # [0.01]
+ """
+ check_variable_and_dtype(input, "input", ['float32', 'float64'], 'mse_loss')
+ check_variable_and_dtype(label, "label", ['float32', 'float64'], 'mse_loss')
+ return nn.reduce_mean(square_error_cost(input, label))
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/math_op_patch.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/math_op_patch.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfa74f3505bc970801b230c292eee2b6575c410a
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/math_op_patch.py
@@ -0,0 +1,542 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import warnings
+import inspect
+
+from .. import core
+from ..framework import Variable, unique_name, static_only
+from .layer_function_generator import OpProtoHolder
+from .control_flow import array_write, array_length
+from paddle.fluid.dygraph.base import in_declarative_mode
+
+_supported_int_dtype_ = [
+ core.VarDesc.VarType.BOOL,
+ core.VarDesc.VarType.UINT8,
+ core.VarDesc.VarType.INT8,
+ core.VarDesc.VarType.INT16,
+ core.VarDesc.VarType.INT32,
+ core.VarDesc.VarType.INT64,
+]
+
+compare_ops = ['__eq__', '__ne__', '__lt__', '__le__', '__gt__', '__ge__']
+
+EXPRESSION_MAP = {
+ "__add__": "A + B",
+ "__radd__": "A += B",
+ "__sub__": "A - B",
+ "__rsub__": "A -= B",
+ "__mul__": "A * B",
+ "__rmul__": "A *= B",
+ "__div__": "A / B",
+ "__truediv__": "A / B",
+ "__rdiv__": "A /= B",
+ "__rtruediv__": "A /= B",
+ "__pow__": "A ** B",
+ "__rpow__": "A **= B",
+ "__floordiv__": "A //B",
+ "__mod__": "A % B",
+ "__matmul__": "A @ B",
+ "__eq__": "A == B",
+ "__ne__": "A != B",
+ "__lt__": "A < B",
+ "__le__": "A <= B",
+ "__gt__": "A > B",
+ "__ge__": "A >= B"
+}
+
+_already_patch_variable = False
+
+
+def monkey_patch_variable():
+
+ def unique_tmp_name():
+ return unique_name.generate("tmp")
+
+ def safe_get_dtype(var):
+ try:
+ dtype = var.dtype
+ except:
+ raise ValueError("Cannot get data type from %s", var.name)
+ return dtype
+
+ def current_block(var):
+ return var.block.program.current_block()
+
+ def create_new_tmp_var(block, dtype):
+ tmp_name = unique_tmp_name()
+ return block.create_var(name=tmp_name, dtype=dtype)
+
+ def create_new_tmp_sparse_var(block, dtype, type):
+ tmp_name = unique_tmp_name()
+ return block.create_var(name=tmp_name, dtype=dtype, type=type)
+
+ def create_tensor(block, value, dtype, shape):
+ value = float(value)
+ var = create_new_tmp_var(block, dtype)
+ block.append_op(type="fill_constant",
+ outputs={'Out': [var]},
+ attrs={
+ 'dtype': var.dtype,
+ 'shape': shape,
+ 'value': value,
+ 'force_cpu': False
+ },
+ stop_gradient=True)
+ var.stop_gradient = True
+ return var
+
+ def create_scalar(block, value, dtype):
+ return create_tensor(block, value, dtype, shape=[1])
+
+ def create_tensor_with_batchsize(ref_var, value, dtype):
+ assert isinstance(ref_var, Variable)
+ value = float(value)
+ block = current_block(ref_var)
+ var = create_new_tmp_var(block, dtype)
+ batch_dim = -1
+ out_shape = []
+ for i, d in enumerate(ref_var.shape):
+ if d < 0:
+ if batch_dim < 0:
+ batch_dim = i
+ out_shape.append(d)
+ else:
+ out_shape.append(1)
+ else:
+ out_shape.append(d)
+ assert batch_dim != -1
+ block.append_op(type='fill_constant_batch_size_like',
+ outputs={'Out': [var]},
+ inputs={'Input': [ref_var]},
+ attrs={
+ 'shape': out_shape,
+ 'value': value,
+ 'input_dim_idx': batch_dim,
+ 'output_dim_idx': batch_dim
+ },
+ stop_gradient=True)
+
+ var.stop_gradient = True
+ return var
+
+ @static_only
+ def cpu(self):
+ """
+ Variable should not have cpu() and cuda() interface.
+ But this interface can greatly facilitate dy2static.
+ We do nothing here.
+ """
+ return self
+
+ @static_only
+ def cuda(self):
+ """
+ Variable should not have cpu() and cuda() interface.
+ But this interface can greatly facilitate dy2static.
+ We do nothing here.
+ """
+ return self
+
+ @static_only
+ def place(self):
+ """
+ Variable don't have 'place' interface in static mode
+ But this interface can greatly facilitate dy2static.
+ So we give a warnning here and return None.
+ """
+ warnings.warn(
+ "Variable do not have 'place' interface for static mode, try not to use it. None will be returned."
+ )
+ return None
+
+ def astype(self, dtype):
+ """
+ **Notes**:
+ **The variable must be a** :ref:`api_fluid_Tensor`
+
+ Cast a variable to a specified data type.
+
+ Args:
+
+ self(Variable): The source variable
+
+ dtype: The target data type
+
+ Returns:
+ Variable: Variable with new dtype
+
+ Examples:
+ In Static Graph Mode:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ startup_prog = fluid.Program()
+ main_prog = fluid.Program()
+ with fluid.program_guard(startup_prog, main_prog):
+ original_variable = fluid.data(name = "new_variable", shape=[2,2], dtype='float32')
+ new_variable = original_variable.astype('int64')
+ print("new var's dtype is: {}".format(new_variable.dtype))
+
+ In Dygraph Mode:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ x = np.ones([2, 2], np.float32)
+ with fluid.dygraph.guard():
+ original_variable = fluid.dygraph.to_variable(x)
+ print("original var's dtype is: {}, numpy dtype is {}".format(original_variable.dtype, original_variable.numpy().dtype))
+ new_variable = original_variable.astype('int64')
+ print("new var's dtype is: {}, numpy dtype is {}".format(new_variable.dtype, new_variable.numpy().dtype))
+
+ """
+ block = current_block(self)
+ out = create_new_tmp_var(block, dtype)
+ block.append_op(type="cast",
+ inputs={"X": [self]},
+ outputs={"Out": [out]},
+ attrs={
+ "in_dtype": self.dtype,
+ "out_dtype": out.dtype
+ })
+ out.stop_gradient = self.stop_gradient
+ return out
+
+ @static_only
+ def append(self, var):
+ """
+ **Notes**:
+ **The type variable must be LoD Tensor Array.
+
+ """
+ if not isinstance(var, Variable):
+ if in_declarative_mode():
+ """ in dy2static mode, x may be tensorable values such as int, float, np.array
+ """
+ from paddle.tensor.creation import to_tensor
+ var = to_tensor(var)
+ else:
+ raise TypeError(
+ "Required input var should be Variable, but received {}".
+ format(type(var)))
+ if self.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ raise TypeError(
+ "Only Variable with VarType.LOD_TENSOR_ARRAY support `append` method, but received type: {}"
+ .format(self.type))
+ array_write(x=var, i=array_length(self), array=self)
+
+ @static_only
+ def _item(self):
+ """
+ In order to be compatible with the item interface introduced by the dynamic graph, it does nothing but returns self.
+ It will check that the shape must be a 1-D tensor
+ """
+ if len(self.shape) > 1:
+ raise TypeError(
+ "Required input var should be 1-D Variable, but received {}".
+ format(self.shape))
+ return self
+
+ @static_only
+ def pop(self, *args):
+ """
+ The type variable must be LoD Tensor Array.
+ When self is LoDTensorArray, calling pop is similar to Python's pop on list.
+ This interface is used to simplify dygraph to static graph operations.
+
+ Args:
+ self(Variable): The source variable, which must be LOD_TENSOR_ARRAY
+ *args: optional, a int means index.
+ Returns:
+ Variable: self[index]
+ """
+ from paddle.fluid.dygraph.dygraph_to_static.convert_operators import _run_paddle_pop
+ if self.type != core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ raise TypeError(
+ "Only Variable with VarType.LOD_TENSOR_ARRAY support `append` method, but received type: {}"
+ .format(self.type))
+ return _run_paddle_pop(self, *args)
+
+ def _scalar_op_(var, scale, bias):
+ block = current_block(var)
+ out = create_new_tmp_var(block, var.dtype)
+ block.append_op(type="scale",
+ inputs={"X": [var]},
+ outputs={"Out": [out]},
+ attrs={
+ "scale": scale,
+ "bias": bias
+ })
+ return out
+
+ def _neg_(var):
+ return _scalar_op_(var, -1.0, 0.0)
+
+ @property
+ def _ndim_(self):
+ """
+ Returns the dimension of current Variable
+
+ Returns:
+ the dimension
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+
+ # create a static Variable
+ x = paddle.static.data(name='x', shape=[3, 2, 1])
+ # print the dimension of the Variable
+ print(x.ndim)
+ """
+ return len(self.shape)
+
+ def _scalar_add_(var, value):
+ return _scalar_op_(var, 1.0, value)
+
+ def _scalar_sub_(var, value):
+ return _scalar_op_(var, 1.0, -value)
+
+ def _scalar_rsub_(var, value):
+ return _scalar_op_(var, -1.0, value)
+
+ def _scalar_mul_(var, value):
+ return _scalar_op_(var, value, 0.0)
+
+ def _scalar_div_(var, value):
+ return _scalar_op_(var, 1.0 / value, 0.0)
+
+ def _binary_creator_(method_name,
+ op_type,
+ reverse=False,
+ scalar_method=None):
+
+ def __impl__(self, other_var):
+ # 1. scalar exists cases
+ # we need combine the tensor.dtype and scalar.dtype, cast correct object
+ if isinstance(other_var, float):
+ # in all cases(+, -, *, /, **, //, %), we need cast tensor.dtype to float
+ if self.dtype in _supported_int_dtype_:
+ self = astype(self, 'float32')
+ # here use `scale` replace `elementwise` to get better performance
+ # but only +, -, *, / can use this method
+ if scalar_method is not None:
+ return scalar_method(self, other_var)
+ elif isinstance(other_var, int):
+ # in all cases(+, -, *, /, **, //, %), we can cast it to float
+ # because the output tensor.dtype depend on the type of input tensor
+ other_var = float(other_var)
+ # division is a special case
+ # NOTE(chenweihang): because we cast tensor to float32 instead float64,
+ # the division result can only guarantee the numerical accuracy of 6 digits
+ # after the decimal point. The result of numpy calculation is of float64 type,
+ # so the calculation result here and the calculation result of numpy are
+ # different after 6 decimal point. If necessary, we can also use float64 here.
+ # torch's behavior here is consistent with ours
+ if op_type == 'elementwise_div' and self.dtype in _supported_int_dtype_:
+ self = astype(self, 'float32')
+ # here use `scale` replace `elementwise` to get better performance
+ # but only +, -, *, / can use this method
+ if scalar_method is not None:
+ return scalar_method(self, other_var)
+ else:
+ # do nothing
+ pass
+
+ # 2. create variable for scalar
+ lhs_dtype = safe_get_dtype(self)
+ if not isinstance(other_var, Variable):
+ if reverse:
+ has_batch_size = False
+ for elem in self.shape:
+ if elem < 0:
+ has_batch_size = True
+ break
+ if not has_batch_size:
+ other_var = create_tensor(current_block(self),
+ other_var,
+ dtype=lhs_dtype,
+ shape=self.shape)
+ else:
+ other_var = create_tensor_with_batchsize(
+ self, other_var, lhs_dtype)
+ else:
+ # add fill_op to current_block
+ other_var = create_scalar(current_block(self),
+ value=other_var,
+ dtype=lhs_dtype)
+
+ # 3. unify right var type to left var
+ rhs_dtype = safe_get_dtype(other_var)
+ if lhs_dtype != rhs_dtype:
+ other_var = astype(other_var, lhs_dtype)
+ if reverse:
+ tmp = self
+ self = other_var
+ other_var = tmp
+
+ # NOTE(zhiqiu): the output of compare operator should be bool.
+ if method_name in compare_ops:
+ out = create_new_tmp_var(current_block(self), dtype="bool")
+ else:
+ out = create_new_tmp_var(current_block(self), dtype=lhs_dtype)
+
+ axis = -1
+ if other_var.shape[0] == -1:
+ stack = inspect.stack()[1]
+ file_name = stack[1]
+ line_num = stack[2]
+ warnings.warn(
+ "%s:%s\nThe behavior of expression %s has been unified with %s(X, Y, axis=-1) from Paddle 2.0. "
+ "If your code works well in the older versions but crashes in this version, try to use "
+ "%s(X, Y, axis=0) instead of %s. This transitional warning will be dropped in the future."
+ % (file_name, line_num, EXPRESSION_MAP[method_name],
+ op_type, op_type, EXPRESSION_MAP[method_name]),
+ category=DeprecationWarning)
+ current_block(self).append_op(type=op_type,
+ inputs={
+ 'X': [self],
+ 'Y': [other_var]
+ },
+ outputs={'Out': out},
+ attrs={'axis': axis})
+ return out
+
+ comment = OpProtoHolder.instance().get_op_proto(op_type).comment
+
+ __impl__.__doc__ = """
+ {0}
+ Args:
+ self(Variable): left hand variable
+ other_var(Variable|float|int): right hand variable
+
+ Returns:
+ Variable
+ """.format(comment)
+ __impl__.__name__ = method_name
+ return __impl__
+
+ def values(var):
+ block = current_block(var)
+ out = create_new_tmp_var(block, var.dtype)
+ block.append_op(type="sparse_values",
+ inputs={"x": [var]},
+ outputs={"out": [out]},
+ attrs={})
+ return out
+
+ def indices(var):
+ block = current_block(var)
+ out = create_new_tmp_var(block, var.dtype)
+ block.append_op(type="sparse_indices",
+ inputs={"x": [var]},
+ outputs={"out": [out]},
+ attrs={})
+ return out
+
+ def to_dense(var):
+ block = current_block(var)
+ out = create_new_tmp_var(block, var.dtype)
+ block.append_op(type="sparse_to_dense",
+ inputs={"x": [var]},
+ outputs={"out": [out]},
+ attrs={})
+ return out
+
+ variable_methods = [
+ # b=-a
+ ('__neg__', _neg_),
+ ('astype', astype),
+ ('cpu', cpu),
+ ('cuda', cuda),
+ ('place', place),
+ ('append', append),
+ ('item', _item),
+ ('pop', pop),
+ ('dim', lambda x: len(x.shape)),
+ ('ndimension', lambda x: len(x.shape)),
+ ('ndim', _ndim_),
+ ('__add__',
+ _binary_creator_('__add__', 'elementwise_add', False, _scalar_add_)),
+ # a+b == b+a. Do not need to reverse explicitly
+ ('__radd__',
+ _binary_creator_('__radd__', 'elementwise_add', False, _scalar_add_)),
+ ('__sub__',
+ _binary_creator_('__sub__', 'elementwise_sub', False, _scalar_sub_)),
+ ('__rsub__',
+ _binary_creator_('__rsub__', 'elementwise_sub', True, _scalar_rsub_)),
+ ('__mul__',
+ _binary_creator_('__mul__', 'elementwise_mul', False, _scalar_mul_)),
+ # a*b == b*a. Do not need to reverse explicitly
+ ('__rmul__',
+ _binary_creator_('__rmul__', 'elementwise_mul', False, _scalar_mul_)),
+ ('__div__',
+ _binary_creator_('__div__', 'elementwise_div', False, _scalar_div_)),
+ ('__truediv__',
+ _binary_creator_('__truediv__', 'elementwise_div', False,
+ _scalar_div_)),
+ ('__rdiv__', _binary_creator_('__rdiv__', 'elementwise_div', True,
+ None)),
+ ('__rtruediv__',
+ _binary_creator_('__rtruediv__', 'elementwise_div', True, None)),
+ ('__pow__', _binary_creator_('__pow__', 'elementwise_pow', False,
+ None)),
+ ('__rpow__', _binary_creator_('__rpow__', 'elementwise_pow', True,
+ None)),
+ ('__floordiv__',
+ _binary_creator_('__floordiv__', 'elementwise_floordiv', False, None)),
+ ('__mod__', _binary_creator_('__mod__', 'elementwise_mod', False,
+ None)),
+ ('__matmul__', _binary_creator_('__matmul__', "matmul_v2", False,
+ None)),
+ # for logical compare
+ ('__eq__', _binary_creator_('__eq__', 'equal', False, None)),
+ ('__ne__', _binary_creator_('__ne__', 'not_equal', False, None)),
+ ('__lt__', _binary_creator_('__lt__', 'less_than', False, None)),
+ ('__le__', _binary_creator_('__le__', 'less_equal', False, None)),
+ ('__gt__', _binary_creator_('__gt__', 'greater_than', False, None)),
+ ('__ge__', _binary_creator_('__ge__', 'greater_equal', False, None)),
+ ('values', values),
+ ('indices', indices),
+ ('to_dense', to_dense),
+ ]
+
+ global _already_patch_variable
+ if not _already_patch_variable:
+ for method in variable_methods:
+ method_name = method[0]
+ method_impl = method[1]
+ setattr(Variable, method_name, method_impl)
+ else:
+ import paddle.tensor
+ for method_name in paddle.tensor.tensor_method_func:
+ if hasattr(Variable, method_name): continue
+ method_impl = getattr(paddle.tensor, method_name, None)
+ if method_impl: setattr(Variable, method_name, method_impl)
+
+ for magic_method, origin_method in paddle.tensor.magic_method_func:
+ impl = getattr(paddle.tensor, origin_method, None)
+ if impl: setattr(Variable, magic_method, impl)
+
+ _already_patch_variable = True
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/metric_op.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/metric_op.py
new file mode 100644
index 0000000000000000000000000000000000000000..1df224ed05048261e17f4ca6885a7a36d62fe02c
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/metric_op.py
@@ -0,0 +1,323 @@
+# Copyright (c) 2018 PaddlePaddle 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.
+"""
+All layers just related to metric.
+"""
+
+from __future__ import print_function
+
+import warnings
+from ..layer_helper import LayerHelper
+from ..initializer import Normal, Constant
+from ..framework import (
+ Variable,
+ _non_static_mode,
+ _varbase_creator,
+ _in_legacy_dygraph,
+ in_dygraph_mode,
+)
+from .. import core
+from ..param_attr import ParamAttr
+from . import nn
+from . import tensor
+from ..data_feeder import check_variable_and_dtype
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = ['accuracy', 'auc']
+
+
+def accuracy(input, label, k=1, correct=None, total=None):
+ """
+
+ accuracy layer.
+ Refer to the https://en.wikipedia.org/wiki/Precision_and_recall
+ This function computes the accuracy using the input and label.
+ If the correct label occurs in top k predictions, then correct will increment by one.
+
+ Note:
+ the dtype of accuracy is determined by input. the input and label dtype can be different.
+
+ Args:
+ input(Tensor): The input of accuracy layer, which is the predictions of network. A Tensor with type float32,float64.
+ The shape is ``[sample_number, class_dim]`` .
+ label(Tensor): The label of dataset. Tensor with type int32,int64. The shape is ``[sample_number, 1]`` .
+ k(int, optional): The top k predictions for each class will be checked. Data type is int64 or int32. Default is 1.
+ correct(Tensor, optional): The correct predictions count. A Tensor with type int64 or int32. Default is None.
+ total(Tensor, optional): The total entries count. A tensor with type int64 or int32. Default is None.
+
+ Returns:
+ Tensor, The correct rate. A Tensor with type float32.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle
+ import paddle.static as static
+ import paddle.nn.functional as F
+ paddle.enable_static()
+ data = static.data(name="input", shape=[-1, 32, 32], dtype="float32")
+ label = static.data(name="label", shape=[-1,1], dtype="int")
+ fc_out = static.nn.fc(x=data, size=10)
+ predict = F.softmax(x=fc_out)
+ result = static.accuracy(input=predict, label=label, k=5)
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+ x = np.random.rand(3, 32, 32).astype("float32")
+ y = np.array([[1],[0],[1]])
+ output= exe.run(feed={"input": x,"label": y},
+ fetch_list=[result[0]])
+ print(output)
+ #[array([0.], dtype=float32)]
+
+ """
+ if _non_static_mode():
+ if correct is None:
+ correct = _varbase_creator(dtype="int32")
+ if total is None:
+ total = _varbase_creator(dtype="int32")
+
+ _k = k.numpy().item(0) if isinstance(k, Variable) else k
+ topk_out, topk_indices = _legacy_C_ops.top_k_v2(
+ input, 'k', _k, 'sorted', False
+ )
+ _acc, _, _ = _legacy_C_ops.accuracy(
+ topk_out, topk_indices, label, correct, total
+ )
+ return _acc
+
+ helper = LayerHelper("accuracy", **locals())
+ check_variable_and_dtype(
+ input, 'input', ['float16', 'float32', 'float64'], 'accuracy'
+ )
+ topk_out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ topk_indices = helper.create_variable_for_type_inference(dtype="int64")
+ inputs = {"X": [input]}
+ if isinstance(k, Variable):
+ inputs['K'] = [k]
+ else:
+ attrs = {'k': k}
+ attrs['sorted'] = False
+ helper.append_op(
+ type="top_k_v2",
+ inputs=inputs,
+ attrs=attrs,
+ outputs={"Out": [topk_out], "Indices": [topk_indices]},
+ )
+ acc_out = helper.create_variable_for_type_inference(dtype="float32")
+ if correct is None:
+ correct = helper.create_variable_for_type_inference(dtype="int32")
+ if total is None:
+ total = helper.create_variable_for_type_inference(dtype="int32")
+ helper.append_op(
+ type="accuracy",
+ inputs={"Out": [topk_out], "Indices": [topk_indices], "Label": [label]},
+ outputs={
+ "Accuracy": [acc_out],
+ "Correct": [correct],
+ "Total": [total],
+ },
+ )
+ return acc_out
+
+
+def auc(
+ input,
+ label,
+ curve='ROC',
+ num_thresholds=2**12 - 1,
+ topk=1,
+ slide_steps=1,
+ ins_tag_weight=None,
+):
+ """
+ **Area Under the Curve (AUC) Layer**
+
+ This implementation computes the AUC according to forward output and label.
+ It is used very widely in binary classification evaluation.
+
+ Note: If input label contains values other than 0 and 1, it will be cast
+ to `bool`. Find the relevant definitions `here `_.
+
+ There are two types of possible curves:
+
+ 1. ROC: Receiver operating characteristic;
+ 2. PR: Precision Recall
+
+ Args:
+ input(Tensor): A floating-point 2D Tensor, values are in the range
+ [0, 1]. Each row is sorted in descending order. This
+ input should be the output of topk. Typically, this
+ Tensor indicates the probability of each label.
+ A Tensor with type float32,float64.
+ label(Tensor): A 2D int Tensor indicating the label of the training
+ data. The height is batch size and width is always 1.
+ A Tensor with type int32,int64.
+ curve(str): Curve type, can be 'ROC' or 'PR'. Default 'ROC'.
+ num_thresholds(int): The number of thresholds to use when discretizing
+ the roc curve. Default 4095.
+ topk(int): only topk number of prediction output will be used for auc.
+ slide_steps: when calc batch auc, we can not only use step currently but the previous steps can be used. slide_steps=1 means use the current step, slide_steps=3 means use current step and the previous second steps, slide_steps=0 use all of the steps.
+ ins_tag_weight(Tensor): A 2D int Tensor indicating the data's tag weight, 1 means real data, 0 means fake data. Default None, and it will be assigned to a tensor of value 1.
+ A Tensor with type float32,float64.
+
+ Returns:
+ Tensor: A tuple representing the current AUC.
+ The return tuple is auc_out, batch_auc_out, [
+ batch_stat_pos, batch_stat_neg, stat_pos, stat_neg ]
+ Data type is Tensor, supporting float32, float64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+
+ data = paddle.static.data(name="input", shape=[-1, 32,32], dtype="float32")
+ label = paddle.static.data(name="label", shape=[-1], dtype="int")
+ fc_out = paddle.static.nn.fc(x=data, size=2)
+ predict = paddle.nn.functional.softmax(x=fc_out)
+ result=paddle.static.auc(input=predict, label=label)
+
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+
+ exe.run(paddle.static.default_startup_program())
+ x = np.random.rand(3,32,32).astype("float32")
+ y = np.array([1,0,1])
+ output= exe.run(feed={"input": x,"label": y},
+ fetch_list=[result[0]])
+ print(output)
+
+ #you can learn the usage of ins_tag_weight by the following code.
+ '''
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+
+ data = paddle.static.data(name="input", shape=[-1, 32,32], dtype="float32")
+ label = paddle.static.data(name="label", shape=[-1], dtype="int")
+ ins_tag_weight = paddle.static.data(name='ins_tag', shape=[-1,16], lod_level=0, dtype='float64')
+ fc_out = paddle.static.nn.fc(x=data, size=2)
+ predict = paddle.nn.functional.softmax(x=fc_out)
+ result=paddle.static.auc(input=predict, label=label, ins_tag_weight=ins_tag_weight)
+
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+
+ exe.run(paddle.static.default_startup_program())
+ x = np.random.rand(3,32,32).astype("float32")
+ y = np.array([1,0,1])
+ z = np.array([1,0,1])
+ output= exe.run(feed={"input": x,"label": y, "ins_tag_weight":z},
+ fetch_list=[result[0]])
+ print(output)
+ '''
+
+ """
+ helper = LayerHelper("auc", **locals())
+
+ if ins_tag_weight is None:
+ ins_tag_weight = tensor.fill_constant(
+ shape=[1, 1], dtype="float32", value=1.0
+ )
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'auc')
+ check_variable_and_dtype(label, 'label', ['int32', 'int64'], 'auc')
+ check_variable_and_dtype(
+ ins_tag_weight, 'ins_tag_weight', ['float32', 'float64'], 'auc'
+ )
+ auc_out = helper.create_variable_for_type_inference(dtype="float64")
+ batch_auc_out = helper.create_variable_for_type_inference(dtype="float64")
+ # make tp, tn, fp, fn persistable, so that can accumulate all batches.
+
+ # for batch auc
+ # we create slide_step+1 buckets, the first slide_steps buckets store
+ # historical batch-level values, and the last bucket stores the sum values of
+ # previous slide_step buckets.
+ # The index of bucket that the newest batch will use is determined by batch_id mod slide_steps,
+ # and batch_id is store in the last posision of following variable
+ batch_stat_pos = helper.create_global_variable(
+ persistable=True,
+ dtype='int64',
+ shape=[(1 + slide_steps) * (num_thresholds + 1) + 1],
+ )
+ batch_stat_neg = helper.create_global_variable(
+ persistable=True,
+ dtype='int64',
+ shape=[(1 + slide_steps) * (num_thresholds + 1) + 1],
+ )
+
+ # for global auc
+ # Needn't maintain the batch id
+ stat_pos = helper.create_global_variable(
+ persistable=True, dtype='int64', shape=[1, num_thresholds + 1]
+ )
+ stat_neg = helper.create_global_variable(
+ persistable=True, dtype='int64', shape=[1, num_thresholds + 1]
+ )
+
+ for var in [batch_stat_pos, batch_stat_neg, stat_pos, stat_neg]:
+ helper.set_variable_initializer(
+ var, Constant(value=0.0, force_cpu=False)
+ )
+
+ # "InsTagWeight": [ins_tag_weight]
+ # Batch AUC
+ helper.append_op(
+ type="auc",
+ inputs={
+ "Predict": [input],
+ "Label": [label],
+ "StatPos": [batch_stat_pos],
+ "StatNeg": [batch_stat_neg],
+ },
+ attrs={
+ "curve": curve,
+ "num_thresholds": num_thresholds,
+ "slide_steps": slide_steps,
+ },
+ outputs={
+ "AUC": [batch_auc_out],
+ "StatPosOut": [batch_stat_pos],
+ "StatNegOut": [batch_stat_neg],
+ },
+ )
+ # Global AUC
+ helper.append_op(
+ type="auc",
+ inputs={
+ "Predict": [input],
+ "Label": [label],
+ "StatPos": [stat_pos],
+ "StatNeg": [stat_neg],
+ },
+ attrs={
+ "curve": curve,
+ "num_thresholds": num_thresholds,
+ "slide_steps": 0,
+ },
+ outputs={
+ "AUC": [auc_out],
+ "StatPosOut": [stat_pos],
+ "StatNegOut": [stat_neg],
+ },
+ )
+ return (
+ auc_out,
+ batch_auc_out,
+ [batch_stat_pos, batch_stat_neg, stat_pos, stat_neg],
+ )
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/nn.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/nn.py
new file mode 100644
index 0000000000000000000000000000000000000000..49180f8c9670fb648257edaace136fead6c66a8c
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/nn.py
@@ -0,0 +1,16659 @@
+# Copyright (c) 2018 PaddlePaddle 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.
+"""
+All layers just related to the neural network.
+"""
+from __future__ import print_function
+
+import os
+import inspect
+import warnings
+
+import numpy as np
+import six
+
+import paddle
+from ..layer_helper import LayerHelper
+from paddle.fluid.framework import _in_legacy_dygraph
+from ..initializer import Normal, Constant, NumpyArrayInitializer
+from ..framework import (
+ Variable,
+ OpProtoHolder,
+ _non_static_mode,
+ dygraph_only,
+ _dygraph_tracer,
+ default_main_program,
+ _varbase_creator,
+ static_only,
+ _global_flags,
+ _in_legacy_dygraph,
+ in_dygraph_mode,
+)
+from ..framework import _current_expected_place
+from .. import dygraph_utils
+from ..param_attr import ParamAttr
+from .layer_function_generator import (
+ autodoc,
+ templatedoc,
+ _generate_doc_string_,
+)
+from .tensor import concat, assign, fill_constant, zeros, tensor_array_to_tensor
+from . import utils
+from .. import unique_name
+from functools import reduce
+from .. import core
+from ...utils import deprecated
+from ..data_feeder import (
+ convert_dtype,
+ check_variable_and_dtype,
+ check_type,
+ check_dtype,
+)
+import paddle
+from paddle.utils import deprecated
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'fc',
+ 'embedding',
+ 'linear_chain_crf',
+ 'crf_decoding',
+ 'cos_sim',
+ 'chunk_eval',
+ 'conv2d',
+ 'conv3d',
+ 'softmax',
+ 'pool2d',
+ 'pool3d',
+ 'adaptive_pool2d',
+ 'adaptive_pool3d',
+ 'batch_norm',
+ 'inplace_abn',
+ 'instance_norm',
+ 'data_norm',
+ 'conv2d_transpose',
+ 'conv3d_transpose',
+ 'reduce_sum',
+ 'reduce_mean',
+ 'reduce_max',
+ 'reduce_min',
+ 'reduce_prod',
+ 'reduce_all',
+ 'reduce_any',
+ 'dropout',
+ 'split',
+ 'ctc_greedy_decoder',
+ 'l2_normalize',
+ 'matmul',
+ 'topk',
+ 'transpose',
+ 'im2sequence',
+ 'row_conv',
+ 'multiplex',
+ 'layer_norm',
+ 'group_norm',
+ 'spectral_norm',
+ 'smooth_l1',
+ 'one_hot',
+ 'autoincreased_step_counter',
+ 'reshape',
+ 'squeeze',
+ 'unsqueeze',
+ 'lod_reset',
+ 'lod_append',
+ 'lrn',
+ 'pad',
+ 'pad_constant_like',
+ 'label_smooth',
+ 'roi_pool',
+ 'roi_align',
+ 'dice_loss',
+ 'image_resize',
+ 'image_resize_short',
+ 'resize_linear',
+ 'resize_bilinear',
+ 'resize_trilinear',
+ 'resize_nearest',
+ 'gather',
+ 'gather_nd',
+ 'scatter',
+ 'scatter_nd_add',
+ 'scatter_nd',
+ 'random_crop',
+ 'mean_iou',
+ 'relu',
+ 'selu',
+ 'log',
+ 'crop',
+ 'crop_tensor',
+ 'elu',
+ 'relu6',
+ 'pow',
+ 'stanh',
+ 'hard_sigmoid',
+ 'swish',
+ 'prelu',
+ 'brelu',
+ 'leaky_relu',
+ 'soft_relu',
+ 'flatten',
+ 'stack',
+ 'pad2d',
+ 'unstack',
+ 'unique',
+ 'unique_with_counts',
+ 'expand',
+ 'expand_as',
+ 'scale',
+ 'elementwise_add',
+ 'elementwise_div',
+ 'elementwise_sub',
+ 'elementwise_mul',
+ 'elementwise_max',
+ 'elementwise_min',
+ 'elementwise_pow',
+ 'elementwise_mod',
+ 'elementwise_floordiv',
+ 'uniform_random_batch_size_like',
+ 'gaussian_random',
+ 'sampling_id',
+ 'gaussian_random_batch_size_like',
+ 'sum',
+ 'slice',
+ 'strided_slice',
+ 'shape',
+ 'rank',
+ 'size',
+ 'logical_and',
+ 'logical_or',
+ 'logical_xor',
+ 'logical_not',
+ 'clip',
+ 'clip_by_norm',
+ 'mean',
+ 'mul',
+ 'maxout',
+ 'space_to_depth',
+ 'affine_grid',
+ 'affine_channel',
+ 'similarity_focus',
+ 'hash',
+ 'grid_sampler',
+ 'log_loss',
+ 'add_position_encoding',
+ 'bilinear_tensor_product',
+ 'merge_selected_rows',
+ 'get_tensor_from_selected_rows',
+ 'shuffle_channel',
+ 'temporal_shift',
+ 'py_func',
+ 'psroi_pool',
+ 'prroi_pool',
+ 'pixel_shuffle',
+ 'fsp_matrix',
+ 'continuous_value_model',
+ 'where',
+ 'sign',
+ 'deformable_conv',
+ 'unfold',
+ 'deformable_roi_pooling',
+ 'filter_by_instag',
+ 'shard_index',
+ 'hard_swish',
+ 'mish',
+ 'gather_tree',
+ 'uniform_random',
+ 'unbind',
+]
+
+OP_NAMEMAPPING = {
+ 'elementwise_max': 'maximum',
+ 'elementwise_min': 'minimum',
+ 'elementwise_pow': 'elementwise_pow',
+ 'elementwise_floordiv': 'floor_divide',
+ 'elementwise_add': 'add',
+ 'elementwise_sub': 'subtract',
+ 'elementwise_mul': 'multiply',
+ 'elementwise_div': 'divide',
+ 'elementwise_mod': 'remainder',
+}
+
+
+@dygraph_only
+def _elementwise_op_in_dygraph(
+ x, y, axis=-1, act=None, use_mkldnn=False, op_name=None
+):
+ def is_inplace(op_name):
+ return op_name[-1] == "_"
+
+ if op_name not in OP_NAMEMAPPING.keys() or axis != -1:
+ op = getattr(_legacy_C_ops, op_name)
+ out = op(x, y, 'axis', axis, 'use_mkldnn', use_mkldnn)
+ else:
+ if in_dygraph_mode():
+ op = getattr(
+ _C_ops,
+ OP_NAMEMAPPING[op_name] if not is_inplace(op_name) else op_name,
+ )
+ out = op(x, y)
+
+ if _in_legacy_dygraph():
+ op = getattr(_legacy_C_ops, op_name)
+ out = op(x, y, 'axis', axis, 'use_mkldnn', use_mkldnn)
+ return dygraph_utils._append_activation_in_dygraph(
+ out, act, use_mkldnn=use_mkldnn
+ )
+
+
+def fc(
+ input,
+ size,
+ num_flatten_dims=1,
+ param_attr=None,
+ bias_attr=None,
+ act=None,
+ name=None,
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Fully Connected Layer**
+
+ This operator creates a fully connected layer in the network. It can take
+ a Tensor(or LoDTensor) or a list of Tensor(or LoDTensor) as its inputs(see
+ Args in detail). It creates a variable called weight for each input Tensor,
+ which represents a fully connected weight matrix from each input unit to
+ each output unit. The fully connected layer multiplies each input Tensor
+ with its corresponding weight to produce an output Tensor with shape :math:`[M, size]` ,
+ where M is batch size. If a list of Tensor is given, the results of
+ multiple output Tensors with shape :math:`[M, size]` will be summed up. If :attr:`bias_attr`
+ is not None, a bias variable will be created and added to the output.
+ Finally, if :attr:`act` is not None, it will be applied to the output as well.
+
+ When the input is a single Tensor(or LoDTensor):
+
+ .. math::
+
+ Out = Act({XW + b})
+
+ When the input is a list of Tensor(or LoDTensor):
+
+ .. math::
+
+ Out = Act({\sum_{i=0}^{N-1}X_iW_i + b})
+
+ In the above equation:
+
+ * :math:`N`: Number of the input. N equals to len(input) if input is list of Variable.
+ * :math:`X_i`: The i-th input tensor.
+ * :math:`W_i`: The i-th weights matrix corresponding i-th input tensor.
+ * :math:`b`: The bias parameter created by this layer (if needed).
+ * :math:`Act`: The activation function.
+ * :math:`Out`: The output Tensor.
+
+ .. code-block:: text
+
+ Case 1:
+ Given a single Tensor data_1, and num_flatten_dims = 2:
+ data_1.data = [[[0.1, 0.2],
+ [0.3, 0.4]]]
+ data_1.shape = (1, 2, 2) # 1 is batch_size
+
+ out = fluid.layers.fc(input=data_1, size=1, num_flatten_dims=2)
+
+ Then output is:
+ out.data = [[0.83234344], [0.34936576]]
+ out.shape = (1, 2, 1)
+
+ Case 2:
+ Given a list of Tensor:
+ data_1.data = [[[0.1, 0.2],
+ [0.3, 0.4]]]
+ data_1.shape = (1, 2, 2) # 1 is batch_size
+
+ data_2 = [[[0.1, 0.2, 0.3]]]
+ data_2.shape = (1, 1, 3)
+
+ out = fluid.layers.fc(input=[data_1, data_2], size=2)
+
+ Then:
+ out.data = [[0.18669507, 0.1893476]]
+ out.shape = (1, 2)
+
+ Args:
+ input (Variable|list of Variable): A Tensor(or LoDTensor) with shape :math:`[N_1, N_2,..., N_k]` or
+ a list of Tensor(or LoDTensor). The dimensions of the input Tensor is at least 2 and the data
+ type should be float32 or float64.
+ size(int): The number of output units in this layer, which also means the feature size of output
+ Tensor(or LoDTensor).
+ num_flatten_dims (int): The fc layer can accept an input Tensor with more than
+ two dimensions. If this happens, the multidimensional tensor will first be flattened
+ into a 2-D matrix. The parameter :attr:`num_flatten_dims` determines how the input
+ Tensor is flattened: the first :attr:`num_flatten_dims` (inclusive, index starts from 1)
+ dimensions will be flatten to form the first dimension of the final matrix (height of
+ the matrix), and the rest :math:`rank(X) - num\_flatten\_dims` dimensions are flattened to
+ form the second dimension of the final matrix (width of the matrix). For example, assuming that
+ X is a 5-dimensional Tensor with a shape [2, 3, 4, 5, 6], and :attr:`num_flatten_dims` = 3.
+ Then, the flattened matrix will have a shape [2 x 3 x 4, 5 x 6] = [24, 30]. Default: 1.
+ param_attr (ParamAttr): To specify the weight parameter property. Default: None, which means the
+ default weight parameter property is used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr): To specify the bias parameter property. Default: None, which means the
+ default bias parameter property is used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ act (str): Activation to be applied to the output of this layer, such as tanh, softmax,
+ sigmoid, relu. For more information, please refer to :ref:`api_guide_activations_en` . Default: None.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: Tensor or LoDTensor calculated by fc layer. The data type is same with input.
+
+ Raises:
+ ValueError: If dimensions of the input Tensor is less than 2.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # when input is single tensor
+ data = fluid.data(name="data", shape=[-1, 32], dtype="float32")
+ fc = fluid.layers.fc(input=data, size=1000, act="tanh")
+
+ # when input are multiple tensors
+ data_1 = fluid.data(name="data_1", shape=[-1, 32], dtype="float32")
+ data_2 = fluid.data(name="data_2", shape=[-1, 36], dtype="float32")
+ fc = fluid.layers.fc(input=[data_1, data_2], size=1000, act="tanh")
+ """
+ helper = LayerHelper("fc", **locals())
+ check_type(input, 'input', (list, tuple, Variable), 'fc')
+ if isinstance(input, (list, tuple)):
+ for i, input_x in enumerate(input):
+ check_type(input_x, 'input[' + str(i) + ']', Variable, 'fc')
+ dtype = helper.input_dtype()
+ check_dtype(
+ dtype, 'input', ['float16', 'uint16', 'float32', 'float64'], 'fc'
+ )
+ mul_results = []
+ for input_var, param_attr in helper.iter_inputs_and_params():
+ input_shape = input_var.shape
+ if num_flatten_dims == -1:
+ num_flatten_dims = len(input_shape) - 1
+ param_shape = [
+ reduce(lambda a, b: a * b, input_shape[num_flatten_dims:], 1)
+ ] + [size]
+
+ w = helper.create_parameter(
+ attr=param_attr, shape=param_shape, dtype=dtype, is_bias=False
+ )
+ tmp = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="mul",
+ inputs={"X": input_var, "Y": w},
+ outputs={"Out": tmp},
+ attrs={"x_num_col_dims": num_flatten_dims, "y_num_col_dims": 1},
+ )
+ mul_results.append(tmp)
+
+ if len(mul_results) == 1:
+ pre_bias = mul_results[0]
+ else:
+ pre_bias = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="sum",
+ inputs={"X": mul_results},
+ outputs={"Out": pre_bias},
+ attrs={"use_mkldnn": False},
+ )
+ # add bias
+ pre_activation = helper.append_bias_op(pre_bias, dim_start=num_flatten_dims)
+ # add activation
+ return helper.append_activation(pre_activation)
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.embedding")
+def embedding(
+ input,
+ size,
+ is_sparse=False,
+ is_distributed=False,
+ padding_idx=None,
+ param_attr=None,
+ dtype='float32',
+):
+ r"""
+ :api_attr: Static Graph
+
+ **WARING:** This OP will be deprecated in a future release. This OP requires the
+ last dimension of Tensor shape must be equal to 1. It is recommended to use
+ fluid. :ref:`api_fluid_embedding` .
+
+ The operator is used to lookup embeddings vector of ids provided by :attr:`input` .
+ It automatically constructs a 2D embedding matrix based on the
+ input :attr:`size` (vocab_size, emb_size) and :attr:`dtype` .
+
+ This OP requires the last dimension of Tensor shape must be equal to 1. The shape
+ of output Tensor is generated by replacing the last dimension of the input Tensor shape
+ with emb_size.
+
+ **Note:** The id in :attr:`input` must satisfy :math:`0 =< id < size[0]` ,
+ otherwise the program will throw an exception and exit.
+
+ .. code-block:: text
+
+ Case 1:
+
+ input is a Tensor. padding_idx = -1
+ input.data = [[[1], [3]], [[2], [4]], [[4], [127]]]
+ input.shape = [3, 2, 1]
+ Given size = [128, 16]
+ output is a Tensor:
+ out.shape = [3, 2, 16]
+ out.data = [[[0.129435295, 0.244512452, ..., 0.436322452],
+ [0.345421456, 0.524563927, ..., 0.144534654]],
+
+ [[0.345249859, 0.124939536, ..., 0.194353745],
+ [0.945345345, 0.435394634, ..., 0.435345365]],
+
+ [[0.945345345, 0.435394634, ..., 0.435345365],
+ [0.0, 0.0, ..., 0.0 ]]] # padding data
+ The input padding_idx is less than 0, it is automatically converted to padding_idx = -1 + 128 = 127
+ It will pad all-zero data when ids is 127.
+
+ Case 2:
+
+ input is a LoDTensor with 1-level LoD. padding_idx = 0
+ input.lod = [[2, 3]]
+ input.data = [[1], [3], [2], [4], [0]]
+ input.shape = [5, 1]
+ Given size = [128, 16]
+ output is a LoDTensor:
+ out.lod = [[2, 3]]
+ out.shape = [5, 16]
+ out.data = [[0.129435295, 0.244512452, ..., 0.436322452],
+ [0.345421456, 0.524563927, ..., 0.144534654],
+ [0.345249859, 0.124939536, ..., 0.194353745],
+ [0.945345345, 0.435394634, ..., 0.435345365],
+ [0.0, 0.0, ..., 0.0 ]] # padding data
+ It will pad all-zero data when ids is 0.
+
+ Args:
+ input(Variable): A Tensor or LoDTensor with type int64, which contains the id information.
+ The last dimension of Tensor shape must be equal to 1. The value of the input id should
+ satisfy :math:`0<= id < size[0]` .
+ size(tuple|list): The shape of lookup table parameter. It should have two elements which
+ indicates the size of the dictionary of embeddings and the size of each embedding vector respectively.
+ is_sparse(bool): The flag indicating whether to use sparse update. This parameter only
+ affects the performance of the backwards gradient update. It is recommended to set
+ True because sparse update is faster. But some optimizer does not support sparse update,
+ such as :ref:`api_fluid_optimizer_AdadeltaOptimizer` , :ref:`api_fluid_optimizer_AdamaxOptimizer` ,
+ :ref:`api_fluid_optimizer_DecayedAdagradOptimizer` , :ref:`api_fluid_optimizer_FtrlOptimizer` ,
+ :ref:`api_fluid_optimizer_LambOptimizer` and :ref:`api_fluid_optimizer_LarsMomentumOptimizer` .
+ In these case, is_sparse must be False. Default: False.
+ is_distributed(bool): Whether to store the embedding matrix in a distributed manner. Only used
+ in multi-machine distributed CPU training. Default: False.
+ padding_idx(int|long|None): padding_idx needs to be in the interval [-vocab_size, vocab_size).
+ If :math:`padding\_idx < 0`, the :math:`padding\_idx` will automatically be converted
+ to :math:`vocab\_size + padding\_idx` . It will output all-zero padding data whenever lookup
+ encounters :math:`padding\_idx` in id. And the padding data will not be updated while training.
+ If set None, it makes no effect to output. Default: None.
+ param_attr(ParamAttr): To specify the weight parameter property. Default: None, which means the
+ default weight parameter property is used. See usage for details in :ref:`api_fluid_ParamAttr` . In addition,
+ user-defined or pre-trained word vectors can be loaded with the :attr:`param_attr` parameter.
+ The local word vector needs to be transformed into numpy format, and the shape of local word
+ vector should be consistent with :attr:`size` . Then :ref:`api_fluid_initializer_NumpyArrayInitializer`
+ is used to load custom or pre-trained word vectors. See code example 2 for details.
+ dtype(str|core.VarDesc.VarType): It refers to the data type of output Tensor.
+ It must be float32 or float64. Default: float32.
+
+ Returns:
+ Variable: Embedding Tensor or LoDTensor mapped by input. The data type is the same as :attr:`dtype` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ data = fluid.data(name='x', shape=[None, 1], dtype='int64')
+
+ # example 1
+ emb_1 = fluid.embedding(input=data, size=[128, 64])
+
+ # example 2: load custom or pre-trained word vectors
+ weight_data = np.random.random(size=(128, 100)) # word vectors with numpy format
+ w_param_attrs = fluid.ParamAttr(
+ name="emb_weight",
+ learning_rate=0.5,
+ initializer=fluid.initializer.NumpyArrayInitializer(weight_data),
+ trainable=True)
+ emb_2 = fluid.layers.embedding(input=data, size=(128, 100), param_attr=w_param_attrs, dtype='float32')
+ """
+
+ helper = LayerHelper('embedding', **locals())
+ check_variable_and_dtype(
+ input, 'input', ['int64'], 'fluid.layers.embedding'
+ )
+ check_dtype(
+ dtype,
+ 'dtype',
+ ['uint16', 'float16', 'float32', 'float64'],
+ 'fluid.layers.embedding',
+ )
+
+ if is_distributed:
+ is_distributed = False
+ warnings.warn(
+ "is_distributed is go out of use, `fluid.contrib.layers.sparse_embedding` is your needed"
+ )
+
+ remote_prefetch = True if is_sparse else False
+
+ w = helper.create_parameter(
+ attr=helper.param_attr, shape=size, dtype=dtype, is_bias=False
+ )
+ tmp = helper.create_variable_for_type_inference(dtype)
+ padding_idx = (
+ -1
+ if padding_idx is None
+ else padding_idx
+ if padding_idx >= 0
+ else (size[0] + padding_idx)
+ )
+ helper.append_op(
+ type='lookup_table',
+ inputs={'Ids': input, 'W': w},
+ outputs={'Out': tmp},
+ attrs={
+ 'is_sparse': is_sparse,
+ 'is_distributed': is_distributed,
+ 'remote_prefetch': remote_prefetch,
+ 'padding_idx': padding_idx,
+ },
+ )
+ return tmp
+
+
+def _pull_sparse(
+ input,
+ size,
+ table_id,
+ accessor_class,
+ name="embedding",
+ ctr_label_name="",
+ padding_id=0,
+ dtype='float32',
+ scale_sparse_grad=True,
+):
+ r"""
+ **Pull Fleet Sparse Layer**
+
+ This layer is used to lookup embeddings of IDs, provided by :attr:`input`, in
+ Fleet lookup table. The result of this lookup is the embedding of each ID in the
+ :attr:`input`.
+
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable, which
+ contains the IDs information.
+ size(int): The embedding size parameter, which indicates the size of
+ each embedding vector respectively.
+ table_id(int): the fleet table id of this embedding.
+ accessor_class(str): the pslib accessor of the table, default is DownpourCtrAccessor.
+ ctr_label_name(str): the layer name of click.
+ padding_id(int): the padding id during lookup, default is 0.
+ dtype(str): The dtype refers to the data type of output tensor. Only supports
+ float32 now.
+ scale_sparse_grad(bool): whether to scale sparse gradient with batch size. default
+ is True.
+
+ Returns:
+ Variable|list of Variable: The tensor variable storing the embeddings of the \
+ supplied inputs.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
+ emb = fluid.layers.nn._pull_sparse(
+ input=data, size=11, table_id=0, accessor_class="DownpourCtrAccessor")
+ """
+ helper = LayerHelper(name, **locals())
+ inputs = helper.multiple_input()
+ outs = [helper.create_variable_for_type_inference(dtype)]
+ input_names = [i.name for i in inputs]
+ attrs = {
+ 'EmbeddingDim': size,
+ 'TableId': table_id,
+ 'AccessorClass': accessor_class,
+ 'CtrLabelName': ctr_label_name,
+ 'PaddingId': padding_id,
+ 'ScaleSparseGrad': scale_sparse_grad,
+ 'InputNames': input_names,
+ # this is only for compatible with embedding op
+ 'is_distributed': True,
+ }
+ # this is only for compatible with embedding op
+ w, _ = helper.create_or_get_global_variable(
+ name=name, shape=[size], dtype=dtype, is_bias=False, persistable=True
+ )
+ helper.append_op(
+ type='pull_sparse',
+ inputs={'Ids': inputs, 'W': w},
+ outputs={'Out': outs},
+ attrs=attrs,
+ )
+ if len(outs) == 1:
+ return outs[0]
+ return outs
+
+
+def _pull_sparse_v2(
+ input,
+ size,
+ table_id,
+ accessor_class,
+ name="embedding",
+ ctr_label_name="",
+ padding_id=0,
+ dtype='float32',
+ scale_sparse_grad=True,
+):
+ r"""
+ **Pull Fleet Sparse Layer**
+
+ This layer is used to lookup embeddings of IDs, provided by :attr:`input`, in
+ Fleet lookup table. The result of this lookup is the embedding of each ID in the
+ :attr:`input`.
+
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable, which
+ contains the IDs information.
+ size(int): The embedding size parameter, which indicates the size of
+ each embedding vector respectively.
+ table_id(int): the pslib table id of this embedding.
+ accessor_class(str): the fleet accessor of the table, default is DownpourCtrAccessor.
+ ctr_label_name(str): the layer name of click.
+ padding_id(int): the padding id during lookup, default is 0.
+ dtype(str): The dtype refers to the data type of output tensor. Only supports
+ float32 now.
+ scale_sparse_grad(bool): whether to scale sparse gradient with batch size. default
+ is True.
+
+ Returns:
+ Variable|list of Variable: The tensor variable storing the embeddings of the \
+ supplied inputs.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
+ emb = fluid.layers.nn._pull_sparse_v2(
+ input=data, size=11, table_id=0, accessor_class="DownpourCtrAccessor")
+ """
+ helper = LayerHelper(name, **locals())
+ inputs = helper.multiple_input()
+ outs = [helper.create_variable_for_type_inference(dtype)]
+ input_names = [i.name for i in inputs]
+ attrs = {
+ 'EmbeddingDim': size,
+ 'TableId': table_id,
+ 'AccessorClass': accessor_class,
+ 'CtrLabelName': ctr_label_name,
+ 'PaddingId': padding_id,
+ 'ScaleSparseGrad': scale_sparse_grad,
+ 'InputNames': input_names,
+ # this is only for compatible with embedding op
+ 'is_distributed': True,
+ }
+ # this is only for compatible with embedding op
+ w, _ = helper.create_or_get_global_variable(
+ name=name, shape=[size], dtype=dtype, is_bias=False, persistable=True
+ )
+ helper.append_op(
+ type='pull_sparse_v2',
+ inputs={'Ids': inputs, 'W': w},
+ outputs={'Out': outs},
+ attrs=attrs,
+ )
+ if len(outs) == 1:
+ return outs[0]
+ return outs
+
+
+def _pull_gpups_sparse(
+ input, size, dtype='float32', is_distributed=False, is_sparse=False
+):
+ r"""
+ **Pull GpuPS Sparse Layer**
+
+ This layer is used to lookup embeddings of IDs, provided by :attr:`input`, in
+ GpuPS lookup table. The result of this lookup is the embedding of each ID in the
+ :attr:`input`.
+
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable, which
+ contains the IDs information.
+ size(int|list of int): The embedding size parameter of each input, which indicates the size of
+ each embedding vector respectively.
+ dtype(str): The dtype refers to the data type of output tensor. Only supports
+ float32 now.
+
+ Returns:
+ Variable|list of Variable: The tensor variable storing the embeddings of the \
+ supplied inputs, whose size are indicated by size respectively.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ slots = []
+ data_1 = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
+ slots.append(data_1)
+ data_2 = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
+ slots.append(data_2)
+ embs = fluid.layers.pull_gpups_sparse(input=slots, size=[11, 35])
+ """
+ helper = LayerHelper('pull_gpups_sparse', **locals())
+ if dtype != 'float32':
+ raise ValueError(
+ "GpuPS only support float type embedding now, and your type is: "
+ + dtype
+ )
+ helper.input_dtype()
+ inputs = helper.multiple_input()
+ outs = [
+ helper.create_variable_for_type_inference(dtype)
+ for i in range(len(inputs))
+ ]
+ w = helper.create_parameter(
+ attr=helper.param_attr, shape=[size[0]], dtype=dtype, is_bias=False
+ )
+ helper.append_op(
+ type='pull_gpups_sparse',
+ inputs={'Ids': inputs, 'W': w},
+ outputs={'Out': outs},
+ attrs={
+ 'size': size,
+ 'is_distributed': is_distributed,
+ 'is_sparse': is_sparse,
+ },
+ )
+ if len(outs) == 1:
+ return outs[0]
+ return outs
+
+
+def _pull_box_sparse(
+ input, size, dtype='float32', is_distributed=False, is_sparse=False
+):
+ r"""
+ **Pull Box Sparse Layer**
+
+ This layer is used to lookup embeddings of IDs, provided by :attr:`input`, in
+ BoxPS lookup table. The result of this lookup is the embedding of each ID in the
+ :attr:`input`.
+
+ Args:
+ input(Variable|list of Variable): Input is a Tensor Variable, which
+ contains the IDs information.
+ size(int): The embedding size parameter, which indicates the size of
+ each embedding vector respectively.
+ dtype(str): The dtype refers to the data type of output tensor. Only supports
+ float32 now.
+
+ Returns:
+ Variable|list of Variable: The tensor variable storing the embeddings of the \
+ supplied inputs.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
+ emb = fluid.layers.pull_box_sparse(input=data, size=[11])
+ """
+ helper = LayerHelper('pull_box_sparse', **locals())
+ if dtype != 'float32':
+ raise ValueError(
+ "BoxPS only support float type embedding now, and your type is: "
+ + dtype
+ )
+ helper.input_dtype()
+ inputs = helper.multiple_input()
+ outs = [
+ helper.create_variable_for_type_inference(dtype)
+ for i in range(len(inputs))
+ ]
+ w = helper.create_parameter(
+ attr=helper.param_attr, shape=[size], dtype=dtype, is_bias=False
+ )
+ helper.append_op(
+ type='pull_box_sparse',
+ inputs={'Ids': inputs, 'W': w},
+ outputs={'Out': outs},
+ attrs={
+ 'size': size,
+ 'is_distributed': is_distributed,
+ 'is_sparse': is_sparse,
+ },
+ )
+ if len(outs) == 1:
+ return outs[0]
+ return outs
+
+
+@templatedoc()
+def linear_chain_crf(input, label, param_attr=None, length=None):
+ """
+ :api_attr: Static Graph
+
+ Linear Chain CRF.
+
+ ${comment}
+
+ Args:
+ input(${emission_type}): ${emission_comment}
+ label(${label_type}): ${label_comment}
+ Length(${length_type}): ${length_comment}
+ param_attr(ParamAttr): The attribute of the learnable parameter for transition parameter.
+
+ Returns:
+ output(${emission_exps_type}): ${emission_exps_comment} \n
+ output(${transition_exps_type}): ${transition_exps_comment} \n
+ output(${log_likelihood_type}): ${log_likelihood_comment} \n
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ #define net structure, using LodTensor
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ input_data = fluid.data(name='input_data', shape=[-1,10], dtype='float32')
+ label = fluid.data(name='label', shape=[-1,1], dtype='int')
+ emission= fluid.layers.fc(input=input_data, size=10, act="tanh")
+ crf_cost = fluid.layers.linear_chain_crf(
+ input=emission,
+ label=label,
+ param_attr=fluid.ParamAttr(
+ name='crfw',
+ learning_rate=0.01))
+ use_cuda = False
+ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(startup_program)
+ #define data, using LoDTensor
+ a = fluid.create_lod_tensor(np.random.rand(12,10).astype('float32'), [[3,3,4,2]], place)
+ b = fluid.create_lod_tensor(np.array([[1],[1],[2],[3],[1],[1],[1],[3],[1],[1],[1],[1]]),[[3,3,4,2]] , place)
+ feed1 = {'input_data':a,'label':b}
+ loss= exe.run(train_program,feed=feed1, fetch_list=[crf_cost])
+ print(loss)
+
+ #define net structure, using padding
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ input_data2 = fluid.data(name='input_data2', shape=[-1,10,10], dtype='float32')
+ label2 = fluid.data(name='label2', shape=[-1,10,1], dtype='int')
+ label_length = fluid.data(name='length', shape=[-1,1], dtype='int')
+ emission2= fluid.layers.fc(input=input_data2, size=10, act="tanh", num_flatten_dims=2)
+ crf_cost2 = fluid.layers.linear_chain_crf(
+ input=emission2,
+ label=label2,
+ length=label_length,
+ param_attr=fluid.ParamAttr(
+ name='crfw',
+ learning_rate=0.01))
+
+ use_cuda = False
+ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(startup_program)
+
+ #define data, using padding
+ cc=np.random.rand(4,10,10).astype('float32')
+ dd=np.random.rand(4,10,1).astype('int64')
+ ll=np.array([[3],[3],[4],[2]])
+ feed2 = {'input_data2':cc,'label2':dd,'length':ll}
+ loss2= exe.run(train_program,feed=feed2, fetch_list=[crf_cost2])
+ print(loss2)
+ #[array([[ 7.8902354],
+ # [ 7.3602567],
+ # [ 10.004011],
+ # [ 5.86721 ]], dtype=float32)]
+
+ #you can use find_var to get transition parameter.
+ transition=np.array(fluid.global_scope().find_var('crfw').get_tensor())
+ print(transition)
+
+ """
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'linear_chain_crf'
+ )
+ check_variable_and_dtype(label, 'label', ['int64'], 'linear_chain_crf')
+ helper = LayerHelper('linear_chain_crf', **locals())
+ size = input.shape[2] if length else input.shape[1]
+ transition = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=[size + 2, size],
+ dtype=helper.input_dtype(),
+ )
+ alpha = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype()
+ )
+ emission_exps = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype()
+ )
+ transition_exps = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype()
+ )
+ log_likelihood = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype()
+ )
+ this_inputs = {
+ "Emission": [input],
+ "Transition": transition,
+ "Label": [label],
+ }
+ if length:
+ this_inputs['Length'] = [length]
+ helper.append_op(
+ type='linear_chain_crf',
+ inputs=this_inputs,
+ outputs={
+ "Alpha": [alpha],
+ "EmissionExps": [emission_exps],
+ "TransitionExps": transition_exps,
+ "LogLikelihood": log_likelihood,
+ },
+ )
+
+ return log_likelihood
+
+
+@templatedoc()
+def crf_decoding(input, param_attr, label=None, length=None):
+ """
+ :api_attr: Static Graph
+
+ ${comment}
+
+ Args:
+ input(Tensor): ${emission_comment}
+
+ param_attr (ParamAttr|None): To specify the weight parameter attribute.
+ Default: None, which means the default weight parameter property is
+ used. See usage for details in :ref:`api_paddle_fluid_param_attr_ParamAttr` .
+
+ label(${label_type}, optional): ${label_comment}
+
+ length(${length_type}, optional): ${length_comment}
+
+ Returns:
+ Tensor: ${viterbi_path_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ # LoDTensor-based example
+ num_labels = 10
+ feature = paddle.static.data(name='word_emb', shape=[-1, 784], dtype='float32', lod_level=1)
+ label = paddle.static.data(name='label', shape=[-1, 1], dtype='int64', lod_level=1)
+ emission = paddle.static.nn.fc(feature, size=num_labels)
+
+ crf_cost = paddle.fluid.layers.linear_chain_crf(input=emission, label=label,
+ param_attr=paddle.ParamAttr(name="crfw"))
+ crf_decode = paddle.static.nn.crf_decoding(input=emission,
+ param_attr=paddle.ParamAttr(name="crfw"))
+
+ # Common tensor example
+ num_labels, max_len = 10, 20
+ feature = paddle.static.data(name='word_emb_pad', shape=[-1, max_len, 784], dtype='float32')
+ label = paddle.static.data(name='label_pad', shape=[-1, max_len, 1], dtype='int64')
+ length = paddle.static.data(name='length', shape=[-1, 1], dtype='int64')
+ emission = paddle.static.nn.fc(feature, size=num_labels,
+ num_flatten_dims=2)
+
+ crf_cost = paddle.fluid.layers.linear_chain_crf(input=emission, label=label, length=length,
+ param_attr=paddle.ParamAttr(name="crfw_pad"))
+ crf_decode = paddle.static.nn.crf_decoding(input=emission, length=length,
+ param_attr=paddle.ParamAttr(name="crfw_pad"))
+ """
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'crf_decoding'
+ )
+ helper = LayerHelper('crf_decoding', **locals())
+ transition = helper.get_parameter(param_attr.name)
+ viterbi_path = helper.create_variable_for_type_inference(
+ dtype=core.VarDesc.VarType.INT64
+ )
+ inputs = {"Emission": [input], "Transition": transition, "Label": label}
+ if length:
+ inputs['Length'] = length
+ helper.append_op(
+ type='crf_decoding',
+ inputs=inputs,
+ outputs={"ViterbiPath": [viterbi_path]},
+ )
+
+ return viterbi_path
+
+
+@templatedoc()
+def cos_sim(X, Y):
+ """
+ ${comment}
+
+ Args:
+ X (Tensor): ${x_comment}.
+ Y (Tensor): ${y_comment}.
+
+ Returns:
+ A Tensor representing the output of cosine(X, Y).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.rand(shape=[3, 7], dtype='float32')
+ y = paddle.rand(shape=[1, 7], dtype='float32')
+ out = paddle.fluid.layers.cos_sim(x, y)
+ print(out)
+
+ """
+ check_variable_and_dtype(X, 'X', ['float32'], 'cos_sim')
+ check_variable_and_dtype(Y, 'Y', ['float32'], 'cos_sim')
+ helper = LayerHelper('cos_sim', **locals())
+ out = helper.create_variable_for_type_inference(dtype=X.dtype)
+ xnorm = helper.create_variable_for_type_inference(dtype=X.dtype)
+ ynorm = helper.create_variable_for_type_inference(dtype=X.dtype)
+ helper.append_op(
+ type='cos_sim',
+ inputs={'X': [X], 'Y': [Y]},
+ outputs={'Out': [out], 'XNorm': [xnorm], 'YNorm': [ynorm]},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.dropout")
+def dropout(
+ x,
+ dropout_prob,
+ is_test=None,
+ seed=None,
+ name=None,
+ dropout_implementation="downgrade_in_infer",
+):
+ """
+
+ Computes dropout.
+
+ Drop or keep each element of `x` independently. Dropout is a regularization
+ technique for reducing overfitting by preventing neuron co-adaption during
+ training. The dropout operator randomly sets (according to the given dropout
+ probability) the outputs of some units to zero, while others are remain
+ unchanged.
+
+ dropout op can be removed from the program to make the program more efficient.
+
+ Args:
+ x (Variable): The input tensor variable. The data type is float16 or float32 or float64.
+ dropout_prob (float): Probability of setting units to zero.
+ is_test (bool): A flag indicating whether it is in test phrase or not.
+ Default None, in dynamic graph, it use global tracer mode; in static graph, it means False.
+ seed (int): A Python integer used to create random seeds. If this
+ parameter is set to None, a random seed is used.
+ NOTE: If an integer seed is given, always the same output
+ units will be dropped. DO NOT use a fixed seed in training.Default: None.
+ name (str|None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+ dropout_implementation(string): ['downgrade_in_infer'(default)|'upscale_in_train']
+
+ 1. downgrade_in_infer(default), downgrade the outcome at inference
+
+ - train: out = input * mask
+ - inference: out = input * (1.0 - dropout_prob)
+
+ (mask is a tensor same shape with input, value is 0 or 1
+ ratio of 0 is dropout_prob)
+ 2. upscale_in_train, upscale the outcome at training time
+
+ - train: out = input * mask / ( 1.0 - dropout_prob )
+ - inference: out = input
+
+ (mask is a tensor same shape with input, value is 0 or 1
+ ratio of 0 is dropout_prob)
+
+
+ Returns:
+ A Variable holding Tensor representing the dropout, has same shape and data type with `x`.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.enable_static()
+ x = fluid.data(name="data", shape=[None, 32, 32], dtype="float32")
+ dropped = fluid.layers.dropout(x, dropout_prob=0.5)
+ """
+ if not isinstance(dropout_prob, (float, int, Variable)):
+ raise TypeError(
+ "dropout_prob argument should be a number(int|float) or Variable"
+ )
+ # fast return for p == 0
+ if isinstance(dropout_prob, (int, float)) and dropout_prob == 0:
+ return x
+
+ if _non_static_mode():
+ if (
+ seed is None or seed == 0
+ ) and default_main_program().random_seed != 0:
+ seed = default_main_program().random_seed
+ if is_test is None:
+ is_test = not _dygraph_tracer()._train_mode
+ out, mask = _legacy_C_ops.dropout(
+ x,
+ 'dropout_prob',
+ dropout_prob,
+ 'is_test',
+ is_test,
+ 'fix_seed',
+ seed is not None,
+ 'seed',
+ seed if seed is not None else 0,
+ 'dropout_implementation',
+ dropout_implementation,
+ )
+ return out
+
+ def get_attrs(prog, dropout_prob, is_test, seed):
+ if (seed is None or seed == 0) and prog.random_seed != 0:
+ seed = prog.random_seed
+ if isinstance(dropout_prob, Variable) and not dropout_prob.shape != [1]:
+ raise TypeError(
+ "Required dropout_prob.shape == [1] if type(dropout_prob) is Variable, but received dropout_prob.shape = {}".format(
+ dropout_prob.shape
+ )
+ )
+ attrs = {
+ 'dropout_prob': dropout_prob,
+ 'is_test': is_test,
+ 'fix_seed': seed is not None,
+ 'seed': seed if seed is not None else 0,
+ 'dropout_implementation': dropout_implementation,
+ }
+ return attrs
+
+ helper = LayerHelper('dropout', **locals())
+ check_variable_and_dtype(
+ x, 'x', ['float16', 'float32', 'float64'], 'dropout'
+ )
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ mask = helper.create_variable_for_type_inference(
+ dtype=core.VarDesc.VarType.UINT8, stop_gradient=True
+ )
+
+ attrs = get_attrs(helper.main_program, dropout_prob, is_test, seed)
+
+ helper.append_op(
+ type='dropout',
+ inputs={'X': [x]},
+ outputs={'Out': [out], 'Mask': [mask]},
+ attrs=attrs,
+ )
+ return out
+
+
+@templatedoc()
+def chunk_eval(
+ input,
+ label,
+ chunk_scheme,
+ num_chunk_types,
+ excluded_chunk_types=None,
+ seq_length=None,
+):
+ r"""
+ This operator computes the precision, recall and F1-score for chunk detection.
+ It is often used in sequence tagging tasks, such as Named Entity Recognition(NER).
+
+ For some basics of chunking, please refer to
+ `Chunking with Support Vector Machines `_ .
+
+ This operator supports IOB, IOE, IOBES and IO (also known as plain) tagging schemes.
+ Here is a NER example for the usage of these tagging schemes:
+
+ .. code-block:: python
+
+ ====== ====== ====== ===== == ============ ===== ===== ===== == =========
+ Li Ming works at Agricultural Bank of China in Beijing.
+ ====== ====== ====== ===== == ============ ===== ===== ===== == =========
+ IO I-PER I-PER O O I-ORG I-ORG I-ORG I-ORG O I-LOC
+ IOB B-PER I-PER O O B-ORG I-ORG I-ORG I-ORG O B-LOC
+ IOE I-PER E-PER O O I-ORG I-ORG I-ORG E-ORG O E-LOC
+ IOBES B-PER E-PER O O I-ORG I-ORG I-ORG E-ORG O S-LOC
+ ====== ====== ====== ===== == ============ ===== ===== ===== == =========
+
+ There are three chunk types(named entity types) including PER(person), ORG(organization)
+ and LOC(location), and we can see that the labels have the form `-` .
+
+ Since the implementation of this operator actually uses label ids rather than
+ label strings, to make it work, there should be a way to map label ids to
+ tag types and chunk types. This operator uses the following way to do mapping:
+
+ .. code-block:: python
+
+ tag_type = label % num_tag_type
+ chunk_type = label / num_tag_type
+
+ where `num_tag_type` is the num of tag types in the tagging scheme, `num_chunk_type`
+ is the num of chunk types, and `tag_type` get its value from the following table.
+
+ .. code-block:: python
+
+ Scheme Begin Inside End Single
+ plain 0 - - -
+ IOB 0 1 - -
+ IOE - 0 1 -
+ IOBES 0 1 2 3
+
+ Accordingly, in the above NER example, if the tagging scheme is IOB and chunk
+ types are ORG, PER and LOC, then the label ids would be as follows:
+
+ .. code-block:: python
+
+ B-ORG 0
+ I-ORG 1
+ B-PER 2
+ I-PER 3
+ B-LOC 4
+ I-LOC 5
+ O 6
+
+ With which we can map each label id to the corresponding tag type and chunk
+ type correctly.
+
+ Args:
+ input (Tensor): A Tensor representing the predicted labels
+ from the network. Its shape would be `[N, M, 1]`,
+ where `N` stands for batch size, `M` for sequence length.
+ The data type should be int64.
+ label (Tensor): A Tensor representing the ground-truth labels.
+ It should have the same shape, lod and data type as ``input`` .
+ chunk_scheme (str): Indicate the tagging schemes used here. The value must
+ be IOB, IOE, IOBES or plain.
+ num_chunk_types (int): The number of chunk types.
+ excluded_chunk_types (list, optional): Indicate the chunk types shouldn't
+ be taken into account. It should be a list of chunk type ids(integer).
+ Default None.
+ seq_length(Tensor, optional): A 1D Tensor containing the length of each
+ sequence when ``input`` and ``label`` are Tensor. Default None.
+
+ Returns:
+ tuple: A tuple including precision, recall, F1-score, chunk number detected, \
+ chunk number in ground-truth, chunk number correctly detected. Each \
+ is a Tensor with shape `[1]`. The data type of precision, recall and \
+ F1-score all is float32, and the others' data type all is int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ dict_size = 10000
+ label_dict_len = 7
+ sequence = fluid.data(
+ name='id', shape=[None, 1], lod_level=1, dtype='int64')
+ embedding = fluid.embedding(
+ input=sequence, size=[dict_size, 512])
+ hidden = fluid.layers.fc(input=embedding, size=512)
+ label = fluid.data(
+ name='label', shape=[None, 1], lod_level=1, dtype='int64')
+ crf = fluid.layers.linear_chain_crf(
+ input=hidden, label=label, param_attr=fluid.ParamAttr(name="crfw"))
+ crf_decode = fluid.layers.crf_decoding(
+ input=hidden, param_attr=fluid.ParamAttr(name="crfw"))
+ fluid.layers.chunk_eval(
+ input=crf_decode,
+ label=label,
+ chunk_scheme="IOB",
+ num_chunk_types=int((label_dict_len - 1) / 2))
+ """
+ helper = LayerHelper("chunk_eval", **locals())
+
+ check_variable_and_dtype(input, 'input', ['int64'], 'chunk_eval')
+ check_variable_and_dtype(label, 'label', ['int64'], 'chunk_eval')
+
+ # prepare output
+ precision = helper.create_variable_for_type_inference(dtype="float32")
+ recall = helper.create_variable_for_type_inference(dtype="float32")
+ f1_score = helper.create_variable_for_type_inference(dtype="float32")
+ num_infer_chunks = helper.create_variable_for_type_inference(dtype="int64")
+ num_label_chunks = helper.create_variable_for_type_inference(dtype="int64")
+ num_correct_chunks = helper.create_variable_for_type_inference(
+ dtype="int64"
+ )
+
+ this_input = {"Inference": [input], "Label": [label]}
+
+ if seq_length is not None:
+ this_input["SeqLength"] = [seq_length]
+
+ helper.append_op(
+ type="chunk_eval",
+ inputs=this_input,
+ outputs={
+ "Precision": [precision],
+ "Recall": [recall],
+ "F1-Score": [f1_score],
+ "NumInferChunks": [num_infer_chunks],
+ "NumLabelChunks": [num_label_chunks],
+ "NumCorrectChunks": [num_correct_chunks],
+ },
+ attrs={
+ "num_chunk_types": num_chunk_types,
+ "chunk_scheme": chunk_scheme,
+ "excluded_chunk_types": excluded_chunk_types or [],
+ },
+ )
+ return (
+ precision,
+ recall,
+ f1_score,
+ num_infer_chunks,
+ num_label_chunks,
+ num_correct_chunks,
+ )
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.softmax")
+def softmax(input, use_cudnn=True, name=None, axis=-1):
+ r"""
+ This operator implements the softmax layer. The calculation process is as follows:
+
+ 1. The dimension :attr:`axis` of the ``input`` will be permuted to the last.
+
+ 2. Then the input tensor will be logically flattened to a 2-D matrix. The matrix's
+ second dimension(row length) is the same as the dimension :attr:`axis` of the input
+ tensor, and the first dimension(column length) is the product of all other
+ dimensions of the input tensor. For each row of the matrix, the softmax operator
+ squashes the K-dimensional(K is the width of the matrix, which is also the size
+ of the input tensor's dimension :attr:`axis`) vector of arbitrary real values to a
+ K-dimensional vector of real values in the range [0, 1] that add up to 1.
+
+ 3. After the softmax operation is completed, the inverse operations of steps 1 and 2
+ are performed to restore the two-dimensional matrix to the same dimension as the ``input``.
+
+ It computes the exponential of the given dimension and the sum of exponential
+ values of all the other dimensions in the K-dimensional vector input.
+ Then the ratio of the exponential of the given dimension and the sum of
+ exponential values of all the other dimensions is the output of the softmax
+ operator.
+
+ For each row :math:`i` and each column :math:`j` in the matrix, we have:
+
+ .. math::
+
+ Out[i, j] = \\frac{\\exp(X[i, j])}{\\sum_j(exp(X[i, j])}
+
+ Example:
+
+ .. code-block:: text
+
+ Case 1:
+ Input:
+ X.shape = [2, 3, 4]
+ X.data = [[[2.0, 3.0, 4.0, 5.0],
+ [3.0, 4.0, 5.0, 6.0],
+ [7.0, 8.0, 8.0, 9.0]],
+ [[1.0, 2.0, 3.0, 4.0],
+ [5.0, 6.0, 7.0, 8.0],
+ [6.0, 7.0, 8.0, 9.0]]]
+
+ Attrs:
+ axis = -1
+
+ Output:
+ Out.shape = [2, 3, 4]
+ Out.data = [[[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+ [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+ [0.07232949, 0.19661193, 0.19661193, 0.53444665]],
+ [[0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+ [0.0320586 , 0.08714432, 0.23688282, 0.64391426],
+ [0.0320586 , 0.08714432, 0.23688282, 0.64391426]]]
+
+ Case 2:
+ Input:
+ X.shape = [2, 3, 4]
+ X.data = [[[2.0, 3.0, 4.0, 5.0],
+ [3.0, 4.0, 5.0, 6.0],
+ [7.0, 8.0, 8.0, 9.0]],
+ [[1.0, 2.0, 3.0, 4.0],
+ [5.0, 6.0, 7.0, 8.0],
+ [6.0, 7.0, 8.0, 9.0]]]
+ Attrs:
+ axis = 1
+
+ Output:
+ Out.shape = [2, 3, 4]
+ Out.data = [[[0.00657326, 0.00657326, 0.01714783, 0.01714783],
+ [0.01786798, 0.01786798, 0.04661262, 0.04661262],
+ [0.97555875, 0.97555875, 0.93623955, 0.93623955]],
+ [[0.00490169, 0.00490169, 0.00490169, 0.00490169],
+ [0.26762315, 0.26762315, 0.26762315, 0.26762315],
+ [0.72747516, 0.72747516, 0.72747516, 0.72747516]]]
+
+ Args:
+ input (Tensor): The input tensor. A multi-dimension ``Tensor`` with type float32 or float64.
+ use_cudnn (bool, optional): Use cudnn kernel or not, it is valid only when the cudnn \
+ library is installed. To improve performance, set use_cudnn to True by default.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` . Default: None.
+ will be named automatically. Default: None.
+ axis (int, optional): The index of dimension to perform softmax calculations, it should
+ be in range :math:`[-1, rank - 1]`, while :math:`rank` is the rank of
+ input tensor. Default: -1. -1 means the last dimension.
+
+ Returns:
+ Tensor: ``Tensor`` indicates the output of softmax. The data type and shape are the same as ``input`` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([[[2.0, 3.0, 4.0, 5.0],
+ [3.0, 4.0, 5.0, 6.0],
+ [7.0, 8.0, 8.0, 9.0]],
+ [[1.0, 2.0, 3.0, 4.0],
+ [5.0, 6.0, 7.0, 8.0],
+ [6.0, 7.0, 8.0, 9.0]]], dtype='float32')
+ y = F.softmax(x, axis=1)
+ print(y)
+ # [[[0.00657326, 0.00657326, 0.01714783, 0.01714783],
+ # [0.01786798, 0.01786798, 0.04661262, 0.04661262],
+ # [0.97555870, 0.97555870, 0.93623954, 0.93623954]],
+ # [[0.00490169, 0.00490169, 0.00490169, 0.00490169],
+ # [0.26762316, 0.26762316, 0.26762316, 0.26762316],
+ # [0.72747517, 0.72747517, 0.72747517, 0.72747517]]]
+
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.softmax(input, axis)
+
+ if _non_static_mode():
+ return _legacy_C_ops.softmax(
+ input, 'axis', axis, 'use_cudnn', use_cudnn
+ )
+
+ inputs = {"X": [input]}
+ attrs = {"axis": axis, "use_cudnn": use_cudnn}
+
+ helper = LayerHelper('softmax', **locals())
+ check_variable_and_dtype(
+ input, 'input/x', ['float16', 'float32', 'float64'], 'softmax'
+ )
+
+ dtype = helper.input_dtype()
+ softmax_out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="softmax",
+ inputs={"X": input},
+ outputs={"Out": softmax_out},
+ attrs=attrs,
+ )
+ return softmax_out
+
+
+def conv2d(
+ input,
+ num_filters,
+ filter_size,
+ stride=1,
+ padding=0,
+ dilation=1,
+ groups=None,
+ param_attr=None,
+ bias_attr=None,
+ use_cudnn=True,
+ act=None,
+ name=None,
+ data_format="NCHW",
+):
+ r"""
+ :api_attr: Static Graph
+
+ The convolution2D layer calculates the output based on the input, filter
+ and strides, paddings, dilations, groups parameters. Input and
+ Output are in NCHW or NHWC format, where N is batch size, C is the number of
+ channels, H is the height of the feature, and W is the width of the feature.
+ Filter is in MCHW format, where M is the number of output image channels,
+ C is the number of input image channels, H is the height of the filter,
+ and W is the width of the filter. If the groups is greater than 1,
+ C will equal the number of input image channels divided by the groups.
+ Please refer to UFLDL's `convolution
+ `_
+ for more details.
+ If bias attribution and activation type are provided, bias is added to the
+ output of the convolution, and the corresponding activation function is
+ applied to the final result.
+
+ For each input :math:`X`, the equation is:
+
+ .. math::
+
+ Out = \sigma (W \\ast X + b)
+
+ Where:
+
+ * :math:`X`: Input value, a tensor with NCHW or NHWC format.
+ * :math:`W`: Filter value, a tensor with MCHW format.
+ * :math:`\\ast`: Convolution operation.
+ * :math:`b`: Bias value, a 2-D tensor with shape [M, 1].
+ * :math:`\\sigma`: Activation function.
+ * :math:`Out`: Output value, the shape of :math:`Out` and :math:`X` may be different.
+
+ Example:
+
+ - Input:
+
+ Input shape: :math:`(N, C_{in}, H_{in}, W_{in})`
+
+ Filter shape: :math:`(C_{out}, C_{in}, H_f, W_f)`
+
+ - Output:
+
+ Output shape: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+ Where
+
+ .. math::
+
+ H_{out}&= \\frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (H_f - 1) + 1))}{strides[0]} + 1 \\\\
+ W_{out}&= \\frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (W_f - 1) + 1))}{strides[1]} + 1
+
+ Args:
+ input (Tensor): The input is 4-D Tensor with shape [N, C, H, W], the data type
+ of input is float16 or float32 or float64.
+ num_filters(int): The number of filter. It is as same as the output
+ image channel.
+ filter_size (int|tuple): The filter size. If filter_size
+ is a tuple, it must contain two integers, (filter_size_height,
+ filter_size_width). Otherwise, filter_size_height = filter_size_width =\
+ filter_size.
+ stride (int|tuple): The stride size. It means the stride in convolution.
+ If stride is a tuple, it must contain two integers, (stride_height, stride_width).
+ Otherwise, stride_height = stride_width = stride. Default: stride = 1.
+ padding (string|int|list|tuple): The padding size. It means the number of zero-paddings
+ on both sides for each dimension.If `padding` is a string, either 'VALID' or
+ 'SAME' which is the padding algorithm. If padding size is a tuple or list,
+ it could be in three forms: `[pad_height, pad_width]` or
+ `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`, and when
+ `data_format` is `"NCHW"`, `padding` can be in the form `[[0,0], [0,0],
+ [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `"NHWC"`, `pool_padding` can be in the form
+ `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ Default: padding = 0.
+ dilation (int|tuple): The dilation size. It means the spacing between the kernel
+ points. If dilation is a tuple, it must contain two integers, (dilation_height,
+ dilation_width). Otherwise, dilation_height = dilation_width = dilation.
+ Default: dilation = 1.
+ groups (int): The groups number of the Conv2d Layer. According to grouped
+ convolution in Alex Krizhevsky's Deep CNN paper: when group=2,
+ the first half of the filters is only connected to the first half
+ of the input channels, while the second half of the filters is only
+ connected to the second half of the input channels. Default: groups=1.
+ param_attr (ParamAttr|None): The parameter attribute for learnable parameters/weights
+ of conv2d. If it is set to None or one attribute of ParamAttr, conv2d
+ will create ParamAttr as param_attr. If the Initializer of the param_attr
+ is not set, the parameter is initialized with :math:`Normal(0.0, std)`,
+ and the :math:`std` is :math:`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`. Default: None.
+ bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of conv2d.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, conv2d
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True
+ act (str): Activation type, if it is set to None, activation is not appended.
+ Default: None
+ name(str|None): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ A Tensor representing the conv2d, whose data type is the
+ same with input. If act is None, the tensor storing the convolution
+ result, and if act is not None, the tensor storing convolution
+ and non-linearity activation result.
+
+ Raises:
+ ValueError: If the type of `use_cudnn` is not bool.
+ ValueError: If `data_format` is not "NCHW" or "NHWC".
+ ValueError: If the channel dimmention of the input is less than or equal to zero.
+ ValueError: If `padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `padding` is a tuple, but the element corresponding to the input's batch size is not 0
+ or the element corresponding to the input's channel is not 0.
+ ShapeError: If the input is not 4-D Tensor.
+ ShapeError: If the input's dimension size and filter's dimension size not equal.
+ ShapeError: If the dimension size of input minus the size of `stride` is not 2.
+ ShapeError: If the number of input channels is not equal to filter's channels * groups.
+ ShapeError: If the number of output channels is not be divided by groups.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ data = paddle.static.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
+ conv2d = paddle.static.nn.conv2d(input=data, num_filters=2, filter_size=3, act="relu")
+ print(conv2d.shape) # [-1, 2, 30, 30]
+ """
+
+ check_variable_and_dtype(
+ input, 'input', ['float16', 'float32', 'float64'], 'conv2d'
+ )
+ if len(input.shape) != 4:
+ raise ValueError(
+ "Input size should be 4, "
+ "but received {}".format(len(input.shape))
+ )
+ num_channels = input.shape[1]
+ if not isinstance(use_cudnn, bool):
+ raise ValueError(
+ "Attr(use_cudnn) should be True or False. Received "
+ "Attr(use_cudnn): %s. " % str(use_cudnn)
+ )
+
+ if data_format not in ["NCHW", "NHWC"]:
+ raise ValueError(
+ "Attr(data_format) should be 'NCHW' or 'NHWC'. Received "
+ "Attr(data_format): %s." % str(data_format)
+ )
+
+ channel_last = data_format == "NHWC"
+ num_channels = input.shape[3] if channel_last else input.shape[1]
+ if num_channels < 0:
+ raise ValueError(
+ "The channel dimmention of the input(%s) should be defined. "
+ "Received: %s." % (str(input.shape), str(num_channels))
+ )
+ assert param_attr is not False, "param_attr should not be False here."
+
+ if groups is None:
+ num_filter_channels = num_channels
+ elif groups <= 0:
+ raise ValueError(
+ "the groups of input must be greater than 0, "
+ "but received the groups of input is {}".format(groups)
+ )
+ else:
+ if num_channels % groups != 0:
+ raise ValueError(
+ "the channel of input must be divisible by groups,"
+ "received: the channel of input is {}, the shape of input is {}"
+ ", the groups is {}".format(num_channels, input.shape, groups)
+ )
+ num_filter_channels = num_channels // groups
+
+ l_type = 'conv2d'
+ if (
+ num_channels == groups
+ and num_filters % num_channels == 0
+ and not use_cudnn
+ ):
+ l_type = 'depthwise_conv2d'
+
+ if (
+ num_channels == groups
+ and num_filters % num_channels == 0
+ and core.is_compiled_with_rocm()
+ ):
+ l_type = 'depthwise_conv2d'
+
+ # NPU only supports depthwise_conv2d when "input_channel = output_channel = groups"
+ if core.is_compiled_with_npu():
+ if num_channels == groups and num_channels == num_filters:
+ l_type = 'depthwise_conv2d'
+ else:
+ l_type = 'conv2d'
+
+ helper = LayerHelper(l_type, **locals())
+ dtype = helper.input_dtype()
+
+ filter_size = utils.convert_to_list(filter_size, 2, 'filter_size')
+ stride = utils.convert_to_list(stride, 2, 'stride')
+ dilation = utils.convert_to_list(dilation, 2, 'dilation')
+
+ # padding
+ def _update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, list) or isinstance(ele, tuple):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 4:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NHWC"):
+ if not (padding[0] == [0, 0] and padding[3] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:3]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 4, 'padding')
+ if utils._is_symmetric_padding(padding, 2):
+ padding = [padding[0], padding[2]]
+
+ else:
+ padding = utils.convert_to_list(padding, 2, 'padding')
+
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(padding, str):
+ padding = padding.upper()
+ if padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown padding: '%s'. It can only be 'SAME' or 'VALID'."
+ % str(padding)
+ )
+ if padding == "VALID":
+ padding_algorithm = "VALID"
+ padding = [0, 0]
+ elif padding == "SAME":
+ padding_algorithm = "SAME"
+ padding = [0, 0]
+
+ padding = _update_padding(padding, data_format)
+
+ filter_shape = [num_filters, int(num_filter_channels)] + filter_size
+
+ def _get_default_param_initializer():
+ filter_elem_num = filter_size[0] * filter_size[1] * num_channels
+ if filter_elem_num <= 0:
+ raise ValueError(
+ "Invalid filter number, excepted number is larger than 0, but"
+ " received {}, please check the input shape and "
+ "filter size.".format(filter_elem_num)
+ )
+ std = (2.0 / filter_elem_num) ** 0.5
+ return Normal(0.0, std, 0)
+
+ filter_param = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=filter_shape,
+ dtype=dtype,
+ default_initializer=_get_default_param_initializer(),
+ )
+
+ pre_bias = helper.create_variable_for_type_inference(dtype)
+
+ if (
+ core.is_compiled_with_cuda()
+ and paddle.fluid.get_flags("FLAGS_conv2d_disable_cudnn")[
+ "FLAGS_conv2d_disable_cudnn"
+ ]
+ ):
+ use_cudnn = False
+
+ helper.append_op(
+ type=l_type,
+ inputs={
+ 'Input': input,
+ 'Filter': filter_param,
+ },
+ outputs={"Output": pre_bias},
+ attrs={
+ 'strides': stride,
+ 'paddings': padding,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'use_cudnn': use_cudnn,
+ 'use_mkldnn': False,
+ 'fuse_relu_before_depthwise_conv': False,
+ "padding_algorithm": padding_algorithm,
+ "data_format": data_format,
+ },
+ )
+
+ if data_format == 'NCHW':
+ pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
+ else:
+ pre_act = helper.append_bias_op(pre_bias, dim_start=3, dim_end=4)
+
+ return helper.append_activation(pre_act)
+
+
+def conv3d(
+ input,
+ num_filters,
+ filter_size,
+ stride=1,
+ padding=0,
+ dilation=1,
+ groups=None,
+ param_attr=None,
+ bias_attr=None,
+ use_cudnn=True,
+ act=None,
+ name=None,
+ data_format="NCDHW",
+):
+ r"""
+ :api_attr: Static Graph
+
+ The convolution3D layer calculates the output based on the input, filter
+ and strides, paddings, dilations, groups parameters. Input(Input) and
+ Output(Output) are in NCDHW or NDHWC format. Where N is batch size C is the number of
+ channels, D is the depth of the feature, H is the height of the feature,
+ and W is the width of the feature. Convlution3D is similar with Convlution2D
+ but adds one dimension(depth). If bias attribution and activation type are
+ provided, bias is added to the output of the convolution, and the
+ corresponding activation function is applied to the final result.
+
+ For each input :math:`X`, the equation is:
+
+ .. math::
+
+ Out = \sigma (W \\ast X + b)
+
+ In the above equation:
+
+ * :math:`X`: Input value, a tensor with NCDHW or NDHWC format.
+ * :math:`W`: Filter value, a tensor with MCDHW format.
+ * :math:`\\ast`: Convolution operation.
+ * :math:`b`: Bias value, a 2-D tensor with shape [M, 1].
+ * :math:`\\sigma`: Activation function.
+ * :math:`Out`: Output value, the shape of :math:`Out` and :math:`X` may be different.
+
+ Example:
+
+ - Input:
+
+ Input shape: :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`
+
+ Filter shape: :math:`(C_{out}, C_{in}, D_f, H_f, W_f)`
+
+ - Output:
+ Output shape: :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
+
+ Where
+
+ .. math::
+
+ D_{out}&= \\frac{(D_{in} + 2 * paddings[0] - (dilations[0] * (D_f - 1) + 1))}{strides[0]} + 1 \\\\
+ H_{out}&= \\frac{(H_{in} + 2 * paddings[1] - (dilations[1] * (H_f - 1) + 1))}{strides[1]} + 1 \\\\
+ W_{out}&= \\frac{(W_{in} + 2 * paddings[2] - (dilations[2] * (W_f - 1) + 1))}{strides[2]} + 1
+
+ Args:
+ input (Tensor): The input is 5-D Tensor with shape [N, C, D, H, W], the data
+ type of input is float16 or float32 or float64.
+ num_filters(int): The number of filter. It is as same as the output
+ image channel.
+ filter_size (int|tuple): The filter size. If filter_size is a tuple,
+ it must contain three integers, (filter_size_depth, filter_size_height,
+ filter_size_width). Otherwise, filter_size_depth = filter_size_height = \
+ filter_size_width = filter_size.
+ stride (int|tuple): The stride size. It means the stride in convolution. If stride is a
+ tuple, it must contain three integers, (stride_depth, stride_height, stride_width).
+ Otherwise, stride_depth = stride_height = stride_width = stride. Default: stride = 1.
+ padding (string|int|list|tuple): The padding size. It means the number of zero-paddings
+ on both sides for each dimension. If `padding` is a string, either 'VALID' or
+ 'SAME' which is the padding algorithm. If padding size is a tuple or list,
+ it could be in three forms: `[pad_depth, pad_height, pad_width]` or
+ `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
+ and when `data_format` is `"NCDHW"`, `pool_padding` can be in the form
+ `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `"NDHWC"`, `pool_padding` can be in the form
+ `[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ Default: padding = 0.
+ dilation (int|tuple): The dilation size. It means the spacing between the kernel points.
+ If dilation is a tuple, it must contain three integers, (dilation_depth, dilation_height,
+ dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation.
+ Default: dilation = 1.
+ groups (int): The groups number of the Conv3d Layer. According to grouped
+ convolution in Alex Krizhevsky's Deep CNN paper: when group=2,
+ the first half of the filters is only connected to the first half
+ of the input channels, while the second half of the filters is only
+ connected to the second half of the input channels. Default: groups=1
+ param_attr (ParamAttr|None): The parameter attribute for learnable parameters/weights
+ of conv3d. If it is set to None or one attribute of ParamAttr, conv3d
+ will create ParamAttr as param_attr. If it is set to None, the parameter
+ is initialized with :math:`Normal(0.0, std)`, and the :math:`std` is
+ :math:`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`. Default: None.
+ bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of conv3d.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, conv3d
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True
+ act (str): Activation type, if it is set to None, activation is not appended.
+ Default: None.
+ name(str|None): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ A Variable holding Tensor representing the conv3d, whose data type is
+ the same with input. If act is None, the tensor variable storing the
+ convolution result, and if act is not None, the tensor variable storing
+ convolution and non-linearity activation result.
+
+ Raises:
+ ValueError: If the type of `use_cudnn` is not bool.
+ ValueError: If `data_format` is not "NCDHW" or "NDHWC".
+ ValueError: If the channel dimmention of the input is less than or equal to zero.
+ ValueError: If `padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `padding` is a tuple, but the element corresponding to the input's batch size is not 0
+ or the element corresponding to the input's channel is not 0.
+ ShapeError: If the input is not 5-D Tensor.
+ ShapeError: If the input's dimension size and filter's dimension size not equal.
+ ShapeError: If the dimension size of input minus the size of `stride` is not 2.
+ ShapeError: If the number of input channels is not equal to filter's channels * groups.
+ ShapeError: If the number of output channels is not be divided by groups.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ paddle.enable_static()
+ data = paddle.static.data(name='data', shape=[None, 3, 12, 32, 32], dtype='float32')
+ param_attr = paddle.framework.ParamAttr(name='conv3d.weight', initializer=paddle.nn.initializer.XavierNormal(), learning_rate=0.001)
+ res = paddle.static.nn.conv3d(input=data, num_filters=2, filter_size=3, act="relu", param_attr=param_attr)
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(paddle.static.default_startup_program())
+ x = np.random.rand(1, 3, 12, 32, 32).astype("float32")
+ output = exe.run(feed={"data": x}, fetch_list=[res])
+ print(output)
+ """
+
+ l_type = 'conv3d'
+ assert param_attr is not False, "param_attr should not be False here."
+ helper = LayerHelper(l_type, **locals())
+ dtype = helper.input_dtype()
+
+ if not isinstance(use_cudnn, bool):
+ raise ValueError(
+ "Attr(use_cudnn) should be True or False. Received "
+ "Attr(use_cudnn): %s. " % str(use_cudnn)
+ )
+
+ if data_format not in ["NCDHW", "NDHWC"]:
+ raise ValueError(
+ "Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
+ "Attr(data_format): %s." % str(data_format)
+ )
+
+ channel_last = data_format == "NDHWC"
+ if len(input.shape) != 5:
+ raise ValueError(
+ "Input should be 5D tensor, but received input with the shape of {}".format(
+ input.shape
+ )
+ )
+ num_channels = input.shape[4] if channel_last else input.shape[1]
+ if num_channels < 0:
+ raise ValueError(
+ "The channel dimmention of the input(%s) should be defined. "
+ "Received: %s." % (str(input.shape), str(num_channels))
+ )
+
+ if groups is None:
+ num_filter_channels = num_channels
+ elif groups <= 0:
+ raise ValueError(
+ "the groups of conv3d should be greater than 0. Received groups: {}".format(
+ groups
+ )
+ )
+ else:
+ if num_channels % groups != 0:
+ raise ValueError(
+ "The number of input channels must be divisible by Attr(groups). "
+ "Received: number of channels(%s), groups(%s)."
+ % (str(num_channels), str(groups))
+ )
+ num_filter_channels = num_channels // groups
+
+ filter_size = utils.convert_to_list(filter_size, 3, 'filter_size')
+ stride = utils.convert_to_list(stride, 3, 'stride')
+ dilation = utils.convert_to_list(dilation, 3, 'dilation')
+
+ def _update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, list) or isinstance(ele, tuple):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 5:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCDHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:5]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NDHWC"):
+ if not (padding[0] == [0, 0] and padding[4] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 6, 'padding')
+ if utils._is_symmetric_padding(padding, 3):
+ padding = [padding[0], padding[2], padding[4]]
+ elif is_list_or_tuple(padding) and len(padding) == 6:
+ padding = utils.convert_to_list(padding, 6, 'padding')
+ if utils._is_symmetric_padding(padding, 3):
+ padding = [padding[0], padding[2], padding[4]]
+ else:
+ padding = utils.convert_to_list(padding, 3, 'padding')
+
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(padding, str):
+ padding = padding.upper()
+ if padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown padding: '%s'. It can only be 'SAME' or 'VALID'."
+ % str(padding)
+ )
+ if padding == "VALID":
+ padding_algorithm = "VALID"
+ padding = [0, 0, 0]
+ elif padding == "SAME":
+ padding_algorithm = "SAME"
+ padding = [0, 0, 0]
+
+ padding = _update_padding(padding, data_format)
+
+ input_shape = input.shape
+ filter_shape = [num_filters, num_filter_channels] + filter_size
+
+ def _get_default_param_initializer():
+ filter_elem_num = (
+ filter_size[0] * filter_size[1] * filter_size[2] * num_channels
+ )
+ if filter_elem_num <= 0:
+ raise ValueError(
+ "Invalid filter number, excepted number is larger than 0, but"
+ " received {}, please check the input shape and "
+ "filter size.".format(filter_elem_num)
+ )
+
+ std = (2.0 / filter_elem_num) ** 0.5
+ return Normal(0.0, std, 0)
+
+ filter_param = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=filter_shape,
+ dtype=dtype,
+ default_initializer=_get_default_param_initializer(),
+ )
+
+ pre_bias = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type=l_type,
+ inputs={
+ 'Input': input,
+ 'Filter': filter_param,
+ },
+ outputs={"Output": pre_bias},
+ attrs={
+ 'strides': stride,
+ 'paddings': padding,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'use_cudnn': use_cudnn,
+ 'use_mkldnn': False,
+ "padding_algorithm": padding_algorithm,
+ "data_format": data_format,
+ },
+ )
+
+ if data_format == 'NCDHW':
+ pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
+ else:
+ pre_act = helper.append_bias_op(pre_bias, dim_start=4, dim_end=5)
+
+ return helper.append_activation(pre_act)
+
+
+@templatedoc()
+def pool2d(
+ input,
+ pool_size=-1,
+ pool_type="max",
+ pool_stride=1,
+ pool_padding=0,
+ global_pooling=False,
+ use_cudnn=True,
+ ceil_mode=False,
+ name=None,
+ exclusive=True,
+ data_format="NCHW",
+):
+ """
+
+ ${comment}
+
+ Args:
+ input (Variable): The input tensor of pooling operator which is a 4-D tensor with
+ shape [N, C, H, W]. The format of input tensor is `"NCHW"` or
+ `"NHWC"`, where `N` is batch size, `C` is the number of channels,
+ `H` is the height of the feature, and `W` is the width of the
+ feature. The data type if float32 or float64.
+ pool_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
+ it must contain two integers, (pool_size_Height, pool_size_Width).
+ Otherwise, the pool kernel size will be a square of an int.
+ pool_type: ${pooling_type_comment}
+ pool_stride (int|list|tuple): The pool stride size. If pool stride size is a tuple or list,
+ it must contain two integers, (pool_stride_Height, pool_stride_Width).
+ Otherwise, the pool stride size will be a square of an int.
+ pool_padding (string|int|list|tuple): The pool padding. If `pool_padding` is a string, either 'VALID' or
+ 'SAME' which is the padding algorithm. If pool padding size is a tuple or list,
+ it could be in three forms: `[pad_height, pad_width]` or
+ `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`, and when `data_format` is `"NCHW"`,
+ `pool_padding` can be in the form `[[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `"NHWC"`, `pool_padding` can be in the form
+ `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ Otherwise, the pool padding size will be a square of an int.
+ global_pooling (bool): ${global_pooling_comment}
+ use_cudnn (bool): ${use_cudnn_comment}
+ ceil_mode (bool): ${ceil_mode_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ exclusive (bool): Whether to exclude padding points in average pooling
+ mode, default is `true`.
+ data_format (string): The data format of the input and output data. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ Variable: The output tensor of pooling result. The data type is same as input tensor.
+
+ Raises:
+ ValueError: If `pool_type` is not "max" nor "avg".
+ ValueError: If `global_pooling` is False and `pool_size` is -1.
+ TypeError: If `use_cudnn` is not a bool value.
+ ValueError: If `data_format` is not "NCHW" or "NHWC".
+ ValueError: If `pool_padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `pool_padding` is "VALID", but `ceil_mode` is True.
+ ValueError: If `pool_padding` is a list or tuple, but the elements in the batch or channel dimensions are non-zero.
+ ShapeError: If the input is not a 4-D or 5-D Tensor.
+ ShapeError: If the dimension of input minus the size of `pool_stride` is not 2.
+ ShapeError: If the size of `pool_size` and `pool_stride` is not equal.
+ ShapeError: If the output's shape calculated is not greater than 0.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+
+ data = fluid.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
+
+ # max pool2d
+ pool2d = fluid.layers.pool2d(
+ input = data,
+ pool_size = 2,
+ pool_type = "max",
+ pool_stride = 1,
+ global_pooling=False)
+
+ # average pool2d
+ pool2d = fluid.layers.pool2d(
+ input = data,
+ pool_size = 2,
+ pool_type = "avg",
+ pool_stride = 1,
+ global_pooling=False)
+
+ # global average pool2d
+ pool2d = fluid.layers.pool2d(
+ input = data,
+ pool_size = 2,
+ pool_type = "avg",
+ pool_stride = 1,
+ global_pooling=True)
+
+ # Attr(pool_padding) is a list with 4 elements, Attr(data_format) is "NCHW".
+ out_1 = fluid.layers.pool2d(
+ input = data,
+ pool_size = 3,
+ pool_type = "avg",
+ pool_stride = 1,
+ pool_padding = [1, 2, 1, 0],
+ data_format = "NCHW")
+
+ # Attr(pool_padding) is a string, Attr(data_format) is "NCHW".
+ out_2 = fluid.layers.pool2d(
+ input = data,
+ pool_size = 3,
+ pool_type = "avg",
+ pool_stride = 1,
+ pool_padding = "VALID",
+ data_format = "NCHW")
+ """
+ if pool_type not in ["max", "avg"]:
+ raise ValueError(
+ "Unknown Attr(pool_type): '%s'. It can only be 'max' or 'avg'.",
+ str(pool_type),
+ )
+
+ if global_pooling is False and pool_size == -1:
+ raise ValueError(
+ "When Attr(global_pooling) is False, Attr(pool_size) must be passed "
+ "and be a valid value. Received pool_size: %s." % str(pool_size)
+ )
+
+ if not isinstance(use_cudnn, bool):
+ raise TypeError(
+ "Attr(use_cudnn) should be True or False. Received "
+ "Attr(use_cudnn): %s." % str(use_cudnn)
+ )
+
+ if data_format not in ["NCHW", "NHWC"]:
+ raise ValueError(
+ "Attr(data_format) should be 'NCHW' or 'NHWC'. Received "
+ "Attr(data_format): %s." % str(data_format)
+ )
+
+ pool_size = utils.convert_to_list(pool_size, 2, 'pool_size')
+ pool_stride = utils.convert_to_list(pool_stride, 2, 'pool_stride')
+
+ def update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, list) or isinstance(ele, tuple):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 4:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero pool_padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NHWC"):
+ if not (padding[0] == [0, 0] and padding[3] == [0, 0]):
+ raise ValueError(
+ "Non-zero pool_padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:3]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 4, 'padding')
+
+ if utils._is_symmetric_padding(padding, 2):
+ padding = [padding[0], padding[2]]
+ else:
+ padding = utils.convert_to_list(padding, 2, 'padding')
+
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(pool_padding, str):
+ pool_padding = pool_padding.upper()
+ if pool_padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown Attr(pool_padding): '%s'. It can only be 'SAME' or 'VALID'."
+ % str(pool_padding)
+ )
+ if pool_padding == "VALID":
+ padding_algorithm = "VALID"
+ pool_padding = [0, 0]
+ if ceil_mode != False:
+ raise ValueError(
+ "When Attr(pool_padding) is \"VALID\", Attr(ceil_mode) must be False. "
+ "Received ceil_mode: True."
+ )
+ elif pool_padding == "SAME":
+ padding_algorithm = "SAME"
+ pool_padding = [0, 0]
+
+ pool_padding = update_padding(pool_padding, data_format)
+ if in_dygraph_mode():
+ return _C_ops.pool2d(
+ input,
+ pool_size,
+ pool_stride,
+ pool_padding,
+ ceil_mode,
+ exclusive,
+ data_format,
+ pool_type,
+ global_pooling,
+ False,
+ padding_algorithm,
+ use_cudnn,
+ )
+ op_type = 'pool2d'
+ helper = LayerHelper(op_type, **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type=op_type,
+ inputs={"X": input},
+ outputs={"Out": pool_out},
+ attrs={
+ "pooling_type": pool_type,
+ "ksize": pool_size,
+ "global_pooling": global_pooling,
+ "strides": pool_stride,
+ "paddings": pool_padding,
+ "padding_algorithm": padding_algorithm,
+ "use_cudnn": use_cudnn,
+ "ceil_mode": ceil_mode,
+ "use_mkldnn": False,
+ "exclusive": exclusive,
+ "data_format": data_format,
+ },
+ )
+
+ return pool_out
+
+
+@templatedoc()
+def pool3d(
+ input,
+ pool_size=-1,
+ pool_type="max",
+ pool_stride=1,
+ pool_padding=0,
+ global_pooling=False,
+ use_cudnn=True,
+ ceil_mode=False,
+ name=None,
+ exclusive=True,
+ data_format="NCDHW",
+):
+ """
+
+ ${comment}
+
+ Args:
+ input (Variable): The input tensor of pooling operator, which is a 5-D tensor with
+ shape [N, C, D, H, W]. The format of
+ input tensor is `"NCDHW"` or `"NDHWC"`, where `N` is batch size, `C` is
+ the number of channels, `D` is the depth of the feature,
+ `H` is the height of the feature, and `W` is the width
+ of the feature.
+ pool_size (int|list|tuple): The pool kernel size. If pool kernel size
+ is a tuple or list, it must contain three integers,
+ (pool_size_Depth, pool_size_Height, pool_size_Width).
+ Otherwise, the pool kernel size will be the cube of an int.
+ pool_type (string): ${pooling_type_comment}
+ pool_stride (string|int|list|tuple)): The pool padding. If `pool_padding` is a string, either 'VALID' or
+ 'SAME' which is the padding algorithm. If pool stride size is a tuple or list,
+ it must contain three integers, `[stride_Depth, stride_Height, stride_Width]`.
+ Otherwise, the pool stride size will be a cube of an int.
+ pool_padding (int|list|tuple): The pool padding size. If pool padding size is a tuple or list,
+ it could be in three forms: `[pad_depth, pad_height, pad_width]` or
+ `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
+ and when `data_format` is `"NCDHW"`, `pool_padding` can be in the form
+ `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `"NDHWC"`, `pool_padding` can be in the form
+ `[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ global_pooling (bool): ${global_pooling_comment}
+ use_cudnn (bool): ${use_cudnn_comment}
+ ceil_mode (bool): ${ceil_mode_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ exclusive (bool): Whether to exclude padding points in average pooling
+ mode, default is true.
+ data_format (string): The data format of the input and output data. An optional string from: `"NCDHW"`, `"NDHWC"`.
+ The default is `"NCDHW"`. When it is `"NCDHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_depth, input_height, input_width]`.
+
+ Returns:
+ Variable: The output tensor of pooling result. The data type is same as input tensor.
+
+ Raises:
+ ValueError: If `pool_type` is not "max" nor "avg".
+ ValueError: If `global_pooling` is False and `pool_size` is -1.
+ TypeError: If `use_cudnn` is not a bool value.
+ ValueError: If `data_format` is not "NCDHW" or "NDHWC".
+ ValueError: If `pool_padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `pool_padding` is "VALID", but `ceil_mode` is True.
+ ValueError: If `pool_padding` is a list or tuple, but the elements in the batch or channel dimensions are non-zero.
+ ShapeError: If the input is not a 4-D or 5-D Tensor.
+ ShapeError: If the dimension of input minus the size of `pool_stride` is not 2.
+ ShapeError: If the size of `pool_size` and `pool_stride` is not equal.
+ ShapeError: If the output's shape calculated is not greater than 0.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+
+ data = fluid.data(name='data', shape=[None, 3, 32, 32, 32], dtype='float32')
+
+ # max pool3d
+ pool3d = fluid.layers.pool3d(
+ input = data,
+ pool_size = 2,
+ pool_type = "max",
+ pool_stride = 1,
+ global_pooling=False)
+
+ # average pool3d
+ pool3d = fluid.layers.pool3d(
+ input = data,
+ pool_size = 2,
+ pool_type = "avg",
+ pool_stride = 1,
+ global_pooling=False)
+
+ # global average pool3d
+ pool3d = fluid.layers.pool3d(
+ input = data,
+ pool_size = 2,
+ pool_type = "avg",
+ pool_stride = 1,
+ global_pooling=True)
+
+ # example 1:
+ # Attr(pool_padding) is a list with 6 elements, Attr(data_format) is "NCDHW".
+ out_1 = fluid.layers.pool3d(
+ input = data,
+ pool_size = 2,
+ pool_type = "avg",
+ pool_stride = 1,
+ pool_padding = [1, 2, 1, 0, 1, 2],
+ global_pooling = False,
+ data_format = "NCDHW")
+
+ # example 2:
+ # Attr(pool_padding) is a string, Attr(data_format) is "NCDHW".
+ out_2 = fluid.layers.pool3d(
+ input = data,
+ pool_size = 3,
+ pool_type = "avg",
+ pool_stride = 1,
+ pool_padding = "VALID",
+ global_pooling = False,
+ data_format = "NCDHW")
+
+ """
+ if pool_type not in ["max", "avg"]:
+ raise ValueError(
+ "Unknown Attr(pool_type): '%s'. It can only be 'max' or 'avg'.",
+ str(pool_type),
+ )
+
+ if global_pooling is False and pool_size == -1:
+ raise ValueError(
+ "When Attr(global_pooling) is False, Attr(pool_size) must be passed "
+ "and be a valid value. Received Attr(pool_size): %s."
+ % str(pool_size)
+ )
+
+ if not isinstance(use_cudnn, bool):
+ raise TypeError(
+ "Attr(use_cudnn) should be True or False. Received "
+ "Attr(use_cudnn): %s. " % str(use_cudnn)
+ )
+
+ if data_format not in ["NCDHW", "NDHWC"]:
+ raise ValueError(
+ "Attr(data_format) should be 'NCDHW' or 'NDHWC'. Received "
+ "Attr(data_format): %s" % str(data_format)
+ )
+
+ pool_size = utils.convert_to_list(pool_size, 3, 'pool_size')
+ pool_stride = utils.convert_to_list(pool_stride, 3, 'pool_stride')
+
+ def update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, (list, tuple)):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 5:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCDHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero pool_padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:5]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NDHWC"):
+ if not (padding[0] == [0, 0] and padding[4] == [0, 0]):
+ raise ValueError(
+ "Non-zero pool_padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 6, 'padding')
+ if utils._is_symmetric_padding(padding, 3):
+ padding = [padding[0], padding[2], padding[4]]
+
+ elif is_list_or_tuple(padding) and len(padding) == 6:
+ padding = utils.convert_to_list(padding, 6, 'padding')
+ if utils._is_symmetric_padding(padding, 3):
+ padding = [padding[0], padding[2], padding[4]]
+ else:
+ padding = utils.convert_to_list(padding, 3, 'padding')
+
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(pool_padding, str):
+ pool_padding = pool_padding.upper()
+ if pool_padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown Attr(pool_padding): '%s'. It can only be 'SAME' or 'VALID'."
+ % str(pool_padding)
+ )
+ if pool_padding == "VALID":
+ padding_algorithm = "VALID"
+ pool_padding = [0, 0, 0]
+ if ceil_mode != False:
+ raise ValueError(
+ "When Attr(pool_padding) is \"VALID\", ceil_mode must be False. "
+ "Received ceil_mode: True."
+ )
+ elif pool_padding == "SAME":
+ padding_algorithm = "SAME"
+ pool_padding = [0, 0, 0]
+
+ pool_padding = update_padding(pool_padding, data_format)
+
+ op_type = "pool3d"
+ helper = LayerHelper(op_type, **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type=op_type,
+ inputs={"X": input},
+ outputs={"Out": pool_out},
+ attrs={
+ "pooling_type": pool_type,
+ "ksize": pool_size,
+ "global_pooling": global_pooling,
+ "strides": pool_stride,
+ "paddings": pool_padding,
+ "padding_algorithm": padding_algorithm,
+ "use_cudnn": use_cudnn,
+ "ceil_mode": ceil_mode,
+ "use_mkldnn": False,
+ "exclusive": exclusive,
+ "data_format": data_format,
+ },
+ )
+
+ return pool_out
+
+
+@deprecated(since="2.0.0")
+@templatedoc(op_type="pool2d")
+def adaptive_pool2d(
+ input, pool_size, pool_type="max", require_index=False, name=None
+):
+ r"""
+
+ This operation calculates the output based on the input, pool_size,
+ pool_type parameters. Input(X) and output(Out) are in NCHW format, where N is batch
+ size, C is the number of channels, H is the height of the feature, and W is
+ the width of the feature. Parameters(pool_size) should contain two elements which
+ represent height and width, respectively. Also the H and W dimensions of output(Out)
+ is same as Parameter(pool_size). The output tensor shape will be [N, C, pool_size[0], pool_size[1]]
+
+ For average adaptive pool2d:
+
+ .. math::
+
+ hstart &= floor(i * H_{in} / H_{out})
+
+ hend &= ceil((i + 1) * H_{in} / H_{out})
+
+ wstart &= floor(j * W_{in} / W_{out})
+
+ wend &= ceil((j + 1) * W_{in} / W_{out})
+
+ Output(i ,j) &= \\frac{sum(Input[hstart:hend, wstart:wend])}{(hend - hstart) * (wend - wstart)}
+
+ Args:
+ input (Tensor): The input tensor of pooling operator, which is a 4-D tensor
+ with shape [N, C, H, W]. The format of input tensor is NCHW,
+ where N is batch size, C is the number of channels, H is the
+ height of the feature, and W is the width of the feature.
+ The data type is float32 or float64.
+ pool_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
+ it must contain two integers, (pool_size_Height, pool_size_Width).
+ pool_type: ${pooling_type_comment}
+ require_index (bool): If true, the index of max pooling point will be returned along
+ with outputs. It cannot be set in average pooling type. Default False.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor: The output tensor of adaptive pooling result. The data type is same
+ as input tensor.
+
+ Raises:
+ ValueError: 'pool_type' is not 'max' nor 'avg'.
+ ValueError: invalid setting 'require_index' true when 'pool_type' is 'avg'.
+ ValueError: 'pool_size' should be a list or tuple with length as 2.
+
+ Examples:
+ .. code-block:: python
+
+ # average adaptive pool2d
+ # suppose input data in shape of [N, C, H, W], `pool_size` is [m, n],
+ # output shape is [N, C, m, n], adaptive pool divide H and W dimensions
+ # of input data into m * n grids averagely and performs poolings in each
+ # grid to get output.
+ # adaptive average pool performs calculations as follow:
+ #
+ # for i in range(m):
+ # for j in range(n):
+ # hstart = floor(i * H / m)
+ # hend = ceil((i + 1) * H / m)
+ # wstart = floor(i * W / n)
+ # wend = ceil((i + 1) * W / n)
+ # output[:, :, i, j] = avg(input[:, :, hstart: hend, wstart: wend])
+ #
+ import paddle
+ paddle.enable_static()
+ data = paddle.rand(shape=[1,3,32,32])
+ pool_out = paddle.fluid.layers.adaptive_pool2d(
+ input=data,
+ pool_size=[3, 3],
+ pool_type='avg')
+
+ # max adaptive pool2d
+ # suppose input data in shape of [N, C, H, W], `pool_size` is [m, n],
+ # output shape is [N, C, m, n], adaptive pool divide H and W dimensions
+ # of input data into m * n grids averagely and performs poolings in each
+ # grid to get output.
+ # adaptive average pool performs calculations as follow:
+ #
+ # for i in range(m):
+ # for j in range(n):
+ # hstart = floor(i * H / m)
+ # hend = ceil((i + 1) * H / m)
+ # wstart = floor(i * W / n)
+ # wend = ceil((i + 1) * W / n)
+ # output[:, :, i, j] = max(input[:, :, hstart: hend, wstart: wend])
+ #
+ import paddle
+ data = paddle.rand(shape=[1,3,32,32])
+ pool_out = paddle.fluid.layers.adaptive_pool2d(
+ input=data,
+ pool_size=[3, 3],
+ pool_type='max')
+ """
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ 'adaptive_pool2d',
+ )
+ check_type(pool_type, 'pool_type', str, 'adaptive_pool2d')
+ check_type(pool_size, 'pool_size', (int, list, tuple), 'adaptive_pool2d')
+ check_type(require_index, 'require_index', bool, 'adaptive_pool2d')
+ if pool_type not in ["max", "avg"]:
+ raise ValueError(
+ "Unknown pool_type: '%s'. It can only be 'max' or 'avg'.",
+ str(pool_type),
+ )
+
+ if pool_type == "avg" and require_index:
+ raise ValueError(
+ "invalid setting 'require_index' true when 'pool_type' is 'avg'."
+ )
+
+ pool_size = utils.convert_to_list(pool_size, 2, 'pool_size')
+
+ if pool_type == "max":
+ l_type = 'max_pool2d_with_index'
+ else:
+ l_type = "pool2d"
+
+ helper = LayerHelper(l_type, **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+
+ outputs = {"Out": pool_out}
+ if pool_type == "max":
+ mask = helper.create_variable_for_type_inference(dtype)
+ outputs["Mask"] = mask
+
+ helper.append_op(
+ type=l_type,
+ inputs={"X": input},
+ outputs=outputs,
+ attrs={
+ "pooling_type": pool_type,
+ "ksize": pool_size,
+ "adaptive": True,
+ },
+ )
+
+ return (pool_out, mask) if require_index else pool_out
+
+
+@deprecated(since="2.0.0")
+@templatedoc(op_type="pool3d")
+def adaptive_pool3d(
+ input, pool_size, pool_type="max", require_index=False, name=None
+):
+ r"""
+
+ This operation calculates the output based on the input, pool_size,
+ pool_type parameters. Input(X) and output(Out) are in NCDHW format, where N is batch
+ size, C is the number of channels, D is the depth of the feature, H is the height of
+ the feature, and W is the width of the feature. Parameters(pool_size) should contain
+ three elements which represent height and width, respectively. Also the D, H and W
+ dimensions of output(Out) is same as Parameter(pool_size). The output tensor shape
+ will be [N, C, pool_size[0], pool_size[1], pool_size[2]]
+
+ For average adaptive pool3d:
+
+ .. math::
+
+ dstart &= floor(i * D_{in} / D_{out})
+
+ dend &= ceil((i + 1) * D_{in} / D_{out})
+
+ hstart &= floor(j * H_{in} / H_{out})
+
+ hend &= ceil((j + 1) * H_{in} / H_{out})
+
+ wstart &= floor(k * W_{in} / W_{out})
+
+ wend &= ceil((k + 1) * W_{in} / W_{out})
+
+ Output(i ,j, k) &= \\frac{sum(Input[dstart:dend, hstart:hend, wstart:wend])}{(dend - dstart) * (hend - hstart) * (wend - wstart)}
+
+ Args:
+ input (Tensor): The input tensor of pooling operator, which is a 5-D tensor with
+ shape [N, C, D, H, W]. The format of input tensor is NCDHW, where
+ N is batch size, C is the number of channels, D is the depth of the feature,
+ H is the height of the feature, and W is the width of the feature.
+ The data type is float32 or float64.
+ pool_size (int|list|tuple): The pool kernel size. If pool kernel size is a tuple or list,
+ it must contain three integers, (Depth, Height, Width).
+ pool_type: ${pooling_type_comment}
+ require_index (bool): If true, the index of max pooling point will be returned along
+ with outputs. It cannot be set in average pooling type. Default False.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor: The output tensor of adaptive pooling result. The data type is same as input tensor.
+
+ Raises:
+ ValueError: 'pool_type' is not 'max' nor 'avg'.
+ ValueError: invalid setting 'require_index' true when 'pool_type' is 'avg'.
+ ValueError: 'pool_size' should be a list or tuple with length as 2.
+
+ Examples:
+ .. code-block:: python
+
+ # average adaptive pool3d
+ # suppose input data in shape of [N, C, D, H, W], `pool_size` is [l, m, n],
+ # output shape is [N, C, l, m, n], adaptive pool divide D, H and W dimensions
+ # of input data into l * m * n grids averagely and performs poolings in each
+ # grid to get output.
+ # adaptive average pool performs calculations as follow:
+ #
+ # for i in range(l):
+ # for j in range(m):
+ # for k in range(n):
+ # dstart = floor(i * D / l)
+ # dend = ceil((i + 1) * D / l)
+ # hstart = floor(j * H / m)
+ # hend = ceil((j + 1) * H / m)
+ # wstart = floor(k * W / n)
+ # wend = ceil((k + 1) * W / n)
+ # output[:, :, i, j, k] =
+ # avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
+ #
+
+ import paddle
+ paddle.enable_static()
+ data = paddle.rand(shape=[1,3,32,32,32])
+ pool_out = paddle.fluid.layers.adaptive_pool3d(
+ input=data,
+ pool_size=[3, 3, 3],
+ pool_type='avg')
+
+ # max adaptive pool3d
+ # suppose input data in shape of [N, C, D, H, W], `pool_size` is [l, m, n],
+ # output shape is [N, C, l, m, n], adaptive pool divide D, H and W dimensions
+ # of input data into l * m * n grids averagely and performs poolings in each
+ # grid to get output.
+ # adaptive average pool performs calculations as follow:
+ #
+ # for i in range(l):
+ # for j in range(m):
+ # for k in range(n):
+ # dstart = floor(i * D / l)
+ # dend = ceil((i + 1) * D / l)
+ # hstart = floor(j * H / m)
+ # hend = ceil((j + 1) * H / m)
+ # wstart = floor(k * W / n)
+ # wend = ceil((k + 1) * W / n)
+ # output[:, :, i, j, k] =
+ # avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
+ #
+
+ import paddle
+ data = paddle.rand(shape=[1,3,32,32,32])
+ pool_out = paddle.fluid.layers.adaptive_pool3d(
+ input=data,
+ pool_size=[3, 3, 3],
+ pool_type='max')
+ """
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ 'adaptive_pool3d',
+ )
+ check_type(pool_type, 'pool_type', str, 'adaptive_pool3d')
+ check_type(pool_size, 'pool_size', (int, list, tuple), 'adaptive_pool3d')
+ check_type(require_index, 'require_index', bool, 'adaptive_pool3d')
+ if pool_type not in ["max", "avg"]:
+ raise ValueError(
+ "Unknown pool_type: '%s'. It can only be 'max' or 'avg'.",
+ str(pool_type),
+ )
+
+ if pool_type == "avg" and require_index:
+ raise ValueError(
+ "invalid setting 'require_index' true when 'pool_type' is 'avg'."
+ )
+
+ pool_size = utils.convert_to_list(pool_size, 3, 'pool_size')
+
+ if pool_type == "max":
+ l_type = 'max_pool3d_with_index'
+ else:
+ l_type = "pool3d"
+
+ helper = LayerHelper(l_type, **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+
+ outputs = {"Out": pool_out}
+ if pool_type == "max":
+ mask = helper.create_variable_for_type_inference(dtype)
+ outputs["Mask"] = mask
+
+ helper.append_op(
+ type=l_type,
+ inputs={"X": input},
+ outputs=outputs,
+ attrs={
+ "pooling_type": pool_type,
+ "ksize": pool_size,
+ "adaptive": True,
+ },
+ )
+
+ return (pool_out, mask) if require_index else pool_out
+
+
+def batch_norm(
+ input,
+ act=None,
+ is_test=False,
+ momentum=0.9,
+ epsilon=1e-05,
+ param_attr=None,
+ bias_attr=None,
+ data_layout='NCHW',
+ in_place=False,
+ name=None,
+ moving_mean_name=None,
+ moving_variance_name=None,
+ do_model_average_for_mean_and_var=True,
+ use_global_stats=False,
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Batch Normalization Layer**
+
+ Can be used as a normalizer function for convolution or fully_connected operations.
+ The required data format for this layer is one of the following:
+
+ 1. NHWC `[batch, in_height, in_width, in_channels]`
+
+ 2. NCHW `[batch, in_channels, in_height, in_width]`
+
+ Refer to `Batch Normalization: Accelerating Deep Network Training by Reducing
+ Internal Covariate Shift `_
+ for more details.
+
+ :math:`input` is the input features over a mini-batch.
+
+ .. math::
+
+ \\mu_{\\beta} &\\gets \\frac{1}{m} \\sum_{i=1}^{m} x_i \\qquad &//\\
+ \ mini-batch\ mean \\\\
+ \\sigma_{\\beta}^{2} &\\gets \\frac{1}{m} \\sum_{i=1}^{m}(x_i - \\
+ \\mu_{\\beta})^2 \\qquad &//\ mini-batch\ variance \\\\
+ \\hat{x_i} &\\gets \\frac{x_i - \\mu_\\beta} {\\sqrt{\\
+ \\sigma_{\\beta}^{2} + \\epsilon}} \\qquad &//\ normalize \\\\
+ y_i &\\gets \\gamma \\hat{x_i} + \\beta \\qquad &//\ scale\ and\ shift
+
+ moving\_mean = moving\_mean * momentum + mini-batch\_mean * (1. - momentum) \\\\
+ moving\_var = moving\_var * momentum + mini-batch\_var * (1. - momentum)
+
+
+ moving_mean is global mean and moving_var is global variance.
+
+ When use_global_stats = True, the :math:`\\mu_{\\beta}`
+ and :math:`\\sigma_{\\beta}^{2}` are not the statistics of one mini-batch.
+ They are global (or running) statistics. (It usually got from the
+ pre-trained model.)
+ The training and testing (or inference) have the same behavior:
+
+ .. math::
+
+ \\hat{x_i} &\\gets \\frac{x_i - \\mu_\\beta} {\\sqrt{\\
+ \\sigma_{\\beta}^{2} + \\epsilon}} \\\\
+ y_i &\\gets \\gamma \\hat{x_i} + \\beta
+
+ Note:
+ if build_strategy.sync_batch_norm=True, the batch_norm in network will use
+ sync_batch_norm automatically.
+ `is_test = True` can only be used in test program and inference program, `is_test` CANNOT be set to True in train program, if you want to use global status from pre_train model in train program, please set `use_global_stats = True`.
+
+ Args:
+ input(Tensor): The rank of input Tensor can be 2, 3, 4, 5. The data type
+ is float16 or float32 or float64.
+ act(string, Default None): Activation type, linear|relu|prelu|...
+ is_test (bool, Default False): A flag indicating whether it is in
+ test phrase or not.
+ momentum(float|Tensor, Default 0.9): The value used for the moving_mean and
+ moving_var computation. This should be a float number or a Tensor with
+ shape [1] and data type as float32. The updated formula is:
+ :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)`
+ :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)`
+ Default is 0.9.
+ epsilon(float, Default 1e-05): A value added to the denominator for
+ numerical stability. Default is 1e-5.
+ param_attr(ParamAttr|None): The parameter attribute for Parameter `scale`
+ of batch_norm. If it is set to None or one attribute of ParamAttr, batch_norm
+ will create ParamAttr as param_attr, the name of scale can be set in ParamAttr.
+ If the Initializer of the param_attr is not set, the parameter is initialized
+ with Xavier. Default: None.
+ bias_attr(ParamAttr|None): The parameter attribute for the bias of batch_norm.
+ If it is set to None or one attribute of ParamAttr, batch_norm
+ will create ParamAttr as bias_attr, the name of bias can be set in ParamAttr.
+ If the Initializer of the bias_attr is not set, the bias is initialized zero.
+ Default: None.
+ data_layout (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+ in_place(bool, Default False): Make the input and output of batch norm reuse memory.
+ name(str|None): For detailed information, please refer to :ref:`api_guide_Name`.
+ Usually name is no need to set and None by default.
+ moving_mean_name(str, Default None): The name of moving_mean which store the global Mean. If it
+ is set to None, batch_norm will save global mean with a random name, otherwise, batch_norm
+ will save global mean with the string.
+ moving_variance_name(str, Default None): The name of the moving_variance which store the global Variance.
+ If it is set to None, batch_norm will save global variance with a random name, otherwise, batch_norm
+ will save global variance with the string.
+ do_model_average_for_mean_and_var(bool, Default True): Whether parameter mean and variance should do model
+ average when model average is enabled.
+ use_global_stats(bool, Default False): Whether to use global mean and
+ variance. In inference or test mode, set use_global_stats to true
+ or is_test to true, and the behavior is equivalent.
+ In train mode, when setting use_global_stats True, the global mean
+ and variance are also used during train period.
+ Returns:
+ A Tensor which is the result after applying batch normalization on the input,
+ has same shape and data type with input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+ x = paddle.static.data(name='x', shape=[3, 7, 3, 7], dtype='float32')
+ hidden1 = paddle.static.nn.fc(x=x, size=200)
+ print(hidden1.shape)
+ # [3, 200]
+ hidden2 = paddle.static.nn.batch_norm(input=hidden1)
+ print(hidden2.shape)
+ # [3, 200]
+ """
+ assert (
+ bias_attr is not False
+ ), "bias_attr should not be False in batch_norm."
+ helper = LayerHelper('batch_norm', **locals())
+
+ check_variable_and_dtype(
+ input, 'input', ['float16', 'float32', 'float64'], 'batch_norm'
+ )
+ dtype = helper.input_dtype()
+
+ # use fp32 for bn parameter
+ if dtype == core.VarDesc.VarType.FP16:
+ dtype = core.VarDesc.VarType.FP32
+
+ input_shape = input.shape
+ if data_layout == 'NCHW':
+ channel_num = input_shape[1]
+ else:
+ if data_layout == 'NHWC':
+ channel_num = input_shape[-1]
+ else:
+ raise ValueError("unsupported data layout:" + data_layout)
+
+ param_shape = [channel_num]
+
+ # create parameter
+ scale = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=param_shape,
+ dtype=dtype,
+ default_initializer=Constant(1.0),
+ )
+ bias = helper.create_parameter(
+ attr=helper.bias_attr, shape=param_shape, dtype=dtype, is_bias=True
+ )
+
+ mean = helper.create_parameter(
+ attr=ParamAttr(
+ name=moving_mean_name,
+ initializer=Constant(0.0),
+ trainable=False,
+ do_model_average=do_model_average_for_mean_and_var,
+ ),
+ shape=param_shape,
+ dtype=dtype,
+ )
+ mean.stop_gradient = True
+
+ variance = helper.create_parameter(
+ attr=ParamAttr(
+ name=moving_variance_name,
+ initializer=Constant(1.0),
+ trainable=False,
+ do_model_average=do_model_average_for_mean_and_var,
+ ),
+ shape=param_shape,
+ dtype=dtype,
+ )
+ variance.stop_gradient = True
+
+ # create output
+ # mean and mean_out share the same memory
+ mean_out = mean
+ # variance and variance_out share the same memory
+ variance_out = variance
+
+ if in_dygraph_mode():
+ inputs_has_MomemtumTensor = False
+ attrs_has_momentum = False
+ tmp_tensor_type = core.eager.Tensor
+ if isinstance(momentum, tmp_tensor_type):
+ inputs_has_MomemtumTensor = True
+ else:
+ attrs_has_momentum = True
+
+ attrs_ = ()
+ if attrs_has_momentum:
+ attrs_ = (
+ 'momentum',
+ momentum,
+ 'epsilon',
+ epsilon,
+ 'is_test',
+ is_test,
+ 'data_layout',
+ data_layout,
+ 'use_mkldnn',
+ False,
+ 'fuse_with_relu',
+ False,
+ 'use_global_stats',
+ use_global_stats,
+ )
+ else:
+ attrs_ = (
+ 'epsilon',
+ epsilon,
+ 'is_test',
+ is_test,
+ 'data_layout',
+ data_layout,
+ 'use_mkldnn',
+ False,
+ 'fuse_with_relu',
+ False,
+ 'use_global_stats',
+ use_global_stats,
+ )
+ if inputs_has_MomemtumTensor:
+ batch_norm_out, _, _, _, _, _ = _legacy_C_ops.batch_norm(
+ input,
+ scale,
+ bias,
+ mean,
+ variance,
+ momentum,
+ mean_out,
+ variance_out,
+ *attrs_,
+ )
+ else:
+ batch_norm_out, _, _, _, _, _ = _legacy_C_ops.batch_norm(
+ input,
+ scale,
+ bias,
+ mean,
+ variance,
+ None,
+ mean_out,
+ variance_out,
+ *attrs_,
+ )
+
+ return dygraph_utils._append_activation_in_dygraph(
+ batch_norm_out, act=act, use_mkldnn=False
+ )
+
+ saved_mean = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ saved_variance = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ reserve_space = None
+ if not is_test:
+ reserve_space = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype(), stop_gradient=True
+ )
+
+ batch_norm_out = (
+ input if in_place else helper.create_variable_for_type_inference(dtype)
+ )
+
+ inputs = {
+ "X": input,
+ "Scale": scale,
+ "Bias": bias,
+ "Mean": mean,
+ "Variance": variance,
+ "MeanOut": mean_out,
+ "VarianceOut": variance_out,
+ }
+ attrs = {
+ "epsilon": epsilon,
+ "is_test": is_test,
+ "data_layout": data_layout,
+ "use_mkldnn": False,
+ "fuse_with_relu": False,
+ "use_global_stats": use_global_stats,
+ }
+ if isinstance(momentum, Variable):
+ inputs['MomemtumTensor'] = momentum
+ else:
+ attrs['momentum'] = momentum
+
+ outputs = {
+ "Y": batch_norm_out,
+ "MeanOut": mean_out,
+ "VarianceOut": variance_out,
+ "SavedMean": saved_mean,
+ "SavedVariance": saved_variance,
+ }
+ if reserve_space is not None:
+ outputs["ReserveSpace"] = reserve_space
+
+ helper.append_op(
+ type="batch_norm", inputs=inputs, outputs=outputs, attrs=attrs
+ )
+
+ return helper.append_activation(batch_norm_out)
+
+
+def inplace_abn(
+ input,
+ act=None,
+ is_test=False,
+ momentum=0.9,
+ epsilon=1e-05,
+ param_attr=None,
+ bias_attr=None,
+ data_layout='NCHW',
+ name=None,
+ moving_mean_name=None,
+ moving_variance_name=None,
+ do_model_average_for_mean_and_var=True,
+ use_global_stats=False,
+ act_alpha=1.0,
+):
+ r"""
+ **In-place Activation Batch Normalization Layer**
+
+ This layer calculates batch normalization and activation with in-place memory.
+ For batch normalization calculations, see `fluid.layers.batch_norm`.
+ For in-place activation batch normalization, see `In-Place Activated BatchNorm for
+ Memory-Optimized Training of DNNs `_
+
+ `inplace_abn` only support activation type as `None`, `identity`, `leaky_relu`,
+ `elu` currently.
+ `inplace_abn` only support data type as `float32`, `float64` currently.
+
+ Note:
+ if build_strategy.sync_batch_norm=True, the batch_norm in network will use
+ sync_batch_norm automatically.
+ `is_test = True` can only be used in test program and inference program, `is_test` CANNOT be set to True in train program, if you want to use global status from pre_train model in train program, please set `use_global_stats = True`.
+
+ Args:
+ input(Variable): The rank of input variable can be 2, 3, 4, 5. The data type
+ is float16 or float32 or float64.
+ act(string, Default None): Activation type, linear|relu|prelu|...
+ is_test (bool, Default False): A flag indicating whether it is in
+ test phrase or not.
+ momentum(float|Variable, Default 0.9): The value used for the moving_mean and
+ moving_var computation. This should be a float number or a Variable with
+ shape [1] and data type as float32. The updated formula is:
+ :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)`
+ :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)`
+ Default is 0.9.
+ epsilon(float, Default 1e-05): A value added to the denominator for
+ numerical stability. Default is 1e-5.
+ param_attr(ParamAttr|None): The parameter attribute for Parameter `scale`
+ of inplace_abn. If it is set to None or one attribute of ParamAttr, inplace_abn
+ will create ParamAttr as param_attr, the name of scale can be set in ParamAttr.
+ If the Initializer of the param_attr is not set, the parameter is initialized
+ with Xavier. Default: None.
+ bias_attr(ParamAttr|None): The parameter attribute for the bias of inplace_abn.
+ If it is set to None or one attribute of ParamAttr, inplace_abn
+ will create ParamAttr as bias_attr, the name of bias can be set in ParamAttr.
+ If the Initializer of the bias_attr is not set, the bias is initialized zero.
+ Default: None.
+ data_layout (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+ name(str|None): For detailed information, please refer to :ref:`api_guide_Name`.
+ Usually name is no need to set and None by default.
+ moving_mean_name(str, Default None): The name of moving_mean which store the global Mean. If it
+ is set to None, inplace_abn will save global mean with a random name, otherwise, inplace_abn
+ will save global mean with the string.
+ moving_variance_name(str, Default None): The name of the moving_variance which store the global Variance.
+ If it is set to None, inplace_abn, will save global variance with a random name, otherwise, inplace_abn
+ will save global variance with the string.
+ do_model_average_for_mean_and_var(bool, Default True): Whether parameter mean and variance should do model
+ average when model average is enabled.
+ use_global_stats(bool, Default False): Whether to use global mean and
+ variance. In inference or test mode, set use_global_stats to true
+ or is_test to true, and the behavior is equivalent.
+ In train mode, when setting use_global_stats True, the global mean
+ and variance are also used during train period.
+ act_alpha(float, Default 1.0): when activation is in ['elu', 'identity', 'leaky_relu'],
+ inplace activative batch normalization will be used, and alpha parameter for activation
+ can be given by this parameter.
+ Returns:
+ A Variable holding Tensor which is the result after applying batch normalization and activation on the input,
+ has same shape and data type with input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[3, 7, 3, 7], dtype='float32')
+ hidden1 = fluid.layers.fc(input=x, size=200, param_attr='fc1.w')
+ hidden2 = fluid.layers.inplace_abn(input=hidden1)
+ hidden3 = fluid.layers.inplace_abn(input=hidden2, act='leaky_relu', act_alpha=0.2)
+
+ """
+ assert act in [None, 'identity', 'leaky_relu', 'elu'], (
+ "inplace_abn only support act as None, 'identity', "
+ "'leaky_relu', 'elu' currently"
+ )
+ assert (
+ bias_attr is not False
+ ), "bias_attr should not be False in inplace_abn."
+ helper = LayerHelper('inplace_abn', **locals())
+
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'inplace_abn'
+ )
+ dtype = helper.input_dtype()
+
+ input_shape = input.shape
+ if data_layout == 'NCHW':
+ channel_num = input_shape[1]
+ else:
+ if data_layout == 'NHWC':
+ channel_num = input_shape[-1]
+ else:
+ raise ValueError("unsupported data layout:" + data_layout)
+
+ param_shape = [channel_num]
+
+ # create parameter
+ scale = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=param_shape,
+ dtype=dtype,
+ default_initializer=Constant(1.0),
+ )
+ bias = helper.create_parameter(
+ attr=helper.bias_attr, shape=param_shape, dtype=dtype, is_bias=True
+ )
+
+ mean = helper.create_parameter(
+ attr=ParamAttr(
+ name=moving_mean_name,
+ initializer=Constant(0.0),
+ trainable=False,
+ do_model_average=do_model_average_for_mean_and_var,
+ ),
+ shape=param_shape,
+ dtype=dtype,
+ )
+ mean.stop_gradient = True
+
+ variance = helper.create_parameter(
+ attr=ParamAttr(
+ name=moving_variance_name,
+ initializer=Constant(1.0),
+ trainable=False,
+ do_model_average=do_model_average_for_mean_and_var,
+ ),
+ shape=param_shape,
+ dtype=dtype,
+ )
+ variance.stop_gradient = True
+
+ # create output
+ # mean and mean_out share the same memory
+ mean_out = mean
+ # variance and variance out share the same memory
+ variance_out = variance
+ # batch_norm_out and input share the same memory
+ batch_norm_out = input
+
+ if in_dygraph_mode():
+ inputs_has_MomemtumTensor = False
+ attrs_has_momentum = False
+ tmp_tensor_type = core.eager.Tensor
+ if isinstance(momentum, tmp_tensor_type):
+ inputs_has_MomemtumTensor = True
+ else:
+ attrs_has_momentum = True
+
+ attrs__ = ()
+ if attrs_has_momentum:
+ attrs__ = (
+ 'momentum',
+ momentum,
+ 'epsilon',
+ epsilon,
+ 'is_test',
+ is_test,
+ 'data_layout',
+ data_layout,
+ 'use_mkldnn',
+ False,
+ 'fuse_with_relu',
+ False,
+ 'use_global_stats',
+ use_global_stats,
+ 'activation',
+ act,
+ 'alpha',
+ act_alpha,
+ )
+ else:
+ attrs__ = (
+ 'epsilon',
+ epsilon,
+ 'is_test',
+ is_test,
+ 'data_layout',
+ data_layout,
+ 'use_mkldnn',
+ False,
+ 'fuse_with_relu',
+ False,
+ 'use_global_stats',
+ use_global_stats,
+ 'activation',
+ act,
+ 'alpha',
+ act_alpha,
+ )
+ if inputs_has_MomemtumTensor:
+ batch_norm_out, _, _, _, _, _ = _legacy_C_ops.inplace_abn_(
+ input,
+ scale,
+ bias,
+ mean,
+ variance,
+ momentum,
+ mean_out,
+ variance_out,
+ *attrs__,
+ )
+ return batch_norm_out
+ else:
+ batch_norm_out, _, _, _, _, _ = _legacy_C_ops.inplace_abn_(
+ input,
+ scale,
+ bias,
+ mean,
+ variance,
+ None,
+ mean_out,
+ variance_out,
+ *attrs__,
+ )
+ return batch_norm_out
+
+ saved_mean = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ saved_variance = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ reserve_space = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+
+ inputs = {
+ "X": input,
+ "Scale": scale,
+ "Bias": bias,
+ "Mean": mean,
+ "Variance": variance,
+ }
+ attrs = {
+ "epsilon": epsilon,
+ "is_test": is_test,
+ "data_layout": data_layout,
+ "use_mkldnn": False,
+ "fuse_with_relu": False,
+ "use_global_stats": use_global_stats,
+ "activation": act,
+ "alpha": act_alpha,
+ }
+ if isinstance(momentum, Variable):
+ inputs['MomemtumTensor'] = momentum
+ else:
+ attrs['momentum'] = momentum
+ outputs = {
+ "Y": batch_norm_out,
+ "MeanOut": mean_out,
+ "VarianceOut": variance_out,
+ "SavedMean": saved_mean,
+ "SavedVariance": saved_variance,
+ }
+ if reserve_space is not None:
+ outputs["ReserveSpace"] = reserve_space
+
+ helper.append_op(
+ type="inplace_abn", inputs=inputs, outputs=outputs, attrs=attrs
+ )
+
+ return batch_norm_out
+
+
+def instance_norm(
+ input, epsilon=1e-05, param_attr=None, bias_attr=None, name=None
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Instance Normalization Layer**
+
+ Can be used as a normalizer function for convolution or fully_connected operations.
+ The required data format for this layer is one of the following:
+
+ DataLayout: NCHW `[batch, in_channels, in_height, in_width]`
+
+ Refer to `Instance Normalization: The Missing Ingredient for
+ Fast Stylization `_
+ for more details.
+
+ :math:`input` is the input features over a mini-batch.
+
+ .. math::
+
+ \\mu_{\\beta} &\\gets \\frac{1}{HW} \\sum_{i=1}^{HW} x_i \\qquad &//\\
+ \\ mean\ of\ one\ feature\ map\ in\ mini-batch \\\\
+ \\sigma_{\\beta}^{2} &\\gets \\frac{1}{HW} \\sum_{i=1}^{HW}(x_i - \\
+ \\mu_{\\beta})^2 \\qquad &//\ variance\ of\ one\ feature\ map\ in\ mini-batch \\\\
+ \\hat{x_i} &\\gets \\frac{x_i - \\mu_\\beta} {\\sqrt{\\
+ \\sigma_{\\beta}^{2} + \\epsilon}} \\qquad &//\ normalize \\\\
+ y_i &\\gets \\gamma \\hat{x_i} + \\beta \\qquad &//\ scale\ and\ shift
+
+ Note:
+ `H` means height of feature map, `W` means width of feature map.
+
+ Args:
+ input(Tensor): The rank of input tensor can be 2, 3, 4, 5.
+ The data type is float32 or float64.
+ epsilon(float, Default 1e-05): A value added to the denominator for
+ numerical stability. Default is 1e-5.
+ param_attr(ParamAttr|None|bool, optional): The parameter attribute for Parameter `scale`
+ of instance_norm. If it is set to None or one attribute of ParamAttr, instance_norm
+ will create ParamAttr as param_attr, the name of scale can be set in ParamAttr.
+ If the Initializer of the param_attr is not set, the parameter is initialized
+ with Xavier. If the param_attr is set to False, instance_norm will not create param_attr.
+ Default: None.
+ bias_attr(ParamAttr|None|bool, optional): The parameter attribute for the bias of instance_norm.
+ If it is set to None or one attribute of ParamAttr, instance_norm
+ will create ParamAttr as bias_attr, the name of bias can be set in ParamAttr.
+ If the Initializer of the bias_attr is not set, the bias is initialized zero.
+ If the bias_attr is set to False, instance_norm will not create bias_attr.
+ Default: None.
+ name(string, Default None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+
+ Returns:
+ A Tensor which is the result after applying instance normalization on the input,
+ has same shape and data type with input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ x = paddle.static.data(name='x', shape=[3, 7, 3, 7], dtype='float32')
+ hidden1 = paddle.static.nn.fc(x, size=200)
+ hidden2 = paddle.static.nn.instance_norm(hidden1)
+ """
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'instance_norm'
+ )
+ if param_attr is False:
+ assert (
+ bias_attr is False
+ ), "param_attr and bias_attr must be set to Fasle at the same time in instance_norm"
+
+ helper = LayerHelper('instance_norm', **locals())
+ dtype = helper.input_dtype()
+
+ # use fp32 for in parameter
+ if dtype == core.VarDesc.VarType.FP16:
+ dtype = core.VarDesc.VarType.FP32
+
+ input_shape = input.shape
+ if len(input.shape) < 2 or len(input.shape) > 5:
+ raise ValueError(
+ 'expected 2D or 3D or 4D or 5D input (got {}D input, input shape is: {})'.format(
+ len(input.shape), input_shape
+ )
+ )
+ channel_num = input_shape[1]
+
+ param_shape = [channel_num]
+
+ if param_attr != False and bias_attr != False:
+ # create parameter
+ scale = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=param_shape,
+ dtype=dtype,
+ default_initializer=Constant(1.0),
+ )
+ bias = helper.create_parameter(
+ attr=helper.bias_attr,
+ shape=param_shape,
+ dtype=dtype,
+ is_bias=True,
+ default_initializer=Constant(0.0),
+ )
+
+ # create output
+ saved_mean = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ saved_variance = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+
+ instance_norm_out = helper.create_variable_for_type_inference(dtype)
+
+ inputs = {"X": input}
+ if param_attr != False and bias_attr != False:
+ inputs["Scale"] = scale
+ inputs["Bias"] = bias
+
+ helper.append_op(
+ type="instance_norm",
+ inputs=inputs,
+ outputs={
+ "Y": instance_norm_out,
+ "SavedMean": saved_mean,
+ "SavedVariance": saved_variance,
+ },
+ attrs={
+ "epsilon": epsilon,
+ },
+ )
+
+ return instance_norm_out
+
+
+@static_only
+def data_norm(
+ input,
+ act=None,
+ epsilon=1e-05,
+ param_attr=None,
+ data_layout='NCHW',
+ in_place=False,
+ name=None,
+ moving_mean_name=None,
+ moving_variance_name=None,
+ do_model_average_for_mean_and_var=True,
+ slot_dim=-1,
+ sync_stats=False,
+ summary_decay_rate=0.9999999,
+ enable_scale_and_shift=False,
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Data Normalization Layer**
+
+ This op can be used as a normalizer function for conv2d and fully_connected operations.
+ The required data format for this layer is one of the following:
+
+ 1. NHWC `[batch, in_height, in_width, in_channels]`
+
+ 2. NCHW `[batch, in_channels, in_height, in_width]`
+
+ :math:`input` is the input features over a mini-batch.
+
+ .. math::
+
+ \\mu_{\\beta} &\\gets \\frac{1}{m} \\sum_{i=1}^{m} x_i \\qquad &//\\
+ \ mini-batch\ mean \\\\
+ \\sigma_{\\beta}^{2} &\\gets \\frac{1}{m} \\sum_{i=1}^{m}(x_i - \\
+ \\mu_{\\beta})^2 \\qquad &//\ mini-batch\ variance \\\\
+ \\hat{x_i} &\\gets \\frac{x_i - \\mu_\\beta} {\\sqrt{\\
+ \\sigma_{\\beta}^{2} + \\epsilon}} \\qquad &//\ normalize \\\\
+ y_i &\\gets \\gamma \\hat{x_i} + \\beta \\qquad &//\ scale\ and\ shift
+
+ Args:
+ input(Tensor): The input Tensor.
+ act(string, Default None): Activation type, linear|relu|prelu|...
+ epsilon(float, Default 1e-05):
+ param_attr(ParamAttr): The parameter attribute for Parameter `scale`.
+ data_layout (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+ in_place(bool, Default False): Make the input and output of batch norm reuse memory.
+ name(string, Default None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+ moving_mean_name(string, Default None): The name of moving_mean which store the global Mean.
+ moving_variance_name(string, Default None): The name of the moving_variance which store the global Variance.
+ do_model_average_for_mean_and_var(bool, Default True): Whether parameter mean and variance
+ should do model average when model average is enabled.
+ slot_dim(int): The embedding dimension of one slot. Slot is a set of one specific feature. In pslib mode, we
+ distinguish feature ids by slot and pull their embeddings from parameter server (pslib). The first
+ place of the embedding is the historical show number (occurence time of this feature id with a label 0).
+ If the input of this op is concated by slot-wise embeddings, and the show number is zero when this slot
+ is new or empty, the normalization result may be impractical. To avoid this, we add slot_dim to locate
+ the show number and judge if the show number is zero. If so, we choose to skip normalization on this
+ embedding.
+ sync_stats(bool, Default False): When running with multiple GPU cards, using allreduce to sync the
+ summary messages.
+ summary_decay_rate(float, Default 0.9999999): The decay rate when updating summary.
+ enable_scale_and_shift(bool, Default False): do scale&shift after normalization.
+
+ Returns:
+ Tensor: A tensor which is the result after applying data normalization on the input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.randn(shape=[32,100])
+ hidden2 = paddle.static.nn.data_norm(input=x)
+ """
+ helper = LayerHelper('data_norm', **locals())
+ dtype = helper.input_dtype()
+
+ input_shape = input.shape
+ if data_layout == 'NCHW':
+ channel_num = input_shape[1]
+ else:
+ if data_layout == 'NHWC':
+ channel_num = input_shape[-1]
+ else:
+ raise ValueError("unsupported data layout:" + data_layout)
+
+ param_shape = [channel_num]
+
+ batch_size_default = 1e4
+ batch_sum_default = 0.0
+ batch_square_sum_default = 1e4
+ scale_w_default = 1.0
+ bias_default = 0.0
+
+ if param_attr and isinstance(param_attr, dict):
+ batch_size_default = param_attr.get("batch_size", 1e4)
+ batch_sum_default = param_attr.get("batch_sum", 0.0)
+ batch_square_sum_default = param_attr.get("batch_square", 1e4)
+ if enable_scale_and_shift:
+ scale_w_default = param_attr.get("scale_w", 1.0)
+ bias_default = param_attr.get("bias", 0.0)
+
+ # create scale and shift(bias) when enable_scale_and_shift is True
+ if name == None:
+ name = "dn"
+ if enable_scale_and_shift:
+ scale_w = helper.create_parameter(
+ attr=ParamAttr(
+ name=name + '.scale_w',
+ initializer=Constant(value=float(scale_w_default)),
+ trainable=True,
+ ),
+ shape=param_shape,
+ dtype=input.dtype,
+ )
+ bias = helper.create_parameter(
+ attr=ParamAttr(
+ name=name + '.bias',
+ initializer=Constant(value=float(bias_default)),
+ trainable=True,
+ ),
+ shape=param_shape,
+ dtype=input.dtype,
+ )
+ # create parameter
+ batch_size = helper.create_parameter(
+ attr=ParamAttr(
+ name=name + '.batch_size',
+ initializer=Constant(value=float(batch_size_default)),
+ trainable=True,
+ ),
+ shape=param_shape,
+ dtype=input.dtype,
+ )
+
+ batch_sum = helper.create_parameter(
+ attr=ParamAttr(
+ name=name + '.batch_sum',
+ initializer=Constant(value=float(batch_sum_default)),
+ trainable=True,
+ ),
+ shape=param_shape,
+ dtype=input.dtype,
+ )
+
+ batch_square_sum = helper.create_parameter(
+ attr=ParamAttr(
+ name=name + '.batch_square_sum',
+ initializer=Constant(value=float(batch_square_sum_default)),
+ trainable=True,
+ ),
+ shape=param_shape,
+ dtype=input.dtype,
+ )
+
+ means = helper.create_variable(dtype=dtype, stop_gradient=True)
+ scales = helper.create_variable(dtype=dtype, stop_gradient=True)
+
+ data_norm_out = input if in_place else helper.create_variable(dtype=dtype)
+
+ inputs = {
+ "X": input,
+ "BatchSize": batch_size,
+ "BatchSum": batch_sum,
+ "BatchSquareSum": batch_square_sum,
+ }
+ attrs = {
+ "epsilon": epsilon,
+ "data_layout": data_layout,
+ "sync_stats": sync_stats,
+ "summary_decay_rate": summary_decay_rate,
+ }
+ if slot_dim > 0:
+ attrs["slot_dim"] = slot_dim
+ if enable_scale_and_shift:
+ attrs["enable_scale_and_shift"] = enable_scale_and_shift
+ if enable_scale_and_shift:
+ inputs["scale_w"] = scale_w
+ inputs["bias"] = bias
+ helper.append_op(
+ type="data_norm",
+ inputs=inputs,
+ outputs={
+ "Y": data_norm_out,
+ "Means": means,
+ "Scales": scales,
+ "BatchSize": batch_size,
+ "BatchSum": batch_sum,
+ "BatchSquareSum": batch_square_sum,
+ },
+ attrs=attrs,
+ )
+
+ return helper.append_activation(data_norm_out)
+
+
+@templatedoc()
+def layer_norm(
+ input,
+ scale=True,
+ shift=True,
+ begin_norm_axis=1,
+ epsilon=1e-05,
+ param_attr=None,
+ bias_attr=None,
+ act=None,
+ name=None,
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Layer Normalization Layer**
+
+ The API implements the function of the Layer Normalization Layer and can be applied to mini-batch input data.
+ Refer to `Layer Normalization `_
+
+ The formula is as follows:
+
+ .. math::
+
+ \\mu & = \\frac{1}{H}\\sum_{i=1}^{H} x_i
+
+ \\sigma & = \\sqrt{\\frac{1}{H}\sum_{i=1}^{H}{(x_i - \\mu)^2} + \\epsilon}
+
+ y & = f(\\frac{g}{\\sigma}(x - \\mu) + b)
+
+ - :math:`x`: the vector representation of the summed inputs to the neurons in that layer.
+ - :math:`H`: the number of hidden units in a layers
+ - :math:`\\epsilon`: the small value added to the variance to prevent division by zero.
+ - :math:`g`: the trainable scale parameter.
+ - :math:`b`: the trainable bias parameter.
+
+ Args:
+ input(Tensor): A multi-dimension ``Tensor`` , and the data type is float32 or float64.
+ scale(bool, optional): Whether to learn the adaptive gain :math:`g` after
+ normalization. Default: True.
+ shift(bool, optional): Whether to learn the adaptive bias :math:`b` after
+ normalization. Default: True.
+ begin_norm_axis(int, optional): The normalization will be performed along
+ dimensions from :attr:`begin_norm_axis` to :attr:`rank(input)`.
+ Default: 1.
+ epsilon(float, optional): The small value added to the variance to prevent
+ division by zero. Default: 1e-05.
+ param_attr(ParamAttr, optional): The parameter attribute for the learnable
+ gain :math:`g`. If :attr:`scale` is False, :attr:`param_attr` is
+ omitted. If :attr:`scale` is True and :attr:`param_attr` is None,
+ a default :code:`ParamAttr` would be added as scale. The
+ :attr:`param_attr` is initialized as 1 if it is added. Default: None.
+ bias_attr(ParamAttr, optional): The parameter attribute for the learnable
+ bias :math:`b`. If :attr:`shift` is False, :attr:`bias_attr` is
+ omitted. If :attr:`shift` is True and :attr:`param_attr` is None,
+ a default :code:`ParamAttr` would be added as bias. The
+ :attr:`bias_attr` is initialized as 0 if it is added. Default: None.
+ act(str, optional): Activation to be applied to the output of layer normalization.
+ Default: None.
+ name(str): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor: ``Tensor`` indicating the normalized result, the data type is the same as ``input`` , and the return dimension is the same as ``input`` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ x = paddle.static.data(name='x', shape=[8, 32, 32], dtype='float32')
+ output = paddle.static.nn.layer_norm(input=x, begin_norm_axis=1)
+ print(output.shape) # [8, 32, 32]
+ """
+ assert (
+ _non_static_mode() is not True
+ ), "please use LayerNorm instead of layer_norm in dygraph mode!"
+ helper = LayerHelper('layer_norm', **locals())
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'layer_norm'
+ )
+ dtype = helper.input_dtype()
+
+ # create intput and parameters
+ inputs = {'X': input}
+ input_shape = input.shape
+ param_shape = [reduce(lambda x, y: x * y, input_shape[begin_norm_axis:])]
+ if scale:
+ assert (
+ param_attr is not False
+ ), "param_attr should not be False when using scale."
+ scale = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=param_shape,
+ dtype=dtype,
+ default_initializer=Constant(1.0),
+ )
+ inputs['Scale'] = scale
+ else:
+ if param_attr:
+ warnings.warn("param_attr is only available with scale is True.")
+ if shift:
+ assert (
+ bias_attr is not False
+ ), "bias_attr should not be False when using shift."
+ bias = helper.create_parameter(
+ attr=helper.bias_attr, shape=param_shape, dtype=dtype, is_bias=True
+ )
+ inputs['Bias'] = bias
+ else:
+ if bias_attr:
+ warnings.warn("bias_attr is only available with shift is True.")
+
+ # create output
+ mean_out = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ variance_out = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ layer_norm_out = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type="layer_norm",
+ inputs=inputs,
+ outputs={
+ "Y": layer_norm_out,
+ "Mean": mean_out,
+ "Variance": variance_out,
+ },
+ attrs={"epsilon": epsilon, "begin_norm_axis": begin_norm_axis},
+ )
+
+ return helper.append_activation(layer_norm_out)
+
+
+@templatedoc()
+def group_norm(
+ input,
+ groups,
+ epsilon=1e-05,
+ param_attr=None,
+ bias_attr=None,
+ act=None,
+ data_layout='NCHW',
+ name=None,
+):
+ """
+ :api_attr: Static Graph
+
+ **Group Normalization Layer**
+
+ Refer to `Group Normalization `_ .
+
+ Parameters:
+ input(Tensor): Tensor with dimension greater than 1, the data type is float32 or float64.
+ groups(int): The number of groups that divided from channels, the data type
+ is int32.
+ epsilon(float, optional): The small value added to the variance to prevent
+ division by zero, the data type is float32. Default: 1e-05.
+ param_attr(ParamAttr|bool, optional): ParamAttr object that specifies weight parameter
+ attribute. If a bool type, only False is supported, which means there is no weight parameter.
+ Default: None, the default weight parameter attribute is used. For more information, please
+ refer to :ref:`api_guide_ParamAttr` .
+ bias_attr(ParamAttr|bool, optional): ParamAttr object that specifies bias parameter
+ attribute. If a bool type, only False is supported, which means there is no bias parameter.
+ Default: None, the default bias parameter attribute is used. For more information, please
+ refer to :ref:`api_guide_ParamAttr` .
+ act(str, optional): Activation to be applied to the output of group normalization.
+ data_layout(str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, *]`.
+ name (str, optional): The default value is None. Normally there is no need for user to set this
+ property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor: A Tensor has same data type and data format with `input`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ data = paddle.static.data(name='data', shape=[2, 8, 32, 32], dtype='float32')
+ x = paddle.static.nn.group_norm(input=data, groups=4)
+ print(x.shape) # [2, 8, 32, 32]
+ """
+ helper = LayerHelper('group_norm', **locals())
+ dtype = helper.input_dtype()
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'group_norm'
+ )
+ # create intput and parameters
+ inputs = {'X': input}
+ input_shape = input.shape
+ if len(input_shape) < 2:
+ raise ValueError(
+ f"The dimensions of Op(fluid.layers.group_norm)'s input should be more than 1. But received {len(input_shape)}"
+ )
+ if data_layout != 'NCHW' and data_layout != 'NHWC':
+ raise ValueError(
+ "Param(data_layout) of Op(fluid.layers.group_norm) got wrong value: received "
+ + data_layout
+ + " but only NCHW or NHWC supported."
+ )
+ channel_num = input_shape[1] if data_layout == 'NCHW' else input_shape[-1]
+ param_shape = [channel_num]
+ if param_attr:
+ scale = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=param_shape,
+ dtype=dtype,
+ default_initializer=Constant(1.0),
+ )
+ inputs['Scale'] = scale
+ if bias_attr:
+ bias = helper.create_parameter(
+ attr=helper.bias_attr, shape=param_shape, dtype=dtype, is_bias=True
+ )
+ inputs['Bias'] = bias
+
+ # create output
+ mean_out = helper.create_variable(dtype=dtype, stop_gradient=True)
+ variance_out = helper.create_variable(dtype=dtype, stop_gradient=True)
+ group_norm_out = helper.create_variable(dtype=dtype)
+
+ helper.append_op(
+ type="group_norm",
+ inputs=inputs,
+ outputs={
+ "Y": group_norm_out,
+ "Mean": mean_out,
+ "Variance": variance_out,
+ },
+ attrs={
+ "epsilon": epsilon,
+ "groups": groups,
+ "data_layout": data_layout,
+ },
+ )
+
+ return helper.append_activation(group_norm_out)
+
+
+@templatedoc()
+def spectral_norm(weight, dim=0, power_iters=1, eps=1e-12, name=None):
+ r"""
+ :api_attr: Static Graph
+
+ **Spectral Normalization Layer**
+
+ This operation calculates the spectral normalization value of weight parameters of
+ fc, conv1d, conv2d, conv3d layers which should be 2-D, 3-D, 4-D, 5-D
+ Parameters. Output tensor will be in same shape with input tensor.
+ Calculations are showed as follows.
+
+ Step 1:
+ Generate vector U in shape of [H], and V in shape of [W].
+ While H is the :attr:`dim` th dimension of the input weights,
+ and W is the product result of remaining dimensions.
+
+ Step 2:
+ :attr:`power_iters` should be a positive integer, do following
+ calculations with U and V for :attr:`power_iters` rounds. Calculations
+ as follows:
+
+ .. math::
+
+ \mathbf{v} := \\frac{\mathbf{W}^{T} \mathbf{u}}{\|\mathbf{W}^{T} \mathbf{u}\|_2}
+
+ \mathbf{u} := \\frac{\mathbf{W}^{T} \mathbf{v}}{\|\mathbf{W}^{T} \mathbf{v}\|_2}
+
+ Step 3:
+ Calculate :math:`\sigma(\mathbf{W})` and normalize weight values.
+
+ .. math::
+
+ \sigma(\mathbf{W}) = \mathbf{u}^{T} \mathbf{W} \mathbf{v}
+
+ \mathbf{W} = \\frac{\mathbf{W}}{\sigma(\mathbf{W})}
+
+
+ Refer to `Spectral Normalization `_ .
+
+ Args:
+ weight(Tensor): ${weight_comment}
+ dim(int): ${dim_comment}
+ power_iters(int): ${power_iters_comment}
+ eps(float): ${eps_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor: A tensor of weight parameters after spectral normalization.
+ The data type and shape is same as input tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+ weight = paddle.static.data(name='weight', shape=[2, 8, 32, 32], dtype='float32')
+ x = paddle.static.nn.spectral_norm(weight=weight, dim=1, power_iters=2)
+ print(x.shape) # [2, 8, 32, 32]
+ """
+ helper = LayerHelper('spectral_norm', **locals())
+ check_variable_and_dtype(
+ weight, 'weight', ['float32', 'float64'], 'spectral_norm'
+ )
+ check_type(dim, 'dim', int, 'spectral_norm')
+ check_type(power_iters, 'power_iters', int, 'spectral_norm')
+ check_type(eps, 'eps', float, 'spectral_norm')
+ dtype = weight.dtype
+
+ # create intput and parameters
+ input_shape = weight.shape
+ assert weight.numel() > 0, "Any dimension of input cannot be equal to 0."
+ assert dim < len(input_shape), (
+ "The input `dim` should be less than the "
+ "rank of `weight`, but received dim="
+ "{}".format(dim)
+ )
+ h = input_shape[dim]
+ w = np.prod(input_shape) // h
+
+ u = helper.create_parameter(
+ attr=ParamAttr(),
+ shape=[h],
+ dtype=dtype,
+ default_initializer=Normal(0.0, 1.0),
+ )
+ u.stop_gradient = True
+ v = helper.create_parameter(
+ attr=ParamAttr(),
+ shape=[w],
+ dtype=dtype,
+ default_initializer=Normal(0.0, 1.0),
+ )
+ v.stop_gradient = True
+
+ if in_dygraph_mode():
+ return _C_ops.spectral_norm(weight, u, v, dim, power_iters, eps)
+
+ inputs = {'Weight': weight}
+ inputs['U'] = u
+ inputs['V'] = v
+
+ # create output
+ out = helper.create_variable(dtype=dtype)
+
+ helper.append_op(
+ type="spectral_norm",
+ inputs=inputs,
+ outputs={
+ "Out": out,
+ },
+ attrs={
+ "dim": dim,
+ "power_iters": power_iters,
+ "eps": eps,
+ },
+ )
+
+ return out
+
+
+def conv2d_transpose(
+ input,
+ num_filters,
+ output_size=None,
+ filter_size=None,
+ padding=0,
+ stride=1,
+ dilation=1,
+ groups=None,
+ param_attr=None,
+ bias_attr=None,
+ use_cudnn=True,
+ act=None,
+ name=None,
+ data_format='NCHW',
+):
+ r"""
+ :api_attr: Static Graph
+
+ The convolution2D transpose layer calculates the output based on the input,
+ filter, and dilations, strides, paddings. Input(Input) and output(Output)
+ are in NCHW or NHWC format. Where N is batch size, C is the number of channels,
+ H is the height of the feature, and W is the width of the feature.
+ Parameters(dilations, strides, paddings) are two elements. These two elements
+ represent height and width, respectively. The details of convolution transpose
+ layer, please refer to the following explanation and references
+ `therein `_.
+ If bias attribution and activation type are provided, bias is added to
+ the output of the convolution, and the corresponding activation function
+ is applied to the final result.
+
+ For each input :math:`X`, the equation is:
+
+ .. math::
+
+ Out = \sigma (W \\ast X + b)
+
+ Where:
+
+ * :math:`X`: Input value, a 4-D Tensor with NCHW or NHWC format.
+ * :math:`W`: Filter value, a 4-D Tensor with MCHW format.
+ * :math:`\\ast`: Convolution operation.
+ * :math:`b`: Bias value, a 2-D Tensor with shape [M, 1].
+ * :math:`\\sigma`: Activation function.
+ * :math:`Out`: Output value, a 4-D Tensor with data format 'NCHW' or 'NHWC', the shape of :math:`Out` and :math:`X` may be different.
+
+ Example:
+
+ - Input:
+
+ Input shape: :math:`(N, C_{in}, H_{in}, W_{in})`
+
+ Filter shape: :math:`(C_{in}, C_{out}, H_f, W_f)`
+
+ - Output:
+
+ Output shape: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+ Where
+
+ .. math::
+
+ H^\prime_{out} &= (H_{in} - 1) * strides[0] - pad_height_top - pad_height_bottom + dilations[0] * (H_f - 1) + 1 \\\\
+ W^\prime_{out} &= (W_{in} - 1) * strides[1] - pad_width_left - pad_width_right + dilations[1] * (W_f - 1) + 1 \\\\
+ H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[0] ] \\\\
+ W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[1] ]
+
+ Note:
+ The conv2d_transpose can be seen as the backward of the conv2d. For conv2d,
+ when stride > 1, conv2d maps multiple input shape to the same output shape,
+ so for conv2d_transpose, when stride > 1, input shape maps multiple output shape.
+ If output_size is None, :math:`H_{out} = H^\prime_{out}, W_{out} = W^\prime_{out}`;
+ else, the :math:`H_{out}` of the output size must between :math:`H^\prime_{out}`
+ and :math:`H^\prime_{out} + strides[0]`, and the :math:`W_{out}` of the output size must
+ between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[1]`,
+ conv2d_transpose can compute the kernel size automatically.
+
+ Args:
+ input(Tensor): 4-D Tensor with [N, C, H, W] or [N, H, W, C] format,
+ its data type is float32 or float64.
+ num_filters(int): The number of the filter. It is as same as the output
+ image channel.
+ output_size(int|tuple, optional): The output image size. If output size is a
+ tuple, it must contain two integers, (image_height, image_width). None if use
+ filter_size, padding, and stride to calculate output_size.
+ If output_size and filter_size are specified at the same time, They
+ should follow the formula above. Default: None. output_size and filter_size
+ should not be None at the same time.
+ filter_size(int|tuple, optional): The filter size. If filter_size is a tuple,
+ it must contain two integers, (filter_size_height, filter_size_width).
+ Otherwise, filter_size_height = filter_size_width = filter_size. None if
+ use output size to calculate filter_size. Default: None. filter_size and
+ output_size should not be None at the same time.
+ stride(int|tuple, optional): The stride size. It means the stride in transposed convolution.
+ If stride is a tuple, it must contain two integers, (stride_height, stride_width).
+ Otherwise, stride_height = stride_width = stride. Default: stride = 1.
+ padding(str|int|list|tuple, optional): The padding size. It means the number of zero-paddings
+ on both sides for each dimension. If `padding` is a string, either 'VALID' or
+ 'SAME' which is the padding algorithm. If `padding` is a tuple or list,
+ it could be in three forms: `[pad_height, pad_width]` or
+ `[pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
+ and when `data_format` is `"NCHW"`, `padding` can be in the form
+ `[[0,0], [0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `"NHWC"`, `padding` can be in the form
+ `[[0,0], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ Default: padding = 0.
+ dilation(int|tuple, optional): The dilation size. It means the spacing between the kernel points.
+ If dilation is a tuple, it must contain two integers, (dilation_height, dilation_width).
+ Otherwise, dilation_height = dilation_width = dilation. Default: dilation = 1.
+ filter_size(int|tuple, optional): The filter size. If filter_size is a tuple,
+ it must contain two integers, (filter_size_height, filter_size_width).
+ Otherwise, filter_size_height = filter_size_width = filter_size. None if
+ use output size to calculate filter_size. Default: None.
+ groups(int, optional): The groups number of the Conv2d transpose layer. Inspired by
+ grouped convolution in Alex Krizhevsky's Deep CNN paper, in which
+ when group=2, the first half of the filters is only connected to the
+ first half of the input channels, while the second half of the
+ filters is only connected to the second half of the input channels.
+ Default: groups = 1.
+ param_attr (ParamAttr, optional): The parameter attribute for learnable parameters/weights
+ of conv2d_transpose. If it is set to None or one attribute of ParamAttr, conv2d_transpose
+ will create ParamAttr as param_attr. If the Initializer of the param_attr
+ is not set, the parameter is initialized with Xavier. Default: None.
+ bias_attr (ParamAttr|bool, optional): The parameter attribute for the bias of conv2d_transpose.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, conv2d_transpose
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ use_cudnn(bool, optional): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True.
+ act (str, optional): Activation type, if it is set to None, activation is not appended.
+ Default: None.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ A Tensor representing the conv2d_transpose, whose
+ data type is the same with input and shape is (num_batches, channels, out_h,
+ out_w) or (num_batches, out_h, out_w, channels). If act is None, the tensor
+ storing the transposed convolution result, and if act is not None, the
+ tensor storing transposed convolution and non-linearity activation
+ result.
+
+ Raises:
+ ValueError: If the type of `use_cudnn` is not bool.
+ ValueError: If `data_format` is not "NCHW" or "NHWC".
+ ValueError: If `padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `padding` is a tuple, but the element corresponding to the input's batch size is not 0
+ or the element corresponding to the input's channel is not 0.
+ ValueError: If `output_size` and filter_size are None at the same time.
+ ShapeError: If the input is not 4-D Tensor.
+ ShapeError: If the input's dimension size and filter's dimension size not equal.
+ ShapeError: If the dimension size of input minus the size of `stride` is not 2.
+ ShapeError: If the number of input channels is not equal to filter's channels.
+ ShapeError: If the size of `output_size` is not equal to that of `stride`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ data = paddle.static.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
+ conv2d_transpose = paddle.static.nn.conv2d_transpose(input=data, num_filters=2, filter_size=3)
+ print(conv2d_transpose.shape) # [-1, 2, 34, 34]
+ """
+ assert (
+ param_attr is not False
+ ), "param_attr should not be False in conv2d_transpose."
+ if len(input.shape) != 4:
+ raise ValueError(
+ "Input size should be 4, "
+ "but received {}".format(len(input.shape))
+ )
+
+ if data_format not in ['NCHW', 'NHWC']:
+ raise ValueError(
+ "Attr(data_format) of Op(fluid.layers.conv2d_transpose) got wrong value: received "
+ + data_format
+ + " but only NCHW or NHWC supported."
+ )
+
+ input_channel = input.shape[1] if data_format == 'NCHW' else input.shape[-1]
+ op_type = 'conv2d_transpose'
+ if (
+ input_channel == groups
+ and num_filters == input_channel
+ and not use_cudnn
+ ):
+ op_type = 'depthwise_conv2d_transpose'
+
+ helper = LayerHelper(op_type, **locals())
+ if not isinstance(input, Variable):
+ raise TypeError("Input of conv2d_transpose must be Variable")
+
+ stride = utils.convert_to_list(stride, 2, 'stride')
+ dilation = utils.convert_to_list(dilation, 2, 'dilation')
+
+ if not isinstance(use_cudnn, bool):
+ raise ValueError("use_cudnn should be True or False")
+
+ def _update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, list) or isinstance(ele, tuple):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 4:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NHWC"):
+ if not (padding[0] == [0, 0] and padding[3] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:3]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 4, 'padding')
+ else:
+ padding = utils.convert_to_list(padding, 2, 'padding')
+ padding = [padding[0], padding[0], padding[1], padding[1]]
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(padding, str):
+ padding = padding.upper()
+ if padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown padding: '%s'. It can only be 'SAME' or 'VALID'."
+ % str(padding)
+ )
+ if padding == "VALID":
+ padding_algorithm = "VALID"
+ padding = [0, 0, 0, 0]
+ elif padding == "SAME":
+ padding_algorithm = "SAME"
+ padding = [0, 0, 0, 0]
+
+ padding = _update_padding(padding, data_format)
+
+ if output_size is None:
+ output_size = []
+ elif isinstance(output_size, (list, tuple)):
+ if utils._contain_var(output_size):
+ output_size = utils._convert_to_tensor_list(output_size)
+ else:
+ output_size = utils.convert_to_list(output_size, 2, 'output_size')
+ elif isinstance(output_size, int):
+ output_size = utils.convert_to_list(output_size, 2, 'output_size')
+ elif isinstance(output_size, Variable):
+ check_dtype(
+ output_size.dtype,
+ 'output_size',
+ ['int32', 'int64'],
+ 'conv2d_transpose',
+ )
+ if len(output_size.shape) == 1 and (
+ output_size.shape[0] == 1 or output_size.shape[0] == 2
+ ):
+ if output_size.shape[0] == 1:
+ output_size = [output_size, output_size]
+ else:
+ raise ValueError("output_size must contain one or two integers.")
+ else:
+ raise ValueError(
+ "output_size should be int, list[int] or tuple[int] or Tensor"
+ )
+
+ if filter_size is None:
+ if output_size is []:
+ raise ValueError("output_size must be set when filter_size is None")
+ if not _non_static_mode():
+ if isinstance(output_size, Variable) or utils._contain_var(
+ output_size
+ ):
+ raise ValueError(
+ "filter_size should not be None when output_size is Variable or contain Variable in static mode."
+ )
+ else:
+ output_size = utils.convert_shape_to_list(output_size)
+ if len(output_size) == 1:
+ output_size = utils.convert_to_list(
+ output_size[0], 2, 'output_size'
+ )
+
+ h_in = input.shape[2] if data_format == 'NCHW' else input.shape[1]
+ w_in = input.shape[3] if data_format == 'NCHW' else input.shape[2]
+
+ filter_size_h = (
+ output_size[0]
+ - (h_in - 1) * stride[0]
+ + padding[0]
+ + padding[1]
+ - 1
+ ) // dilation[0] + 1
+ filter_size_w = (
+ output_size[1]
+ - (w_in - 1) * stride[1]
+ + padding[2]
+ + padding[3]
+ - 1
+ ) // dilation[1] + 1
+ filter_size = [filter_size_h, filter_size_w]
+ else:
+ filter_size = utils.convert_to_list(
+ filter_size, 2, 'conv2d_transpose.filter_size'
+ )
+
+ if len(padding) == 4 and utils._is_symmetric_padding(padding, 2):
+ padding = [padding[0], padding[2]]
+
+ if groups is None:
+ groups = 1
+ elif groups <= 0:
+ raise ValueError(
+ "the groups of input must be greater than 0, "
+ "but received the groups of input is {}".format(groups)
+ )
+
+ filter_shape = [input_channel, num_filters // groups] + filter_size
+
+ img_filter = helper.create_parameter(
+ dtype=input.dtype, shape=filter_shape, attr=helper.param_attr
+ )
+
+ pre_bias = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type=op_type,
+ inputs={'Input': [input], 'Filter': [img_filter]},
+ outputs={'Output': pre_bias},
+ attrs={
+ 'output_size': output_size,
+ 'strides': stride,
+ 'paddings': padding,
+ 'padding_algorithm': padding_algorithm,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'use_cudnn': use_cudnn,
+ 'data_format': data_format,
+ },
+ )
+
+ if data_format == 'NCHW':
+ pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
+ else:
+ pre_act = helper.append_bias_op(pre_bias, dim_start=3, dim_end=4)
+ out = helper.append_activation(pre_act)
+ return out
+
+
+def conv3d_transpose(
+ input,
+ num_filters,
+ output_size=None,
+ filter_size=None,
+ padding=0,
+ stride=1,
+ dilation=1,
+ groups=None,
+ param_attr=None,
+ bias_attr=None,
+ use_cudnn=True,
+ act=None,
+ name=None,
+ data_format='NCDHW',
+):
+ r"""
+ :api_attr: Static Graph
+
+ The convolution3D transpose layer calculates the output based on the input,
+ filter, and dilations, strides, paddings. Input(Input) and output(Output)
+ are in NCDHW or NDHWC format. Where N is batch size, C is the number of channels,
+ D is the depth of the feature, H is the height of the feature, and W
+ is the width of the feature. Parameters(dilations, strides, paddings) are
+ two elements. These two elements represent height and width, respectively.
+ The details of convolution transpose layer, please refer to the following
+ explanation and references `therein `_.
+ If bias attribution and activation type are provided, bias is added to
+ the output of the convolution, and the corresponding activation function
+ is applied to the final result.
+
+ For each input :math:`X`, the equation is:
+
+ .. math::
+
+ Out = \sigma (W \ast X + b)
+
+ In the above equation:
+
+ * :math:`X`: Input value, a Tensor with NCDHW or NDHWC format.
+ * :math:`W`: Filter value, a Tensor with MCDHW format.
+ * :math:`\ast`: Convolution operation.
+ * :math:`b`: Bias value, a 2-D Tensor with shape [M, 1].
+ * :math:`\sigma`: Activation function.
+ * :math:`Out`: Output value, the shape of :math:`Out` and :math:`X` may be different.
+
+ Example:
+
+ - Input:
+
+ Input shape: :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`
+
+ Filter shape: :math:`(C_{in}, C_{out}, D_f, H_f, W_f)`
+
+ - Output:
+
+ Output shape: :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
+
+ Where
+
+ .. math::
+
+ D^\prime_{out} &= (D_{in} - 1) * strides[0] - 2 * paddings[0] + dilations[0] * (D_f - 1) + 1 \\\\
+ H^\prime_{out} &= (H_{in} - 1) * strides[1] - 2 * paddings[1] + dilations[1] * (H_f - 1) + 1 \\\\
+ W^\prime_{out} &= (W_{in} - 1) * strides[2] - 2 * paddings[2] + dilations[2] * (W_f - 1) + 1 \\\\
+ D_{out} &\in [ D^\prime_{out}, D^\prime_{out} + strides[0] ] \\\\
+ H_{out} &\in [ H^\prime_{out}, H^\prime_{out} + strides[1] ] \\\\
+ W_{out} &\in [ W^\prime_{out}, W^\prime_{out} + strides[2] ]
+
+ Note:
+ The conv3d_transpose can be seen as the backward of the conv3d. For conv3d,
+ when stride > 1, conv3d maps multiple input shape to the same output shape,
+ so for conv3d_transpose, when stride > 1, input shape maps multiple output shape.
+ If output_size is None, :math:`H_{out} = H^\prime_{out}, :math:`H_{out} = \
+ H^\prime_{out}, W_{out} = W^\prime_{out}`; else, the :math:`D_{out}` of the output
+ size must between :math:`D^\prime_{out}` and :math:`D^\prime_{out} + strides[0]`,
+ the :math:`H_{out}` of the output size must between :math:`H^\prime_{out}`
+ and :math:`H^\prime_{out} + strides[1]`, and the :math:`W_{out}` of the output size must
+ between :math:`W^\prime_{out}` and :math:`W^\prime_{out} + strides[2]`,
+ conv3d_transpose can compute the kernel size automatically.
+
+ Args:
+ input(Tensor): The input is 5-D Tensor with shape [N, C, D, H, W] or [N, D, H, W, C], the data type
+ of input is float32 or float64.
+ num_filters(int): The number of the filter. It is as same as the output
+ image channel.
+ output_size(int|tuple, optional): The output image size. If output size is a
+ tuple, it must contain three integers, (image_depth, image_height, image_width). This
+ parameter only works when filter_size is None. If output_size and filter_size are
+ specified at the same time, They should follow the formula above. Default: None.
+ Output_size and filter_size should not be None at the same time.
+ filter_size(int|tuple, optional): The filter size. If filter_size is a tuple,
+ it must contain three integers, (filter_size_depth, filter_size_height,
+ filter_size_width). Otherwise, filter_size_depth = filter_size_height = \
+ filter_size_width = filter_size. None if use output size to
+ calculate filter_size. Default: None. filter_size and output_size should not be
+ None at the same time.
+ padding(int|list|str|tuple, optional): The padding size. The padding argument effectively
+ adds `dilation * (kernel - 1)` amount of zero-padding on both sides of input. If `padding` is a string,
+ either 'VALID' or 'SAME' supported, which is the padding algorithm. If `padding`
+ is a tuple or list, it could be in three forms: `[pad_depth, pad_height, pad_width]` or
+ `[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]`,
+ and when `data_format` is `'NCDHW'`, `padding` can be in the form
+ `[[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]`.
+ when `data_format` is `'NDHWC'`, `padding` can be in the form
+ `[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]`.
+ Default: padding = 0.
+ stride(int|tuple, optional): The stride size. It means the stride in transposed convolution.
+ If stride is a tuple, it must contain three integers, (stride_depth, stride_height,
+ stride_width). Otherwise, stride_depth = stride_height = stride_width = stride.
+ Default: stride = 1.
+ dilation(int|tuple, optional): The dilation size. It means the spacing between the kernel points.
+ If dilation is a tuple, it must contain three integers, (dilation_depth, dilation_height,
+ dilation_width). Otherwise, dilation_depth = dilation_height = dilation_width = dilation.
+ Default: dilation = 1.
+ groups(int, optional): The groups number of the Conv3d transpose layer. Inspired by
+ grouped convolution in Alex Krizhevsky's Deep CNN paper, in which
+ when group=2, the first half of the filters is only connected to the
+ first half of the input channels, while the second half of the
+ filters is only connected to the second half of the input channels.
+ Default: groups=1
+ param_attr (ParamAttr, optional): The parameter attribute for learnable parameters/weights
+ of conv3d_transpose. If it is set to None or one attribute of ParamAttr, conv3d_transpose
+ will create ParamAttr as param_attr. If the Initializer of the param_attr
+ is not set, the parameter is initialized with Xavier. Default: None.
+ bias_attr (ParamAttr|bool, optional): The parameter attribute for the bias of conv3d_transpose.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, conv3d_transpose
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ use_cudnn(bool, optional): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True
+ act (str, optional): Activation type, if it is set to None, activation is not appended.
+ Default: None.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ A Variable holding Tensor representing the conv3d_transpose, whose data
+ type is the same with input and shape is (num_batches, channels, out_d, out_h,
+ out_w) or (num_batches, out_d, out_h, out_w, channels). If act is None, the tensor
+ variable storing the transposed convolution result, and if act is not None, the tensor
+ variable storing transposed convolution and non-linearity activation result.
+
+ Raises:
+ ValueError: If the type of `use_cudnn` is not bool.
+ ValueError: If `data_format` is not "NCDHW" or "NDHWC".
+ ValueError: If `padding` is a string, but not "SAME" or "VALID".
+ ValueError: If `padding` is a tuple, but the element corresponding to the input's batch size is not 0
+ or the element corresponding to the input's channel is not 0.
+ ValueError: If `output_size` and filter_size are None at the same time.
+ ShapeError: If the input is not 5-D Tensor.
+ ShapeError: If the input's dimension size and filter's dimension size not equal.
+ ShapeError: If the dimension size of input minus the size of `stride` is not 2.
+ ShapeError: If the number of input channels is not equal to filter's channels.
+ ShapeError: If the size of `output_size` is not equal to that of `stride`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ paddle.enable_static()
+ data = paddle.static.data(name='data', shape=[None, 3, 12, 32, 32], dtype='float32')
+ param_attr = paddle.framework.ParamAttr(name='conv3d.weight', initializer=paddle.nn.initializer.XavierNormal(), learning_rate=0.001)
+ res = paddle.static.nn.conv3d_transpose(input=data, num_filters=2, filter_size=3, act="relu", param_attr=param_attr)
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(paddle.static.default_startup_program())
+ x = np.random.rand(1, 3, 12, 32, 32).astype("float32")
+ output = exe.run(feed={"data": x}, fetch_list=[res])
+ print(output)
+ """
+ assert (
+ param_attr is not False
+ ), "param_attr should not be False in conv3d_transpose."
+ if data_format not in ['NCDHW', 'NDHWC']:
+ raise ValueError(
+ "Param(data_format) of Op(fluid.layers.conv3d_transpose) got wrong value: received "
+ + data_format
+ + " but only NCDHW or NDHWC supported."
+ )
+
+ l_type = "conv3d_transpose"
+ helper = LayerHelper(l_type, **locals())
+ if not isinstance(input, Variable):
+ raise TypeError("Input of conv3d_transpose must be Variable")
+ if len(input.shape) != 5:
+ raise ValueError(
+ "Input should be 5D tensor, but received input with the shape of {}".format(
+ input.shape
+ )
+ )
+ input_channel = (
+ input.shape[1] if data_format == 'NCDHW' else input.shape[-1]
+ )
+
+ stride = utils.convert_to_list(stride, 3, 'stride')
+ dilation = utils.convert_to_list(dilation, 3, 'dilation')
+
+ if not isinstance(use_cudnn, bool):
+ raise ValueError("use_cudnn should be True or False")
+
+ def _update_padding(padding, data_format):
+ def is_list_or_tuple(ele):
+ if isinstance(ele, list) or isinstance(ele, tuple):
+ return True
+ return False
+
+ if is_list_or_tuple(padding) and len(padding) == 5:
+ if is_list_or_tuple(padding[0]) and (data_format == "NCDHW"):
+ if not (padding[0] == [0, 0] and padding[1] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[2:5]
+ padding = [ele for a_list in padding for ele in a_list]
+ elif is_list_or_tuple(padding[0]) and (data_format == "NDHWC"):
+ if not (padding[0] == [0, 0] and padding[4] == [0, 0]):
+ raise ValueError(
+ "Non-zero padding(%s) in the batch or channel dimensions "
+ "is not supported." % str(padding)
+ )
+ padding = padding[1:4]
+ padding = [ele for a_list in padding for ele in a_list]
+ padding = utils.convert_to_list(padding, 6, 'padding')
+
+ elif is_list_or_tuple(padding) and len(padding) == 6:
+ padding = utils.convert_to_list(padding, 6, 'padding')
+
+ else:
+ padding = utils.convert_to_list(padding, 3, 'padding')
+ padding = [
+ padding[0],
+ padding[0],
+ padding[1],
+ padding[1],
+ padding[2],
+ padding[2],
+ ]
+ return padding
+
+ padding_algorithm = "EXPLICIT"
+ if isinstance(padding, str):
+ padding = padding.upper()
+ if padding not in ["SAME", "VALID"]:
+ raise ValueError(
+ "Unknown padding: '%s'. It can only be 'SAME' or 'VALID'."
+ % str(padding)
+ )
+ if padding == "VALID":
+ padding_algorithm = "VALID"
+ padding = [0, 0, 0, 0, 0, 0]
+ elif padding == "SAME":
+ padding_algorithm = "SAME"
+ padding = [0, 0, 0, 0, 0, 0]
+
+ padding = _update_padding(padding, data_format)
+
+ if filter_size is None:
+ if output_size is None:
+ raise ValueError("output_size must be set when filter_size is None")
+ if isinstance(output_size, int):
+ output_size = [output_size, output_size, output_size]
+
+ d_in = input.shape[2] if data_format == 'NCDHW' else input.shape[1]
+ h_in = input.shape[3] if data_format == 'NCDHW' else input.shape[2]
+ w_in = input.shape[4] if data_format == 'NCDHW' else input.shape[3]
+
+ filter_size_d = (
+ output_size[0]
+ - (d_in - 1) * stride[0]
+ + padding[0]
+ + padding[1]
+ - 1
+ ) // dilation[0] + 1
+ filter_size_h = (
+ output_size[1]
+ - (h_in - 1) * stride[1]
+ + padding[2]
+ + padding[3]
+ - 1
+ ) // dilation[1] + 1
+ filter_size_w = (
+ output_size[2]
+ - (w_in - 1) * stride[2]
+ + padding[4]
+ + padding[5]
+ - 1
+ ) // dilation[2] + 1
+ filter_size = [filter_size_d, filter_size_h, filter_size_w]
+ else:
+ filter_size = utils.convert_to_list(
+ filter_size, 3, 'conv3d_transpose.filter_size'
+ )
+
+ if len(padding) == 6 and utils._is_symmetric_padding(padding, 3):
+ padding = [padding[0], padding[2], padding[4]]
+
+ if output_size is None:
+ output_size = []
+ elif isinstance(output_size, (list, tuple, int)):
+ output_size = utils.convert_to_list(output_size, 3, 'output_size')
+ else:
+ raise ValueError("output_size should be int, list[int] or tuple[int]")
+
+ groups = 1 if groups is None else groups
+ if groups <= 0:
+ raise ValueError(
+ "the groups of conv3d_transpose should be greater than 0. Received groups: {}".format(
+ groups
+ )
+ )
+ if num_filters % groups != 0:
+ raise ValueError(
+ "Attr(num_filters) must be divisible by groups,"
+ "Received: Attr(num_filters) is {}, the groups is {}".format(
+ num_filters, groups
+ )
+ )
+
+ filter_shape = [input_channel, num_filters // groups] + filter_size
+ img_filter = helper.create_parameter(
+ dtype=input.dtype, shape=filter_shape, attr=helper.param_attr
+ )
+
+ if data_format == 'NCDHW':
+ data_format = 'NCHW'
+ if data_format == 'NDHWC':
+ data_format = 'NHWC'
+
+ pre_bias = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type=l_type,
+ inputs={'Input': [input], 'Filter': [img_filter]},
+ outputs={'Output': pre_bias},
+ attrs={
+ 'output_size': output_size,
+ 'strides': stride,
+ 'paddings': padding,
+ 'padding_algorithm': padding_algorithm,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'use_cudnn': use_cudnn,
+ 'data_format': data_format,
+ },
+ )
+
+ if data_format == 'NCHW':
+ pre_act = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
+ else:
+ pre_act = helper.append_bias_op(pre_bias, dim_start=4, dim_end=5)
+ out = helper.append_activation(pre_act)
+ return out
+
+
+def reduce_sum(input, dim=None, keep_dim=False, name=None):
+ """
+
+ Computes the sum of tensor elements over the given dimension.
+
+ Args:
+ input (Variable): The input variable which is a Tensor, the data type is float32,
+ float64, int32, int64.
+ dim (list|int, optional): The dimensions along which the sum is performed. If
+ :attr:`None`, sum all elements of :attr:`input` and return a
+ Tensor variable with a single element, otherwise must be in the
+ range :math:`[-rank(input), rank(input))`. If :math:`dim[i] < 0`,
+ the dimension to reduce is :math:`rank + dim[i]`.
+ keep_dim (bool, optional): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true, default
+ value is False.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: Tensor, results of summation operation on the specified dim of input tensor,
+ it's data type is the same as input's Tensor.
+
+ Raises:
+ TypeError, if out data type is different with the input data type.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # x is a Tensor variable with following elements:
+ # [[0.2, 0.3, 0.5, 0.9]
+ # [0.1, 0.2, 0.6, 0.7]]
+ # Each example is followed by the corresponding output tensor.
+ x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+ fluid.layers.reduce_sum(x) # [3.5]
+ fluid.layers.reduce_sum(x, dim=0) # [0.3, 0.5, 1.1, 1.6]
+ fluid.layers.reduce_sum(x, dim=-1) # [1.9, 1.6]
+ fluid.layers.reduce_sum(x, dim=1, keep_dim=True) # [[1.9], [1.6]]
+
+ # y is a Tensor variable with shape [2, 2, 2] and elements as below:
+ # [[[1, 2], [3, 4]],
+ # [[5, 6], [7, 8]]]
+ # Each example is followed by the corresponding output tensor.
+ y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+ fluid.layers.reduce_sum(y, dim=[1, 2]) # [10, 26]
+ fluid.layers.reduce_sum(y, dim=[0, 1]) # [16, 20]
+
+ """
+ if dim is not None and not isinstance(dim, list):
+ dim = [dim]
+
+ if in_dygraph_mode():
+ reduce_all = (
+ True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False
+ )
+ dim = dim if dim != None and dim != [] else [0]
+ if reduce_all:
+ return _C_ops.sum(input, [], None, keep_dim)
+ else:
+ return _C_ops.sum(input, dim, None, keep_dim)
+ elif _in_legacy_dygraph():
+ reduce_all = (
+ True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False
+ )
+ dim = dim if dim != None and dim != [] else [0]
+ return _legacy_C_ops.reduce_sum(
+ input, 'dim', dim, 'keep_dim', keep_dim, 'reduce_all', reduce_all
+ )
+ attrs = {
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ }
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ 'reduce_sum',
+ )
+ helper = LayerHelper('reduce_sum', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(
+ type='reduce_sum',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs=attrs,
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.mean")
+def reduce_mean(input, dim=None, keep_dim=False, name=None):
+ """
+ Computes the mean of the input tensor's elements along the given dimension.
+
+ Args:
+ input (Variable): The input variable which is a Tensor, the data type is float32,
+ float64, int32, int64.
+ dim (list|int, optional): The dimension along which the mean is computed. If
+ `None`, compute the mean over all elements of :attr:`input`
+ and return a variable with a single element, otherwise it
+ must be in the range :math:`[-rank(input), rank(input))`. If
+ :math:`dim[i] < 0`, the dimension to reduce is
+ :math:`rank(input) + dim[i]`.
+ keep_dim (bool, optional): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true, default
+ value is False.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: Tensor, results of average on the specified dim of input tensor,
+ it's data type is the same as input's Tensor.
+
+ Raises:
+ TypeError, if out data type is different with the input data type.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # x is a Tensor variable with following elements:
+ # [[0.2, 0.3, 0.5, 0.9]
+ # [0.1, 0.2, 0.6, 0.7]]
+ # Each example is followed by the corresponding output tensor.
+ x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+ fluid.layers.reduce_mean(x) # [0.4375]
+ fluid.layers.reduce_mean(x, dim=0) # [0.15, 0.25, 0.55, 0.8]
+ fluid.layers.reduce_mean(x, dim=-1) # [0.475, 0.4]
+ fluid.layers.reduce_mean(x, dim=1, keep_dim=True) # [[0.475], [0.4]]
+
+ # y is a Tensor variable with shape [2, 2, 2] and elements as below:
+ # [[[1.0, 2.0], [3.0, 4.0]],
+ # [[5.0, 6.0], [7.0, 8.0]]]
+ # Each example is followed by the corresponding output tensor.
+ y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+ fluid.layers.reduce_mean(y, dim=[1, 2]) # [2.5, 6.5]
+ fluid.layers.reduce_mean(y, dim=[0, 1]) # [4.0, 5.0]
+ """
+
+ return paddle.mean(x=input, axis=dim, keepdim=keep_dim, name=name)
+
+
+def reduce_max(input, dim=None, keep_dim=False, name=None):
+ """
+
+ Computes the maximum of tensor elements over the given dimension.
+
+ Args:
+ input (Variable): The input variable which is a Tensor, the data type is float32,
+ float64, int32, int64.
+ dim (list|int, optional): The dimension along which the maximum is computed.
+ If :attr:`None`, compute the maximum over all elements of
+ :attr:`input` and return a Tensor variable with a single element,
+ otherwise must be in the range :math:`[-rank(input), rank(input))`.
+ If :math:`dim[i] < 0`, the dimension to reduce is :math:`rank + dim[i]`.
+ keep_dim (bool, optional): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true, default
+ value is False.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: Tensor, results of maximum on the specified dim of input tensor,
+ it's data type is the same as input's Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # x is a Tensor variable with following elements:
+ # [[0.2, 0.3, 0.5, 0.9]
+ # [0.1, 0.2, 0.6, 0.7]]
+ # Each example is followed by the corresponding output tensor.
+ x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+ fluid.layers.reduce_max(x) # [0.9]
+ fluid.layers.reduce_max(x, dim=0) # [0.2, 0.3, 0.6, 0.9]
+ fluid.layers.reduce_max(x, dim=-1) # [0.9, 0.7]
+ fluid.layers.reduce_max(x, dim=1, keep_dim=True) # [[0.9], [0.7]]
+
+ # y is a Tensor variable with shape [2, 2, 2] and elements as below:
+ # [[[1.0, 2.0], [3.0, 4.0]],
+ # [[5.0, 6.0], [7.0, 8.0]]]
+ # Each example is followed by the corresponding output tensor.
+ y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+ fluid.layers.reduce_max(y, dim=[1, 2]) # [4.0, 8.0]
+ fluid.layers.reduce_max(y, dim=[0, 1]) # [7.0, 8.0]
+ """
+ helper = LayerHelper('reduce_max', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+
+ if dim is not None and not isinstance(dim, list):
+ dim = [dim]
+
+ if in_dygraph_mode():
+ return _C_ops.max(input, dim if dim != None else [], keep_dim)
+
+ helper.append_op(
+ type='reduce_max',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ },
+ )
+ return out
+
+
+def reduce_min(input, dim=None, keep_dim=False, name=None):
+ """
+
+ Computes the minimum of tensor elements over the given dimension.
+
+ Args:
+ input (Variable): The input variable which is a Tensor, the data type is float32,
+ float64, int32, int64.
+ dim (list|int, optional): The dimensions along which the minimum is computed.
+ If :attr:`None`, compute the minimum over all elements of
+ :attr:`input` and return a Tensor variable with a single element,
+ otherwise must be in the range :math:`[-rank(input), rank(input))`.
+ If :math:`dim[i] < 0`, the dimension to reduce is :math:`rank + dim[i]`.
+ keep_dim (bool, optional): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true, default
+ value is False.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: Tensor, result of minimum on the specified dim of input tensor,
+ it's data type is the same as input's Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ # x is a Tensor variable with following elements:
+ # [[0.2, 0.3, 0.5, 0.9]
+ # [0.1, 0.2, 0.6, 0.7]]
+ # Each example is followed by the corresponding output tensor.
+ x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+ fluid.layers.reduce_min(x) # [0.1]
+ fluid.layers.reduce_min(x, dim=0) # [0.1, 0.2, 0.5, 0.7]
+ fluid.layers.reduce_min(x, dim=-1) # [0.2, 0.1]
+ fluid.layers.reduce_min(x, dim=1, keep_dim=True) # [[0.2], [0.1]]
+
+ # y is a Tensor variable with shape [2, 2, 2] and elements as below:
+ # [[[1.0, 2.0], [3.0, 4.0]],
+ # [[5.0, 6.0], [7.0, 8.0]]]
+ # Each example is followed by the corresponding output tensor.
+ y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+ fluid.layers.reduce_min(y, dim=[1, 2]) # [1.0, 5.0]
+ fluid.layers.reduce_min(y, dim=[0, 1]) # [1.0, 2.0]
+ """
+ helper = LayerHelper('reduce_min', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ if dim is not None and not isinstance(dim, list):
+ dim = [dim]
+
+ if in_dygraph_mode():
+ return _C_ops.min(input, dim if dim != None else [], keep_dim)
+
+ helper.append_op(
+ type='reduce_min',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ },
+ )
+ return out
+
+
+def reduce_prod(input, dim=None, keep_dim=False, name=None):
+ """
+
+ Computes the product of tensor elements over the given dimension.
+
+ Args:
+ input (Variable): The input variable which is a Tensor, the data type is float32,
+ float64, int32, int64.
+ dim (int|list|tuple, optional): The dimensions along which the product is performed. If
+ :attr:`None`, multiply all elements of :attr:`input` and return a
+ Tensor variable with a single element, otherwise must be in the
+ range :math:`[-rank(input), rank(input))`. If :math:`dim[i] < 0`,
+ the dimension to reduce is :math:`rank + dim[i]`.
+ keep_dim (bool, optional): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true, default
+ value is False.
+ name(str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: Tensor, result of product on the specified dim of input tensor,
+ it's data type is the same as input's Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # x is a Tensor variable with following elements:
+ # [[0.2, 0.3, 0.5, 0.9]
+ # [0.1, 0.2, 0.6, 0.7]]
+ # Each example is followed by the corresponding output tensor.
+ x = fluid.data(name='x', shape=[2, 4], dtype='float32')
+ fluid.layers.reduce_prod(x) # [0.0002268]
+ fluid.layers.reduce_prod(x, dim=0) # [0.02, 0.06, 0.3, 0.63]
+ fluid.layers.reduce_prod(x, dim=-1) # [0.027, 0.0084]
+ fluid.layers.reduce_prod(x, dim=1,
+ keep_dim=True) # [[0.027], [0.0084]]
+
+ # y is a Tensor variable with shape [2, 2, 2] and elements as below:
+ # [[[1.0, 2.0], [3.0, 4.0]],
+ # [[5.0, 6.0], [7.0, 8.0]]]
+ # Each example is followed by the corresponding output tensor.
+ y = fluid.data(name='y', shape=[2, 2, 2], dtype='float32')
+ fluid.layers.reduce_prod(y, dim=[1, 2]) # [24.0, 1680.0]
+ fluid.layers.reduce_prod(y, dim=[0, 1]) # [105.0, 384.0]
+ """
+
+ if dim is not None and not isinstance(dim, list):
+ if isinstance(dim, tuple):
+ dim = list(dim)
+ elif isinstance(dim, int):
+ dim = [dim]
+ else:
+ raise TypeError(
+ "The type of axis must be int, list or tuple, but received {}".format(
+ type(dim)
+ )
+ )
+ if in_dygraph_mode():
+ return _C_ops.reduce_prod(
+ input,
+ dim if dim != None and dim != [] else [0],
+ keep_dim,
+ True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ )
+
+ helper = LayerHelper('reduce_prod', **locals())
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64', 'int32', 'int64'], 'reduce_prod'
+ )
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(
+ type='reduce_prod',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ },
+ )
+ return out
+
+
+def reduce_all(input, dim=None, keep_dim=False, name=None):
+ """
+
+ This OP computes the ``logical and`` of tensor elements over the given dimension, and output the result.
+
+ Args:
+ input (Tensor): the input tensor, it's data type should be `bool`.
+ dim (list|int|optional): The dimension along which the logical and is computed.
+ If :attr:`None`, compute the logical and over all elements of
+ :attr:`input` and return a Tensor variable with a single element,
+ otherwise must be in the range :math:`[-rank(input), rank(input))`.
+ If :math:`dim[i] < 0`, the dimension to reduce is :math:`rank + dim[i]`. The default value is None.
+ keep_dim (bool): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true. The default value is False.
+ name(str|None): A name for this layer(optional). If set None, the layer
+ will be named automatically. The default value is None.
+
+ Returns:
+ Tensor, the output data type is bool. : The reduced tensor variable with ``logical and`` in given dims.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ import numpy as np
+
+ # x is a bool Tensor variable with following elements:
+ # [[True, False]
+ # [True, True]]
+ x = fluid.layers.assign(np.array([[1, 0], [1, 1]], dtype='int32'))
+ x = fluid.layers.cast(x, 'bool')
+
+ out = fluid.layers.reduce_all(x) # False
+ out = fluid.layers.reduce_all(x, dim=0) # [True, False]
+ out = fluid.layers.reduce_all(x, dim=-1) # [False, True]
+ # keep_dim=False, x.shape=(2,2), out.shape=(2,)
+
+ out = fluid.layers.reduce_all(x, dim=1, keep_dim=True) # [[False], [True]]
+ # keep_dim=True, x.shape=(2,2), out.shape=(2,1)
+
+ """
+ if dim is not None and not isinstance(dim, list):
+ dim = [dim]
+
+ if in_dygraph_mode():
+ return _C_ops.all(input, dim if dim != None else [], keep_dim)
+
+ check_variable_and_dtype(input, 'input', ('bool'), 'reduce_all')
+ helper = LayerHelper('reduce_all', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(
+ type='reduce_all',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ },
+ )
+ return out
+
+
+def reduce_any(input, dim=None, keep_dim=False, name=None):
+ """
+ This OP computes the ``logical or`` of tensor elements over the given dimension, and output the result.
+
+ Args:
+ input (Tensor): the input tensor, it's data type should be `bool`.
+ dim (list|int|optional): The dimension along which the logical and is computed.
+ If :attr:`None`, compute the logical and over all elements of
+ :attr:`input` and return a Tensor variable with a single element,
+ otherwise must be in the range :math:`[-rank(input), rank(input))`.
+ If :math:`dim[i] < 0`, the dimension to reduce is :math:`rank + dim[i]`. The default value is None.
+ keep_dim (bool): Whether to reserve the reduced dimension in the
+ output Tensor. The result tensor will have one fewer dimension
+ than the :attr:`input` unless :attr:`keep_dim` is true. The default value is False.
+ name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor, the output data type is bool. : The reduced tensor variable with ``logical or`` in given dims.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ import numpy as np
+
+ # x is a bool Tensor variable with following elements:
+ # [[True, False]
+ # [False, False]]
+ x = fluid.layers.assign(np.array([[1, 0], [0, 0]], dtype='int32'))
+ x = fluid.layers.cast(x, 'bool')
+
+ out = fluid.layers.reduce_any(x) # True
+ out = fluid.layers.reduce_any(x, dim=0) # [True, False]
+ out = fluid.layers.reduce_any(x, dim=-1) # [True, False]
+ # keep_dim=False, x.shape=(2,2), out.shape=(2,)
+
+ out = fluid.layers.reduce_any(x, dim=1,
+ keep_dim=True) # [[True], [False]]
+ # keep_dim=True, x.shape=(2,2), out.shape=(2,1)
+
+ """
+ check_variable_and_dtype(input, 'input', ('bool'), 'reduce_any')
+ helper = LayerHelper('reduce_any', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ if dim is not None and not isinstance(dim, list):
+ dim = [dim]
+ helper.append_op(
+ type='reduce_any',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'dim': dim if dim != None and dim != [] else [0],
+ 'keep_dim': keep_dim,
+ 'reduce_all': True
+ if dim == None or dim == [] or len(dim) == len(input.shape)
+ else False,
+ },
+ )
+ return out
+
+
+def split(input, num_or_sections, dim=-1, name=None):
+ """
+ Split the input tensor into multiple sub-Tensors.
+
+ Args:
+ input (Tensor): A N-D Tensor. The data type is bool, float16, float32, float64, int32 or int64.
+ num_or_sections (int|list|tuple): If ``num_or_sections`` is int, then the ``num_or_sections``
+ indicates the number of equal sized sub-Tensors that the ``input``
+ will be divided into. If ``num_or_sections`` is a list or tuple, the length of it
+ indicates the number of sub-Tensors and the elements in it indicate the sizes of sub-Tensors'
+ dimension orderly. The length of the list mustn't be larger than the ``input`` 's size of specified dim.
+ dim (int|Tensor, optional): The dimension along which to split, it can be a scalar with type ``int`` or
+ a ``Tensor`` with shape [1] and data type ``int32`` or ``int64``. If :math:`dim < 0`,
+ the dimension to split along is :math:`rank(input) + dim`. Default is -1.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ list(Tensor): The list of segmented Tensors.
+
+ Example:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ # input is a Tensor which shape is [3, 9, 5]
+ input = fluid.data(
+ name="input", shape=[3, 9, 5], dtype="float32")
+
+ out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=1)
+ # out0.shape [3, 3, 5]
+ # out1.shape [3, 3, 5]
+ # out2.shape [3, 3, 5]
+
+ out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=1)
+ # out0.shape [3, 2, 5]
+ # out1.shape [3, 3, 5]
+ # out2.shape [3, 4, 5]
+
+ out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, -1], dim=1)
+ # out0.shape [3, 2, 5]
+ # out1.shape [3, 3, 5]
+ # out2.shape [3, 4, 5]
+
+ # dim is negative, the real dim is (rank(input) + axis) which real
+ # value is 1.
+ out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=-2)
+ # out0.shape [3, 3, 5]
+ # out1.shape [3, 3, 5]
+ # out2.shape [3, 3, 5]
+
+ """
+ if _non_static_mode():
+ num = None
+ attrs = ()
+
+ if isinstance(dim, Variable):
+ dim = dim.numpy()
+ dim = dim.item(0)
+ assert len(input.shape) + dim >= 0, "(rank(x) + axis) must >= 0"
+ dim = (len(input.shape) + dim) if dim < 0 else dim
+ attrs += ('axis', dim)
+
+ if isinstance(num_or_sections, int):
+ num = num_or_sections
+ attrs += ('num', num_or_sections)
+ elif isinstance(num_or_sections, (list, tuple)):
+ num = len(num_or_sections)
+ if utils._contain_var(num_or_sections):
+ for index, item in enumerate(num_or_sections):
+ if isinstance(item, Variable):
+ num_or_sections[index] = num_or_sections[index].numpy()[
+ 0
+ ]
+ attrs += ('sections', list(num_or_sections))
+ else:
+ attrs += ('sections', list(num_or_sections))
+ else:
+ raise TypeError(
+ "The type of 'num_or_sections' in split must be int, list or tuple in imperative mode, but "
+ "received %s." % (type(num_or_sections))
+ )
+ if in_dygraph_mode():
+ if isinstance(num_or_sections, int):
+ return _C_ops.split_with_num(input, num_or_sections, dim)
+ else:
+ return _C_ops.split(input, num_or_sections, dim)
+ elif _in_legacy_dygraph():
+ out = [_varbase_creator() for n in range(num)]
+ _legacy_C_ops.split(input, out, *attrs)
+ return out
+
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
+ 'split',
+ )
+ check_type(num_or_sections, 'num_or_sections', (list, int, tuple), 'split')
+ check_type(dim, 'dim', (int, Variable), 'split')
+ if isinstance(dim, Variable):
+ check_dtype(dim.dtype, 'dim', ['int32', 'int64'], 'split')
+
+ helper = LayerHelper('split', **locals())
+
+ input_shape = input.shape
+ inputs = {'X': input}
+ attrs = {'num': num_or_sections if isinstance(num_or_sections, int) else 0}
+
+ def _get_SectionsTensorList(one_list):
+ tensor_list = []
+ unk_dim_idx = -1
+ for idx, dim_size in enumerate(one_list):
+ if isinstance(dim_size, Variable):
+ dim_size.stop_gradient = True
+ tensor_list.append(dim_size)
+ else:
+ assert isinstance(dim_size, int)
+ if dim_size == -1:
+ assert unk_dim_idx == -1, (
+ "Only one value of 'num_or_section' in split can "
+ "be -1. But received num_or_section[%d] is also -1."
+ % idx
+ )
+ unk_dim_idx = idx
+ temp_out = helper.create_variable_for_type_inference('int32')
+ fill_constant(
+ [1], 'int32', dim_size, force_cpu=True, out=temp_out
+ )
+ tensor_list.append(temp_out)
+ return tensor_list
+
+ if isinstance(dim, Variable):
+ dim.stop_gradient = True
+ inputs['AxisTensor'] = dim
+ else:
+ assert len(input.shape) + dim >= 0, "(rank(x) + axis) must >= 0"
+ dim = (len(input_shape) + dim) if dim < 0 else dim
+ attrs['axis'] = dim
+
+ if isinstance(num_or_sections, int):
+ assert num_or_sections > 1, 'num_or_sections must be more than 1.'
+ if isinstance(dim, int) and input_shape[dim] > 0:
+ assert input_shape[dim] % num_or_sections == 0, (
+ "The input's size along the split dimension "
+ "must be evenly divisible by Attr(num_or_sections). "
+ "But %d is not evenly divisible by %d. "
+ % (num_or_sections, input_shape[dim])
+ )
+ num = num_or_sections
+ else:
+ if isinstance(dim, int) and input_shape[dim] > 0:
+ assert (
+ len(num_or_sections) <= input_shape[dim]
+ ), 'len(num_or_sections) must not be more than input.shape[dim].'
+ num = len(num_or_sections)
+ attrs['sections'] = list(
+ map(
+ lambda ele: -1 if isinstance(ele, Variable) else ele,
+ num_or_sections,
+ )
+ )
+ if utils._contain_var(num_or_sections):
+ inputs['SectionsTensorList'] = _get_SectionsTensorList(
+ num_or_sections
+ )
+
+ outs = [
+ helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ for i in range(num)
+ ]
+ helper.append_op(
+ type='split', inputs=inputs, outputs={'Out': outs}, attrs=attrs
+ )
+ return outs
+
+
+def l2_normalize(x, axis, epsilon=1e-12, name=None):
+ r"""
+
+ This op normalizes `x` along dimension `axis` using an L2
+ norm. For a 1-D tensor (`dim` is fixed to 0), this layer computes
+
+ .. math::
+
+ y = \\frac{x}{ \sqrt{\sum {x^2} + epsion }}
+
+ For `x` with more dimensions, this layer independently normalizes each 1-D
+ slice along dimension `axis`.
+
+ Args:
+ x(Variable|list): The input tensor could be N-D tensor, and the input data type could be float16, float32 or float64.
+ axis(int): The axis on which to apply normalization. If `axis < 0`, \
+ the dimension to normalization is rank(X) + axis. -1 is the
+ last dimension.
+ epsilon(float): The epsilon value is used to avoid division by zero, \
+ the default value is 1e-12.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: The output has the same shape and data type with `x`.
+
+ Examples:
+
+ .. code-block:: python
+ :name: code-example1
+
+ import paddle
+
+ X = paddle.randn(shape=[3, 5], dtype='float64')
+ out = paddle.fluid.layers.l2_normalize(X, axis=-1)
+ print(out)
+
+ # [[ 0.21558504 0.56360189 0.47466096 0.46269539 -0.44326736]
+ # [-0.70602414 -0.52745777 0.37771788 -0.2804768 -0.04449922]
+ # [-0.33972208 -0.43014923 0.31772556 0.76617881 -0.10761525]]
+
+ """
+ if len(x.shape) == 1:
+ axis = 0
+ if _non_static_mode():
+ if in_dygraph_mode():
+ out, _ = _C_ops.norm(x, 1 if axis is None else axis, epsilon, False)
+ elif _in_legacy_dygraph():
+ _, out = _legacy_C_ops.norm(
+ x, 'axis', 1 if axis is None else axis, 'epsilon', epsilon
+ )
+ return out
+
+ check_variable_and_dtype(x, "X", ("float16", "float32", "float64"), "norm")
+
+ helper = LayerHelper("l2_normalize", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ norm = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type="norm",
+ inputs={"X": x},
+ outputs={"Out": out, "Norm": norm},
+ attrs={
+ "axis": 1 if axis is None else axis,
+ "epsilon": epsilon,
+ },
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.matmul")
+def matmul(x, y, transpose_x=False, transpose_y=False, alpha=1.0, name=None):
+ """
+ Applies matrix multiplication to two tensors.
+
+ Currently, the input tensors' rank can be any, but when the rank of any
+ inputs is bigger than 3, this two inputs' rank should be equal.
+
+ The actual behavior depends on the shapes of :math:`x`, :math:`y` and the
+ flag values of :attr:`transpose_x`, :attr:`transpose_y`. Specifically:
+
+ - If a transpose flag is specified, the last two dimensions of the tensor
+ are transposed. If the tensor is rank-1 of shape :math:`[D]`, then for
+ :math:`x` it is treated as :math:`[1, D]` in nontransposed form and as
+ :math:`[D, 1]` in transposed form, whereas for :math:`y` it is the
+ opposite: It is treated as :math:`[D, 1]` in nontransposed form and as
+ :math:`[1, D]` in transposed form.
+
+ - After transpose, the two tensors are 2-D or n-D and matrix multiplication
+ performs in the following way.
+
+ - If both are 2-D, they are multiplied like conventional matrices.
+ - If either is n-D, it is treated as a stack of matrices residing in the
+ last two dimensions and a batched matrix multiply supporting broadcast
+ applies on the two tensors.
+
+ Also note that if the raw tensor :math:`x` or :math:`y` is rank-1 and
+ nontransposed, the prepended or appended dimension :math:`1` will be
+ removed after matrix multiplication.
+
+ Args:
+ x (Variable): The input variable which is a Tensor or LoDTensor.
+ y (Variable): The input variable which is a Tensor or LoDTensor.
+ transpose_x (bool): Whether to transpose :math:`x` before multiplication.
+ transpose_y (bool): Whether to transpose :math:`y` before multiplication.
+ alpha (float): The scale of output. Default 1.0.
+ name(str|None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+
+ Returns:
+ Variable: The product Tensor (or LoDTensor) variable.
+
+ Examples:
+ .. code-block:: python
+
+ # Examples to clarify shapes of the inputs and output
+ # x: [B, ..., M, K], y: [B, ..., K, N]
+ # fluid.layers.matmul(x, y) # out: [B, ..., M, N]
+
+ # x: [B, M, K], y: [B, K, N]
+ # fluid.layers.matmul(x, y) # out: [B, M, N]
+
+ # x: [B, M, K], y: [K, N]
+ # fluid.layers.matmul(x, y) # out: [B, M, N]
+
+ # x: [M, K], y: [K, N]
+ # fluid.layers.matmul(x, y) # out: [M, N]
+
+ # x: [B, M, K], y: [K]
+ # fluid.layers.matmul(x, y) # out: [B, M]
+
+ # x: [K], y: [K]
+ # fluid.layers.matmul(x, y) # out: [1]
+
+ # x: [M], y: [N]
+ # fluid.layers.matmul(x, y, True, True) # out: [M, N]
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ x = fluid.layers.data(name='x', shape=[2, 3], dtype='float32')
+ y = fluid.layers.data(name='y', shape=[3, 2], dtype='float32')
+ out = fluid.layers.matmul(x, y, True, True)
+ """
+ if _non_static_mode():
+ out = _varbase_creator(dtype=x.dtype)
+ _legacy_C_ops.matmul(
+ x,
+ y,
+ out,
+ 'transpose_X',
+ transpose_x,
+ 'transpose_Y',
+ transpose_y,
+ 'alpha',
+ float(alpha),
+ )
+ return out
+
+ def __check_input(x, y):
+ var_names = {'x': x, 'y': y}
+ for name, val in var_names.items():
+ check_variable_and_dtype(
+ val, name, ['float16', 'float32', 'float64'], 'matmul'
+ )
+ x_shape = list(x.shape)
+ y_shape = list(y.shape)
+ if len(x_shape) == 1:
+ x_shape = [1] + x_shape
+ if len(y_shape) == 1:
+ y_shape = y_shape + [1]
+
+ # check the inner 2 dimensions
+ if transpose_x:
+ x_shape[-2], x_shape[-1] = x_shape[-1], x_shape[-2]
+ if transpose_y:
+ y_shape[-2], y_shape[-1] = y_shape[-1], y_shape[-2]
+ if x_shape[-1] != y_shape[-2]:
+ assert (x_shape[-1] == -1) or (y_shape[-2] == -1), (
+ "After performing an optional transpose, Input X's width should be "
+ "equal to Y's width for multiplication "
+ "prerequisites. But received X's shape: %s, Y's shape: %s\n"
+ % (x_shape, y_shape)
+ )
+
+ if len(y_shape) > 2 and len(x_shape) > 2:
+ for i, dim_x in enumerate(x_shape[:-2]):
+ # don't check neg shape
+ if dim_x < 0 or y_shape[i] < 0:
+ continue
+ if dim_x != y_shape[i]:
+ raise ValueError(
+ "When the matrix is larger than 2 dimensions, the higher "
+ "dimensional values of the two matrices need to be equal. "
+ "But received x_shape[%d] != y_shape[%d]. X's shape: %s, "
+ "Y's shape: %s.\n" % (i, i, x_shape, y_shape)
+ )
+
+ attrs = {
+ 'transpose_X': transpose_x,
+ 'transpose_Y': transpose_y,
+ 'alpha': float(alpha),
+ }
+
+ __check_input(x, y)
+
+ helper = LayerHelper('matmul', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='matmul',
+ inputs={'X': x, 'Y': y},
+ outputs={'Out': out},
+ attrs=attrs,
+ )
+ return out
+
+
+def topk(input, k, name=None):
+ """
+ :alias_main: paddle.topk
+ :alias: paddle.topk,paddle.tensor.topk,paddle.tensor.search.topk
+ :old_api: paddle.fluid.layers.topk
+
+ This OP is used to find values and indices of the k largest entries
+ for the last dimension.
+
+ If the input is a 1-D Tensor, finds the k largest entries and outputs
+ their values and indices.
+
+ If the input is a Tensor with higher rank, this operator computes the top k
+ entries along the last dimension.
+
+ .. code-block:: text
+
+ Case 1:
+
+ Input:
+ input.shape = [3, 4]
+ input.data = [[5, 4, 2, 3],
+ [9, 7, 10, 25],
+ [6, 2, 10, 1]]
+ k = 2
+
+ Output:
+ The first output:
+ values.shape = [3, 2]
+ values.data = [[5, 4],
+ [10, 25],
+ [6, 10]]
+
+ The second output:
+ indices.shape = [3, 2]
+ indices.data = [[0, 1],
+ [2, 3],
+ [0, 2]]
+
+ Args:
+ input(Variable): The input tensor. Support data types: float32, float64.
+ k(int | Variable): The number of top elements to look for along the last dimension
+ of input tensor.
+ name (str, optional): Please refer to :ref:`api_guide_Name`, Default None.
+
+ Returns:
+ Values (Variable): Input tensor's k largest elements along each last dimensional slice. The dimension is: :math:`input.shape[:-1]+[k]`.
+ Indices (Variable): Indices of k largest elements alone the last dimension of input. The dimension is same as values.
+
+ Raises:
+ ValueError: If :math:`k < 1` or :math:`k > last dimension of input`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ # set batch size=None
+ input = fluid.data(name="input", shape=[None, 13, 11], dtype='float32')
+ top5_values, top5_indices = layers.topk(input, k=5) # top5_values.shape[None, 13, 5], top5_indices.shape=[None, 13, 5]
+
+ # 1D Tensor
+ input1 = fluid.data(name="input1", shape=[None, 13], dtype='float32')
+ top5_values, top5_indices = layers.topk(input1, k=5) #top5_values.shape=[None, 5], top5_indices.shape=[None, 5]
+
+ # k=Variable
+ input2 = fluid.data(name="input2", shape=[None, 13, 11], dtype='float32')
+ vk = fluid.data(name="vk", shape=[None, 1], dtype='int32') # save k in vk.data[0]
+ vk_values, vk_indices = layers.topk(input2, k=vk) #vk_values.shape=[None, 13, k], vk_indices.shape=[None, 13, k]
+
+ """
+ if _non_static_mode():
+ _k = k.numpy().item(0) if isinstance(k, Variable) else k
+ out, indices = _legacy_C_ops.top_k(input, 'k', _k)
+ out.stop_gradient = True
+ indices.stop_gradient = True
+ return out, indices
+
+ inputs = {"X": [input]}
+ attrs = {}
+ if isinstance(k, Variable):
+ inputs['K'] = [k]
+ else:
+ attrs = {'k': k}
+
+ helper = LayerHelper("top_k", **locals())
+ values = helper.create_variable_for_type_inference(dtype=input.dtype)
+ indices = helper.create_variable_for_type_inference(dtype="int64")
+
+ helper.append_op(
+ type="top_k",
+ inputs=inputs,
+ outputs={"Out": [values], "Indices": [indices]},
+ attrs=attrs,
+ )
+ values.stop_gradient = True
+ indices.stop_gradient = True
+ return values, indices
+
+
+def ctc_greedy_decoder(
+ input, blank, input_length=None, padding_value=0, name=None
+):
+ r"""
+ This op is used to decode sequences by greedy policy by the following steps:
+
+ 1. Get the indexes of maximum value for each row in input. a.k.a.
+ numpy.argmax(input, axis=0).
+ 2. For each sequence in result of step1, merge repeated tokens between two
+ blanks and delete all blanks.
+
+ This op is implemented in two modes: lod and padding, either of them can be used.
+ The input can be either LoDTensor or Tensor, corresponding to lod and padding
+ mode respectively.
+
+ A simple example as below:
+
+ .. code-block:: text
+
+ Given:
+ (1) for lod mode:
+
+ input.data = [[0.6, 0.1, 0.3, 0.1],
+ [0.3, 0.2, 0.4, 0.1],
+ [0.1, 0.5, 0.1, 0.3],
+ [0.5, 0.1, 0.3, 0.1],
+
+ [0.5, 0.1, 0.3, 0.1],
+ [0.2, 0.2, 0.2, 0.4],
+ [0.2, 0.2, 0.1, 0.5],
+ [0.5, 0.1, 0.3, 0.1]]
+
+ input.lod = [[4, 4]]
+
+ Computation:
+
+ step1: Apply argmax to first input sequence which is input.data[0:4]. Then we get:
+ [[0], [2], [1], [0]]
+ step2: merge repeated tokens and remove blank which is 0. Then we get first output sequence:
+ [[2], [1]]
+
+ Finally:
+
+ output.data = [[2],
+ [1],
+ [3]]
+
+ output.lod = [[2, 1]]
+
+ (2) for padding mode:
+
+ input.data = [[[0.6, 0.1, 0.3, 0.1],
+ [0.3, 0.2, 0.4, 0.1],
+ [0.1, 0.5, 0.1, 0.3],
+ [0.5, 0.1, 0.3, 0.1]],
+
+ [[0.5, 0.1, 0.3, 0.1],
+ [0.2, 0.2, 0.2, 0.4],
+ [0.2, 0.2, 0.1, 0.5],
+ [0.5, 0.1, 0.3, 0.1]]]
+
+ input_length.data = [[4], [4]]
+ input.shape = [2, 4, 4]
+
+ step1: Apply argmax to first input sequence which is input.data[0:4]. Then we get:
+ [[0], [2], [1], [0]], for input.data[4:8] is [[0], [3], [3], [0]], shape is [2,4,1]
+ step2: Change the argmax result to use padding mode, then argmax result is
+ [[0, 2, 1, 0], [0, 3, 3, 0]], shape is [2, 4], lod is [], input_length is [[4], [4]]
+ step3: Apply ctc_align to padding argmax result, padding_value is 0
+
+ Finally:
+ output.data = [[2, 1, 0, 0],
+ [3, 0, 0, 0]]
+ output_length.data = [[2], [1]]
+
+
+ Parameters:
+
+ input(Variable): the probabilities of variable-length sequences. When in lod mode,
+ it is a 2-D LoDTensor with LoD information. It's shape is [Lp, num_classes + 1]
+ where Lp is the sum of all input sequences' length and
+ num_classes is the true number of classes. When in padding mode,
+ it is a 3-D Tensor with padding, It's shape is [batch_size, N, num_classes + 1].
+ (not including the blank label). The data type can be float32 or float64.
+ blank(int): the blank label index of Connectionist Temporal
+ Classification (CTC) loss, which is in the half-opened
+ interval [0, num_classes + 1).
+ input_length(Variable, optional): 2-D LoDTensor, shape is [batch_size, 1], data type is int64.
+ It is used for padding mode. In lod mode, input_length is None.
+ padding_value(int): padding value.
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ For lod mode, returns the result of CTC greedy decoder, 2-D LoDTensor, shape is [Lp, 1], \
+ data type is int64. 'Lp' is the sum of all output sequences' length. If all the sequences \
+ in result were empty, the result LoDTensor will be [-1] with empty \
+ LoD [[]].
+
+ For padding mode, returns a tuple of (output, output_length), which was described as below:
+
+ output, 2-D Tensor, shape is [batch_size, N], data type is int64.
+
+ output_length, 2-D Tensor, shape is [batch_size, 1], data type is int64. It is the length of \
+ each sequence of output for padding mode.
+
+ Return type:
+ For lod mode: Variable
+
+ For padding mode: tuple of two Variables (output, output_length).
+
+
+ Examples:
+ .. code-block:: python
+
+ # for lod mode
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[None, 8], dtype='float32', lod_level=1)
+ cost = fluid.layers.ctc_greedy_decoder(input=x, blank=0)
+
+ # for padding mode
+ x_pad = fluid.data(name='x_pad', shape=[10, 4, 8], dtype='float32')
+ x_pad_len = fluid.data(name='x_pad_len', shape=[10, 1], dtype='int64')
+ out, out_len = fluid.layers.ctc_greedy_decoder(input=x_pad, blank=0,
+ input_length=x_pad_len)
+
+ """
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'ctc_greedy_decoder'
+ )
+
+ helper = LayerHelper("ctc_greedy_decoder", **locals())
+ _, topk_indices = topk(input, k=1)
+
+ # ctc align op
+ ctc_out = helper.create_variable_for_type_inference(dtype="int64")
+
+ if input_length is None:
+ helper.append_op(
+ type="ctc_align",
+ inputs={"Input": [topk_indices]},
+ outputs={"Output": [ctc_out]},
+ attrs={"merge_repeated": True, "blank": blank},
+ )
+ return ctc_out
+ else:
+ ctc_out_len = helper.create_variable_for_type_inference(dtype="int64")
+ ctc_input = squeeze(topk_indices, [2])
+
+ helper.append_op(
+ type="ctc_align",
+ inputs={"Input": [ctc_input], "InputLength": [input_length]},
+ outputs={"Output": [ctc_out], "OutputLength": [ctc_out_len]},
+ attrs={
+ "merge_repeated": True,
+ "blank": blank,
+ "padding_value": padding_value,
+ },
+ )
+ return ctc_out, ctc_out_len
+
+
+def transpose(x, perm, name=None):
+ """
+ Permute the data dimensions of `input` according to `perm`.
+
+ The `i`-th dimension of the returned tensor will correspond to the
+ perm[i]-th dimension of `input`.
+
+ Args:
+ x (Tensor): The input Tensor. It is a N-D Tensor of data types bool, float32, float64, int32.
+ perm (list|tuple): Permute the input according to the data of perm.
+ name (str): The name of this layer. It is optional.
+
+ Returns:
+ Tensor: A transposed n-D Tensor, with data type being bool, float32, float64, int32, int64.
+
+ For Example:
+
+ .. code-block:: text
+
+ x = [[[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]
+ [[13 14 15 16] [17 18 19 20] [21 22 23 24]]]
+ shape(x) = [2,3,4]
+
+ # Example 1
+ perm0 = [1,0,2]
+ y_perm0 = [[[ 1 2 3 4] [13 14 15 16]]
+ [[ 5 6 7 8] [17 18 19 20]]
+ [[ 9 10 11 12] [21 22 23 24]]]
+ shape(y_perm0) = [3,2,4]
+
+ # Example 2
+ perm1 = [2,1,0]
+ y_perm1 = [[[ 1 13] [ 5 17] [ 9 21]]
+ [[ 2 14] [ 6 18] [10 22]]
+ [[ 3 15] [ 7 19] [11 23]]
+ [[ 4 16] [ 8 20] [12 24]]]
+ shape(y_perm1) = [4,3,2]
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.randn([2, 3, 4])
+ x_transposed = paddle.transpose(x, perm=[1, 0, 2])
+ print(x_transposed.shape)
+ # [3L, 2L, 4L]
+
+ """
+ if in_dygraph_mode():
+ return _C_ops.transpose(x, perm)
+ else:
+ if _in_legacy_dygraph():
+ out, _ = _legacy_C_ops.transpose2(x, 'axis', perm)
+ return out
+
+ check_variable_and_dtype(
+ x,
+ 'x',
+ [
+ 'bool',
+ 'float16',
+ 'float32',
+ 'float64',
+ 'int32',
+ 'int64',
+ 'complex64',
+ 'complex128',
+ ],
+ 'transpose',
+ )
+ check_type(perm, 'perm', (list, tuple), 'transpose')
+ if isinstance(perm, tuple):
+ perm = list(perm)
+ if len(perm) != len(x.shape):
+ raise ValueError(
+ "Input(perm) is the permutation of dimensions of Input(x), "
+ "its length should be equal to dimensions of Input(x), "
+ "but received dimension of Input(x) is %s, "
+ "the length of Input(perm) is %s." % (len(x.shape), len(perm))
+ )
+ for idx, dim in enumerate(perm):
+ if dim >= len(x.shape):
+ raise ValueError(
+ "Each element in Input(perm) should be less than Input(x)'s dimension, "
+ "but %d-th element in Input(perm) is %d which exceeds Input(x)'s "
+ "dimension %d." % (idx, perm[idx], len(x.shape))
+ )
+
+ helper = LayerHelper('transpose', **locals())
+ out = helper.create_variable_for_type_inference(x.dtype)
+ x_shape = helper.create_variable_for_type_inference(x.dtype)
+ helper.append_op(
+ type='transpose2',
+ inputs={'X': [x]},
+ outputs={'Out': [out], 'XShape': [x_shape]},
+ attrs={'axis': perm},
+ )
+ return out
+
+
+def im2sequence(
+ input,
+ filter_size=1,
+ stride=1,
+ padding=0,
+ input_image_size=None,
+ out_stride=1,
+ name=None,
+):
+ r"""
+ :api_attr: Static Graph
+
+ Extracts image patches from the input tensor to form a tensor of shape
+ {input.batch_size * output_height * output_width, filter_size_height *
+ filter_size_width * input.channels}. This op use filter to scan images
+ and convert these images to sequences. After expanding, the number of time step are
+ output_height * output_width for an image, in which output_height and
+ output_width are calculated by below equation:
+
+ .. math::
+
+ output\_height = 1 + \
+ (padding\_up + padding\_down + input\_height - filter\_size\_height + stride\_height - 1) / stride\_height \\\\
+ output\_width = 1 + \
+ (padding\_left + padding\_right + input\_width - filter\_size\_width + stride\_width - 1) / stride\_width
+
+ And the dimension of each time step is filter_size_height * filter_size_width * input.channels.
+
+ Parameters:
+ input (Variable): The input should be a 4-D Tensor in :math:`NCHW` format. The data type is float32.
+
+ filter_size(int32 | List[int32]): The filter size. If filter_size is a List,
+ it must contain two integers, :math:`[filter\_size\_height, filter\_size\_width]` .
+ Otherwise, the filter size will be a square :math:`[filter\_size, filter\_size]` . Default is 1.
+
+ stride(int32 | List[int32]): The stride size. If stride is a List, it must
+ contain two integers, :math:`[stride\_height, stride\_width]` . Otherwise, the stride size will be a square :math:`[stride\_size, stride\_size]` . Default is 1.
+
+ padding(int32 | List[int32]): The padding size. If padding is a List, it can
+ contain four integers like :math:`[padding\_up, padding\_left, padding\_down, padding\_right]` to indicate
+ paddings of four direction. Or it can contain two integers :math:`[padding\_height, padding\_width]` which means
+ padding_up = padding_down = padding_height and
+ padding_left = padding_right = padding_width. Otherwise, a scalar padding means
+ padding_up = padding_down = padding_left = padding_right = padding.
+ Default is 0.
+
+ input_image_size(Variable, optional): the input contains image real size.It's dim
+ is :math:`[batchsize, 2]` . It is just for batch inference when not None. Default is None.
+
+ out_stride(int32 | List[int32]): The scaling of image through CNN. It is valid only when input_image_size is not None.
+ If out_stride is List, it must contain two integers,
+ :math:`[out\_stride\_height, out\_stride\_W]` . Otherwise,
+ the out_stride_height = out_stride_width = out_stride. Default is 1.
+
+ name (str, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ The output is a 2-D LoDTensor with shape {input.batch\_size * output\_height * output\_width, \
+ filter\_size\_height * filter\_size\_width * input.channels}. The data type is float32.
+
+ Return Type: Variable
+
+ Examples:
+
+ .. code-block:: text
+
+ Given:
+
+ x = [[[[ 6. 2. 1.]
+ [ 8. 3. 5.]
+ [ 0. 2. 6.]]
+
+ [[ 2. 4. 4.]
+ [ 6. 3. 0.]
+ [ 6. 4. 7.]]]
+
+ [[[ 6. 7. 1.]
+ [ 5. 7. 9.]
+ [ 2. 4. 8.]]
+
+ [[ 1. 2. 1.]
+ [ 1. 3. 5.]
+ [ 9. 0. 8.]]]]
+
+ x.dims = {2, 2, 3, 3}
+
+ And:
+
+ filter = [2, 2]
+ stride = [1, 1]
+ padding = [0, 0]
+
+ Then:
+
+ output.data = [[ 6. 2. 8. 3. 2. 4. 6. 3.]
+ [ 2. 1. 3. 5. 4. 4. 3. 0.]
+ [ 8. 3. 0. 2. 6. 3. 6. 4.]
+ [ 3. 5. 2. 6. 3. 0. 4. 7.]
+ [ 6. 7. 5. 7. 1. 2. 1. 3.]
+ [ 7. 1. 7. 9. 2. 1. 3. 5.]
+ [ 5. 7. 2. 4. 1. 3. 9. 0.]
+ [ 7. 9. 4. 8. 3. 5. 0. 8.]]
+
+ output.dims = {8, 8}
+
+ output.lod = [[4, 4]]
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ data = fluid.data(name='data', shape=[None, 3, 32, 32],
+ dtype='float32')
+ output = fluid.layers.im2sequence(
+ input=data, stride=[1, 1], filter_size=[2, 2])
+
+
+ """
+ assert (
+ not _non_static_mode()
+ ), "sequence layer is not supported in dygraph mode yet."
+
+ check_variable_and_dtype(input, 'input', ['float32'], 'im2sequence')
+
+ if isinstance(filter_size, int):
+ filter_size = [filter_size, filter_size]
+ if isinstance(stride, int):
+ stride = [stride, stride]
+ if isinstance(padding, int):
+ padding = [padding, padding]
+ if len(padding) == 2:
+ padding.append(padding[0])
+ padding.append(padding[1])
+ inputs = {"X": input}
+ attrs = {"kernels": filter_size, "strides": stride, "paddings": padding}
+ if input_image_size:
+ if isinstance(out_stride, int):
+ out_stride = [out_stride, out_stride]
+ inputs["Y"] = input_image_size
+ attrs["out_stride"] = out_stride
+ helper = LayerHelper('im2sequence', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(
+ type='im2sequence', inputs=inputs, outputs={'Out': out}, attrs=attrs
+ )
+ return out
+
+
+@templatedoc()
+def row_conv(input, future_context_size, param_attr=None, act=None):
+ """
+ :api_attr: Static Graph
+
+ ${comment}
+
+ Args:
+ input (${x_type}): ${x_comment}.
+ future_context_size (int): Future context size. Please note, the shape
+ of convolution kernel is [future_context_size + 1, D].
+ param_attr (ParamAttr): Attributes of parameters, including
+ name, initializer etc.
+ act (str): Non-linear activation to be applied to output variable.
+
+ Returns:
+ ${out_comment}.
+
+ Examples:
+
+ .. code-block:: python
+
+ # for LodTensor inputs
+ import paddle
+ paddle.enable_static()
+ x = paddle.static.data(name='x', shape=[9, 16],
+ dtype='float32', lod_level=1)
+ out = paddle.static.nn.row_conv(input=x, future_context_size=2)
+ # for Tensor inputs
+ x = paddle.static.data(name='x', shape=[9, 4, 16], dtype='float32')
+ out = paddle.static.nn.row_conv(input=x, future_context_size=2)
+ """
+ helper = LayerHelper('row_conv', **locals())
+ check_variable_and_dtype(input, 'input', ['float32'], 'row_conv')
+ dtype = helper.input_dtype()
+ filter_shape = [future_context_size + 1, input.shape[-1]]
+ filter_param = helper.create_parameter(
+ attr=helper.param_attr, shape=filter_shape, dtype=dtype
+ )
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='row_conv',
+ inputs={'X': [input], 'Filter': [filter_param]},
+ outputs={'Out': [out]},
+ )
+ return helper.append_activation(out)
+
+
+@templatedoc()
+def multiplex(inputs, index, name=None):
+ """
+
+ Based on the given index parameter, the OP selects a specific row from each input Tensor to construct the output Tensor.
+
+ If the input of this OP contains :math:`m` Tensors, where :math:`I_{i}` means the i-th input Tensor, :math:`i` between :math:`[0,m)` .
+
+ And :math:`O` means the output, where :math:`O[i]` means the i-th row of the output, then the output satisfies that :math:`O[i] = I_{index[i]}[i]` .
+
+ For Example:
+
+ .. code-block:: text
+
+ Given:
+
+ inputs = [[[0,0,3,4], [0,1,3,4], [0,2,4,4], [0,3,3,4]],
+ [[1,0,3,4], [1,1,7,8], [1,2,4,2], [1,3,3,4]],
+ [[2,0,3,4], [2,1,7,8], [2,2,4,2], [2,3,3,4]],
+ [[3,0,3,4], [3,1,7,8], [3,2,4,2], [3,3,3,4]]]
+
+ index = [[3],[0],[1],[2]]
+
+ out = [[3,0,3,4], # out[0] = inputs[index[0]][0] = inputs[3][0] = [3,0,3,4]
+ [0,1,3,4], # out[1] = inputs[index[1]][1] = inputs[0][1] = [0,1,3,4]
+ [1,2,4,2], # out[2] = inputs[index[2]][2] = inputs[1][2] = [1,2,4,2]
+ [2,3,3,4]] # out[3] = inputs[index[3]][3] = inputs[2][3] = [2,3,3,4]
+
+
+ Args:
+ inputs (list): The input Tensor list. The list elements are N-D Tensors of data types float32, float64, int32, int64. All input Tensor shapes should be the same and rank must be at least 2.
+ index (Tensor): Used to select some rows in the input Tensor to construct an index of the output Tensor. It is a 2-D Tensor with data type int32 or int64 and shape [M, 1], where M is the number of input Tensors.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+ Returns:
+ Tensor: Output of multiplex OP, with data type being float32, float64, int32, int64.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+ img1 = np.array([[1, 2], [3, 4]]).astype(np.float32)
+ img2 = np.array([[5, 6], [7, 8]]).astype(np.float32)
+ inputs = [paddle.to_tensor(img1), paddle.to_tensor(img2)]
+ index = paddle.to_tensor(np.array([[1], [0]]).astype(np.int32))
+ res = paddle.multiplex(inputs, index)
+ print(res) # [array([[5., 6.], [3., 4.]], dtype=float32)]
+
+ """
+
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.multiplex(index, inputs)
+ if in_dygraph_mode():
+ return _C_ops.multiplex(inputs, index)
+ helper = LayerHelper('multiplex', **locals())
+
+ check_type(inputs, 'inputs', (list), 'multiplex')
+ if len(inputs) < 2:
+ raise ValueError(
+ "inputs should be a list object with at least 2 elements."
+ )
+ for id, x in enumerate(inputs):
+ check_variable_and_dtype(
+ x,
+ 'input[' + str(id) + ']',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'multiplex',
+ )
+ check_variable_and_dtype(index, "index", ['int32', 'int64'], 'multiplex')
+
+ out = helper.create_variable_for_type_inference(inputs[0].dtype)
+ helper.append_op(
+ type='multiplex',
+ inputs={'X': inputs, 'Ids': index},
+ outputs={'Out': [out]},
+ )
+ return out
+
+
+def smooth_l1(x, y, inside_weight=None, outside_weight=None, sigma=None):
+ """
+
+ This layer computes the smooth L1 loss for Variable :attr:`x` and :attr:`y`.
+ It takes the first dimension of :attr:`x` and :attr:`y` as batch size.
+ For each instance, it computes the smooth L1 loss element by element first
+ and then sums all the losses. So the shape of output Variable is
+ [batch_size, 1].
+
+ Args:
+ x (Variable): A tensor with rank at least 2. The input value of smooth
+ L1 loss op with shape [batch_size, dim1, ..., dimN].
+ A LoDTensor or Tensor with type float32.
+ y (Variable): A tensor with rank at least 2. The target value of smooth
+ L1 loss op with same shape as :attr:`x`.
+ A LoDTensor or Tensor with type float32.
+ inside_weight (Variable|None): A tensor with rank at least 2. This
+ input is optional and should have same shape with :attr:`x`. If
+ provided, the result of (:attr:`x` - :attr:`y`) will be multiplied
+ by this tensor element by element.
+ A Tensor with type float32.
+ outside_weight (Variable|None): A tensor with rank at least 2. This
+ input is optional and should have same shape with :attr:`x`. If
+ provided, the out smooth L1 loss will be multiplied by this tensor
+ element by element.
+ A Tensor with type float32.
+ sigma (float|None): Hyper parameter of smooth L1 loss layer. A float
+ scalar with default value 1.0.
+
+ Returns:
+ Variable: The output smooth L1 loss with shape [batch_size, 1]. A Tensor with type float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+ data = fluid.data(name="x", shape=[-1, 3], dtype="float32")
+ label = fluid.data(name="y", shape=[-1, 3], dtype="float32")
+ result = fluid.layers.smooth_l1(data,label)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ x = np.random.rand(3,3).astype("float32")
+ y = np.random.rand(3,3).astype("float32")
+ output= exe.run(feed={"x":x, "y":y},
+ fetch_list=[result])
+ print(output)
+
+ #[array([[0.08220536],
+ # [0.36652038],
+ # [0.20541131]], dtype=float32)]
+
+ """
+ check_variable_and_dtype(x, 'X', ['float32', 'float64'], 'smooth_l1_loss')
+ check_variable_and_dtype(y, 'Y', ['float32', 'float64'], 'smooth_l1_loss')
+
+ helper = LayerHelper('smooth_l1_loss', **locals())
+
+ diff = helper.create_variable_for_type_inference(dtype=x.dtype)
+ loss = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='smooth_l1_loss',
+ inputs={
+ 'X': x,
+ 'Y': y,
+ 'InsideWeight': inside_weight,
+ 'OutsideWeight': outside_weight,
+ },
+ outputs={'Diff': diff, 'Out': loss},
+ attrs={'sigma': sigma if sigma is not None else 1.0},
+ )
+ return loss
+
+
+@deprecated(since='2.0.0', update_to='paddle.nn.functional.one_hot')
+def one_hot(input, depth, allow_out_of_range=False):
+ """
+
+ **WARING:** This OP requires the last dimension of Tensor shape must be equal to 1.
+ This OP will be deprecated in a future release. It is recommended to use fluid. :ref:`api_fluid_one_hot` .
+
+ The operator converts each id in the input to an one-hot vector with a
+ :attr:`depth` length. The value in the vector dimension corresponding to the id
+ is 1, and the value in the remaining dimension is 0.
+
+ The shape of output Tensor or LoDTensor is generated by adding :attr:`depth` dimension
+ behind the last dimension of the input shape.
+
+ .. code-block:: text
+
+ Example 1 (allow_out_of_range=False):
+
+ input:
+ X.shape = [4, 1]
+ X.data = [[1], [1], [3], [0]]
+ depth = 4
+
+ output:
+ Out.shape = [4, 4]
+ Out.data = [[0., 1., 0., 0.],
+ [0., 1., 0., 0.],
+ [0., 0., 0., 1.],
+ [1., 0., 0., 0.]]
+
+ Example 2 (allow_out_of_range=True):
+
+ input:
+ X.shape = [4, 1]
+ X.data = [[1], [1], [5], [0]]
+ depth = 4
+ allow_out_of_range = True
+
+ output:
+ Out.shape = [4, 4]
+ Out.data = [[0., 1., 0., 0.],
+ [0., 1., 0., 0.],
+ [0., 0., 0., 0.], # This id is 5, which goes beyond depth, so set it all-zeros data.
+ [1., 0., 0., 0.]]
+
+ Example 3 (allow_out_of_range=False):
+
+ input:
+ X.shape = [4, 1]
+ X.data = [[1], [1], [5], [0]]
+ depth = 4
+ allow_out_of_range = False
+
+ output: Throw an exception for Illegal value
+ The second dimension in X is 5, which is greater than depth.
+ Allow_out_of_range =False means that does not allow the word id to exceed depth,
+ so it throws an exception.
+
+ Args:
+ input(Variable): Tensor or LoDTensor with shape :math:`[N_1, N_2, ..., N_k, 1]` ,
+ which contains at least one dimension and the last dimension must be 1.
+ The data type is int32 or int64.
+ depth(scalar): An integer defining the :attr:`depth` of the one hot dimension. If input
+ is word id, depth is generally the dictionary size.
+ allow_out_of_range(bool): A bool value indicating whether the input
+ indices could be out of range :math:`[0, depth)` . When input indices are
+ out of range, exceptions :code:`Illegal value` is raised if :attr:`allow_out_of_range`
+ is False, or zero-filling representations is created if it is set True.
+ Default: False.
+
+ Returns:
+ Variable: The one-hot representations of input. A Tensor or LoDTensor with type float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # Correspond to the first example above, where label.shape is [4, 1] and one_hot_label.shape is [4, 4].
+ label = fluid.data(name="label", shape=[4, 1], dtype="int64")
+ one_hot_label = fluid.layers.one_hot(input=label, depth=4)
+ """
+ if _non_static_mode():
+ if isinstance(depth, Variable):
+ depth = depth.numpy()
+ assert depth.shape == (
+ 1,
+ ), "depth of type Variable should have shape [1]"
+ depth = depth.item(0)
+ out = _legacy_C_ops.one_hot(
+ input, 'depth', depth, 'allow_out_of_range', allow_out_of_range
+ )
+ out.stop_gradient = True
+ return out
+
+ helper = LayerHelper("one_hot", **locals())
+ check_variable_and_dtype(input, 'input', ['int32', 'int64'], 'one_hot')
+ check_type(depth, 'depth', (six.integer_types, Variable), 'one_hot')
+ one_hot_out = helper.create_variable_for_type_inference(dtype='float32')
+
+ if not isinstance(depth, Variable):
+ # user attribute
+ inputs = {'X': input}
+ attrs = {'depth': depth, 'allow_out_of_range': allow_out_of_range}
+ else:
+ depth.stop_gradient = True
+ inputs = {'X': input, 'depth_tensor': depth}
+ attrs = {'allow_out_of_range': allow_out_of_range}
+ helper.append_op(
+ type="one_hot", inputs=inputs, attrs=attrs, outputs={'Out': one_hot_out}
+ )
+ one_hot_out.stop_gradient = True
+ return one_hot_out
+
+
+def autoincreased_step_counter(counter_name=None, begin=1, step=1):
+ """
+ :api_attr: Static Graph
+
+ Create an auto-increase variable. which will be automatically increased
+ by 1 in every iteration. By default, the first return of this counter is 1,
+ and the step size is 1.
+
+ Args:
+ counter_name(str, optional): The counter name. Default '@STEP_COUNTER@'.
+ begin(int, optional): The first return value of this counter. Default 1.
+ step(int, optional): The step size. Default 1.
+
+ Returns:
+ Variable: The auto-increased Variable with data type int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ global_step = fluid.layers.autoincreased_step_counter(
+ counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)
+ """
+ helper = LayerHelper('global_step_counter')
+ if counter_name is None:
+ counter_name = '@STEP_COUNTER@'
+ counter, is_new_var = helper.create_or_get_global_variable(
+ name=counter_name,
+ dtype='int64',
+ shape=[1],
+ persistable=True,
+ belong_to_optimizer=True,
+ )
+ if is_new_var:
+ helper.set_variable_initializer(
+ counter, initializer=Constant(value=begin - 1, force_cpu=True)
+ )
+ helper.main_program.global_block()._prepend_op(
+ type='increment',
+ inputs={'X': [counter]},
+ outputs={'Out': [counter]},
+ attrs={'step': float(step)},
+ )
+ counter.stop_gradient = True
+
+ return counter
+
+
+def reshape(x, shape, actual_shape=None, act=None, inplace=False, name=None):
+ r"""
+ :alias_main: paddle.reshape
+ :alias: paddle.reshape,paddle.tensor.reshape,paddle.tensor.manipulation.reshape
+
+ This operator changes the shape of ``x`` without changing its data.
+
+ The target shape can be given by ``shape`` or ``actual_shape``.
+ When ``shape`` and ``actual_shape`` are set at the same time,
+ ``actual_shape`` has a higher priority than ``shape``
+ but at this time ``shape`` can only be an integer list or tuple, and ``shape`` still should be set correctly to
+ guarantee shape inference in compile-time.
+
+ Some tricks exist when specifying the target shape.
+
+ 1. -1 means the value of this dimension is inferred from the total element
+ number of x and remaining dimensions. Thus one and only one dimension can
+ be set -1.
+
+ 2. 0 means the actual dimension value is going to be copied from the
+ corresponding dimension of x. The index of 0s in shape can not exceed
+ the dimension of x.
+
+ Here are some examples to explain it.
+
+ 1. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape
+ is [6, 8], the reshape operator will transform x into a 2-D tensor with
+ shape [6, 8] and leaving x's data unchanged.
+
+ 2. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape
+ specified is [2, 3, -1, 2], the reshape operator will transform x into a
+ 4-D tensor with shape [2, 3, 4, 2] and leaving x's data unchanged. In this
+ case, one dimension of the target shape is set to -1, the value of this
+ dimension is inferred from the total element number of x and remaining
+ dimensions.
+
+ 3. Given a 3-D tensor x with a shape [2, 4, 6], and the target shape
+ is [-1, 0, 3, 2], the reshape operator will transform x into a 4-D tensor
+ with shape [2, 4, 3, 2] and leaving x's data unchanged. In this case,
+ besides -1, 0 means the actual dimension value is going to be copied from
+ the corresponding dimension of x.
+
+ **Note**:
+ The parameter ``actual_shape`` will be deprecated in the future and only use ``shape`` instead to represent the target shape.
+
+ Args:
+ x(Tensor): An N-D Tensor. The data type is ``float32``, ``float64``, ``int32`` or ``int64``.
+ shape(list|tuple|Tensor): Define the target shape. At most one dimension of the target shape can be -1.
+ The data type is ``int32`` . If ``shape`` is a list or tuple, the elements of it should be integers or Tensors with shape [1].
+ If ``shape`` is an Tensor, it should be an 1-D Tensor .
+ actual_shape(variable, optional): An 1-D ``Tensor`` or ``LoDTensor`` . The data type is ``int32`` . If provided, reshape
+ according to this given shape rather than ``shape`` specifying shape.
+ That is to say ``actual_shape`` has a higher priority
+ than ``shape(list|tuple)`` but not ``shape(Tensor)``. \
+ This argument ``actual_shape`` will be removed in a future version. \
+ Instructions for updating: ``actual_shape`` will be removed in future versions and replaced by ``shape``.
+ act (str, optional): The non-linear activation to be applied to the reshaped input. Default None.
+ inplace(bool, optional): If ``inplace`` is True, the input and output of ``layers.reshape``
+ are the same variable. Otherwise, the input and output of
+ ``layers.reshape`` are different variable. Default False. Note that if ``x``
+ is more than one OPs' input, ``inplace`` must be False.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor: A reshaped Tensor with the same data type as ``x``. It is a new tensor variable if ``inplace`` is ``False``, otherwise it is ``x``. If ``act`` is None, return the reshaped tensor variable, otherwise return the activated tensor variable.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # example 1:
+ # attr shape is a list which doesn't contain Tensors.
+ data_1 = fluid.data(
+ name='data_1', shape=[2, 4, 6], dtype='float32')
+ reshaped_1 = fluid.layers.reshape(
+ x=data_1, shape=[-1, 0, 3, 2])
+ # the shape of reshaped_1 is [2,4,3,2].
+
+ # example 2:
+ # attr shape is a list which contains Tensors.
+ data_2 = fluid.layers.fill_constant([2,25], "int32", 3)
+ dim = fluid.layers.fill_constant([1], "int32", 5)
+ reshaped_2 = fluid.layers.reshape(data_2, shape=[dim, 10])
+ # the shape of reshaped_2 is [5,10].
+
+ # example 3:
+ data_3 = fluid.data(
+ name="data_3", shape=[2,4,6], dtype='float32')
+ reshaped_3 = fluid.layers.reshape(x=data_3, shape=[6,8])
+ # the shape of reshaped_3 is [6,8].
+ """
+ if in_dygraph_mode():
+ tmp_tensor_type = core.eager.Tensor
+ # TODO(zhiqiu): enable inplace in dygraph mode.
+ if inplace:
+ warnings.warn(
+ "Inplace on reshape is not allowed and will be discarded in dygraph mode currently."
+ )
+ if isinstance(shape, (list, tuple)):
+ shape = [
+ item.numpy().item(0) if isinstance(item, Variable) else item
+ for item in shape
+ ]
+ out = _C_ops.reshape(x, shape)
+ elif isinstance(shape, tmp_tensor_type):
+ # TODO: Tensor shape in reshape has not been tested
+ shape.stop_gradient = True
+ out = _C_ops.reshape(x, shape)
+ else:
+ raise ValueError(
+ "shape must be an instance of `list`, `tuple` or `Variable`,"
+ " got '{}.'".format(type(shape))
+ )
+
+ return dygraph_utils._append_activation_in_dygraph(out, act)
+ else:
+ if _in_legacy_dygraph():
+ tmp_tensor_type = Variable
+ if inplace:
+ warnings.warn(
+ "Inplace on reshape is not allowed and will be discarded in dygraph mode currently."
+ )
+ if isinstance(shape, (list, tuple)):
+ shape = [
+ item.numpy().item(0) if isinstance(item, Variable) else item
+ for item in shape
+ ]
+ out, _ = _legacy_C_ops.reshape2(x, None, 'shape', shape)
+ elif isinstance(shape, tmp_tensor_type):
+ shape.stop_gradient = True
+ out, _ = _legacy_C_ops.reshape2(x, shape)
+ else:
+ raise ValueError(
+ "shape must be an instance of `list`, `tuple` or `Variable`,"
+ " got '{}.'".format(type(shape))
+ )
+
+ return dygraph_utils._append_activation_in_dygraph(out, act)
+
+ check_variable_and_dtype(
+ x,
+ 'x',
+ [
+ 'float16',
+ 'float32',
+ 'float64',
+ 'int16',
+ 'int32',
+ 'int64',
+ 'bool',
+ 'uint16',
+ ],
+ 'reshape',
+ )
+ check_type(shape, 'shape', (list, tuple, Variable), 'reshape')
+ check_type(actual_shape, 'actual_shape', (Variable, type(None)), 'reshape')
+
+ helper = LayerHelper("reshape2", **locals())
+
+ def get_attr_shape(list_shape):
+ unk_dim_idx = -1
+ attrs_shape = []
+ for dim_idx, dim_size in enumerate(list_shape):
+ if isinstance(dim_size, Variable):
+ attrs_shape.append(-1)
+ else:
+ attrs_shape.append(dim_size)
+ if dim_size == -1:
+ assert unk_dim_idx == -1, (
+ "Only one dimension value of 'shape' in reshape can "
+ "be -1. But received shape[%d] is also -1.\n"
+ "\n\t# N = x.shape()[2]\t\t# N is an int. "
+ "(NOT recommend under @to_static)\n\tN = paddle.shape(x)[2]\t\t"
+ "# N is a Tensor. (Recommend)\n\tz = paddle.reshape([N, -1, 4])"
+ "\t# z.shape is [-1, -1, 4]\n\n"
+ " If your target shape in Reshape represents dynamic shape, "
+ "please turn it into a Tensor under @to_static. See above example for details."
+ % dim_idx
+ )
+ unk_dim_idx = dim_idx
+ elif dim_size == 0:
+ assert dim_idx < len(x.shape), (
+ "The index of 0 in `shape` must be less than "
+ "the input tensor X's dimensions. "
+ "But received shape[%d] = 0, X's dimensions = %d."
+ % (dim_idx, len(x.shape))
+ )
+ else:
+ assert dim_size > 0, (
+ "Each dimension value of 'shape' in reshape must not "
+ "be negative except one unknown dimension. "
+ "But received shape[%d] = %s."
+ % (dim_idx, str(dim_size))
+ )
+ return attrs_shape
+
+ inputs = {"X": x}
+ attrs = {}
+ if isinstance(shape, Variable):
+ shape.stop_gradient = True
+ inputs["Shape"] = shape
+ elif isinstance(shape, (list, tuple)):
+ assert len(shape) > 0, (
+ "The size of 'shape' in reshape can't be zero, "
+ "but received %s." % len(shape)
+ )
+ attrs["shape"] = get_attr_shape(shape)
+ if utils._contain_var(shape):
+ inputs['ShapeTensor'] = utils._convert_to_tensor_list(shape)
+ elif isinstance(actual_shape, Variable):
+ actual_shape.stop_gradient = True
+ inputs["Shape"] = actual_shape
+
+ out = (
+ x
+ if inplace
+ else helper.create_variable_for_type_inference(dtype=x.dtype)
+ )
+ x_shape = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type="reshape2",
+ inputs=inputs,
+ attrs=attrs,
+ outputs={"Out": out, "XShape": x_shape},
+ )
+
+ return helper.append_activation(out)
+
+
+def squeeze(input, axes, name=None):
+ """
+ This OP will squeeze single-dimensional entries of input tensor's shape. If axes is provided, will
+ remove the dims by axes, the dims selected by axes should be one. If not provide axes, all dims equal
+ to one will be deleted.
+
+
+ .. code-block:: text
+
+ Case1:
+
+ Input:
+ X.shape = (1, 3, 1, 5)
+ axes = [0]
+ Output:
+ Out.shape = (3, 1, 5)
+
+ Case2:
+
+ Input:
+ X.shape = (1, 3, 1, 5)
+ axes = []
+ Output:
+ Out.shape = (3, 5)
+
+ Case3:
+
+ Input:
+ X.shape = [1,3,1,5]
+ axes = [-2]
+ Output:
+ Out.shape = [1,3,5]
+
+ Args:
+ input (Variable): The input Tensor. Supported data type: float32, float64, bool, int8, int32, int64.
+ axes (list): One integer or List of integers, indicating the dimensions to be squeezed.
+ Axes range is :math:`[-rank(input), rank(input))`.
+ If axes is negative, :math:`axes=axes+rank(input)`.
+ name (str, optional): Please refer to :ref:`api_guide_Name`, Default None.
+
+ Returns:
+ Variable: Output squeezed Tensor. Data type is same as input Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ # set batch size=None
+ x = fluid.data(name='x', shape=[None, 5, 1, 10])
+ y = layers.squeeze(input=x, axes=[2]) # y.shape=[None, 5, 10]
+
+ """
+ if in_dygraph_mode():
+ return _C_ops.squeeze(input, axes)
+ if _in_legacy_dygraph():
+ out, _ = _legacy_C_ops.squeeze2(input, 'axes', axes)
+ return out
+
+ helper = LayerHelper("squeeze", **locals())
+ check_variable_and_dtype(
+ input,
+ 'input',
+ [
+ 'float16',
+ 'float32',
+ 'float64',
+ 'bool',
+ 'int8',
+ 'int32',
+ 'int64',
+ 'complex64',
+ 'complex128',
+ ],
+ 'squeeze',
+ )
+ check_type(axes, 'axis/axes', (list, tuple, Variable), 'squeeze')
+
+ attrs = {}
+ if isinstance(axes, Variable):
+ axes.stop_gradient = True
+ attrs["axes"] = axes
+ elif isinstance(axes, (list, tuple)):
+ if utils._contain_var(axes):
+ attrs["axes"] = utils._convert_to_tensor_list(axes)
+ else:
+ attrs["axes"] = axes
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ x_shape = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type="squeeze2",
+ inputs={"X": input},
+ attrs=attrs,
+ outputs={"Out": out, "XShape": x_shape},
+ )
+
+ return out
+
+
+def unsqueeze(input, axes, name=None):
+ """
+ Insert single-dimensional entries to the shape of a Tensor. Takes one
+ required argument axes, a list of dimensions that will be inserted.
+ Dimension indices in axes are as seen in the output tensor.
+
+ For example:
+
+ .. code-block:: text
+
+ Given a tensor such that tensor with shape [3, 4, 5],
+ then Unsqueezed tensor with axes=[0, 4] has shape [1, 3, 4, 5, 1].
+
+ Args:
+ input (Variable): The input Tensor to be unsqueezed. Supported data type: float32, float64, bool, int8, int32, int64.
+ axes (int|list|tuple|Variable): Indicates the dimensions to be inserted. The data type is ``int32`` . If ``axes`` is a list or tuple, the elements of it should be integers or Tensors with shape [1]. If ``axes`` is an Variable, it should be an 1-D Tensor .
+ name (str|None): Name for this layer.
+
+ Returns:
+ Variable: Unsqueezed Tensor, with the same data type as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[5, 10])
+ y = fluid.layers.unsqueeze(input=x, axes=[1])
+
+ """
+ if _non_static_mode():
+ if isinstance(axes, int):
+ axes = [axes]
+ elif isinstance(axes, Variable):
+ axes = axes.numpy().tolist()
+ elif isinstance(axes, (list, tuple)):
+ axes = [
+ item.numpy().item(0) if isinstance(item, Variable) else item
+ for item in axes
+ ]
+ if _in_legacy_dygraph():
+ out, _ = _legacy_C_ops.unsqueeze2(input, 'axes', axes)
+ return out
+ return _C_ops.unsqueeze(input, axes)
+
+ check_type(axes, 'axis/axes', (int, list, tuple, Variable), 'unsqueeze')
+ check_variable_and_dtype(
+ input,
+ 'input',
+ [
+ 'float16',
+ 'float32',
+ 'float64',
+ 'bool',
+ 'int8',
+ 'int16',
+ 'int32',
+ 'int64',
+ 'complex64',
+ 'complex128',
+ ],
+ 'unsqueeze',
+ )
+ helper = LayerHelper("unsqueeze2", **locals())
+ inputs = {"X": input}
+ attrs = {}
+
+ if isinstance(axes, int):
+ axes = [axes]
+ if isinstance(axes, Variable):
+ axes.stop_gradient = True
+ inputs["AxesTensor"] = axes
+ elif isinstance(axes, (list, tuple)):
+ if utils._contain_var(axes):
+ inputs["AxesTensorList"] = utils._convert_to_tensor_list(axes)
+ else:
+ attrs["axes"] = axes
+
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ x_shape = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type="unsqueeze2",
+ inputs=inputs,
+ attrs=attrs,
+ outputs={"Out": out, "XShape": x_shape},
+ )
+
+ return out
+
+
+def lod_reset(x, y=None, target_lod=None):
+ """
+ Set LoD of :attr:`x` to a new one specified by :attr:`y` or
+ :attr:`target_lod`. When :attr:`y` provided, :attr:`y.lod` would be
+ considered as target LoD first, otherwise :attr:`y.data` would be
+ considered as target LoD. If :attr:`y` is not provided, target LoD should
+ be specified by :attr:`target_lod`. If target LoD is specified by
+ :attr:`y.data` or :attr:`target_lod`, only one level LoD is supported.
+
+ .. code-block:: text
+
+ * Example 1:
+
+ Given a 1-level LoDTensor x:
+ x.lod = [[ 2, 3, 1 ]]
+ x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ x.dims = [6, 1]
+
+ target_lod: [4, 2]
+
+ then we get a 1-level LoDTensor:
+ out.lod = [[4, 2]]
+ out.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ out.dims = [6, 1]
+
+ * Example 2:
+
+ Given a 1-level LoDTensor x:
+ x.lod = [[2, 3, 1]]
+ x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ x.dims = [6, 1]
+
+ y is a Tensor:
+ y.data = [[2, 4]]
+ y.dims = [1, 3]
+
+ then we get a 1-level LoDTensor:
+ out.lod = [[2, 4]]
+ out.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ out.dims = [6, 1]
+
+ * Example 3:
+
+ Given a 1-level LoDTensor x:
+ x.lod = [[2, 3, 1]]
+ x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ x.dims = [6, 1]
+
+ y is a 2-level LoDTensor:
+ y.lod = [[2, 2], [2, 2, 1, 1]]
+ y.data = [[1.1], [2.1], [3.1], [4.1], [5.1], [6.1]]
+ y.dims = [6, 1]
+
+ then we get a 2-level LoDTensor:
+ out.lod = [[2, 2], [2, 2, 1, 1]]
+ out.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ out.dims = [6, 1]
+
+ Args:
+ x (Variable): Input variable which could be a Tensor or LoDTensor.
+ The data type should be int32, int64, float32 or float64.
+ y (Variable, optional): If provided, output's LoD would be derived from :attr:`y`.
+ If y's lod level>0, the data type can be any type.
+ If y's lod level=0, the data type should be int32.
+ target_lod (list|tuple, optional): One level LoD which should be considered
+ as target LoD when :attr:`y` not provided.
+
+ Returns:
+ Variable: Output variable with LoD specified by this layer.
+
+ Raises:
+ ValueError: If :attr:`y` and :attr:`target_lod` are both None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[10])
+ y = fluid.layers.data(name='y', shape=[10, 20], lod_level=2)
+ out = fluid.layers.lod_reset(x=x, y=y)
+ """
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64'], 'lod_reset'
+ )
+ helper = LayerHelper("lod_reset", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ if y is not None:
+ check_type(y, 'y', (Variable), 'lod_reset')
+ # TODO: check y.lod_level = 0 dtype
+ helper.append_op(
+ type="lod_reset", inputs={'X': x, 'Y': y}, outputs={'Out': out}
+ )
+ elif target_lod is not None:
+ helper.append_op(
+ type="lod_reset",
+ inputs={'X': x},
+ attrs={'target_lod': target_lod},
+ outputs={'Out': out},
+ )
+ else:
+ raise ValueError("y and target_lod should not be both none.")
+ return out
+
+
+def lod_append(x, level):
+ """
+ Append level to LoD of :attr:`x`.
+
+ .. code-block:: text
+
+ * Example 1:
+
+ given a 1-level LoDTensor x:
+ x.lod = [[ 2, 3, 1 ]]
+ x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ x.dims = [6, 1]
+
+ level: [1, 1, 1, 1, 1, 1, 1]
+
+ then we get a 2-level LoDTensor:
+ x.lod = [[ 2, 3, 1 ], [1, 1, 1, 1, 1, 1]]
+ x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]]
+ x.dims = [6, 1]
+
+ Args:
+ x (Variable): Input variable which could be a tensor or LoDTensor.
+ The data type should be int32, int64, float32 or float64.
+ level (list|tuple|Variable, optional): The LoD level to be appended into LoD of x.
+ If level is variable and its lod level>0, the data type can be any type.
+ If level is variable and its lod level=0, the data type should be int32.
+ Returns:
+ Variable: Output variable with new LoD level.
+
+ Raises:
+ ValueError: If :attr:`y` is None or and :attr:`level` is not Iterator.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.layers.data(name='x', shape=[6, 10], lod_level=1)
+ out = fluid.layers.lod_append(x, [1,1,1,1,1,1])
+ """
+ try:
+ from collections.abc import Iterable
+ except:
+ from collections import Iterable
+ if x is None:
+ raise ValueError("Input(x) can't be None.")
+ if (not isinstance(level, Iterable)) and (not isinstance(level, Variable)):
+ raise ValueError("Input(level) must be list, tuple or Variable.")
+
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64'], 'lod_append'
+ )
+
+ helper = LayerHelper("lod_append", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ inputs = {'X': x}
+ attrs = {'append': True}
+
+ if isinstance(level, Variable):
+ inputs['Y'] = level
+ # TODO: check y.lod_level = 0 dtype
+ else:
+ attrs['target_lod'] = level
+ helper.append_op(
+ type="lod_reset", inputs=inputs, attrs=attrs, outputs={'Out': out}
+ )
+ return out
+
+
+def lrn(
+ input, n=5, k=1.0, alpha=1e-4, beta=0.75, name=None, data_format='NCHW'
+):
+ r"""
+ :alias_main: paddle.nn.functional.lrn
+ :alias: paddle.nn.functional.lrn,paddle.nn.functional.norm.lrn
+ :old_api: paddle.fluid.layers.lrn
+
+ This operator implements the Local Response Normalization Layer.
+ This layer performs a type of "lateral inhibition" by normalizing over local input regions.
+ For more information, please refer to `ImageNet Classification with Deep Convolutional Neural Networks `_
+
+ The formula is as follows:
+
+ .. math::
+
+ Output(i, x, y) = Input(i, x, y) / \\left(k + \\alpha \\sum\\limits^{\\min(C-1, i + n/2)}_{j = \\max(0, i - n/2)}(Input(j, x, y))^2\\right)^{\\beta}
+
+ In the above equation:
+
+ - :math:`n` : The number of channels to sum over.
+ - :math:`k` : The offset (avoid being divided by 0).
+ - :math:`\\alpha` : The scaling parameter.
+ - :math:`\\beta` : The exponent parameter.
+
+
+ Args:
+ input (Variable): Input feature, 4D-Tensor with the shape of [N,C,H,W] or [N, H, W, C],
+ where N is the batch size, C is the input channel, H is Height, W is weight. The data
+ type is float32. The rank of this tensor must be 4, otherwise it will raise ValueError.
+ n (int, optional): The number of channels to sum over. Default: 5
+ k (float, optional): An offset, positive. Default: 1.0
+ alpha (float, optional): The scaling parameter, positive. Default:1e-4
+ beta (float, optional): The exponent, positive. Default:0.75
+ name (str, optional): The default value is None. Normally there is no need for user to set
+ this property. For more information, please refer to :ref:`api_guide_Name`
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ Variable: A tensor variable storing the transformation result with the same shape and data type as input.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.data(
+ name="data", shape=[None, 3, 112, 112], dtype="float32")
+ lrn = fluid.layers.lrn(input=data)
+ print(lrn.shape) # [-1, 3, 112, 112]
+ print(lrn.dtype) # float32
+ """
+ helper = LayerHelper('lrn', **locals())
+ check_variable_and_dtype(input, 'input', ['float32'], 'lrn')
+ dtype = helper.input_dtype()
+ input_shape = input.shape
+ dims = len(input_shape)
+
+ if dims != 4:
+ raise ValueError(
+ "Input's dimension size of Op(lrn) must be 4, but received %d."
+ % (dims)
+ )
+ if data_format not in ['NCHW', 'NHWC']:
+ raise ValueError(
+ "Attr(data_format) of Op(lrn) got wrong value: received "
+ + data_format
+ + " but only NCHW or NHWC supported."
+ )
+
+ mid_out = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=True
+ )
+ lrn_out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="lrn",
+ inputs={"X": input},
+ outputs={
+ "Out": lrn_out,
+ "MidOut": mid_out,
+ },
+ attrs={
+ "n": n,
+ "k": k,
+ "alpha": alpha,
+ "beta": beta,
+ "data_format": data_format,
+ },
+ )
+
+ return lrn_out
+
+
+def pad(x, paddings, pad_value=0.0, name=None):
+ r"""
+ :alias_main: paddle.nn.functional.pad
+ :alias: paddle.nn.functional.pad,paddle.nn.functional.common.pad
+ :old_api: paddle.fluid.layers.pad
+
+ This op will pad a tensor with a constant value given by :attr:`pad_value`, and the
+ padded shape is specified by :attr:`paddings`.
+
+ Specifically, the number of values padded before the elements of :attr:`x`
+ in dimension :attr:`i` is indicated by :attr:`paddings[2*i]`, and the number
+ of values padded after the elements of :attr:`x` in dimension :attr:`i` is
+ indicated by :attr:`paddings[2*i+1]`.
+
+ See below for an example.
+
+ .. code-block:: text
+
+ Given:
+ x = [[1, 2], [3, 4]]
+
+ paddings = [0, 1, 1, 2]
+
+ pad_value = 0
+
+ Return:
+ out = [[0, 1, 2, 0, 0]
+ [0, 3, 4, 0, 0]
+ [0, 0, 0, 0, 0]]
+
+ Args:
+ x (Variable): Tensor, data type is float32.
+ paddings (list): A list of integers. Its elements specify the padded
+ width before and after each dimension in turn.
+ The length of :attr:`paddings` must be equal to
+ :math:`rank(x) \\times 2`.
+ pad_value (float): The constant value used to pad.
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ The padded tensor, with the same data type and rank as :attr:`x`
+
+ Return Type:
+ Variable
+
+ Examples:
+ .. code-block:: python
+
+ # x is a rank 2 tensor variable
+ import paddle.fluid as fluid
+ x = fluid.data(name='data', shape=[300, 300], dtype='float32')
+ out = fluid.layers.pad(x=x, paddings=[0, 1, 1, 2], pad_value=0.)
+ """
+ check_variable_and_dtype(
+ x,
+ 'x',
+ [
+ 'float16',
+ 'float32',
+ 'float64',
+ 'int32',
+ 'int64',
+ 'complex64',
+ 'complex128',
+ ],
+ "pad",
+ )
+
+ check_type(pad_value, 'pad_value', (float, int, Variable), 'pad')
+ if isinstance(pad_value, int):
+ pad_value = float(pad_value)
+
+ helper = LayerHelper('pad', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='pad',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'paddings': paddings, 'pad_value': pad_value},
+ )
+ return out
+
+
+def pad_constant_like(x, y, pad_value=0.0, name=None):
+ r"""
+ Pad :attr:`y` with :attr:`pad_value`, the number of values padded to
+ the edges of each axis is specified by the difference of the shape
+ of :attr:`x` and :attr:`y` . ((0, shape_x_0 - shape_y_0), ... (0, shape_x_n - shape_y_n))
+ specify padding widths for each axis. The input should be a k-D tensor(k > 0 and k < 7).
+
+ See below for an example.
+
+ .. code-block:: text
+
+ Given:
+ X = [[[[ 0, 1, 2],
+ [ 3, 4, 5]],
+ [[ 6, 7, 8],
+ [ 9, 10, 11]],
+ [[12, 13, 14],
+ [15, 16, 17]]],
+ [[[18, 19, 20],
+ [21, 22, 23]],
+ [[24, 25, 26],
+ [27, 28, 29]],
+ [[30, 31, 32],
+ [33, 34, 35]]]]
+
+ X.shape = (2, 3, 2, 3)
+
+ Y = [[[[35, 36, 37]],
+ [[38, 39, 40]],
+ [[41, 42, 43]]]]
+
+ Y.shape = (1, 3, 1, 3)
+
+ And
+ pad_value = 0.
+
+ Return:
+ Out = [[[[35, 36, 37],
+ [ 0, 0, 0]],
+ [[38, 39, 40],
+ [ 0, 0, 0]],
+ [[41, 42, 43],
+ [ 0, 0, 0]]],
+ [[[ 0, 0, 0],
+ [ 0, 0, 0]],
+ [[ 0, 0, 0],
+ [ 0, 0, 0]],
+ [[ 0, 0, 0],
+ [ 0, 0, 0]]]]
+
+ Out.shape = [2, 3, 2, 3]
+
+
+ Args:
+ x (Variable): Tensor, its shape specifies the shape of output.
+ y (Variable): Tensor, its rank is the same with :attr:`x`, and for each dimension :math:`i` ,
+ :math:`y\_shape[i] <= x\_shape[i]` . The data type can be float32 or float64.
+ pad_value (float): The constant value used to pad.
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ The padded tensor, with the same shape as :attr:`x` and the same data type as :attr:`y`
+
+ Return Type:
+ Variable
+
+ Examples:
+ .. code-block:: python
+
+ # x is a rank 4 tensor variable, x.shape = (2, 3, 2, 3)
+ # y is a rank 4 tensor variable, y.shape = (1, 3, 1, 3)
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[2,3,2,3], dtype='float32')
+ y = fluid.data(name='y', shape=[1,3,1,3], dtype='float32')
+ out = fluid.layers.pad_constant_like(x=x, y=y, pad_value=0.)
+ # out is a rank 4 tensor variable, and out.shape = [2, 3 ,2 , 3]
+ """
+ check_type(x, 'x', (Variable), 'pad_constant_like')
+ check_variable_and_dtype(
+ y, 'y', ['float32', 'float64', 'int32', 'int64'], "pad_constant_like"
+ )
+
+ helper = LayerHelper('pad_constant_like', **locals())
+ dtype = helper.input_dtype(input_param_name='y')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='pad_constant_like',
+ inputs={'X': x, 'Y': y},
+ outputs={'Out': out},
+ attrs={'pad_value': float(pad_value)},
+ )
+ return out
+
+
+def label_smooth(
+ label, prior_dist=None, epsilon=0.1, dtype="float32", name=None
+):
+ r"""
+ :alias_main: paddle.nn.functional.label_smooth
+ :alias: paddle.nn.functional.label_smooth,paddle.nn.functional.common.label_smooth
+ :old_api: paddle.fluid.layers.label_smooth
+
+ Label smoothing is a mechanism to regularize the classifier layer and is called
+ label-smoothing regularization (LSR).
+
+ Label smoothing is proposed to encourage the model to be less confident,
+ since optimizing the log-likelihood of the correct label directly may
+ cause overfitting and reduce the ability of the model to adapt. Label
+ smoothing replaces the ground-truth label :math:`y` with the weighted sum
+ of itself and some fixed distribution :math:`\mu`. For class :math:`k`,
+ i.e.
+
+ .. math::
+
+ \\tilde{y_k} = (1 - \epsilon) * y_k + \epsilon * \mu_k,
+
+ where :math:`1 - \epsilon` and :math:`\epsilon` are the weights
+ respectively, and :math:`\\tilde{y}_k` is the smoothed label. Usually
+ uniform distribution is used for :math:`\mu`.
+
+ See more details about label smoothing in https://arxiv.org/abs/1512.00567.
+
+ Parameters:
+ label(Variable): The input variable containing the label data. The
+ label data should use one-hot representation. It's
+ a multidimensional tensor with a shape of
+ :math:`[N_1, ..., Depth]`, where Depth is class number. The dtype can be "float32" and "float64".
+ prior_dist(Variable, optional): The prior distribution to be used to smooth
+ labels. If not provided, an uniform distribution
+ is used. It's a multidimensional tensor with a shape of
+ :math:`[1, class\_num]` . The default value is None.
+ epsilon(float, optional): The weight used to mix up the original ground-truth
+ distribution and the fixed distribution. The default value is
+ 0.1.
+ dtype(np.dtype|core.VarDesc.VarType|str, optional): The data type can be set
+ as 'float32', 'float64'. The default value is 'float32'.
+ name(str, optional): The default value is None. Normally there is no need for user
+ to set this property. For more information, please refer to
+ :ref:`api_guide_Name`.
+
+ Returns:
+ Variable: The tensor variable containing the smoothed labels.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ label = layers.data(name="label", shape=[1], dtype="int32")
+ one_hot_label = layers.one_hot(input=label, depth=10)
+ smooth_label = layers.label_smooth(
+ label=one_hot_label, epsilon=0.1, dtype="float32")
+ """
+ if in_dygraph_mode():
+ return _C_ops.label_smooth(label, prior_dist, float(epsilon))
+
+ if epsilon > 1.0 or epsilon < 0.0:
+ raise ValueError("The value of epsilon must be between 0 and 1.")
+
+ if _non_static_mode():
+ return _legacy_C_ops.label_smooth(
+ label, prior_dist, 'epsilon', float(epsilon)
+ )
+
+ check_variable_and_dtype(
+ label, 'label', ['float32', 'float64'], 'label_smooth'
+ )
+
+ helper = LayerHelper("label_smooth", **locals())
+ label.stop_gradient = True
+ smooth_label = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="label_smooth",
+ inputs={"X": label, "PriorDist": prior_dist}
+ if prior_dist
+ else {"X": label},
+ outputs={"Out": smooth_label},
+ attrs={"epsilon": float(epsilon)},
+ )
+ return smooth_label
+
+
+@templatedoc()
+def roi_pool(
+ input,
+ rois,
+ pooled_height=1,
+ pooled_width=1,
+ spatial_scale=1.0,
+ rois_num=None,
+ name=None,
+):
+ """
+
+ This operator implements the roi_pooling layer.
+ Region of interest pooling (also known as RoI pooling) is to perform max pooling on inputs of nonuniform sizes to obtain fixed-size feature maps (e.g. 7*7).
+
+ The operator has three steps:
+
+ 1. Dividing each region proposal into equal-sized sections with the pooled_width and pooled_height;
+ 2. Finding the largest value in each section;
+ 3. Copying these max values to the output buffer.
+
+ For more information, please refer to https://stackoverflow.com/questions/43430056/what-is-roi-layer-in-fast-rcnn
+
+ Args:
+ input (Variable): Input feature, 4D-Tensor with the shape of [N,C,H,W], where N is the batch size, C is the input channel, H is Height, W is weight. The data type is float32 or float64.
+ rois (Variable): ROIs (Regions of Interest) to pool over. 2D-LoDTensor with the shape of [num_rois,4], the lod level is 1. Given as [[x1, y1, x2, y2], ...], (x1, y1) is the top left coordinates, and (x2, y2) is the bottom right coordinates.
+ pooled_height (int, optional): The pooled output height, data type is int32. Default: 1
+ pooled_width (int, optional): The pooled output height, data type is int32. Default: 1
+ spatial_scale (float, optional): Multiplicative spatial scale factor to translate ROI coords from their input scale to the scale used when pooling. Default: 1.0
+ rois_num (Tensor): The number of RoIs in each image. Default: None
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+
+ Returns:
+ Variable: The pooled feature, 4D-Tensor with the shape of [num_rois, C, pooled_height, pooled_width].
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ DATATYPE='float32'
+
+ place = fluid.CPUPlace()
+ #place = fluid.CUDAPlace(0)
+
+ input_data = np.array([i for i in range(1,17)]).reshape(1,1,4,4).astype(DATATYPE)
+ roi_data =fluid.create_lod_tensor(np.array([[1., 1., 2., 2.], [1.5, 1.5, 3., 3.]]).astype(DATATYPE),[[2]], place)
+ rois_num_data = np.array([2]).astype('int32')
+
+ x = fluid.data(name='input', shape=[None,1,4,4], dtype=DATATYPE)
+ rois = fluid.data(name='roi', shape=[None,4], dtype=DATATYPE)
+ rois_num = fluid.data(name='rois_num', shape=[None], dtype='int32')
+
+ pool_out = fluid.layers.roi_pool(
+ input=x,
+ rois=rois,
+ pooled_height=1,
+ pooled_width=1,
+ spatial_scale=1.0,
+ rois_num=rois_num)
+
+ exe = fluid.Executor(place)
+ out, = exe.run(feed={'input':input_data ,'roi':roi_data, 'rois_num': rois_num_data}, fetch_list=[pool_out.name])
+ print(out) #array([[[[11.]]], [[[16.]]]], dtype=float32)
+ print(np.array(out).shape) # (2, 1, 1, 1)
+ """
+ if _non_static_mode():
+ assert (
+ rois_num is not None
+ ), "rois_num should not be None in dygraph mode."
+ pool_out, argmaxes = _legacy_C_ops.roi_pool(
+ input,
+ rois,
+ rois_num,
+ "pooled_height",
+ pooled_height,
+ "pooled_width",
+ pooled_width,
+ "spatial_scale",
+ spatial_scale,
+ )
+ return pool_out, argmaxes
+
+ check_variable_and_dtype(input, 'input', ['float32'], 'roi_pool')
+ check_variable_and_dtype(rois, 'rois', ['float32'], 'roi_pool')
+ helper = LayerHelper('roi_pool', **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+ argmaxes = helper.create_variable_for_type_inference(dtype='int32')
+
+ inputs = {
+ "X": input,
+ "ROIs": rois,
+ }
+ if rois_num is not None:
+ inputs['RoisNum'] = rois_num
+ helper.append_op(
+ type="roi_pool",
+ inputs=inputs,
+ outputs={"Out": pool_out, "Argmax": argmaxes},
+ attrs={
+ "pooled_height": pooled_height,
+ "pooled_width": pooled_width,
+ "spatial_scale": spatial_scale,
+ },
+ )
+ return pool_out
+
+
+@templatedoc()
+def roi_align(
+ input,
+ rois,
+ pooled_height=1,
+ pooled_width=1,
+ spatial_scale=1.0,
+ sampling_ratio=-1,
+ rois_num=None,
+ name=None,
+):
+ """
+
+ ${comment}
+
+ Args:
+ input (Variable): ${x_comment}
+ rois (Variable): ROIs (Regions of Interest) to pool over.It should be
+ a 2-D LoDTensor of shape (num_rois, 4), the lod level is 1. The
+ data type is float32 or float64. Given as [[x1, y1, x2, y2], ...],
+ (x1, y1) is the top left coordinates, and (x2, y2) is the bottom
+ right coordinates.
+ pooled_height (int32, optional): ${pooled_height_comment} Default: 1
+ pooled_width (int32, optional): ${pooled_width_comment} Default: 1
+ spatial_scale (float32, optional): ${spatial_scale_comment} Default: 1.0
+ sampling_ratio(int32, optional): ${sampling_ratio_comment} Default: -1
+ rois_num (Tensor): The number of RoIs in each image. Default: None
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable:
+
+ Output: ${out_comment}.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ x = fluid.data(
+ name='data', shape=[None, 256, 32, 32], dtype='float32')
+ rois = fluid.data(
+ name='rois', shape=[None, 4], dtype='float32')
+ rois_num = fluid.data(name='rois_num', shape=[None], dtype='int32')
+ align_out = fluid.layers.roi_align(input=x,
+ rois=rois,
+ pooled_height=7,
+ pooled_width=7,
+ spatial_scale=0.5,
+ sampling_ratio=-1,
+ rois_num=rois_num)
+ """
+ if in_dygraph_mode():
+ assert (
+ rois_num is not None
+ ), "rois_num should not be None in dygraph mode."
+ return _C_ops.roi_align(
+ input,
+ rois,
+ rois_num,
+ pooled_height,
+ pooled_width,
+ spatial_scale,
+ sampling_ratio,
+ False,
+ )
+ if _in_legacy_dygraph():
+ assert (
+ rois_num is not None
+ ), "rois_num should not be None in dygraph mode."
+ align_out = _legacy_C_ops.roi_align(
+ input,
+ rois,
+ rois_num,
+ "pooled_height",
+ pooled_height,
+ "pooled_width",
+ pooled_width,
+ "spatial_scale",
+ spatial_scale,
+ "sampling_ratio",
+ sampling_ratio,
+ )
+ return align_out
+
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'roi_align'
+ )
+ check_variable_and_dtype(rois, 'rois', ['float32', 'float64'], 'roi_align')
+ helper = LayerHelper('roi_align', **locals())
+ dtype = helper.input_dtype()
+ align_out = helper.create_variable_for_type_inference(dtype)
+ inputs = {
+ "X": input,
+ "ROIs": rois,
+ }
+ if rois_num is not None:
+ inputs['RoisNum'] = rois_num
+ helper.append_op(
+ type="roi_align",
+ inputs=inputs,
+ outputs={"Out": align_out},
+ attrs={
+ "pooled_height": pooled_height,
+ "pooled_width": pooled_width,
+ "spatial_scale": spatial_scale,
+ "sampling_ratio": sampling_ratio,
+ },
+ )
+ return align_out
+
+
+def dice_loss(input, label, epsilon=0.00001, name=None):
+ r"""
+
+ Dice loss for comparing the similarity between the input predictions and the label.
+ This implementation is for binary classification, where the input is sigmoid
+ predictions of each pixel, usually used for segmentation task. The dice loss can
+ be defined as the following equation:
+
+ .. math::
+
+ dice\_loss &= 1 - \frac{2 * intersection\_area}{total\_area} \\
+ &= \frac{(total\_area - intersection\_area) - intersection\_area}{total\_area} \\
+ &= \frac{(union\_area - intersection\_area)}{total\_area}
+
+
+ Parameters:
+ input (Tensor): Tensor, rank>=2, shape is :math:`[N_1, N_2, ..., N_k, D]`, where :math:`N_1` is
+ the batch_size, :math:`D` is the number of categories. It is usually the output
+ predictions of sigmoid activation. The data type can be float32 or float64.
+ label (Tensor): Tensor, the groud truth with the same rank as input, shape is :math:`[N_1, N_2, ..., N_k, 1]`.
+ where :math:`N_1` is the batch_size. The data type can be int32 or int64.
+ epsilon (float): The epsilon will be added to the numerator and denominator.
+ If both input and label are empty, it makes sure dice is 1.
+ Default: 0.00001
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Tensor, which shape is [1], data type is the same as `input` .
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.randn((3,224,224,2))
+ label = paddle.randint(high=2, shape=(3,224,224,1))
+ predictions = F.softmax(x)
+ loss = F.dice_loss(input=predictions, label=label)
+ """
+ return paddle.nn.functional.dice_loss(
+ input, label, epsilon=epsilon, name=name
+ )
+
+
+def image_resize(
+ input,
+ out_shape=None,
+ scale=None,
+ name=None,
+ resample='BILINEAR',
+ actual_shape=None,
+ align_corners=True,
+ align_mode=1,
+ data_format='NCHW',
+):
+ """
+
+ This op resizes a batch of images.
+
+ The input must be a 3-D Tensor of the shape (num_batches, channels, in_w)
+ or a 4-D Tensor of the shape (num_batches, channels, in_h, in_w)
+ or (num_batches, in_h, in_w, channels), or a 5-D Tensor of the shape
+ (num_batches, channels, in_d, in_h, in_w) or (num_batches, in_d, in_h, in_w, channels),
+ and the resizing only applies on the three dimensions(depth, height and width).
+
+ **Warning:** the parameter :attr:`actual_shape` will be deprecated in the
+ future and only use :attr:`out_shape` instead.
+
+ Supporting resample methods:
+ 'LINEAR' : Linear interpolation
+
+ 'BILINEAR' : Bilinear interpolation
+
+ 'TRILINEAR' : Trilinear interpolation
+
+ 'NEAREST' : Nearest neighbor interpolation
+
+ 'BICUBIC' : Bicubic interpolation
+
+ Linear interpolation is the method of using a line connecting two known quantities
+ to determine the value of an unknown quantity between the two known quantities.
+
+ Nearest neighbor interpolation is to perform nearest neighbor interpolation
+ in both the 3rd dimension(in height direction) and the 4th dimension(in width
+ direction) on input tensor.
+
+ Bilinear interpolation is an extension of linear interpolation for
+ interpolating functions of two variables (e.g. H-direction and
+ W-direction in this op) on a rectilinear 2D grid. The key idea is
+ to perform linear interpolation first in one direction, and then
+ again in the other direction.
+
+ Trilinear interpolation is an extension of linear interpolation for
+ interpolating functions of three variables (e.g. D-direction,
+ H-direction and W-direction in this op) on a rectilinear 3D grid.
+ The linear interpolation is performed on three directions.
+
+ Bicubic interpolation is an extension of cubic interpolation for interpolating
+ data points on a two-dimensional regular grid. The interpolated surface is
+ smoother than corresponding surfaces obtained by bilinear interpolation or
+ nearest-neighbor interpolation.
+
+ Align_corners and align_mode are optional parameters,the calculation method
+ of interpolation can be selected by them.
+
+ Example:
+
+ .. code-block:: text
+
+ For scale:
+
+ if align_corners = True && out_size > 1 :
+
+ scale_factor = (in_size-1.0)/(out_size-1.0)
+
+ else:
+
+ scale_factor = float(in_size/out_size)
+
+
+ Nearest neighbor interpolation:
+
+ if:
+ align_corners = False
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = floor (H_{in} * scale_{factor})
+ W_out = floor (W_{in} * scale_{factor})
+
+ else:
+ align_corners = True
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = round(H_{in} * scale_{factor})
+ W_out = round(W_{in} * scale_{factor})
+
+ linear interpolation:
+
+ if:
+ align_corners = False , align_mode = 0
+
+ input : (N,C,W_in)
+ output: (N,C,W_out) where:
+
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+ else:
+
+ input : (N,C,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ W_out = W_{in} * scale_{factor}
+
+ Bilinear interpolation:
+
+ if:
+ align_corners = False , align_mode = 0
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+ else:
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = H_{in} * scale_{factor}
+ W_out = W_{in} * scale_{factor}
+
+ Trilinear interpolation:
+
+ if:
+ align_corners = False , align_mode = 0
+
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+
+ D_out = (D_{in}+0.5) * scale_{factor} - 0.5
+ H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+
+ else:
+
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+
+ D_out = D_{in} * scale_{factor}
+
+ Trilinear interpolation:
+ if:
+ align_corners = False , align_mode = 0
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+ D_out = (D_{in}+0.5) * scale_{factor} - 0.5
+ H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+ else:
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+ D_out = D_{in} * scale_{factor}
+ H_out = H_{in} * scale_{factor}
+ W_out = W_{in} * scale_{factor}
+
+
+ For details of linear interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Linear_interpolation.
+
+ For details of nearest neighbor interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation.
+
+ For details of bilinear interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Bilinear_interpolation.
+
+ For details of trilinear interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Trilinear_interpolation.
+
+ For details of bicubic interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Bicubic_interpolation
+
+ Parameters:
+ input (Variable): 3-D, 4-D or 5-D Tensor, its data type is float32, float64, or uint8,
+ its data format is specified by :attr:`data_format`.
+ out_shape (list|tuple|Variable|None): Output shape of image resize
+ layer, the shape is (out_w, ) when input is a 3-D Tensor, the shape is (out_h, out_w)
+ when input is a 4-D Tensor and is (out_d, out_h, out_w) when input is a 5-D Tensor.
+ Default: None. If a list, each element can be an integer or a Tensor Variable of shape: [1].
+ If a Tensor Variable, its dimensions size should be a 1.
+ scale(float|Variable|None): The multiplier for the input height or width. At
+ least one of :attr:`out_shape` or :attr:`scale` must be set.
+ And :attr:`out_shape` has a higher priority than :attr:`scale`.
+ Default: None.
+ name(str|None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+ resample(str): The resample method. It supports 'LINEAR', 'BICUBIC', 'BILINEAR', 'TRILINEAR'
+ and 'NEAREST' currently. Default: 'BILINEAR'
+ actual_shape(Variable): An optional input to specify output shape
+ dynamically. If provided, image resize
+ according to this given shape rather than
+ :attr:`out_shape` and :attr:`scale` specifying
+ shape. That is to say actual_shape has the
+ highest priority. It is recommended to use
+ :attr:`out_shape` if you want to specify output
+ shape dynamically, because :attr:`actual_shape`
+ will be deprecated. When using actual_shape to
+ specify output shape, one of :attr:`out_shape`
+ and :attr:`scale` should also be set, otherwise
+ errors would be occurred in graph constructing stage.
+ Default: None
+ align_corners(bool) : An optional bool, If True, the centers of the 4 corner pixels of the
+ input and output tensors are aligned, preserving the values at the
+ corner pixels.
+ Default: True
+ align_mode(int) : An optional for linear/bilinear/trilinear interpolation. Refer to the fomula in the
+ the example code above, it can be \'0\' for src_idx = scale*(dst_indx+0.5)-0.5 ,
+ can be \'1\' for src_idx = scale*dst_index.
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from:`NCW`, `NWC`, `"NCHW"`, `"NHWC"`, `"NCDHW"`,
+ `"NDHWC"`. The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`. When it is `"NCHW"`, the data is stored
+ in the order of: `[batch_size, input_channels, input_depth, input_height, input_width]`.
+
+ Returns:
+ A 3-D Tensor of the shape (num_batches, channels, out_w) or (num_batches, out_w, channels),
+ A 4-D Tensor of the shape (num_batches, channels, out_h, out_w) or (num_batches, out_h, out_w, channels),
+ or 5-D Tensor of the shape (num_batches, channels, out_d, out_h, out_w) or (num_batches, out_d, out_h, out_w, channels).
+
+ Raises:
+ TypeError: out_shape should be a list or tuple or Variable.
+ TypeError: actual_shape should either be Variable or None.
+ ValueError: The 'resample' of image_resize can only be 'LINEAR', 'BILINEAR',
+ 'TRILINEAR', 'BICUBIC' or 'NEAREST' currently.
+ ValueError: 'LINEAR' only support 3-D tensor.
+ ValueError: 'BICUBIC', 'BILINEAR' and 'NEAREST' only support 4-D tensor.
+ ValueError: 'TRILINEAR' only support 5-D tensor.
+ ValueError: One of out_shape and scale must not be None.
+ ValueError: out_shape length should be 1 for input 3-D tensor.
+ ValueError: out_shape length should be 2 for input 4-D tensor.
+ ValueError: out_shape length should be 3 for input 5-D tensor.
+ ValueError: scale should be greater than zero.
+ TypeError: align_corners should be a bool value
+ ValueError: align_mode can only be '0' or '1'
+ ValueError: data_format can only be 'NCW', 'NWC', 'NCHW', 'NHWC', 'NCDHW' or 'NDHWC'.
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+ paddle.enable_static()
+ input = fluid.data(name="input", shape=[None,3,6,10])
+
+ #1
+ output = fluid.layers.image_resize(input=input,out_shape=[12,12])
+
+ #2
+ #x = np.array([2]).astype("int32")
+ #dim1 = fluid.data(name="dim1", shape=[1], dtype="int32")
+ #fluid.layers.assign(input=x, output=dim1)
+ #output = fluid.layers.image_resize(input=input,out_shape=[12,dim1])
+
+ #3
+ #x = np.array([3,12]).astype("int32")
+ #shape_tensor = fluid.data(name="shape_tensor", shape=[2], dtype="int32")
+ #fluid.layers.assign(input=x, output=shape_tensor)
+ #output = fluid.layers.image_resize(input=input,out_shape=shape_tensor)
+
+ #4
+ #x = np.array([0.5]).astype("float32")
+ #scale_tensor = fluid.data(name="scale", shape=[1], dtype="float32")
+ #fluid.layers.assign(x,scale_tensor)
+ #output = fluid.layers.image_resize(input=input,scale=scale_tensor)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(2,3,6,10).astype("float32")
+
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ print(output_data[0].shape)
+
+ #1
+ # (2, 3, 12, 12)
+ #2
+ # (2, 3, 12, 2)
+ #3
+ # (2, 3, 3, 12)
+ #4
+ # (2, 3, 3, 5)
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ output = fluid.layers.image_resize(input=input, out_shape=[12,12])
+ print(output.shape)
+
+ # [2L, 3L, 12L, 12L]
+
+ """
+ resample_methods = {
+ 'LINEAR': 'linear',
+ 'BILINEAR': 'bilinear',
+ 'TRILINEAR': 'trilinear',
+ 'NEAREST': 'nearest',
+ 'LINEAR': 'linear',
+ }
+ resample = resample.upper()
+ if resample not in resample_methods:
+ raise ValueError(
+ "The 'resample' of image_resize can only be 'LINEAR', 'BILINEAR', 'TRILINEAR' "
+ "or 'NEAREST' currently."
+ )
+ resample_type = resample_methods[resample]
+
+ if resample == 'LINEAR' and len(input.shape) != 3:
+ raise ValueError("'LINER only support 3-D tensor.")
+ elif resample in ['BILINEAR', 'NEAREST'] and len(input.shape) != 4:
+ raise ValueError("'BILINEAR' and 'NEAREST' only support 4-D tensor.")
+ elif resample == 'TRILINEAR' and len(input.shape) != 5:
+ raise ValueError("'TRILINEAR'only support 5-D tensor.")
+
+ if not isinstance(align_corners, bool):
+ raise TypeError("Attr align_corners should be a bool value")
+ if align_mode != 0 and align_mode != 1:
+ raise ValueError("align_mode can only be 0 or 1")
+
+ if out_shape is None and scale is None:
+ raise ValueError("One of out_shape and scale must not be None.")
+ helper = LayerHelper('{}_interp'.format(resample_type), **locals())
+ dtype = helper.input_dtype()
+
+ if len(input.shape) == 3 and data_format not in ['NCW', 'NWC']:
+ raise ValueError(
+ "Got wrong value for param `data_format`: "
+ + data_format
+ + " received but only `NCW` or `NWC` supported for 3-D input."
+ )
+ elif len(input.shape) == 4 and data_format not in ['NCHW', 'NHWC']:
+ raise ValueError(
+ "Got wrong value for param `data_format`: "
+ + data_format
+ + " received but only `NCHW` or `NHWC` supported for 4-D input."
+ )
+ elif len(input.shape) == 5 and data_format not in ['NCDHW', 'NDHWC']:
+ raise ValueError(
+ "Got wrong value for param `data_format`: "
+ + data_format
+ + " received but only `NCDHW` or `NDHWC` supported for 5-D input."
+ )
+
+ def _is_list_or_turple_(data):
+ return isinstance(data, list) or isinstance(data, tuple)
+
+ if data_format == 'NCHW' or data_format == 'NCDHW' or data_format == 'NCW':
+ data_layout = 'NCHW'
+ if data_format == 'NHWC' or data_format == 'NDHWC' or data_format == 'NWC':
+ data_layout = 'NHWC'
+
+ inputs = {"X": input}
+ attrs = {
+ "out_d": -1,
+ "out_h": -1,
+ "out_w": -1,
+ "interp_method": resample_type,
+ "align_corners": align_corners,
+ "align_mode": align_mode,
+ "data_layout": data_layout,
+ }
+
+ if out_shape is not None:
+ if isinstance(out_shape, Variable) and not _non_static_mode():
+ out_shape.stop_gradient = True
+ inputs['OutSize'] = out_shape
+ else:
+ if _non_static_mode():
+ if isinstance(out_shape, Variable):
+ out_shape = list(out_shape.numpy())
+ else:
+ out_shape = list(out_shape)
+ for i, dim in enumerate(out_shape):
+ if isinstance(dim, Variable):
+ out_shape[i] = dim.numpy()[0]
+ if not (_is_list_or_turple_(out_shape)):
+ raise TypeError(
+ "out_shape should be a list or tuple or Variable."
+ )
+ # Validate the shape
+ contain_var = False
+ for dim_idx, dim_size in enumerate(out_shape):
+ if isinstance(dim_size, Variable):
+ contain_var = True
+ continue
+ assert (
+ dim_size > 0
+ ), "Each dimension size given in out_shape must be greater than 0."
+
+ if contain_var:
+ new_size_tensor = []
+ size_list = []
+ for dim in out_shape:
+ if isinstance(dim, Variable):
+ dim.stop_gradient = True
+ new_size_tensor.append(dim)
+ size_list.append(-1)
+ else:
+ assert isinstance(dim, int)
+ temp_out = helper.create_variable_for_type_inference(
+ 'int32'
+ )
+ fill_constant(
+ [1], 'int32', dim, force_cpu=True, out=temp_out
+ )
+ new_size_tensor.append(temp_out)
+ size_list.append(dim)
+ inputs['SizeTensor'] = new_size_tensor
+
+ if len(input.shape) == 3:
+ if len(out_shape) != 1:
+ raise ValueError(
+ "out_shape length should be 1 for " "input 3-D tensor."
+ )
+ if contain_var:
+ attrs['out_w'] = size_list[0]
+ else:
+ out_shape = list(map(int, out_shape))
+ attrs['out_w'] = out_shape[0]
+ elif len(input.shape) == 4:
+ if len(out_shape) != 2:
+ raise ValueError(
+ "out_shape length should be 2 for " "input 4-D tensor."
+ )
+ if contain_var:
+ attrs['out_h'] = size_list[0]
+ attrs['out_w'] = size_list[1]
+ else:
+ out_shape = list(map(int, out_shape))
+ attrs['out_h'] = out_shape[0]
+ attrs['out_w'] = out_shape[1]
+ if len(input.shape) == 5:
+ if len(out_shape) != 3:
+ raise ValueError(
+ "out_shape length should be 3 for " "input 5-D tensor."
+ )
+ if contain_var:
+ attrs['out_d'] = size_list[0]
+ attrs['out_h'] = size_list[1]
+ attrs['out_w'] = size_list[2]
+ else:
+ out_shape = list(map(int, out_shape))
+ attrs['out_d'] = out_shape[0]
+ attrs['out_h'] = out_shape[1]
+ attrs['out_w'] = out_shape[2]
+
+ else:
+ if _non_static_mode() and isinstance(scale, Variable):
+ scale = scale.numpy()
+ elif isinstance(scale, Variable):
+ scale.stop_gradient = True
+ inputs["Scale"] = scale
+ elif isinstance(scale, float) or isinstance(scale, int):
+ if scale <= 0:
+ raise ValueError("Attr(scale) should be greater than zero.")
+ attrs['scale'] = float(scale)
+ else:
+ raise TypeError(
+ "Attr(scale)'s type should be float, int or Variable."
+ )
+
+ if isinstance(actual_shape, Variable):
+ warnings.warn(
+ "actual_shape will be deprecated, it is recommended to use "
+ "out_shape instead of actual_shape to specify output shape dynamically."
+ )
+ actual_shape.stop_gradient = True
+ inputs["OutSize"] = actual_shape
+ elif actual_shape is not None:
+ raise TypeError("actual_shape should either be Variable or None.")
+
+ if _non_static_mode():
+ attr_list = []
+ for k, v in attrs.items():
+ attr_list.append(k)
+ attr_list.append(v)
+ dy_attr = tuple(attr_list)
+
+ if resample_type == "linear":
+ out = _legacy_C_ops.linear_interp(input, actual_shape, *dy_attr)
+ elif resample_type == "bilinear":
+ out = _legacy_C_ops.bilinear_interp(input, actual_shape, *dy_attr)
+ elif resample_type == "trilinear":
+ out = _legacy_C_ops.trilinear_interp(input, actual_shape, *dy_attr)
+ elif resample_type == "nearest":
+ out = _legacy_C_ops.nearest_interp(input, actual_shape, *dy_attr)
+ elif resample_type == "bicubic":
+ out = _legacy_C_ops.bicubic_interp(input, actual_shape, *dy_attr)
+ return out
+
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='{}_interp'.format(resample_type),
+ inputs=inputs,
+ outputs={"Out": out},
+ attrs=attrs,
+ )
+ return out
+
+
+@templatedoc(op_type="linear_interp")
+def resize_linear(
+ input,
+ out_shape=None,
+ scale=None,
+ name=None,
+ actual_shape=None,
+ align_corners=True,
+ align_mode=1,
+ data_format='NCW',
+):
+ """
+ This op resizes the input by performing linear interpolation based on given
+ output shape which specified by actual_shape, out_shape and scale
+ in priority order.
+
+ **Warning:** the parameter :attr:`actual_shape` will be deprecated in
+ the future and only use :attr:`out_shape` instead.
+
+ Align_corners and align_mode are optional parameters,the calculation
+ method of interpolation can be selected by them.
+
+ Example:
+
+ .. code-block:: text
+
+ For scale:
+
+ if align_corners = True && out_size > 1 :
+
+ scale_factor = (in_size-1.0)/(out_size-1.0)
+
+ else:
+
+ scale_factor = float(in_size/out_size)
+
+ Linear interpolation:
+
+ if:
+ align_corners = False , align_mode = 0
+
+ input : (N,C,W_in)
+ output: (N,C,W_out) where:
+
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+ else:
+
+ input : (N,C,W_in)
+ output: (N,C,W_out) where:
+ W_out = W_{in} * scale_{factor}
+
+ Parameters:
+ input(Variable): 3-D Tensor(NCW), its data type is float32, float64, or uint8,
+ its data format is specified by :attr:`data_format`.
+ out_shape(list|tuple|Variable|None): Output shape of resize linear
+ layer, the shape is (out_w,). Default: None. If a list, each
+ element can be an integer or a Tensor Variable with shape: [1]. If a
+ Tensor Variable, its dimension size should be 1.
+ scale(float|Variable|None): The multiplier for the input height or width. At
+ least one of :attr:`out_shape` or :attr:`scale` must be set.
+ And :attr:`out_shape` has a higher priority than :attr:`scale`.
+ Default: None.
+ actual_shape(Variable): An optional input to specify output shape
+ dynamically. If provided, image resize
+ according to this given shape rather than
+ :attr:`out_shape` and :attr:`scale` specifying
+ shape. That is to say actual_shape has the
+ highest priority. It is recommended to use
+ :attr:`out_shape` if you want to specify output
+ shape dynamically, because :attr:`actual_shape`
+ will be deprecated. When using actual_shape to
+ specify output shape, one of :attr:`out_shape`
+ and :attr:`scale` should also be set, otherwise
+ errors would be occurred in graph constructing stage.
+ Default: None
+ align_corners(bool): ${align_corners_comment}
+ align_mode(bool): ${align_mode_comment}
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCW"`, `"NWC"`.
+ The default is `"NCW"`. When it is `"NCW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_width]`.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: 3-D tensor(NCW or NWC).
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle.fluid as fluid
+ import numpy as np
+ input = fluid.data(name="input", shape=[None,3,100])
+
+ output = fluid.layers.resize_linear(input=input,out_shape=[50,])
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(1,3,100).astype("float32")
+
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ print(output_data[0].shape)
+
+ # (1, 3, 50)
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ output = fluid.layers.resize_linear(input=input, out_shape=[50,])
+ print(output.shape)
+
+ # [1L, 3L, 50L]
+
+ """
+
+ return image_resize(
+ input,
+ out_shape,
+ scale,
+ name,
+ 'LINEAR',
+ actual_shape,
+ align_corners,
+ align_mode,
+ data_format,
+ )
+
+
+@templatedoc(op_type="bilinear_interp")
+def resize_bilinear(
+ input,
+ out_shape=None,
+ scale=None,
+ name=None,
+ actual_shape=None,
+ align_corners=True,
+ align_mode=1,
+ data_format='NCHW',
+):
+ """
+
+ This op resizes the input by performing bilinear interpolation based on given
+ output shape which specified by actual_shape, out_shape and scale
+ in priority order.
+
+ **Warning:** the parameter :attr:`actual_shape` will be deprecated in
+ the future and only use :attr:`out_shape` instead.
+
+ Bilinear interpolation is an extension of linear interpolation for
+ interpolating functions of two variables (e.g. H-direction and
+ W-direction in this op) on a rectilinear 2D grid. The key idea is
+ to perform linear interpolation first in one direction, and then
+ again in the other direction.
+
+ For details of bilinear interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Bilinear_interpolation
+
+ Align_corners and align_mode are optional parameters,the calculation
+ method of interpolation can be selected by them.
+
+ Example:
+
+ .. code-block:: text
+
+ For scale:
+
+ if align_corners = True && out_size > 1 :
+
+ scale_factor = (in_size-1.0)/(out_size-1.0)
+
+ else:
+
+ scale_factor = float(in_size/out_size)
+
+ Bilinear interpolation:
+
+ if:
+ align_corners = False , align_mode = 0
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+ else:
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+ H_out = H_{in} * scale_{factor}
+ W_out = W_{in} * scale_{factor}
+
+ Parameters:
+ input(Variable): 4-D Tensor(NCHW), its data type is float32, float64, or uint8,
+ its data format is specified by :attr:`data_format`.
+ out_shape(list|tuple|Variable|None): Output shape of resize bilinear
+ layer, the shape is (out_h, out_w).Default: None. If a list, each
+ element can be an integer or a Tensor Variable with shape: [1]. If a
+ Tensor Variable, its dimension size should be 1.
+ scale(float|Variable|None): The multiplier for the input height or width. At
+ least one of :attr:`out_shape` or :attr:`scale` must be set.
+ And :attr:`out_shape` has a higher priority than :attr:`scale`.
+ Default: None.
+ actual_shape(Variable): An optional input to specify output shape
+ dynamically. If provided, image resize
+ according to this given shape rather than
+ :attr:`out_shape` and :attr:`scale` specifying
+ shape. That is to say actual_shape has the
+ highest priority. It is recommended to use
+ :attr:`out_shape` if you want to specify output
+ shape dynamically, because :attr:`actual_shape`
+ will be deprecated. When using actual_shape to
+ specify output shape, one of :attr:`out_shape`
+ and :attr:`scale` should also be set, otherwise
+ errors would be occurred in graph constructing stage.
+ Default: None
+ align_corners(bool): ${align_corners_comment}
+ align_mode(bool): ${align_mode_comment}
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: 4-D tensor(NCHW or NHWC).
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+ input = fluid.data(name="input", shape=[None,3,6,10])
+
+ #1
+ output = fluid.layers.resize_bilinear(input=input,out_shape=[12,12])
+
+ #2
+ #x = np.array([2]).astype("int32")
+ #dim1 = fluid.data(name="dim1", shape=[1], dtype="int32")
+ #fluid.layers.assign(input=x, output=dim1)
+ #output = fluid.layers.resize_bilinear(input=input,out_shape=[12,dim1])
+
+ #3
+ #x = np.array([3,12]).astype("int32")
+ #shape_tensor = fluid.data(name="shape_tensor", shape=[2], dtype="int32")
+ #fluid.layers.assign(input=x, output=shape_tensor)
+ #output = fluid.layers.resize_bilinear(input=input,out_shape=shape_tensor)
+
+ #4
+ #x = np.array([0.5]).astype("float32")
+ #scale_tensor = fluid.data(name="scale", shape=[1], dtype="float32")
+ #fluid.layers.assign(x,scale_tensor)
+ #output = fluid.layers.resize_bilinear(input=input,scale=scale_tensor)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(2,3,6,10).astype("float32")
+
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ print(output_data[0].shape)
+
+ #1
+ # (2, 3, 12, 12)
+ #2
+ # (2, 3, 12, 2)
+ #3
+ # (2, 3, 3, 12)
+ #4
+ # (2, 3, 3, 5)
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ output = fluid.layers.resize_bilinear(input=input, out_shape=[12,12])
+ print(output.shape)
+
+ # [2L, 3L, 12L, 12L]
+
+ """
+
+ return image_resize(
+ input,
+ out_shape,
+ scale,
+ name,
+ 'BILINEAR',
+ actual_shape,
+ align_corners,
+ align_mode,
+ data_format,
+ )
+
+
+@templatedoc(op_type="trilinear_interp")
+def resize_trilinear(
+ input,
+ out_shape=None,
+ scale=None,
+ name=None,
+ actual_shape=None,
+ align_corners=True,
+ align_mode=1,
+ data_format='NCDHW',
+):
+ """
+
+ This op resizes the input by performing trilinear interpolation based on given
+ output shape which specified by actual_shape, out_shape and scale
+ in priority order.
+
+ **Warning:** the parameter :attr:`actual_shape` will be deprecated
+ in the future and only use :attr:`out_shape` instead.
+
+ Trilinear interpolation is an extension of linear interpolation for
+ interpolating functions of three variables (e.g. D-direction,
+ H-direction and W-direction in this op) on a rectilinear 3D grid.
+ The linear interpolation is performed on three directions.
+
+ For details of trilinear interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Trilinear_interpolation
+
+ Align_corners and align_mode are optional parameters,the calculation
+ method of interpolation can be selected by them.
+
+ Example:
+
+ .. code-block:: text
+
+ For scale:
+
+ if align_corners = True && out_size > 1 :
+
+ scale_factor = (in_size-1.0)/(out_size-1.0)
+
+ else:
+
+ scale_factor = float(in_size/out_size)
+
+ Bilinear interpolation:
+
+ if:
+
+ align_corners = False , align_mode = 0
+
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+
+ D_out = (D_{in}+0.5) * scale_{factor} - 0.5
+ H_out = (H_{in}+0.5) * scale_{factor} - 0.5
+ W_out = (W_{in}+0.5) * scale_{factor} - 0.5
+
+ else:
+
+ input : (N,C,D_in,H_in,W_in)
+ output: (N,C,D_out,H_out,W_out) where:
+
+ D_out = D_{in} * scale_{factor}
+ H_out = H_{in} * scale_{factor}
+ W_out = W_{in} * scale_{factor}
+
+ Parameters:
+ input(${x_type}): 5-D Tensor, its data type is float32, float64, or uint8,
+ its data format is specified by :attr:`data_format`.
+ out_shape(list|tuple|Variable|None): The output shape of resized tensor, the shape is (out_d, out_h, out_w). Default: None. Every element should be an integer or a Tensor Variable with shape: [1] if it is a list. If it is a Tensor Variable, its dimension size should be 1.
+ scale(float|Variable|None): The multiplier for the input depth, height or width.
+ At least one of :attr:`out_shape` or :attr:`scale` must be set.
+ And :attr:`out_shape` has a higher priority than :attr:`scale`.
+ Default: None.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+ actual_shape(Variable): An optional input to specify output shape
+ dynamically. If provided, image resize
+ according to this given shape rather than
+ :attr:`out_shape` and :attr:`scale` specifying
+ shape. That is to say actual_shape has the
+ highest priority. It is recommended to use
+ :attr:`out_shape` if you want to specify output
+ shape dynamically, because :attr:`actual_shape`
+ will be deprecated. When using actual_shape to
+ specify output shape, one of :attr:`out_shape`
+ and :attr:`scale` should also be set, otherwise
+ errors would be occurred in graph constructing stage.
+ Default: None
+ align_corners(bool): ${align_corners_comment}
+ align_mode(bool): ${align_mode_comment}
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCDHW"`, `"NDHWC"`.
+ The default is `"NCDHW"`. When it is `"NCDHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_depth, input_height, input_width]`.
+
+ Returns:
+ Variable: A 5-D Tensor(NCDHW or NDHWC)
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle.fluid as fluid
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+ input = fluid.data(name="input", shape=[None,3,6,8,10])
+
+ #1
+ output = fluid.layers.resize_trilinear(input=input,out_shape=[12,12,12])
+
+ #2
+ #x = np.array([2]).astype("int32")
+ #dim1 = fluid.data(name="dim1", shape=[1], dtype="int32")
+ #fluid.layers.assign(input=x, output=dim1)
+ #output = fluid.layers.resize_trilinear(input=input,out_shape=[12,dim1,4])
+
+ #3
+ #x = np.array([3,12,12]).astype("int32")
+ #shape_tensor = fluid.data(name="shape_tensor", shape=[3], dtype="int32")
+ #fluid.layers.assign(input=x, output=shape_tensor)
+ #output = fluid.layers.resize_trilinear(input=input,out_shape=shape_tensor)
+
+ #4
+ #x = np.array([0.5]).astype("float32")
+ #scale_tensor = fluid.data(name="scale", shape=[1], dtype="float32")
+ #fluid.layers.assign(x,scale_tensor)
+ #output = fluid.layers.resize_trilinear(input=input,scale=scale_tensor)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(2,3,6,8,10).astype("float32")
+
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ print(output_data[0].shape)
+
+ #1
+ # (2, 3, 12, 12, 12)
+ #2
+ # (2, 3, 12, 2, 4)
+ #3
+ # (2, 3, 3, 12, 12)
+ #4
+ # (2, 3, 3, 4, 5)
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ output = fluid.layers.resize_trilinear(input=input, out_shape=[12,12,12])
+ print(output.shape)
+
+ # [2L, 3L, 12L, 12L, 12L]
+
+
+
+ """
+
+ return image_resize(
+ input,
+ out_shape,
+ scale,
+ name,
+ 'TRILINEAR',
+ actual_shape,
+ align_corners,
+ align_mode,
+ data_format,
+ )
+
+
+@templatedoc(op_type="nearest_interp")
+def resize_nearest(
+ input,
+ out_shape=None,
+ scale=None,
+ name=None,
+ actual_shape=None,
+ align_corners=True,
+ data_format='NCHW',
+):
+ """
+
+ This op resizes the input by performing nearest neighbor interpolation in both the
+ height direction and the width direction based on given output shape
+ which is specified by actual_shape, out_shape and scale in priority order.
+
+ **Warning:** the parameter :attr:`actual_shape` will be deprecated in the
+ future and only use :attr:`out_shape` instead.
+
+ Example:
+
+ .. code-block:: text
+
+ For scale:
+
+ if align_corners = True && out_size > 1 :
+ scale_factor = (in_size-1.0)/(out_size-1.0)
+
+ else:
+
+ scale_factor = float(in_size/out_size)
+
+ Nearest neighbor interpolation:
+
+ if:
+ align_corners = False
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = floor(H_{in} * scale_{factor})
+ W_out = floor(W_{in} * scale_{factor})
+
+ else:
+ align_corners = True
+
+ input : (N,C,H_in,W_in)
+ output: (N,C,H_out,W_out) where:
+
+ H_out = round(H_{in} * scale_{factor})
+ W_out = round(W_{in} * scale_{factor})
+
+
+ For details of nearest neighbor interpolation, please refer to Wikipedia:
+ https://en.wikipedia.org/wiki/Nearest-neighbor_interpolation
+
+ Parameters:
+ input(${x_type}): 4-D Tensor, its data type is float32, float64, or uint8,
+ its data format is specified by :attr:`data_format`.
+ out_shape(list|tuple|Variable|None): The output shape of resized tensor, the shape is (out_h, out_w). Default: None. Every element should be an integer or a tensor Variable with shape: [1] if it is a list. If it is a tensor Variable, its dimension size should be 1.
+ scale(float|Variable|None): The multiplier for the input height or width. At
+ least one of :attr:`out_shape` or :attr:`scale` must be set.
+ And :attr:`out_shape` has a higher priority than :attr:`scale`.
+ Default: None.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+ actual_shape(Variable): An optional input to specify output shape
+ dynamically. If provided, image resize
+ according to this given shape rather than
+ :attr:`out_shape` and :attr:`scale` specifying
+ shape. That is to say actual_shape has the
+ highest priority. It is recommended to use
+ :attr:`out_shape` if you want to specify output
+ shape dynamically, because :attr:`actual_shape`
+ will be deprecated. When using actual_shape to
+ specify output shape, one of :attr:`out_shape`
+ and :attr:`scale` should also be set, otherwise
+ errors would be occurred in graph constructing stage.
+ Default: None
+ align_corners(bool): ${align_corners_comment}
+ data_format (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`.
+
+ Returns:
+ Variable: 4-D tensor(NCHW or NHWC).
+
+ Examples:
+ .. code-block:: python
+
+ #declarative mode
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ input = fluid.data(name="input", shape=[None,3,6,10])
+
+ #1
+ output = fluid.layers.resize_nearest(input=input,out_shape=[12,12])
+
+ #2
+ #x = np.array([2]).astype("int32")
+ #dim1 = fluid.data(name="dim1", shape=[1], dtype="int32")
+ #fluid.layers.assign(input=x, output=dim1)
+ #output = fluid.layers.resize_nearest(input=input,out_shape=[12,dim1])
+
+ #3
+ #x = np.array([3,12]).astype("int32")
+ #shape_tensor = fluid.data(name="shape_tensor", shape=[2], dtype="int32")
+ #fluid.layers.assign(input=x, output=shape_tensor)
+ #output = fluid.layers.resize_nearest(input=input,out_shape=shape_tensor)
+
+ #4
+ #x = np.array([0.5]).astype("float32")
+ #scale_tensor = fluid.data(name="scale", shape=[1], dtype="float32")
+ #fluid.layers.assign(x,scale_tensor)
+ #output = fluid.layers.resize_nearest(input=input,scale=scale_tensor)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(2,3,6,10).astype("float32")
+
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ print(output_data[0].shape)
+
+ #1
+ # (2, 3, 12, 12)
+ #2
+ # (2, 3, 12, 2)
+ #3
+ # (2, 3, 3, 12)
+ #4
+ # (2, 3, 3, 5)
+
+ #imperative mode
+ import paddle.fluid.dygraph as dg
+
+ with dg.guard(place) as g:
+ input = dg.to_variable(input_data)
+ output = fluid.layers.resize_nearest(input=input, out_shape=[12,12])
+ print(output.shape)
+
+ # [2L, 3L, 12L, 12L]
+
+
+
+ """
+
+ return image_resize(
+ input,
+ out_shape,
+ scale,
+ name,
+ 'NEAREST',
+ actual_shape,
+ align_corners,
+ align_mode=1,
+ data_format=data_format,
+ )
+
+
+def image_resize_short(input, out_short_len, resample='BILINEAR'):
+ """
+ This op resizes a batch of images. The short edge of input images will be
+ resized to the given 'out_short_len'. The long edge of input images
+ will be resized proportionately to make images' length-width ratio
+ constant.
+
+ Parameters:
+ input (Variable): 4-D tensor(NCHW), The input tensor of image resize layer.
+ out_short_len(int): The length of output images' short edge.
+ resample (str): resample method, default: BILINEAR.
+
+ Returns:
+ Variable: 4-D tensor(NCHW).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ input = fluid.data(name="input", shape=[None,3,6,9], dtype="float32")
+ out = fluid.layers.image_resize_short(input, out_short_len=3)
+ """
+ in_shape = input.shape
+ if len(in_shape) != 4:
+ raise ValueError(
+ "The rank of input must be 4 (num_batches, channels, in_h, in_w)."
+ )
+ hw = in_shape[2:4]
+ short_idx = hw.index(min(hw))
+ long_idx = 1 - short_idx
+ out_shape = list(hw)
+ out_shape[short_idx] = out_short_len
+ out_shape[long_idx] = int(
+ float(out_shape[long_idx])
+ * (float(out_short_len) / float(hw[short_idx]))
+ + 0.5
+ )
+ return image_resize(input=input, out_shape=out_shape, resample=resample)
+
+
+@deprecated(since="2.0.0", update_to="paddle.gather")
+def gather(input, index, overwrite=True):
+ """
+
+ Output is obtained by gathering entries of the outer-most dimension
+ of X indexed by `index` and concatenate them together.
+
+ .. math::
+
+ Out = X[Index]
+
+
+ .. code-block:: text
+
+
+ Given:
+
+ X = [[1, 2],
+ [3, 4],
+ [5, 6]]
+
+ Index = [1, 2]
+
+ Then:
+
+ Out = [[3, 4],
+ [5, 6]]
+
+ Args:
+ input (Tensor): The source input tensor with rank>=1. Supported data type is
+ int32, int64, float32, float64 and uint8 (only for CPU),
+ float16 (only for GPU).
+ index (Tensor): The index input tensor with rank=1. Data type is int32 or int64.
+ overwrite (bool, optional): The mode that updating the grad when has same index.
+ If True, use the overwrite mode to update the grad of the same index,
+ if False, use the accumulate mode to update the grad of the same index.
+ Default value is True.
+
+ Returns:
+ output (Tensor): The output is a tensor with the same rank as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ x = fluid.data(name='x', shape=[-1, 5], dtype='float32')
+ index = fluid.data(name='index', shape=[-1, 1], dtype='int32')
+ output = fluid.layers.gather(x, index)
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.gather(input, index, None, 'overwrite', overwrite)
+
+ check_variable_and_dtype(
+ input,
+ 'x',
+ ['float16', 'float32', 'float64', 'int32', 'int64', 'uint8'],
+ 'gather',
+ )
+ check_variable_and_dtype(index, 'index', ['int32', 'int64'], 'gather')
+ helper = LayerHelper('gather', **locals())
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="gather",
+ inputs={"X": input, "Index": index},
+ outputs={"Out": out},
+ attrs={'overwrite': overwrite},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.gather_nd")
+def gather_nd(input, index, name=None):
+ """
+ **Gather Nd Layer**
+
+ This function is actually a high-dimensional extension of :code:`gather`
+ and supports for simultaneous indexing by multiple axes. :attr:`index` is a
+ K-dimensional integer tensor, which is regarded as a (K-1)-dimensional
+ tensor of :attr:`index` into :attr:`input`, where each element defines
+ a slice of params:
+
+ .. math::
+
+ output[(i_0, ..., i_{K-2})] = input[index[(i_0, ..., i_{K-2})]]
+
+ Obviously, :code:`index.shape[-1] <= input.rank` . And, the output tensor has
+ shape :code:`index.shape[:-1] + input.shape[index.shape[-1]:]` .
+
+ .. code-block:: text
+
+ Given:
+ input = [[[ 0, 1, 2, 3],
+ [ 4, 5, 6, 7],
+ [ 8, 9, 10, 11]],
+ [[12, 13, 14, 15],
+ [16, 17, 18, 19],
+ [20, 21, 22, 23]]]
+ input.shape = (2, 3, 4)
+
+ * Case 1:
+ index = [[1]]
+
+ gather_nd(input, index)
+ = [input[1, :, :]]
+ = [[12, 13, 14, 15],
+ [16, 17, 18, 19],
+ [20, 21, 22, 23]]
+
+ * Case 2:
+ index = [[0,2]]
+
+ gather_nd(input, index)
+ = [input[0, 2, :]]
+ = [8, 9, 10, 11]
+
+ * Case 3:
+ index = [[1, 2, 3]]
+
+ gather_nd(input, index)
+ = [input[1, 2, 3]]
+ = [23]
+
+ Args:
+ input (Tensor): The input Tensor which it's data type should be bool, float32, float64, int32, int64.
+ index (Tensor): The index input with rank > 1, index.shape[-1] <= input.rank.
+ Its dtype should be int32, int64.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ output (Tensor): A tensor with the shape index.shape[:-1] + input.shape[index.shape[-1]:]
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ x = fluid.data(name='x', shape=[3, 4, 5], dtype='float32')
+ index = fluid.data(name='index', shape=[2, 2], dtype='int32')
+ output = fluid.layers.gather_nd(x, index)
+
+ """
+ if in_dygraph_mode():
+ return _C_ops.gather_nd(input, index)
+ else:
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.gather_nd(input, index)
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['bool', 'float32', 'float64', 'int16', 'int32', 'int64'],
+ 'gather_np',
+ )
+ check_variable_and_dtype(index, 'index', ['int32', 'int64'], 'gather_np')
+ helper = LayerHelper('gather_nd', **locals())
+ dtype = helper.input_dtype()
+ output = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="gather_nd",
+ inputs={"X": input, "Index": index},
+ outputs={"Out": output},
+ )
+ return output
+
+
+@deprecated(since="2.0.0", update_to="paddle.scatter")
+def scatter(input, index, updates, name=None, overwrite=True):
+ """
+ :alias_main: paddle.scatter
+ :alias: paddle.scatter,paddle.tensor.scatter,paddle.tensor.manipulation.scatter
+ :old_api: paddle.fluid.layers.scatter
+
+ **Scatter Layer**
+
+ Output is obtained by updating the input on selected indices based on updates.
+
+ .. code-block:: python
+
+ import numpy as np
+
+ #input:
+ input = np.array([[1, 1], [2, 2], [3, 3]])
+ index = np.array([2, 1, 0, 1])
+ # shape of updates should be the same as input
+ # shape of updates with dim > 1 should be the same as input
+ updates = np.array([[1, 1], [2, 2], [3, 3], [4, 4]])
+ overwrite = False
+
+ # calculation:
+ if not overwrite:
+ for i in range(len(index)):
+ input[index[i]] = np.zeros((2))
+
+ for i in range(len(index)):
+ if (overwrite):
+ input[index[i]] = updates[i]
+ else:
+ input[index[i]] += updates[i]
+ # output:
+ out = np.array([[3, 3], [6, 6], [1, 1]])
+ out.shape # [3, 2]
+
+ Args:
+ input (Variable): The input N-D Tensor with rank>=1. Data type can be float32.
+ index (Variable): The index 1-D Tensor. Data type can be int32, int64. The length of index cannot exceed updates's length, and the value in index cannot exceed input's length.
+ updates (Variable): update input with updates parameter based on index. shape should be the same as input, and dim value with dim > 1 should be the same as input.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+ overwrite (bool): The mode that updating the output when there are same indices.
+ If True, use the overwrite mode to update the output of the same index,
+ if False, use the accumulate mode to update the output of the same index.
+ Default value is True.
+
+ Returns:
+ Variable(Tensor|LoDTensor): The output is a Tensor with the same shape as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ input = fluid.layers.data(name='data', shape=[3, 2], dtype='float32', append_batch_size=False)
+ index = fluid.layers.data(name='index', shape=[4], dtype='int64', append_batch_size=False)
+ updates = fluid.layers.data(name='update', shape=[4, 2], dtype='float32', append_batch_size=False)
+
+ output = fluid.layers.scatter(input, index, updates, overwrite=False)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ in_data = np.array([[1, 1], [2, 2], [3, 3]]).astype(np.float32)
+ index_data = np.array([2, 1, 0, 1]).astype(np.int64)
+ update_data = np.array([[1, 1], [2, 2], [3, 3], [4, 4]]).astype(np.float32)
+
+ res = exe.run(fluid.default_main_program(), feed={'data':in_data, "index":index_data, "update":update_data}, fetch_list=[output])
+ print(res)
+ # [array([[3., 3.],
+ # [6., 6.],
+ # [1., 1.]], dtype=float32)]
+ """
+ helper = LayerHelper('scatter', **locals())
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="scatter",
+ inputs={"X": input, "Ids": index, "Updates": updates},
+ attrs={'overwrite': overwrite},
+ outputs={"Out": out},
+ )
+ return out
+
+
+def scatter_nd_add(ref, index, updates, name=None):
+ r"""
+ **Scatter_nd_add Layer**
+
+ Output is obtained by applying sparse addition to a single value
+ or slice in a Variable.
+
+ :attr:`ref` is a Tensor with rank :math:`R`
+ and :attr:`index` is a Tensor with rank :math:`K` . Thus, :attr:`index`
+ has shape :math:`[i_0, i_1, ..., i_{K-2}, Q]` where :math:`Q \leq R` . :attr:`updates`
+ is a Tensor with rank :math:`K - 1 + R - Q` and its
+ shape is :math:`index.shape[:-1] + ref.shape[index.shape[-1]:]` .
+
+ According to the :math:`[i_0, i_1, ..., i_{K-2}]` of :attr:`index` ,
+ add the corresponding :attr:`updates` slice to the :attr:`ref` slice
+ which is obtained by the last one dimension of :attr:`index` .
+
+ .. code-block:: text
+
+ Given:
+
+ * Case 1:
+ ref = [0, 1, 2, 3, 4, 5]
+ index = [[1], [2], [3], [1]]
+ updates = [9, 10, 11, 12]
+
+ we get:
+
+ output = [0, 22, 12, 14, 4, 5]
+
+ * Case 2:
+ ref = [[65, 17], [-14, -25]]
+ index = [[], []]
+ updates = [[[-1, -2], [1, 2]],
+ [[3, 4], [-3, -4]]]
+ ref.shape = (2, 2)
+ index.shape = (2, 0)
+ updates.shape = (2, 2, 2)
+
+ we get:
+
+ output = [[67, 19], [-16, -27]]
+
+ Args:
+ ref (Variable): The ref input. Its dtype should be int32, int64, float32, float64.
+ index (Variable): The index input with rank > 1 and index.shape[-1] <= ref.rank.
+ Its dtype should be int32 or int64 as it is used as indexes.
+ updates (Variable): The updated value of scatter_nd_add op, and it must have the same dtype
+ as ref. It must have the shape index.shape[:-1] + ref.shape[index.shape[-1]:].
+ name (str|None): The output variable name. If set None, the layer will be named automatically.
+
+ Returns:
+ output (Variable): The output is a tensor with the same shape and dtype as ref.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ ref = fluid.data(name='ref', shape=[3, 5, 9, 10], dtype='float32')
+ index = fluid.data(name='index', shape=[3, 2], dtype='int32')
+ updates = fluid.data(name='update', shape=[3, 9, 10], dtype='float32')
+
+ output = fluid.layers.scatter_nd_add(ref, index, updates)
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.scatter_nd_add(ref, index, updates)
+ else:
+ if _in_legacy_dygraph():
+ op = getattr(_legacy_C_ops, 'scatter_nd_add')
+ return op(ref, index, updates)
+ else:
+ if ref.dtype != updates.dtype:
+ raise ValueError("ref and updates must have same data type.")
+
+ helper = LayerHelper('scatter_nd_add', **locals())
+ dtype = helper.input_dtype(input_param_name='ref')
+ output = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="scatter_nd_add",
+ inputs={"X": ref, "Index": index, "Updates": updates},
+ outputs={"Out": output},
+ )
+ return output
+
+
+def scatter_nd(index, updates, shape, name=None):
+ """
+ **Scatter_nd Layer**
+
+ Output is obtained by scattering the :attr:`updates` in a new tensor according
+ to :attr:`index` . This op is similar to :code:`scatter_nd_add`, except the
+ tensor of :attr:`shape` is zero-initialized. Correspondingly, :code:`scatter_nd(index, updates, shape)`
+ is equal to :code:`scatter_nd_add(paddle.zeros(shape, updates.dtype), index, updates)` .
+ If :attr:`index` has repeated elements, then the corresponding updates are accumulated.
+ Because of the numerical approximation issues, the different order of repeated elements
+ in :attr:`index` may cause different results. The specific calculation method can be
+ seen :code:`scatter_nd_add` . This op is the inverse of the :code:`gather_nd` op.
+
+ Args:
+ index (Tensor): The index input with ndim > 1 and index.shape[-1] <= len(shape).
+ Its dtype should be int32 or int64 as it is used as indexes.
+ updates (Tensor): The updated value of scatter_nd op. Its dtype should be float32, float64.
+ It must have the shape index.shape[:-1] + shape[index.shape[-1]:]
+ shape(tuple|list): Shape of output tensor.
+ name (str|None): The output Tensor name. If set None, the layer will be named automatically.
+
+ Returns:
+ output (Tensor): The output is a tensor with the same type as :attr:`updates` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ index_data = np.array([[1, 1],
+ [0, 1],
+ [1, 3]]).astype(np.int64)
+ index = paddle.to_tensor(index_data)
+ updates = paddle.rand(shape=[3, 9, 10], dtype='float32')
+ shape = [3, 5, 9, 10]
+
+ output = paddle.scatter_nd(index, updates, shape)
+ """
+ return scatter_nd_add(zeros(shape, updates.dtype), index, updates, name)
+
+
+@templatedoc()
+def random_crop(x, shape, seed=None):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ shape(${shape_type}): ${shape_comment}
+ seed(int|${seed_type}|None): ${seed_comment} By default, the seed will
+ get from `random.randint(-65536, 65535)`.
+
+ Returns:
+ ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ img = fluid.data("img", [None, 3, 256, 256])
+ # cropped_img is [-1, 3, 224, 224]
+ cropped_img = fluid.layers.random_crop(img, shape=[3, 224, 224])
+
+ # cropped_img2 shape: [-1, 2, 224, 224]
+ # cropped_img2 = fluid.layers.random_crop(img, shape=[2, 224, 224])
+
+ # cropped_img3 shape: [-1, 3, 128, 224]
+ # cropped_img3 = fluid.layers.random_crop(img, shape=[128, 224])
+
+ """
+ helper = LayerHelper("random_crop", **locals())
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32'], 'random_crop'
+ )
+ check_type(shape, 'shape', (list, Variable), 'random_crop')
+ dtype = x.dtype
+ out = helper.create_variable_for_type_inference(dtype)
+ if seed is None:
+ seed = np.random.randint(-65536, 65536)
+ op_attrs = {"shape": shape}
+ if isinstance(seed, int):
+ op_attrs["startup_seed"] = seed
+ seed = helper.create_variable(
+ name=unique_name.generate("random_crop_seed"),
+ dtype="int64",
+ persistable=True,
+ )
+ elif not isinstance(seed, Variable):
+ raise ValueError("'seed' must be a Variable or an int.")
+ helper.append_op(
+ type="random_crop",
+ inputs={"X": x, "Seed": seed},
+ outputs={"Out": out, "SeedOut": seed},
+ attrs=op_attrs,
+ )
+ return out
+
+
+def log(x, name=None):
+ r"""
+ Calculates the natural log of the given input tensor, element-wise.
+
+ .. math::
+
+ Out = \\ln(x)
+
+ Args:
+ x (Tensor): Input Tensor. Must be one of the following types: float32, float64.
+ name (str|None): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+
+ Returns:
+ Tensor: The natural log of the input Tensor computed element-wise.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ x = [[2,3,4], [7,8,9]]
+ x = paddle.to_tensor(x, dtype='float32')
+ res = paddle.log(x)
+ # [[0.693147, 1.09861, 1.38629], [1.94591, 2.07944, 2.19722]]
+ """
+ if in_dygraph_mode():
+ return _C_ops.log(x)
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.log(x)
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], "log")
+ inputs = {'X': [x]}
+ helper = LayerHelper('log', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type="log", inputs={"X": x}, outputs={"Out": out})
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.relu")
+def relu(x, name=None):
+ """
+ ${comment}
+
+ Args:
+ x(Variable): ${x_comment}
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable: ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ in1 = np.array([[-1,0],[1,2.6]])
+ with fluid.dygraph.guard():
+ x1 = fluid.dygraph.to_variable(in1)
+ out1 = fluid.layers.relu(x1)
+ print(out1.numpy())
+ # [[0. 0. ]
+ # [1. 2.6]]"""
+
+ if in_dygraph_mode():
+ return _C_ops.relu(x)
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.relu(x)
+
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'relu')
+
+ inputs = {'X': [x]}
+ helper = LayerHelper('relu', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="relu", inputs={"X": helper.input('x')}, outputs={"Out": out}
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.selu")
+def selu(x, scale=None, alpha=None, name=None):
+ r"""
+
+ Selu Operator.
+
+ The equation is:
+
+ .. math::
+ selu= \\lambda*
+ \\begin{cases}
+ x &\\quad \\text{ if } x>0 \n
+ \\alpha * e^x - \\alpha &\\quad \\text{ if } x<=0
+ \\end{cases}
+
+
+ The input `X` can carry the LoD (Level of Details) information,
+ or not. And the output shares the LoD information with input `X`.
+
+ Args:
+ x (Variable): The input N-D Tensor.
+ scale(float, optional): lambda in selu activation function,
+ the default value is 1.0507009873554804934193349852946.
+ For more information about this value, please refer
+ to: https://arxiv.org/abs/1706.02515.
+ alpha(float, optional): alpha in selu activation function,
+ the default value is 1.6732632423543772848170429916717.
+ For more information about this value, please refer
+ to: https://arxiv.org/abs/1706.02515.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+
+ Returns:
+ Variable(Tensor|LoDTensor): The output Tensor or LoDTensor with the same shape and LoD information as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+ paddle.enable_static()
+
+ inputs = fluid.layers.data(name="x", shape=[2, 2], dtype="float32")
+ output = fluid.layers.selu(inputs)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ img = np.array([[0, 1],[2, 3]]).astype(np.float32)
+
+ res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output])
+ print(res) # [array([[0. , 1.050701],[2.101402, 3.152103]], dtype=float32)]
+ """
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'selu')
+
+ helper = LayerHelper('selu', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ attrs = {}
+ if scale is not None:
+ attrs["scale"] = scale
+ if alpha is not None:
+ attrs["alpha"] = alpha
+
+ helper.append_op(
+ type="selu", inputs={"X": x}, outputs={"Out": out}, attrs=attrs
+ )
+ return out
+
+
+def mean_iou(input, label, num_classes):
+ r"""
+ Mean Intersection-Over-Union is a common evaluation metric for
+ semantic image segmentation, which first computes the IOU for each
+ semantic class and then computes the average over classes.
+ IOU is defined as follows:
+
+ .. math::
+
+ IOU = \\frac{true\_positive}{(true\_positive + false\_positive + false\_negative)}.
+
+ The predictions are accumulated in a confusion matrix and mean-IOU
+ is then calculated from it.
+
+
+ Parameters:
+ input (Tensor): A n-D Tensor of prediction results for semantic labels with type int32 or int64.
+ label (Tensor): A Tensor of ground truth labels with type int32 or int64.
+ Its shape should be the same as input.
+ num_classes (int32): The possible number of labels.
+
+ Returns:
+ Three Tensors.
+
+ - mean_iou(Tensor) : A 1-D Tensor representing the mean intersection-over-union with shape [1]. \
+ Data type is float32.
+ - out_wrong(Tensor) : A 1-D Tensor with shape [num_classes]. Data type is int32. \
+ The wrong numbers of each class.
+ - out_correct(Tensor): A 1-D Tensor with shape [num_classes]. Data type is int32. The correct numbers of each class.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ iou_shape = [64, 32, 32]
+ num_classes = 5
+ predict = paddle.randint(low=0, high=255, shape=iou_shape, dtype='int64')
+ label = paddle.randint(low=0, high=255, shape=iou_shape, dtype='int64')
+ mean_iou, out_wrong, out_correct = paddle.metric.mean_iou(predict, label, num_classes)
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.mean_iou(input, label, 'num_classes', num_classes)
+
+ helper = LayerHelper('mean_iou', **locals())
+ check_variable_and_dtype(
+ input, 'Predictions', ['int32', 'int64'], 'mean_iou'
+ )
+ check_variable_and_dtype(label, 'Labels', ['int32', 'int64'], 'mean_iou')
+ out_mean_iou = helper.create_variable_for_type_inference(dtype='float32')
+ out_wrong = helper.create_variable_for_type_inference(dtype='int32')
+ out_correct = helper.create_variable_for_type_inference(dtype='int32')
+ helper.append_op(
+ type="mean_iou",
+ inputs={"Predictions": input, "Labels": label},
+ outputs={
+ "OutMeanIou": out_mean_iou,
+ "OutWrong": out_wrong,
+ "OutCorrect": out_correct,
+ },
+ attrs={"num_classes": num_classes},
+ )
+ return out_mean_iou, out_wrong, out_correct
+
+
+def crop(x, shape=None, offsets=None, name=None):
+ """
+ Crop input into output, as specified by offsets and shape.
+
+ **Warning:** THIS OP IS DEPRECATED. It will be removed in the future version.
+ Instructions for updating: Use :ref:`api_fluid_layers_crop_tensor` instead.
+
+ .. code-block:: text
+
+ * Case 1:
+ Given
+ X = [[0, 1, 2, 0, 0]
+ [0, 3, 4, 0, 0]
+ [0, 0, 0, 0, 0]],
+ and
+ shape = [2, 2],
+ offsets = [0, 1],
+ output is:
+ Out = [[1, 2],
+ [3, 4]].
+ * Case 2:
+ Given
+ X = [[0, 1, 2, 5, 0]
+ [0, 3, 4, 6, 0]
+ [0, 0, 0, 0, 0]],
+ and shape is tensor
+ shape = [[0, 0, 0]
+ [0, 0, 0]]
+ and
+ offsets = [0, 1],
+
+ output is:
+ Out = [[1, 2, 5],
+ [3, 4, 6]].
+
+ Parameters:
+ x (Variable): Tensor, data type can be float32 or float64.
+ shape (Variable|list/tuple of integers, optional): The output shape is specified
+ by `shape`, which can be a Tensor or a list/tuple of integers.
+ If it is a Tensor, it's rank must be the same as `x` , only
+ it's shape will be used, and the value of it will be ignored. This way
+ is suitable for the case that the output shape may be changed each
+ iteration. If it is a list/tuple of integers, it's length must be the same
+ as the rank of `x`
+ offsets (Variable|list/tuple of integers|None, optional): Specifies the cropping
+ offsets at each dimension. It can be a Tensor or a list/tuple
+ of integers. If it is a Tensor, it's rank must be the same as `x`.
+ This way is suitable for the case that the offsets may be changed
+ each iteration. If it is a list/tuple of integers, it's length must be the
+ same as the rank of `x`. If None, the offsets are 0 at each dimension.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name` . Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor, The cropped Tensor, which has the same rank and data type with `x`.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3, 3, 5], dtype="float32")
+ y = fluid.data(name="y", shape=[2, 2, 3], dtype="float32")
+ crop = fluid.layers.crop(x, shape=y)
+
+ # or
+ z = fluid.data(name="z", shape=[3, 3, 5], dtype="float32")
+ crop = fluid.layers.crop(z, shape=[2, 2, 3])
+
+ """
+ check_variable_and_dtype(x, 'x', ['float32'], 'crop')
+ check_type(shape, 'shape', (list, tuple, Variable), 'crop')
+ helper = LayerHelper('crop', **locals())
+
+ if offsets is None:
+ offsets = [0] * len(x.shape)
+
+ out = helper.create_variable_for_type_inference(x.dtype)
+ ipts = {'X': x}
+ attrs = {}
+ if isinstance(shape, Variable):
+ ipts['Y'] = shape
+ else:
+ attrs['shape'] = shape
+ if isinstance(offsets, Variable):
+ ipts['Offsets'] = offsets
+ else:
+ attrs['offsets'] = offsets
+
+ helper.append_op(
+ type='crop',
+ inputs=ipts,
+ outputs={'Out': out},
+ attrs=None if len(attrs) == 0 else attrs,
+ )
+ return out
+
+
+def crop_tensor(x, shape=None, offsets=None, name=None):
+ """
+ Crop input into output, as specified by offsets and shape.
+
+ .. code-block:: text
+
+ * Case 1 (input is a 2-D Tensor):
+ Input:
+ X.shape = [3, 5]
+ X.data = [[0, 1, 2, 0, 0],
+ [0, 3, 4, 0, 0],
+ [0, 0, 0, 0, 0]]
+ Parameters:
+ shape = [2, 2]
+ offsets = [0, 1]
+ Output:
+ Out.shape = [2, 2]
+ Out.data = [[1, 2],
+ [3, 4]]
+ * Case 2 (input is a 3-D Tensor):
+ Input:
+ X.shape = [2, 3, 4]
+ X.data = [[[0, 1, 2, 3],
+ [0, 5, 6, 7],
+ [0, 0, 0, 0]],
+ [[0, 3, 4, 5],
+ [0, 6, 7, 8],
+ [0, 0, 0, 0]]]
+ Parameters:
+ shape = [2, 2, -1]
+ offsets = [0, 0, 1]
+ Output:
+ Out.shape = [2, 2, 3]
+ Out.data = [[[1, 2, 3],
+ [5, 6, 7]],
+ [[3, 4, 5],
+ [6, 7, 8]]]
+
+ Parameters:
+ x (Tensor): 1-D to 6-D Tensor, the data type is float32, float64, int32 or int64.
+ shape (list|tuple|Tensor): The output shape is specified
+ by `shape`. Its data type is int32. If a list/tuple, it's length must be
+ the same as the dimension size of `x`. If a Tensor, it should be a 1-D Tensor.
+ When it is a list, each element can be an integer or a Tensor of shape: [1].
+ If Variable contained, it is suitable for the case that the shape may
+ be changed each iteration.
+ offsets (list|tuple|Variable, optional): Specifies the cropping
+ offsets at each dimension. Its data type is int32. If a list/tuple, it's length
+ must be the same as the dimension size of `x`. If a Tensor, it should be a 1-D
+ Tensor. When it is a list, each element can be an integer or a Tensor of shape: [1].
+ If Variable contained, it is suitable for the case that the offsets may be changed
+ each iteration. Default: None, the offsets are 0 at each dimension.
+ name(str, optional): The default value is None. Normally there is no need for user to set
+ this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor: The cropped Tensor has same data type with `x`.
+
+ Examples:
+
+ .. code-block:: python
+ :name: code-example1
+
+ import paddle
+ x = paddle.to_tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+ # x.shape = [3, 3]
+ # x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+
+ # shape can be a 1-D Tensor or list or tuple.
+ shape = paddle.to_tensor([2, 2], dtype='int32')
+ # shape = [2, 2]
+ # shape = (2, 2)
+ out = paddle.crop(x, shape)
+ # out.shape = [2, 2]
+ # out = [[1,2], [4,5]]
+
+ # offsets can be a 1-D Tensor or list or tuple.
+ offsets = paddle.to_tensor([0, 1], dtype='int32')
+ # offsets = [1, 0]
+ # offsets = (1, 1)
+ out = paddle.crop(x, shape, offsets)
+ # out.shape = [2, 2]
+ # if offsets = [0, 0], out = [[1,2], [4,5]]
+ # if offsets = [0, 1], out = [[2,3], [5,6]]
+ # if offsets = [1, 0], out = [[4,5], [7,8]]
+ # if offsets = [1, 1], out = [[5,6], [8,9]]
+
+ """
+ helper = LayerHelper('crop_tensor', **locals())
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64'], 'crop_tensor'
+ )
+ check_type(shape, 'shape', (list, tuple, Variable), 'crop_tensor')
+ check_type(
+ offsets, 'offsets', (list, tuple, Variable, type(None)), 'crop_tensor'
+ )
+
+ if offsets is None:
+ offsets = [0] * len(x.shape)
+
+ out = helper.create_variable_for_type_inference(x.dtype)
+ ipts = {'X': x}
+ attrs = {}
+
+ def _attr_shape_check(shape_val):
+ if not isinstance(shape_val, int):
+ raise TypeError(
+ "Attr(shape)'s dtype of Op(crop_tensor) should be int32, but received: %s."
+ % type(shape_val)
+ )
+ if shape_val == 0:
+ raise ValueError(
+ "Attr(shape) of Op(crop_tensor) should not be zero, but received: %s."
+ % str(shape_val)
+ )
+ if shape_val < -1:
+ raise ValueError(
+ "When the element in Attr(shape) of Op(crop_tensor) is negative, only -1 is supported, but received: %s."
+ % str(shape_val)
+ )
+
+ def _attr_offsets_check(offset_val):
+ if not isinstance(offset_val, int):
+ raise TypeError(
+ "Attr(offsets)'s dtype of Op(crop_tensor) should be int32, but received: %s."
+ % type(offset_val)
+ )
+ if offset_val < 0:
+ raise ValueError(
+ "Attr(offsets) of Op(crop_tensor) should be greater or equal to zero, but received: %s."
+ % str(offset_val)
+ )
+
+ if isinstance(offsets, Variable):
+ offsets.stop_gradient = True
+ ipts['Offsets'] = offsets
+ attrs['offsets'] = [-1] * len(x.shape)
+ elif utils._contain_var(offsets):
+ new_offsets_tensor = []
+ offsets_attr = []
+ for dim in offsets:
+ if isinstance(dim, Variable):
+ dim.stop_gradient = True
+ new_offsets_tensor.append(dim)
+ offsets_attr.append(-1)
+ else:
+ _attr_offsets_check(dim)
+ temp_out = helper.create_variable_for_type_inference('int32')
+ fill_constant([1], 'int32', dim, force_cpu=True, out=temp_out)
+ new_offsets_tensor.append(temp_out)
+ offsets_attr.append(dim)
+ ipts['OffsetsTensor'] = new_offsets_tensor
+ attrs['offsets'] = offsets_attr
+ else:
+ for offset in offsets:
+ _attr_offsets_check(offset)
+ attrs['offsets'] = offsets
+
+ if isinstance(shape, Variable):
+ shape.stop_gradient = True
+ ipts['Shape'] = shape
+ elif utils._contain_var(shape):
+ new_shape_tensor = []
+ shape_attr = []
+ for dim_size in shape:
+ if isinstance(dim_size, Variable):
+ dim_size.stop_gradient = True
+ new_shape_tensor.append(dim_size)
+ shape_attr.append(0)
+ else:
+ _attr_shape_check(dim_size)
+ temp_out = helper.create_variable_for_type_inference('int32')
+ fill_constant(
+ [1], 'int32', dim_size, force_cpu=True, out=temp_out
+ )
+ new_shape_tensor.append(temp_out)
+ shape_attr.append(dim_size)
+ ipts['ShapeTensor'] = new_shape_tensor
+ attrs['shape'] = shape_attr
+ else:
+ for dim_size in shape:
+ _attr_shape_check(dim_size)
+ attrs['shape'] = shape
+
+ helper.append_op(
+ type='crop_tensor',
+ inputs=ipts,
+ outputs={'Out': out},
+ attrs=None if len(attrs) == 0 else attrs,
+ )
+ return out
+
+
+def affine_grid(theta, out_shape, name=None):
+ """
+ :alias_main: paddle.nn.functional.affine_grid
+ :alias: paddle.nn.functional.affine_grid,paddle.nn.functional.vision.affine_grid
+ :old_api: paddle.fluid.layers.affine_grid
+
+ It generates a grid of (x,y) coordinates using the parameters of
+ the affine transformation that correspond to a set of points where
+ the input feature map should be sampled to produce the transformed
+ output feature map.
+
+ Args:
+ theta (Variable) - A Tensor with shape [N, 2, 3]. It contains a batch of affine transform parameters.
+ The data type can be float32 or float64.
+ out_shape (Variable | list | tuple): The shape of target output with format [batch_size, channel, height, width].
+ ``out_shape`` can be a Tensor or a list or tuple. The data
+ type must be int32.
+ name(str|None): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable: A Tensor with shape [batch_size, H, W, 2] while 'H' and 'W' are the height and width of feature map in affine transformation. The data type is the same as `theta`.
+
+ Raises:
+ ValueError: If the type of arguments is not supported.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ place = fluid.CPUPlace()
+ theta = fluid.data(name="x", shape=[None, 2, 3], dtype="float32")
+ out_shape = fluid.data(name="y", shape=[4], dtype="int32")
+ grid_0 = fluid.layers.affine_grid(theta, out_shape)
+ grid_1 = fluid.layers.affine_grid(theta, [5, 3, 28, 28])
+ batch_size=2
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ output= exe.run(feed={"x": np.random.rand(batch_size,2,3).astype("float32"),
+ "y": np.array([5, 3, 28, 28]).astype("int32")},
+ fetch_list=[grid_0.name, grid_1.name])
+ print(output[0])
+ print(output[1])
+ """
+ helper = LayerHelper('affine_grid')
+
+ check_variable_and_dtype(
+ theta, 'theta', ['float32', 'float64'], 'affine_grid'
+ )
+
+ if not (
+ isinstance(out_shape, list)
+ or isinstance(out_shape, tuple)
+ or isinstance(out_shape, Variable)
+ ):
+ raise ValueError("The out_shape should be a list, tuple or Variable.")
+
+ if not isinstance(theta, Variable):
+ raise ValueError("The theta should be a Variable.")
+
+ out = helper.create_variable_for_type_inference(theta.dtype)
+ ipts = {'Theta': theta}
+ attrs = {}
+ if isinstance(out_shape, Variable):
+ ipts['OutputShape'] = out_shape
+ check_variable_and_dtype(
+ out_shape, 'out_shape', ['int32'], 'affine_grid'
+ )
+ else:
+ attrs['output_shape'] = out_shape
+ if core.is_compiled_with_rocm():
+ # ROCM platform do not have MIOPEN kernel for affine_grid
+ attrs['use_cudnn'] = False
+
+ helper.append_op(
+ type='affine_grid',
+ inputs=ipts,
+ outputs={'Output': out},
+ attrs=None if len(attrs) == 0 else attrs,
+ )
+ return out
+
+
+def pad2d(
+ input,
+ paddings=[0, 0, 0, 0],
+ mode='constant',
+ pad_value=0.0,
+ data_format="NCHW",
+ name=None,
+):
+ """
+
+ Pad 2-d images according to 'paddings' and 'mode'.
+ If mode is 'reflect', paddings[0] and paddings[1] must be no greater
+ than height-1. And the width dimension has the same condition.
+
+ Parameters:
+ input (Tensor): The input image with [N, C, H, W] format or [N, H, W, C] format, which is a 4-D Tensor with data type float32.
+ paddings (Tensor | List[int32]): The padding size. If padding is a List, it must
+ contain four integers, (padding_top, padding_bottom, padding_left, padding_right).
+ Otherwise, it is a 1-D Tensor with shape [4]. Data type is int32.
+ Default is [0, 0, 0, 0].
+ mode (str): Three modes: 'constant' (default), 'reflect', 'edge' .
+ When in 'constant' mode, this op uses a constant value to pad the input tensor.
+ When in 'reflect' mode, uses reflection of the input boundaries to pad the input tensor.
+ When in 'edge' mode, uses input boundaries to pad the input tensor.
+ Default is 'constant'
+ pad_value (float32): The value to fill the padded areas in 'constant' mode . Default is 0.0
+ data_format (str): An string from: "NHWC", "NCHW". Specify the data format of
+ the input data.
+ Default is "NCHW"
+ name (str, optional) : The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Tensor, a 4-D Tensor padded according to paddings and mode and data type is same as input.
+
+ Examples:
+ .. code-block:: text
+
+ Input = [[[[1., 2., 3.],
+ [4., 5., 6.]]]]
+
+ Case 0:
+ paddings = [0, 1, 2, 3],
+ mode = 'constant'
+ pad_value = 0
+ Out = [[[[0., 0., 1., 2., 3., 0., 0., 0.],
+ [0., 0., 4., 5., 6., 0., 0., 0.],
+ [0., 0., 0., 0., 0., 0., 0., 0.]]]]
+
+ Case 1:
+ paddings = [0, 1, 2, 1],
+ mode = 'reflect'
+ Out = [[[[3., 2., 1., 2., 3., 2.],
+ [6., 5., 4., 5., 6., 5.],
+ [3., 2., 1., 2., 3., 2.]]]]
+
+ Case 2:
+ paddings = [0, 1, 2, 1],
+ mode = 'edge'
+ Out = [[[[1., 1., 1., 2., 3., 3.],
+ [4., 4., 4., 5., 6., 6.],
+ [4., 4., 4., 5., 6., 6.]]]]
+
+ Code Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle
+ import paddle.nn.functional as F
+
+ # example 1
+ x_shape = (1, 1, 3, 4)
+ x = np.arange(np.prod(x_shape), dtype=np.float32).reshape(x_shape) + 1
+ tensor_x = paddle.to_tensor(x)
+ y = paddle.fluid.layers.pad2d(tensor_x, paddings=[1, 2, 2, 1], pad_value=1, mode='constant')
+ print(y.numpy())
+ # [[[[ 1. 1. 1. 1. 1. 1. 1.]
+ # [ 1. 1. 1. 2. 3. 4. 1.]
+ # [ 1. 1. 5. 6. 7. 8. 1.]
+ # [ 1. 1. 9. 10. 11. 12. 1.]
+ # [ 1. 1. 1. 1. 1. 1. 1.]
+ # [ 1. 1. 1. 1. 1. 1. 1.]]]]
+
+ # example 2
+ x_shape = (1, 1, 2, 3)
+ x = np.arange(np.prod(x_shape), dtype=np.float32).reshape(x_shape) + 1
+ tensor_x = paddle.to_tensor(x)
+ y = paddle.fluid.layers.pad2d(tensor_x, paddings=[1, 1, 1, 1], mode='reflect')
+ print(y.numpy())
+ # [[[[5. 4. 5. 6. 5.]
+ # [2. 1. 2. 3. 2.]
+ # [5. 4. 5. 6. 5.]
+ # [2. 1. 2. 3. 2.]]]]
+ """
+ if _non_static_mode():
+ _paddings = (
+ paddings.numpy().tolist()
+ if isinstance(paddings, Variable)
+ else paddings
+ )
+ return _legacy_C_ops.pad2d(
+ input,
+ 'mode',
+ mode,
+ 'pad_value',
+ pad_value,
+ 'data_format',
+ data_format,
+ 'paddings',
+ _paddings,
+ )
+
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ "pad2d",
+ )
+
+ attrs = {'mode': mode, 'pad_value': pad_value, 'data_format': data_format}
+ inputs = {'X': [input]}
+ if isinstance(paddings, Variable):
+ inputs['Paddings'] = [paddings]
+ attrs['paddings'] = []
+ else:
+ attrs['paddings'] = paddings
+
+ helper = LayerHelper('pad2d', **locals())
+
+ assert mode in [
+ 'reflect',
+ 'edge',
+ 'constant',
+ ], "mode should be one of constant, reflect, edge."
+
+ dtype = helper.input_dtype(input_param_name='input')
+ out = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type='pad2d', inputs=inputs, outputs={"Out": out}, attrs=attrs
+ )
+
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.elu")
+def elu(x, alpha=1.0, name=None):
+ """
+ :alias_main: paddle.nn.functional.elu
+ :alias: paddle.nn.functional.elu,paddle.nn.functional.activation.elu
+ :old_api: paddle.fluid.layers.elu
+
+ ${comment}
+ Args:
+ x(${x_type}): ${x_comment}
+ alpha(${alpha_type}|1.0): ${alpha_comment}
+ name(str|None): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ Returns:
+ ${out_type}: ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ input_elu = np.array([[-1,6],[1,15.6]])
+ with fluid.dygraph.guard():
+ x = fluid.dygraph.to_variable(input_elu)
+ y = fluid.layers.elu(x, alpha=0.2)
+ print(y.numpy())
+ # [[-0.12642411 6. ]
+ # [ 1. 15.6 ]]
+ """
+ helper = LayerHelper('elu', **locals())
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'elu')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='elu',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'alpha': alpha},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.relu6")
+def relu6(x, threshold=6.0, name=None):
+ """
+
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ threshold(float, optional): ${threshold_comment}
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ output(${out_type}): ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ in1 = np.array([[-1,0],[2.5,7.8]])
+ with fluid.dygraph.guard():
+ x1 = fluid.dygraph.to_variable(in1)
+ out1 = fluid.layers.relu6(x=x1, threshold=6.0)
+ print(out1.numpy())
+ # [[0. 0. ]
+ # [2.5 6. ]]
+ """
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'relu6')
+
+ helper = LayerHelper('relu6', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='relu6',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={
+ 'threshold': threshold,
+ 'use_mkldnn': _global_flags()["FLAGS_use_mkldnn"],
+ },
+ )
+ return out
+
+
+@templatedoc()
+def pow(x, factor=1.0, name=None):
+ """
+ This is Pow Activation Operator.
+
+ :math:`out = x^{factor}`
+
+ Args:
+ x(Variable): A ``Tensor`` or ``LoDTensor`` . The data type is ``float32`` or ``float64``.
+ factor(float32|Variable, optional): A scalar with type ``float32`` or a ``Tensor`` with shape [1] and type ``float32``. The exponential factor of Pow. Default 1.0.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: A ``Tensor`` or ``LoDTensor``. The data type is same as ``x``.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ x = fluid.data(name="x", shape=[32,32], dtype="float32")
+
+ # example 1: argument factor is float
+ y_1 = fluid.layers.pow(x, factor=2.0)
+ # y_1 is x^{2.0}
+
+ # example 2: argument factor is Variable
+ factor_tensor = fluid.layers.fill_constant([1], "float32", 3.0)
+ y_2 = fluid.layers.pow(x, factor=factor_tensor)
+ # y_2 is x^{3.0}
+ """
+ check_variable_and_dtype(
+ x, 'x', ['int32', 'int64', 'float16', 'float32', 'float64'], 'pow'
+ )
+
+ helper = LayerHelper('pow', **locals())
+ inputs = {'X': x}
+ attrs = {}
+ if isinstance(factor, Variable):
+ check_variable_and_dtype(factor, 'factor', ['float32'], 'pow')
+ factor.stop_gradient = True
+ inputs['FactorTensor'] = factor
+ else:
+ attrs['factor'] = factor
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='pow', inputs=inputs, outputs={'Out': out}, attrs=attrs
+ )
+ return out
+
+
+@templatedoc()
+def stanh(x, scale_a=0.67, scale_b=1.7159, name=None):
+ """
+ stanh activation.
+
+ .. math::
+
+ out = b * \\frac{e^{a * x} - e^{-a * x}}{e^{a * x} + e^{-a * x}}
+
+ Parameters:
+ x (Tensor): The input Tensor with data type float32, float64.
+ scale_a (float, optional): The scale factor a of the input. Default is 0.67.
+ scale_b (float, optional): The scale factor b of the output. Default is 1.7159.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ A Tensor with the same data type and shape as ``x`` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
+ out = paddle.stanh(x, scale_a=0.67, scale_b=1.72) # [1.00616539, 1.49927628, 1.65933108, 1.70390463]
+
+ """
+
+ if _non_static_mode():
+ return _legacy_C_ops.stanh(x, 'scale_a', scale_a, 'scale_b', scale_b)
+
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'stanh')
+
+ helper = LayerHelper('stanh', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='stanh',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'scale_a': scale_a, 'scale_b': scale_b},
+ )
+ return out
+
+
+@templatedoc()
+def hard_sigmoid(x, slope=0.2, offset=0.5, name=None):
+ """
+ ${comment}
+ Parameters:
+ x (${x_type}): ${x_comment}
+ slope (float, optional): ${slope_comment}
+ offset (float, optional): ${offset_comment}
+ name (str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`
+
+ Returns:
+ ${out_type}: ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ data = fluid.layers.fill_constant(shape=[3, 2], value=0.5, dtype='float32') # [[0.5, 0.5], [0.5, 0.5], [0.5, 0.5]]
+ result = fluid.layers.hard_sigmoid(data) # [[0.6, 0.6], [0.6, 0.6], [0.6, 0.6]]
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.hard_sigmoid(x, 'slope', slope, 'offset', offset)
+
+ check_variable_and_dtype(
+ x, 'x', ['float16', 'float32', 'float64'], 'hard_sigmoid'
+ )
+
+ helper = LayerHelper('hard_sigmoid', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='hard_sigmoid',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'slope': slope, 'offset': offset},
+ )
+ return out
+
+
+@templatedoc()
+def swish(x, beta=1.0, name=None):
+ r"""
+ :alias_main: paddle.nn.functional.swish
+ :alias: paddle.nn.functional.swish,paddle.nn.functional.activation.swish
+ :old_api: paddle.fluid.layers.swish
+
+ Elementwise swish activation function. See `Searching for Activation Functions `_ for more details.
+
+ Equation:
+
+ .. math::
+ out = \\frac{x}{1 + e^{- beta * x}}
+
+ Args:
+ x(Variable): Tensor or LoDTensor, dtype: float32 or float64, the input of swish activation.
+
+ beta(float): Constant beta of swish operator, default 1.0.
+
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+
+ Variable: Output of the swish activation, Tensor or LoDTensor, with the same dtype and shape with the input x.
+
+ Examples:
+
+ .. code-block:: python
+
+ # declarative mode
+ import numpy as np
+ from paddle import fluid
+
+ x = fluid.data(name="x", shape=(-1, 3), dtype="float32")
+ y = fluid.layers.swish(x, beta=2.0)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ start = fluid.default_startup_program()
+ main = fluid.default_main_program()
+
+ data = np.random.randn(2, 3).astype("float32")
+ exe.run(start)
+ y_np, = exe.run(main, feed={"x": data}, fetch_list=[y])
+
+ data
+ # array([[-1.1239197 , 1.3391294 , 0.03921051],
+ # [ 1.1970421 , 0.02440812, 1.2055548 ]], dtype=float32)
+ y_np
+ # array([[-0.2756806 , 1.0610548 , 0.01998957],
+ # [ 0.9193261 , 0.01235299, 0.9276883 ]], dtype=float32)
+
+
+ .. code-block:: python
+
+ # imperative mode
+ import numpy as np
+ from paddle import fluid
+ import paddle.fluid.dygraph as dg
+
+ data = np.random.randn(2, 3).astype("float32")
+ place = fluid.CPUPlace()
+ with dg.guard(place) as g:
+ x = dg.to_variable(data)
+ y = fluid.layers.swish(x)
+ y_np = y.numpy()
+ data
+ # array([[-0.0816701 , 1.1603649 , -0.88325626],
+ # [ 0.7522361 , 1.0978601 , 0.12987892]], dtype=float32)
+ y_np
+ # array([[-0.03916847, 0.8835007 , -0.25835553],
+ # [ 0.51126915, 0.82324016, 0.06915068]], dtype=float32)
+ """
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'swish')
+
+ helper = LayerHelper('swish', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='swish',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'slope': beta},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.static.nn.prelu")
+def prelu(x, mode, param_attr=None, data_format="NCHW", name=None):
+ r"""
+
+ prelu activation.
+
+ .. math::
+ prelu(x) = max(0, x) + \alpha * min(0, x)
+
+ There are three modes for the activation:
+
+ .. code-block:: text
+
+ all: All elements share same alpha.
+ channel: Elements in same channel share same alpha.
+ element: All elements do not share alpha. Each element has its own alpha.
+
+ Parameters:
+ x (Tensor): The input Tensor or LoDTensor with data type float32.
+ mode (str): The mode for weight sharing.
+ param_attr (ParamAttr|None, optional): The parameter attribute for the learnable
+ weight (alpha), it can be create by ParamAttr. None by default.
+ data_format(str, optional): Data format that specifies the layout of input.
+ It may be "NC", "NCL", "NCHW", "NCDHW", "NLC", "NHWC" or "NDHWC". Default: "NCHW".
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor, A tensor with the same shape and data type as x.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-1., 2., 3.])
+ param = paddle.ParamAttr(initializer=paddle.nn.initializer.Constant(0.2))
+ out = paddle.static.nn.prelu(x, 'all', param)
+ # [-0.2, 2., 3.]
+
+ """
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'prelu')
+
+ helper = LayerHelper('prelu', **locals())
+ if mode not in ['all', 'channel', 'element']:
+ raise ValueError('mode should be one of all, channel, element.')
+
+ alpha_shape = [1]
+ if mode == 'channel':
+
+ true_data_format = [
+ 'NC',
+ 'NCL',
+ 'NCHW',
+ 'NCDHW',
+ 'NLC',
+ 'NHWC',
+ 'NDHWC',
+ ]
+ if data_format not in true_data_format:
+ raise ValueError(
+ "data_format must be one of 'NC', 'NCL', 'NCHW', 'NCDHW', "
+ "'NLC', 'NHWC', 'NDHWC' but receive {}".format(data_format)
+ )
+
+ data_format = 'NCHW' if data_format[1] == 'C' else 'NHWC'
+
+ assert (
+ len(x.shape) >= 2
+ ), "The size of input shape should be equal or larger than 2 in prelu() when mode is 'channel'"
+ # NOTE(zhiqiu): The alpha_shape should be [1, channel] + [1] * len(x.shape[2:]).
+ # To be consistent with Prelu, it is simplified.
+ # NOTE(zhiqiu): Revert shape to [1, channel, 1, 1] for compatibility with saved model of old version.
+ # NOTE(GuoxiaWang): support NHWC data format
+ if data_format == 'NHWC':
+ alpha_shape = [1, 1, 1, x.shape[-1]]
+ else:
+ alpha_shape = [1, x.shape[1], 1, 1]
+
+ elif mode == 'element':
+ assert (
+ len(x.shape) >= 1
+ ), "The size of input shape should be equal or larger than 1 in prelu() when mode is 'element'"
+ alpha_shape = [1] + list(x.shape)[1:]
+ dtype = helper.input_dtype(input_param_name='x')
+ alpha = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=alpha_shape,
+ dtype=dtype,
+ is_bias=False,
+ default_initializer=Constant(0.25),
+ )
+ if in_dygraph_mode():
+ return _C_ops.prelu(x, alpha, data_format, mode)
+
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="prelu",
+ inputs={"X": x, 'Alpha': alpha},
+ attrs={"mode": mode, "data_format": data_format},
+ outputs={"Out": out},
+ )
+ return out
+
+
+@templatedoc()
+def brelu(x, t_min=0.0, t_max=24.0, name=None):
+ """
+ ${comment}
+ Args:
+ x(${x_type}): ${x_comment}
+ t_min(${t_min_type}|0.0): ${t_min_comment}
+ t_max(${t_max_type}|24.0): ${t_max_comment}
+ name(str|None): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ Returns:
+ ${out_type}: ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+
+ input_brelu = np.array([[-1,6],[1,15.6]])
+ with fluid.dygraph.guard():
+ x = fluid.dygraph.to_variable(input_brelu)
+ y = fluid.layers.brelu(x, t_min=1.0, t_max=10.0)
+ print(y.numpy())
+ #[[ 1. 6.]
+ #[ 1. 10.]]
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.brelu(x, 't_min', t_min, 't_max', t_max)
+
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'brelu')
+
+ helper = LayerHelper('brelu', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='brelu',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'t_min': t_min, 't_max': t_max},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.leaky_relu")
+@templatedoc()
+def leaky_relu(x, alpha=0.02, name=None):
+ """
+ ${comment}
+ Args:
+ x(${x_type}): ${x_comment}
+ alpha(${alpha_type}|0.02): ${alpha_comment}
+ name(str|None): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ output(${out_type}): ${out_comment}
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([[-1, 2], [3, -4]], dtype='float32')
+ y = paddle.fluid.layers.leaky_relu(x, alpha=0.1)
+ print(y) # [[-0.1, 2], [3, -0.4]]
+
+ """
+ return paddle.nn.functional.leaky_relu(x, alpha, name)
+
+
+def soft_relu(x, threshold=40.0, name=None):
+ r"""
+
+ SoftRelu Activation Operator.
+
+ $out = \ln(1 + \exp(\max(\min(x, threshold), -threshold)))$
+
+ Args:
+ x(Variable): Input of soft_relu operator. Data type can be float32, float64.
+ threshold(float, optional): The threshold value of soft_relu, default value being 40.0.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable(Tensor|LoDTensor)): Output of soft_relu operator, shape and LoD same as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import numpy as np
+ import paddle
+
+ paddle.enable_static()
+ inputs = fluid.layers.data(name="x", shape=[2, 2], dtype="float32")
+ output = fluid.layers.soft_relu(inputs, threshold=20.0)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ img = np.array([[0, 1],[2, 3]]).astype(np.float32)
+
+ res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output])
+ print(res) # [array([[0.6931472, 1.3132616], [2.126928 , 3.0485873]], dtype=float32)]
+ """
+ check_variable_and_dtype(
+ x, 'x', ['float16', 'float32', 'float64'], 'soft_relu'
+ )
+
+ helper = LayerHelper('soft_relu', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='soft_relu',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'threshold': threshold},
+ )
+ return out
+
+
+def flatten(x, axis=1, name=None):
+ r"""
+ **Flatten op**
+
+ Flatten the input tensor into a 2D matrix.
+
+ For Example:
+
+ .. code-block:: text
+
+ Case 1:
+
+ Given
+ X.shape = (3, 100, 100, 4)
+
+ and
+ axis = 2
+
+ We get:
+ Out.shape = (3 * 100, 4 * 100)
+
+ Case 2:
+
+ Given
+ X.shape = (3, 100, 100, 4)
+
+ and
+ axis = 0
+
+ We get:
+ Out.shape = (1, 3 * 100 * 100 * 4)
+
+ Args:
+ x (Variable): A tensor of rank >= axis. A tensor with type float32,
+ float64, int8, int32, int64, uint8.
+ axis (int): Indicate up to which input dimensions (exclusive) should
+ be flattened to the outer dimension of the output.
+ The value for axis must be in the range [0, R], where R
+ is the rank of the input tensor. Default: 1.
+ name(str, Optional): For details, please refer to :ref:`api_guide_Name`.
+ Generally, no setting is required. Default: None.
+
+ Returns:
+ Variable: A 2D tensor with the contents of the input tensor, with input \
+ dimensions up to axis flattened to the outer dimension of \
+ the output and remaining input dimensions flattened into the \
+ inner dimension of the output. A Tensor with type same as input x.
+
+ Raises:
+ ValueError: If x is not a variable.
+ ValueError: If axis is not in range [0, rank(x)].
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[4, 4, 3], dtype="float32")
+ # x shape is [4, 4, 3]
+ out = fluid.layers.flatten(x=x, axis=2)
+ # out shape is [16, 3]
+ """
+ check_variable_and_dtype(
+ x,
+ 'x',
+ ['float32', 'float64', 'int8', 'int32', 'int64', 'uint8'],
+ 'flatten',
+ )
+ if _non_static_mode():
+ return _legacy_C_ops.flatten2(x, 'axis', axis)[0]
+
+ helper = LayerHelper('flatten', **locals())
+
+ if not (isinstance(x, Variable)):
+ raise ValueError("The input x should be a Variable")
+
+ if not (isinstance(axis, int)) or axis > len(x.shape) or axis < 0:
+ raise ValueError("The axis should be a int, and in range [0, rank(x)]")
+
+ out = helper.create_variable_for_type_inference(x.dtype)
+ x_shape = helper.create_variable_for_type_inference(x.dtype)
+ helper.append_op(
+ type='flatten2',
+ inputs={"X": x},
+ outputs={'Out': out, 'XShape': x_shape},
+ attrs={"axis": axis},
+ )
+ return out
+
+
+def stack(x, axis=0, name=None):
+ """
+
+ This OP stacks all the inputs :code:`x` along axis.
+
+ .. code-block:: text
+
+ Case 1:
+
+ Input:
+ x[0].shape = [1, 2]
+ x[0].data = [ [1.0 , 2.0 ] ]
+ x[1].shape = [1, 2]
+ x[1].data = [ [3.0 , 4.0 ] ]
+ x[2].shape = [1, 2]
+ x[2].data = [ [5.0 , 6.0 ] ]
+
+ Attrs:
+ axis = 0
+
+ Output:
+ Out.dims = [3, 1, 2]
+ Out.data =[ [ [1.0, 2.0] ],
+ [ [3.0, 4.0] ],
+ [ [5.0, 6.0] ] ]
+
+
+ Case 2:
+
+
+ Input:
+ x[0].shape = [1, 2]
+ x[0].data = [ [1.0 , 2.0 ] ]
+ x[1].shape = [1, 2]
+ x[1].data = [ [3.0 , 4.0 ] ]
+ x[2].shape = [1, 2]
+ x[2].data = [ [5.0 , 6.0 ] ]
+
+
+ Attrs:
+ axis = 1 or axis = -2
+
+ Output:
+ Out.shape = [1, 3, 2]
+ Out.data =[ [ [1.0, 2.0]
+ [3.0, 4.0]
+ [5.0, 6.0] ] ]
+
+
+ Args:
+ x (list(Variable)|tuple(Variable)): Input :code:`x` can be a :code:`list` or :code:`tuple` of Tensors, the shapes of all these Tensors
+ must be the same. Supposing input is N dims
+ Tensors :math:`[d_0, d_1, ..., d_{n-1}]`, the output is N+1 dims
+ Tensor :math:`[d_0, d_1, d_{axis-1}, len(x), d_{axis}, ..., d_{n-1}]`.
+ Supported data types: float32, float64, int32, int64.
+ axis (int, optional): The axis along which all inputs are stacked. ``axis`` range is ``[-(R+1), R+1)``,
+ where ``R`` is the number of dimensions of the first input tensor ``x[0]``.
+ If ``axis < 0``, ``axis = axis+R+1``. The default value of axis is 0.
+ name (str, optional): Please refer to :ref:`api_guide_Name`, Default None.
+
+
+ Returns:
+ Variable: The stacked Tensor, has same data type with input Tensors. Output dim is :math:`rank(x[0])+1`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ # set batch size=None
+ x1 = fluid.data(name='x1', shape=[None, 1, 2], dtype='int32')
+ x2 = fluid.data(name='x2', shape=[None, 1, 2], dtype='int32')
+ # stack Tensor list
+ data = layers.stack([x1,x2]) # stack according to axis 0, data.shape=[2, None, 1, 2]
+
+ data = layers.stack([x1,x2], axis=1) # stack according to axis 1, data.shape=[None, 2, 1, 2]
+
+
+ """
+ axis = 0 if axis is None else axis
+
+ if in_dygraph_mode():
+ return _C_ops.stack(x, axis)
+
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.stack(x, 'axis', axis)
+
+ if not isinstance(x, list) and not isinstance(x, tuple):
+ # NOTE:(zhiqiu) Only support Variable as input if the Variable is a LOD_TENSOR_ARRAY create by create_array, array_write, array_read, etc.
+ # In that case, Variable is array of tensors indeed.
+ if (
+ isinstance(x, Variable)
+ and x.desc.type() == core.VarDesc.VarType.LOD_TENSOR_ARRAY
+ ):
+ x = [x]
+ else:
+ raise TypeError(
+ "The type of '%s' in %s must be %s, but received %s"
+ % (
+ 'x',
+ 'stack',
+ 'list[Tensor], tuple[Tensor] or TensorArray',
+ type(x),
+ )
+ )
+
+ helper = LayerHelper('stack', **locals())
+
+ out = helper.create_variable_for_type_inference(x[0].dtype)
+ if x[0].desc.type() == core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ assert len(x) == 1, (
+ "If the elements of 'x' in stack are Variable(LoDTensorArray), "
+ "number of the elements must be 1, but received %s." % len(x)
+ )
+ out_index = helper.create_variable_for_type_inference(dtype="int32")
+
+ for i in x:
+ check_variable_and_dtype(
+ i,
+ 'x',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ 'stack',
+ )
+
+ helper.append_op(
+ type='tensor_array_to_tensor',
+ inputs={'X': x[0]},
+ outputs={'Out': [out], 'OutIndex': [out_index]},
+ attrs={'axis': axis, 'use_stack': True},
+ )
+ else:
+ helper.append_op(
+ type='stack',
+ inputs={'X': x},
+ outputs={'Y': out},
+ attrs={'axis': axis},
+ )
+
+ return out
+
+
+@templatedoc(op_type="filter_by_instag")
+def filter_by_instag(ins, ins_tag, filter_tag, is_lod, out_val_if_empty=0):
+ """
+ **Filter By Instag Layer**
+
+ This function filter a batch of ins by instag,
+ There are multiple ins, and every ins belongs to some tags.
+ We can specify some tags we want. So the ins which belongs to that tags
+ remains in the output, and others removed.
+
+ For example, one batch has 4 ins. Every ins has its tag list.
+
+ | Ins | Ins_Tag |
+ |:-----:|:------:|
+ | 0 | 0, 1 |
+ | 1 | 1, 3 |
+ | 2 | 0, 3 |
+ | 3 | 2, 6 |
+
+ And Lod is [1,1,1,1]
+
+ And the filter tags [1]
+
+ From the definition above, ins which has tag 1 can pass the filter
+ So Ins 0 and Ins 1 can pass and be seen in the output,
+ Ins 2 and 3 cannot pass because they do not has tag 1.
+
+ Actually, if is_lod is false, it is normal tensor that equals to
+ lod_tensor with all 1, similar to the example above.
+
+ Args:
+ ins (Variable): Input Variable (LoDTensor), usually it is 2D tensor
+ And first dimension can have lod info or not.
+ ins_tag (Variable): Input Variable (LoDTensor), usually it is 1D list
+ And split them by lod info
+ filter_tag (Variable): Input Variable (1D Tensor/List), usually it is
+ list that holds the tags.
+ is_lod (Bool): Boolean value to indicate ins is lod tensor or not.
+ out_val_if_empty(Int64): If the output after filter is empty, this value
+ will be set to Output tensor.
+
+ Returns:
+ Variable: filtered ins (LoDTensor) and loss weight (Tensor)
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid.layers as layers
+ ins = layers.data(name='Ins', shape=[-1,32], lod_level=0, dtype='float64')
+ ins_tag = layers.data(name='Ins_tag', shape=[-1,16], lod_level=0, dtype='int64')
+ filter_tag = layers.data(name='Filter_tag', shape=[-1,16], dtype='int64')
+ out, loss_weight = layers.filter_by_instag(ins, ins_tag, filter_tag, True)
+
+ """
+ helper = LayerHelper('filter_by_instag', **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=ins.dtype)
+ loss_weight = helper.create_variable_for_type_inference(dtype=np.float64)
+ mmap = helper.create_variable_for_type_inference(dtype=ins_tag.dtype)
+ helper.append_op(
+ type='filter_by_instag',
+ inputs={'Ins': ins, 'Ins_tag': ins_tag, 'Filter_tag': filter_tag},
+ outputs={'Out': out, 'LossWeight': loss_weight, 'IndexMap': mmap},
+ attrs={'is_lod': is_lod, 'out_val_if_empty': out_val_if_empty},
+ )
+
+ return [out, loss_weight]
+
+
+def unstack(x, axis=0, num=None):
+ """
+ :alias_main: paddle.unstack
+ :alias: paddle.unstack,paddle.tensor.unstack,paddle.tensor.manipulation.unstack
+ :old_api: paddle.fluid.layers.unstack
+
+ **UnStack Layer**
+
+ This layer unstacks input Tensor :code:`x` into several Tensors along :code:`axis`.
+
+ If :code:`axis` < 0, it would be replaced with :code:`axis+rank(x)`.
+ If :code:`num` is None, it would be inferred from :code:`x.shape[axis]`,
+ and if :code:`x.shape[axis]` <= 0 or is unknown, :code:`ValueError` is
+ raised.
+
+ Args:
+ x (Tensor): Input Tensor. It is a N-D Tensors of data types float32, float64, int32, int64.
+ axis (int): The axis along which the input is unstacked.
+ num (int|None): The number of output variables.
+
+ Returns:
+ list(Tensor): The unstacked Tensors list. The list elements are N-D Tensors of data types float32, float64, int32, int64.
+
+ Raises:
+ ValueError: If x.shape[axis] <= 0 or axis is not in range [-D, D).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ x = paddle.ones(name='x', shape=[2, 3, 5], dtype='float32') # create a tensor with shape=[2, 3, 5]
+ y = paddle.unstack(x, axis=1) # unstack with second axis, which results 3 tensors with shape=[2, 5]
+
+ """
+
+ if _non_static_mode():
+ if num == None:
+ num = x.shape[axis]
+ if num == 0:
+ return []
+ return _legacy_C_ops.unstack(x, num, 'axis', int(axis), 'num', num)
+
+ helper = LayerHelper('unstack', **locals())
+ if num is None:
+ if axis is None or x.shape[axis] <= 0:
+ raise ValueError('unknown unstack number')
+ else:
+ num = x.shape[axis]
+
+ outs = []
+ for _ in range(num):
+ outs.append(helper.create_variable_for_type_inference(x.dtype))
+
+ helper.append_op(
+ type='unstack',
+ inputs={'X': [x]},
+ outputs={'Y': outs},
+ attrs={'axis': axis, 'num': num},
+ )
+ return outs
+
+
+@deprecated(since='2.0.0', update_to="paddle.expand")
+def expand(x, expand_times, name=None):
+ """
+ :alias_main: paddle.expand
+ :alias: paddle.expand,paddle.tensor.expand,paddle.tensor.manipulation.expand
+ :old_api: paddle.fluid.layers.expand
+
+ This operation tiles ``x`` multiple times according to the parameter ``expand_times``.
+ The times number for each dimension of ``x`` is set by the parameter ``expand_times``.
+ The rank of ``x`` should be less than or equal to 6. Please note that size of ``expand_times`` must be the same
+ with X's rank. Following is a using case:
+
+
+ .. code-block:: text
+
+ Input(X) is a 3-D tensor with shape [2, 3, 1]:
+
+ [
+ [[1], [2], [3]],
+ [[4], [5], [6]]
+ ]
+
+ Attr(expand_times): [1, 2, 2]
+
+ Output(Out) is a 3-D tensor with shape [2, 6, 2]:
+
+ [
+ [[1, 1], [2, 2], [3, 3], [1, 1], [2, 2], [3, 3]],
+ [[4, 4], [5, 5], [6, 6], [4, 4], [5, 5], [6, 6]]
+ ]
+
+ Args:
+ x (Variable): A ``Tensor`` or ``LoDTensor`` with dimension in [1, 6]. The data type is ``bool``, ``float32``, ``float64`` or ``int32`` .
+ expand_times (list|tuple|Variable): The data type is ``int32`` . If ``expand_times`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``expand_times`` is an Variable, it should be an 1-D Tensor.
+ Expand times number for each dimension of ``x`` .
+ name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: A ``Tensor`` or ``LoDTensor``. The data type is same as ``x``. After expanding, size of each dimension of output is equal to the size of the corresponding dimension of ``x`` multiplying the corresponding value given by ``expand_times`` .
+
+ Raises:
+ TypeError: The type of ``expand_times`` must be list, tuple or Variable.
+ ValueError: The elements of ``expand_times`` cannot be negative.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ # example 1:
+ data_1 = fluid.layers.fill_constant(shape=[2, 3, 1], dtype='int32', value=0)
+ expanded_1 = fluid.layers.expand(data_1, expand_times=[1, 2, 2])
+ # the shape of expanded_1 is [2, 6, 2].
+
+ # example 2:
+ data_2 = fluid.layers.fill_constant(shape=[12, 14], dtype="int32", value=3)
+ expand_times = fluid.layers.fill_constant(shape=[2], dtype="int32", value=4)
+ expanded_2 = fluid.layers.expand(data_2, expand_times=expand_times)
+ # the shape of expanded_2 is [48, 56].
+ """
+ if _non_static_mode():
+ attrs = ()
+ expand_times_tensor = None
+ if isinstance(expand_times, (list, tuple)):
+ expand_times = [
+ item.numpy().item(0) if isinstance(item, Variable) else item
+ for item in expand_times
+ ]
+ attrs += ('expand_times', expand_times)
+ elif isinstance(expand_times, Variable):
+ expand_times_tensor = expand_times
+ expand_times_tensor.stop_gradient = True
+
+ return _legacy_C_ops.expand(x, expand_times_tensor, *attrs)
+
+ inputs = {"X": [x]}
+ attrs = {}
+ check_variable_and_dtype(
+ x,
+ 'x',
+ ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
+ 'expand',
+ )
+ check_type(expand_times, 'expand_times', (list, tuple, Variable), 'expand')
+ if convert_dtype(x.dtype) == 'bool' and x.stop_gradient == True:
+ raise ValueError(
+ "expand op bool date type must set the stop_gradient to be False"
+ )
+
+ helper = LayerHelper('expand', input=x, **locals())
+
+ def get_attr_expand_times(list_expand_times):
+ attrs_expand_times = []
+ for idx, times in enumerate(list_expand_times):
+ if isinstance(times, Variable):
+ attrs_expand_times.append(-1)
+ else:
+ attrs_expand_times.append(times)
+ assert (
+ times > 0
+ ), "Each element given in expand_times must not be negative."
+ return attrs_expand_times
+
+ if isinstance(expand_times, Variable):
+ expand_times.stop_gradient = True
+ inputs['ExpandTimes'] = expand_times
+ elif isinstance(expand_times, (list, tuple)):
+ attrs['expand_times'] = get_attr_expand_times(expand_times)
+ if utils._contain_var(expand_times):
+ inputs['expand_times_tensor'] = utils._convert_to_tensor_list(
+ expand_times
+ )
+
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='expand', inputs=inputs, outputs={'Out': out}, attrs=attrs
+ )
+ return out
+
+
+@deprecated(since='2.0.0', update_to="paddle.expand_as")
+def expand_as(x, target_tensor, name=None):
+ """
+ :alias_main: paddle.expand_as
+ :alias: paddle.expand_as,paddle.tensor.expand_as,paddle.tensor.manipulation.expand_as
+ :old_api: paddle.fluid.layers.expand_as
+
+ expand_as operator tiles to the input by given expand tensor. You should set expand tensor
+ for each dimension by providing tensor 'target_tensor'. The rank of X
+ should be in [1, 6]. Please note that size of 'target_tensor' must be the same
+ with X's rank. Following is a using case:
+
+
+ .. code-block:: text
+
+ Input(X) is a 3-D tensor with shape [2, 3, 1]:
+
+ [
+ [[1], [2], [3]],
+ [[4], [5], [6]]
+ ]
+
+ target_tensor's shape: [2, 6, 2]
+
+ Output(Out) is a 3-D tensor with shape [2, 6, 2]:
+
+ [
+ [[1, 1], [2, 2], [3, 3], [1, 1], [2, 2], [3, 3]],
+ [[4, 4], [5, 5], [6, 6], [4, 4], [5, 5], [6, 6]]
+ ]
+
+
+ Args:
+ x (Variable): A Tensor with dtype float64, float32, int32.
+ A tensor with rank in [1, 6].
+ target_tensor (Variable): A Tensor with dtype float64, float32, int32.
+ target_tensor for expanding to Input(X). Only use target_tensor'shape.
+
+ Returns:
+ Variable: A Tensor with dtype float64, float32, int32.
+ After expanding, size of each dimension of Output(Out) is equal to the size
+ of the corresponding dimension of target_tensor multiplying the corresponding
+ value given by target_tensor.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+ paddle.enable_static()
+
+ data = fluid.layers.data(name="data", shape=[-1,10], dtype='float64')
+ target_tensor = fluid.layers.data(
+ name="target_tensor", shape=[-1,20], dtype='float64')
+ result = fluid.layers.expand_as(x=data, target_tensor=target_tensor)
+ use_cuda = False
+ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ x = np.random.rand(3,10)
+ y = np.random.rand(3,20)
+ output= exe.run(feed={"data":x,"target_tensor":y},fetch_list=[result.name])
+ print(output[0].shape)
+ #(3,20)
+
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.expand_as(x, target_tensor)
+
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'int32', 'int64', 'bool'], 'expand_as'
+ )
+ check_variable_and_dtype(
+ target_tensor,
+ 'target_tensor',
+ ['float32', 'float64', 'int32', 'int64', 'bool'],
+ 'expand_as',
+ )
+ helper = LayerHelper('expand_as', input=x, **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ inputs = {'X': x, 'target_tensor': target_tensor}
+ helper.append_op(type='expand_as', inputs=inputs, outputs={'Out': out})
+ return out
+
+
+from paddle.fluid.framework import convert_np_dtype_to_dtype_
+
+
+@deprecated(since='1.8.0', update_to="paddle.uniform")
+@templatedoc()
+def uniform_random_batch_size_like(
+ input,
+ shape,
+ dtype='float32',
+ input_dim_idx=0,
+ output_dim_idx=0,
+ min=-1.0,
+ max=1.0,
+ seed=0,
+):
+ """
+ This OP initializes a variable with random values sampled from a
+ uniform distribution in the range [min, max). The input_dim_idx used to get the input dimension value which will be used to resize the output dimension.
+
+ .. code-block:: text
+
+ *Case 1:
+
+ Given:
+ input =[[0.946741 , 0.1357001 , 0.38086128]] # input.shape=[1,3]
+ shape=[2,4]
+
+ result.shape[output_dim_idx] = input.shape[input_dim_idx],
+ output_dim_idx = 0,
+ input_dim_idx = 0,
+ result.shape[0] = input.shape[0],
+ then:
+ result=[[ 0.3443427 , -0.23056602, 0.3477049 , 0.06139076]] # result.shape=[1,4]
+
+ *Case 2:
+
+ Given:
+ input =[[0.946741 , 0.1357001 , 0.38086128]] # input.shape=[1,3]
+ shape=[2,4]
+ input_dim_idx=1
+ output_dim_idx=1
+
+ result.shape[output_dim_idx] = input.shape[input_dim_idx],
+ output_dim_idx = 1,
+ input_dim_idx = 1,
+ result.shape[1] = input.shape[1],
+ then:
+ result=[[-0.23133647, -0.84195036, 0.21441269],
+ [-0.08774924, 0.25605237, -0.09403259]] # result.shape=[2,3]
+ Args:
+ input (Variable): A Tensor. Supported data types: float32, float64.
+ shape (tuple|list): A python list or python tuple. The shape of the output Tensor, the data type is int.
+ input_dim_idx (int, optional): An index used to get the input dimension value which will be used to resize the output dimension. Default 0.
+ output_dim_idx (int, optional): An index used to indicate the specific dimension that will be replaced by corresponding input dimension value. Default 0.
+ min (float, optional): The lower bound on the range of random values to generate, the min is included in the range. Default -1.0.
+ max (float, optional): The upper bound on the range of random values to generate, the max is excluded in the range. Default 1.0.
+ seed (int, optional): Random seed used for generating samples. 0 means use a seed generated by the system.Note that if seed is not 0, this operator will always generate the same random numbers every time.
+ dtype(np.dtype|core.VarDesc.VarType|str, optional): The data type of output Tensor. Supported data types: float32, float64. Default float32.
+ Returns:
+ Variable: A Tensor of the specified shape filled with uniform_random values. The shape of the Tensor is determined by the shape parameter and the specified dimension of the input Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # example 1:
+ input = fluid.data(name="input", shape=[1, 3], dtype='float32')
+ out_1 = fluid.layers.uniform_random_batch_size_like(input, [2, 4]) # out_1.shape=[1, 4]
+
+ # example 2:
+ out_2 = fluid.layers.uniform_random_batch_size_like(input, [2, 4], input_dim_idx=1, output_dim_idx=1) # out_2.shape=[2, 3]
+
+
+ """
+ check_variable_and_dtype(
+ input,
+ 'Input',
+ ("float32", 'float64', "uint16"),
+ 'uniform_random_batch_size_like',
+ )
+ check_type(shape, 'shape', (list, tuple), 'uniform_random_batch_size_like')
+ check_dtype(
+ dtype,
+ 'dtype',
+ ('float32', 'float64', "uint16"),
+ 'uniform_random_batch_size_like',
+ )
+
+ helper = LayerHelper('uniform_random_batch_size_like', **locals())
+ out = helper.create_variable_for_type_inference(dtype)
+ c_dtype = convert_np_dtype_to_dtype_(dtype)
+ helper.append_op(
+ type='uniform_random_batch_size_like',
+ inputs={'Input': input},
+ outputs={'Out': out},
+ attrs={
+ 'shape': shape,
+ 'input_dim_idx': input_dim_idx,
+ 'output_dim_idx': output_dim_idx,
+ 'min': min,
+ 'max': max,
+ 'seed': seed,
+ 'dtype': c_dtype,
+ },
+ )
+
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.normal")
+@templatedoc()
+def gaussian_random(
+ shape, mean=0.0, std=1.0, seed=0, dtype='float32', name=None
+):
+ """
+ This OP returns a Tensor filled with random values sampled from a Gaussian
+ distribution, with ``shape`` and ``dtype``.
+
+ Args:
+ shape(list|tuple|Tensor): The shape of the output Tensor. If ``shape``
+ is a list or tuple, the elements of it should be integers or Tensors
+ (with the shape [1], and the data type int32 or int64). If ``shape``
+ is a Tensor, it should be a 1-D Tensor(with the data type int32 or
+ int64).
+ mean(float|int, optional): Mean of the output tensor, default is 0.0.
+ std(float|int, optional): Standard deviation of the output tensor, default
+ is 1.0.
+ seed(int, optional): ${seed_comment}
+ dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of
+ the output Tensor. Supported data types: float32, float64.
+ Default is float32.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: A Tensor filled with random values sampled from a Gaussian
+ distribution, with ``shape`` and ``dtype``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # example 1:
+ # attr shape is a list which doesn't contain Tensor.
+ result_1 = fluid.layers.gaussian_random(shape=[3, 4])
+ # [[-0.31261674, 1.8736548, -0.6274357, 0.96988016],
+ # [-0.12294637, 0.9554768, 1.5690808, -1.2894802 ],
+ # [-0.60082096, -0.61138713, 1.5345167, -0.21834975]]
+
+ # example 2:
+ # attr shape is a list which contains Tensor.
+ dim_1 = fluid.layers.fill_constant([1], "int64", 2)
+ dim_2 = fluid.layers.fill_constant([1], "int32", 3)
+ result_2 = fluid.layers.gaussian_random(shape=[dim_1, dim_2])
+ # [[ 0.51398206, -0.3389769, 0.23597084],
+ # [ 1.0388143, -1.2015356, -1.0499583 ]]
+
+ # example 3:
+ # attr shape is a Tensor, the data type must be int64 or int32.
+ var_shape = fluid.data(name='var_shape', shape=[2], dtype="int64")
+ result_3 = fluid.layers.gaussian_random(var_shape)
+ # if var_shape's value is [2, 3]
+ # result_3 is:
+ # [[-0.12310527, 0.8187662, 1.923219 ]
+ # [ 0.70721835, 0.5210541, -0.03214082]]
+
+ .. code-block:: python
+
+ # declarative mode
+ # required: skiptest
+ import numpy as np
+ from paddle import fluid
+
+ x = fluid.layers.gaussian_random((2, 3), std=2., seed=10)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ start = fluid.default_startup_program()
+ main = fluid.default_main_program()
+
+ exe.run(start)
+ x_np, = exe.run(main, feed={}, fetch_list=[x])
+
+ x_np
+ # array([[2.3060477, 2.676496 , 3.9911983],
+ # [0.9990833, 2.8675377, 2.2279181]], dtype=float32)
+
+ .. code-block:: python
+
+ # imperative mode
+ import numpy as np
+ from paddle import fluid
+ import paddle.fluid.dygraph as dg
+
+ place = fluid.CPUPlace()
+ with dg.guard(place) as g:
+ x = fluid.layers.gaussian_random((2, 4), mean=2., dtype="float32", seed=10)
+ x_np = x.numpy()
+ x_np
+ # array([[2.3060477 , 2.676496 , 3.9911983 , 0.9990833 ],
+ # [2.8675377 , 2.2279181 , 0.79029655, 2.8447366 ]], dtype=float32)
+ """
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+
+ if in_dygraph_mode():
+ shape = utils.convert_shape_to_list(shape)
+ place = _current_expected_place()
+ return _C_ops.gaussian_random(
+ shape, float(mean), float(std), seed, dtype, place
+ )
+
+ if _in_legacy_dygraph():
+ shape = utils.convert_shape_to_list(shape)
+ return _legacy_C_ops.gaussian_random(
+ 'shape',
+ shape,
+ 'mean',
+ float(mean),
+ 'std',
+ float(std),
+ 'seed',
+ seed,
+ 'dtype',
+ dtype,
+ )
+
+ check_type(shape, 'shape', (list, tuple, Variable), 'gaussian_random/randn')
+ check_dtype(dtype, 'dtype', ['float32', 'float64'], 'gaussian_random/randn')
+
+ inputs = {}
+ attrs = {
+ 'mean': mean,
+ 'std': std,
+ 'seed': seed,
+ 'dtype': dtype,
+ 'use_mkldnn': False,
+ }
+ utils.get_shape_tensor_inputs(
+ inputs=inputs, attrs=attrs, shape=shape, op_type='gaussian_random/randn'
+ )
+
+ helper = LayerHelper('gaussian_random', **locals())
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='gaussian_random', inputs=inputs, outputs={'Out': out}, attrs=attrs
+ )
+
+ return out
+
+
+@templatedoc()
+def sampling_id(x, min=0.0, max=1.0, seed=0, dtype='float32'):
+ """
+ This op is used for sampling id from multinomial distribution from the input, sampling one id for one sample.
+
+ Parameters:
+ x (Variable): 2-D tensor, [batch_size, input_feature_dimensions]
+ min (Float): minimum , default 0.0.
+ max (Float): maximum, default 1.0.
+ seed (Float): Random seed, default 0. if seed is not 0, will generate same number every time.
+ dtype(np.dtype|core.VarDesc.VarType|str): The type of output data : float32, float_16, int etc
+
+ Returns:
+ Variable: sampling tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(
+ name="X",
+ shape=[13, 11],
+ dtype='float32')
+
+ out = fluid.layers.sampling_id(x)
+ """
+
+ helper = LayerHelper('sampling_id', **locals())
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='sampling_id',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'min': min, 'max': max, 'seed': seed},
+ )
+
+ return out
+
+
+@deprecated(since='1.8.0', update_to="paddle.normal")
+@templatedoc()
+def gaussian_random_batch_size_like(
+ input,
+ shape,
+ input_dim_idx=0,
+ output_dim_idx=0,
+ mean=0.0,
+ std=1.0,
+ seed=0,
+ dtype='float32',
+):
+ """
+ ${comment}
+
+ Args:
+ input (Variable): ${input_comment}
+ shape (tuple|list): ${shape_comment}
+ input_dim_idx (int): ${input_dim_idx_comment}
+ output_dim_idx (int): ${output_dim_idx_comment}
+ mean (float): ${mean_comment}
+ std (float): ${std_comment}
+ seed (int): ${seed_comment}
+ dtype(np.dtype|core.VarDesc.VarType|str): The type of output data, float32 or float_64.
+
+ Returns:
+ out (Variable): ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ input = fluid.data(name="input", shape=[13, 11], dtype='float32')
+
+ out = fluid.layers.gaussian_random_batch_size_like(
+ input, shape=[-1, 11], mean=1.0, std=2.0)
+ """
+
+ helper = LayerHelper('gaussian_random_batch_size_like', **locals())
+ check_type(
+ input,
+ 'input',
+ (Variable),
+ 'fluid.layers.gaussian_random_batch_size_like',
+ )
+ check_type(
+ shape,
+ 'shape',
+ (list, tuple),
+ 'fluid.layers.gaussian_random_batch_size_like',
+ )
+ check_dtype(
+ dtype,
+ 'dtype',
+ ['float16', 'float32', 'int'],
+ 'fluid.layers.gaussian_random_batch_size_like',
+ )
+ out = helper.create_variable_for_type_inference(dtype)
+ c_dtype = convert_np_dtype_to_dtype_(dtype)
+ helper.append_op(
+ type='gaussian_random_batch_size_like',
+ inputs={'Input': input},
+ outputs={'Out': out},
+ attrs={
+ 'shape': shape,
+ 'input_dim_idx': input_dim_idx,
+ 'output_dim_idx': output_dim_idx,
+ 'mean': mean,
+ 'std': std,
+ 'seed': seed,
+ 'dtype': c_dtype,
+ },
+ )
+
+ return out
+
+
+@templatedoc()
+def sum(x):
+ """
+ ${comment}
+
+ Case 1:
+ ::
+ Input:
+ Input. Shape = [2, 3]
+ Input = [[1, 2, 3],
+ [4, 5, 6]]
+
+ Output:
+ The output. Shape = [2, 3]
+ Output = [[1, 2, 3],
+ [4, 5, 6]]
+
+ Case 2:
+ ::
+ Input:
+ First input:
+ Input1. Shape = [2, 3]
+ Input1 = [[1, 2, 3],
+ [4, 5, 6]]
+
+ The second input:
+ Input2. Shape = [2, 3]
+ Input2 = [[7, 8, 9],
+ [10, 11, 12]]
+
+ Output:
+ The output. Shape = [2, 3]
+ Output = [[8, 10, 12],
+ [14, 16, 18]]
+
+ Args:
+ x (Variable|list(Variable)): ${x_comment}
+
+ Returns:
+ Variable: ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ input0 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=5)
+ input1 = fluid.layers.fill_constant(shape=[2, 3], dtype='int64', value=3)
+ sum = fluid.layers.sum([input0, input1])
+
+ # You can print out 'sum' via executor.
+ out = fluid.layers.Print(sum, message="the sum of input0 and input1: ")
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_main_program())
+
+ # The printed result is:
+ # 1570701754 the sum of input0 and input1: The place is:CPUPlace
+ # Tensor[sum_0.tmp_0]
+ # shape: [2,3,]
+ # dtype: l
+ # data: 8,8,8,8,8,8,
+
+ # the sum of input0 and input1 is 2-D Tensor with shape [2,3].
+ # dtype is the corresponding C++ data type, which may vary in different environments.
+ # Eg: if the data type of tensor is int64, then the corresponding C++ data type is int64_t,
+ # so the dtype value is typeid(int64_t).Name(), which is 'x' on MacOS, 'l' on Linux,
+ # and '__int64' on Windows. They both represent 64-bit integer variables.
+ """
+
+ return paddle.add_n(x)
+
+
+@templatedoc()
+def slice(input, axes, starts, ends):
+ """
+ This operator produces a slice of ``input`` along multiple axes. Similar to numpy:
+ https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
+ Slice uses ``axes``, ``starts`` and ``ends`` attributes to specify the start and
+ end dimension for each axis in the list of axes and Slice uses this information
+ to slice the input data tensor. If a negative value is passed to
+ ``starts`` or ``ends`` such as :math:`-i`, it represents the reverse position of the
+ axis :math:`i-1` (here 0 is the initial position).
+ If the value passed to ``starts`` or ``ends`` is greater than n
+ (the number of elements in this dimension), it represents n.
+ For slicing to the end of a dimension with unknown size, it is recommended
+ to pass in INT_MAX. The size of ``axes`` must be equal to ``starts`` and ``ends``.
+ Following examples will explain how slice works:
+
+ .. code-block:: text
+
+ Case1:
+ Given:
+ data = [ [1, 2, 3, 4], [5, 6, 7, 8], ]
+ axes = [0, 1]
+ starts = [1, 0]
+ ends = [2, 3]
+ Then:
+ result = [ [5, 6, 7], ]
+
+ Case2:
+ Given:
+ data = [ [1, 2, 3, 4], [5, 6, 7, 8], ]
+ axes = [0, 1]
+ starts = [0, 1]
+ ends = [-1, 1000] # -1 denotes the reverse 0th position of dimension 0.
+ Then:
+ result = [ [2, 3, 4], ] # result = data[0:1, 1:4]
+
+ Args:
+ input (Tensor): A ``Tensor`` . The data type is ``float16``, ``float32``, ``float64``, ``int32`` or ``int64``.
+ axes (list|tuple): The data type is ``int32`` . Axes that `starts` and `ends` apply to .
+ starts (list|tuple|Tensor): The data type is ``int32`` . If ``starts`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``starts`` is an Tensor, it should be an 1-D Tensor.
+ It represents starting indices of corresponding axis in ``axes``.
+ ends (list|tuple|Tensor): The data type is ``int32`` . If ``ends`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``ends`` is an Tensor, it should be an 1-D Tensor .
+ It represents ending indices of corresponding axis in ``axes``.
+
+ Returns:
+ Tensor: A ``Tensor``. The data type is same as ``input``.
+
+ Raises:
+ TypeError: The type of ``starts`` must be list, tuple or Tensor.
+ TypeError: The type of ``ends`` must be list, tuple or Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ input = paddle.rand(shape=[4, 5, 6], dtype='float32')
+ # example 1:
+ # attr starts is a list which doesn't contain tensor.
+ axes = [0, 1, 2]
+ starts = [-3, 0, 2]
+ ends = [3, 2, 4]
+ sliced_1 = paddle.slice(input, axes=axes, starts=starts, ends=ends)
+ # sliced_1 is input[0:3, 0:2, 2:4].
+
+ # example 2:
+ # attr starts is a list which contain tensor.
+ minus_3 = paddle.full([1], -3, "int32")
+ sliced_2 = paddle.slice(input, axes=axes, starts=[minus_3, 0, 2], ends=ends)
+ # sliced_2 is input[0:3, 0:2, 2:4].
+ """
+ if in_dygraph_mode():
+ attrs = ()
+ starts_tensor = None
+ ends_tensor = None
+
+ if isinstance(axes, (list, tuple)):
+ axes = list(axes)
+ if len(axes) == 0:
+ raise ValueError(
+ "Input axes should not be an empty list/tuple."
+ )
+ for i in range(len(axes)):
+ if axes[i] < 0:
+ axes[i] = max(0, axes[i] + len(input.shape))
+ else:
+ axes[i] = min(len(input.shape) - 1, axes[i])
+
+ else:
+ raise ValueError(
+ "Input axes must be a python list or tuple, but reveived {}".format(
+ type(axes)
+ )
+ )
+
+ infer_flags = list(1 for i in range(len(axes)))
+
+ tmp_tensor_type = core.eager.Tensor
+ if isinstance(starts, (list, tuple)):
+ starts = [
+ item.numpy().item(0)
+ if isinstance(item, tmp_tensor_type)
+ else item
+ for item in starts
+ ]
+ elif isinstance(starts, tmp_tensor_type):
+ tensor_t = starts.numpy()
+ starts = [ele for ele in tensor_t]
+
+ if isinstance(ends, (list, tuple)):
+ ends = [
+ item.numpy().item(0)
+ if isinstance(item, tmp_tensor_type)
+ else item
+ for item in ends
+ ]
+ attrs += ('ends', ends)
+ elif isinstance(ends, tmp_tensor_type):
+ tensor_t = ends.numpy()
+ ends = [ele for ele in tensor_t]
+
+ return _C_ops.slice(input, axes, starts, ends, infer_flags, [])
+ else:
+ if _in_legacy_dygraph():
+ attrs = ()
+ starts_tensor = None
+ ends_tensor = None
+
+ if isinstance(axes, (list, tuple)):
+ axes = list(axes)
+ if len(axes) == 0:
+ raise ValueError(
+ "Input axes should not be an empty list/tuple."
+ )
+ for i in range(len(axes)):
+ if axes[i] < 0:
+ axes[i] = max(0, axes[i] + len(input.shape))
+ else:
+ axes[i] = min(len(input.shape) - 1, axes[i])
+
+ else:
+ raise ValueError(
+ "Input axes must be a python list or tuple, but reveived {}".format(
+ type(axes)
+ )
+ )
+
+ infer_flags = list(1 for i in range(len(axes)))
+
+ tmp_tensor_type = Variable
+
+ if isinstance(starts, (list, tuple)):
+ starts = [
+ item.numpy().item(0)
+ if isinstance(item, tmp_tensor_type)
+ else item
+ for item in starts
+ ]
+ attrs += ('starts', starts)
+ elif isinstance(starts, tmp_tensor_type):
+ starts_tensor = starts
+ starts.stop_gradient = True
+ infer_flags = list(-1 for i in range(len(axes)))
+
+ if isinstance(ends, (list, tuple)):
+ ends = [
+ item.numpy().item(0)
+ if isinstance(item, tmp_tensor_type)
+ else item
+ for item in ends
+ ]
+ attrs += ('ends', ends)
+ elif isinstance(ends, tmp_tensor_type):
+ ends_tensor = ends
+ ends_tensor.stop_gradient = True
+ infer_flags = list(-1 for i in range(len(axes)))
+
+ return _legacy_C_ops.slice(
+ input,
+ starts_tensor,
+ ends_tensor,
+ None,
+ None,
+ 'axes',
+ axes,
+ 'infer_flags',
+ infer_flags,
+ *attrs,
+ )
+
+ if not isinstance(starts, (list, tuple, Variable)):
+ raise ValueError(
+ "Input starts must be an Variable, python list or tuple."
+ )
+ if not isinstance(ends, (list, tuple, Variable)):
+ raise ValueError(
+ "Input ends must be an Variable, python list or tuple."
+ )
+
+ helper = LayerHelper('slice', **locals())
+
+ inputs = {'Input': input}
+ attrs = {'axes': axes}
+ infer_flags = list(1 for i in range(len(axes)))
+
+ # starts
+ if isinstance(starts, Variable):
+ starts.stop_gradient = True
+ inputs['StartsTensor'] = starts
+ infer_flags = list(-1 for i in range(len(axes)))
+ elif isinstance(starts, (list, tuple)):
+ attrs['starts'] = []
+ if utils._contain_var(starts):
+ inputs['StartsTensorList'] = utils._convert_to_tensor_list(starts)
+ for i, dim in enumerate(starts):
+ if isinstance(dim, Variable):
+ attrs['starts'].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs['starts'].append(dim)
+ else:
+ attrs['starts'] = starts
+
+ # ends
+ if isinstance(ends, Variable):
+ ends.stop_gradient = True
+ inputs['EndsTensor'] = ends
+ infer_flags = list(-1 for i in range(len(axes)))
+ elif isinstance(ends, (list, tuple)):
+ attrs['ends'] = []
+ if utils._contain_var(ends):
+ inputs['EndsTensorList'] = utils._convert_to_tensor_list(ends)
+ for i, dim in enumerate(ends):
+ if isinstance(dim, Variable):
+ attrs['ends'].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs['ends'].append(dim)
+ else:
+ attrs['ends'] = ends
+
+ # infer_flags
+ attrs['infer_flags'] = infer_flags
+ out = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype('input')
+ )
+ helper.append_op(
+ type='slice', inputs=inputs, attrs=attrs, outputs={'Out': out}
+ )
+
+ return out
+
+
+@deprecated(since='2.0.0', update_to="paddle.strided_slice")
+def strided_slice(input, axes, starts, ends, strides):
+ """
+ :alias_main: paddle.strided_slice
+ :alias: paddle.strided_slice,paddle.tensor.strided_slice,paddle.tensor.manipulation.strided_slice
+ :old_api: paddle.fluid.layers.strided_slice
+
+ This operator produces a slice of ``input`` along multiple axes. Similar to numpy:
+ https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html
+ Slice uses ``axes``, ``starts`` and ``ends`` attributes to specify the start and
+ end dimension for each axis in the list of axes and Slice uses this information
+ to slice the input data tensor. If a negative value is passed to
+ ``starts`` or ``ends`` such as :math:`-i`, it represents the reverse position of the
+ axis :math:`i-1` th(here 0 is the initial position). The ``strides`` represents steps of
+ slicing and if the ``strides`` is negative, slice operation is in the opposite direction.
+ If the value passed to ``starts`` or ``ends`` is greater than n
+ (the number of elements in this dimension), it represents n.
+ For slicing to the end of a dimension with unknown size, it is recommended
+ to pass in INT_MAX. The size of ``axes`` must be equal to ``starts`` , ``ends`` and ``strides``.
+ Following examples will explain how strided_slice works:
+
+ .. code-block:: text
+
+ Case1:
+ Given:
+ data = [ [1, 2, 3, 4], [5, 6, 7, 8], ]
+ axes = [0, 1]
+ starts = [1, 0]
+ ends = [2, 3]
+ strides = [1, 1]
+ Then:
+ result = [ [5, 6, 7], ]
+
+ Case2:
+ Given:
+ data = [ [1, 2, 3, 4], [5, 6, 7, 8], ]
+ axes = [0, 1]
+ starts = [0, 1]
+ ends = [2, 0]
+ strides = [1, -1]
+ Then:
+ result = [ [8, 7, 6], ]
+
+ Case3:
+ Given:
+ data = [ [1, 2, 3, 4], [5, 6, 7, 8], ]
+ axes = [0, 1]
+ starts = [0, 1]
+ ends = [-1, 1000]
+ strides = [1, 3]
+ Then:
+ result = [ [2], ]
+ Args:
+ input (Variable): An N-D ``Tensor`` or ``LoDTensor`` . The data type is ``bool``, ``float32``, ``float64``, ``int32`` or ``int64``.
+ axes (list|tuple): The data type is ``int32`` . Axes that `starts` and `ends` apply to.
+ It's optional. If it is not provides, it will be treated as :math:`[0,1,...,len(starts)-1]`.
+ starts (list|tuple|Variable): The data type is ``int32`` . If ``starts`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``starts`` is an Variable, it should be an 1-D Tensor.
+ It represents starting indices of corresponding axis in ``axes``.
+ ends (list|tuple|Variable): The data type is ``int32`` . If ``ends`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``ends`` is an Variable, it should be an 1-D Tensor .
+ It represents ending indices of corresponding axis in ``axes``.
+ strides (list|tuple|Variable): The data type is ``int32`` . If ``strides`` is a list or tuple, the elements of
+ it should be integers or Tensors with shape [1]. If ``strides`` is an Variable, it should be an 1-D Tensor .
+ It represents slice step of corresponding axis in ``axes``.
+
+ Returns:
+ Variable: A ``Tensor`` or ``LoDTensor`` with the same dimension as ``input``. The data type is same as ``input``.
+
+ Raises:
+ TypeError: The type of ``starts`` must be list, tuple or Variable.
+ TypeError: The type of ``ends`` must be list, tuple or Variable.
+ TypeError: The type of ``strides`` must be list, tuple or Variable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ input = fluid.data(
+ name="input", shape=[3, 4, 5, 6], dtype='float32')
+
+ # example 1:
+ # attr starts is a list which doesn't contain tensor Variable.
+ axes = [0, 1, 2]
+ starts = [-3, 0, 2]
+ ends = [3, 2, 4]
+ strides_1 = [1, 1, 1]
+ strides_2 = [1, 1, 2]
+ sliced_1 = fluid.layers.strided_slice(input, axes=axes, starts=starts, ends=ends, strides=strides_1)
+ # sliced_1 is input[:, 0:3:1, 0:2:1, 2:4:1].
+
+
+ # example 2:
+ # attr starts is a list which contain tensor Variable.
+ minus_3 = fluid.layers.fill_constant([1], "int32", -3)
+ sliced_2 = fluid.layers.strided_slice(input, axes=axes, starts=[minus_3, 0, 2], ends=ends, strides=strides_2)
+ # sliced_2 is input[:, 0:3:1, 0:2:1, 2:4:2].
+ """
+ if in_dygraph_mode():
+ return _C_ops.strided_slice(input, axes, starts, ends, strides)
+
+ helper = LayerHelper('strided_slice', **locals())
+
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['bool', 'float32', 'float64', 'int32', 'int64'],
+ 'strided_slice',
+ )
+ check_type(axes, 'axes', (list, tuple), 'strided_slice')
+ check_type(starts, 'starts', (list, tuple, Variable), 'strided_slice')
+ check_type(ends, 'ends', (list, tuple, Variable), 'strided_slice')
+ check_type(strides, 'strides', (list, tuple, Variable), 'strided_slice')
+
+ def check_list_elements_dtype(list_input, input_name):
+ if isinstance(list_input, Variable):
+ check_dtype(
+ list_input.dtype, input_name, ['int32'], 'strided_slice'
+ )
+ else:
+ for i, var in enumerate(list_input):
+ var_name = input_name + '[' + str(i) + ']'
+ if isinstance(var, Variable):
+ check_dtype(var.dtype, var_name, ['int32'], 'strided_slice')
+
+ check_list_elements_dtype(axes, 'axes')
+ check_list_elements_dtype(starts, 'starts')
+ check_list_elements_dtype(ends, 'ends')
+ check_list_elements_dtype(strides, 'strides')
+
+ def get_new_list_tensor(old_list):
+ new_list_tensor = []
+ for dim in old_list:
+ if isinstance(dim, Variable):
+ dim.stop_gradient = True
+ new_list_tensor.append(dim)
+ else:
+ assert isinstance(dim, int)
+ temp_out = helper.create_variable_for_type_inference('int32')
+ fill_constant([1], 'int32', dim, force_cpu=True, out=temp_out)
+ new_list_tensor.append(temp_out)
+ return new_list_tensor
+
+ inputs = {'Input': input}
+ attrs = {'axes': axes}
+ infer_flags = list(1 for i in range(len(axes)))
+
+ if _non_static_mode():
+ inputs = {'Input': input}
+ attrs = {
+ 'axes': axes,
+ 'starts': starts,
+ 'ends': ends,
+ 'strides': strides,
+ 'infer_flags': infer_flags,
+ }
+ else:
+ # starts
+ if isinstance(starts, Variable):
+ starts.stop_gradient = True
+ inputs['StartsTensor'] = starts
+ elif isinstance(starts, (list, tuple)):
+ attrs['starts'] = []
+ if utils._contain_var(starts):
+ inputs['StartsTensorList'] = get_new_list_tensor(starts)
+ for i, dim in enumerate(starts):
+ if isinstance(dim, Variable):
+ attrs['starts'].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs['starts'].append(dim)
+ else:
+ attrs['starts'] = starts
+
+ # ends
+ if isinstance(ends, Variable):
+ ends.stop_gradient = True
+ inputs['EndsTensor'] = ends
+ elif isinstance(ends, (list, tuple)):
+ attrs['ends'] = []
+ if utils._contain_var(ends):
+ inputs['EndsTensorList'] = get_new_list_tensor(ends)
+ for i, dim in enumerate(ends):
+ if isinstance(dim, Variable):
+ attrs['ends'].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs['ends'].append(dim)
+ else:
+ attrs['ends'] = ends
+
+ # strides
+ if isinstance(strides, Variable):
+ strides.stop_gradient = True
+ inputs['StridesTensor'] = strides
+ elif isinstance(strides, (list, tuple)):
+ attrs['strides'] = []
+ if utils._contain_var(strides):
+ inputs['StridesTensorList'] = get_new_list_tensor(strides)
+ for i, dim in enumerate(strides):
+ if isinstance(dim, Variable):
+ attrs['strides'].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs['strides'].append(dim)
+ else:
+ attrs['strides'] = strides
+ attrs['infer_flags'] = infer_flags
+ out = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype('input')
+ )
+ helper.append_op(
+ type='strided_slice', inputs=inputs, attrs=attrs, outputs={'Out': out}
+ )
+
+ return out
+
+
+def shape(input):
+ """
+ :alias_main: paddle.shape
+ :alias: paddle.shape,paddle.tensor.shape,paddle.tensor.attribute.shape
+ :old_api: paddle.fluid.layers.shape
+
+ **Shape Layer**
+
+ Get the shape of the input.
+
+ .. code-block:: text
+
+ Case1:
+ Given N-D Tensor:
+ input = [ [1, 2, 3, 4], [5, 6, 7, 8] ]
+
+ Then:
+ input.shape = [2, 4]
+
+ Case2:
+ Given SelectedRows:
+ input.rows = [0, 4, 19]
+ input.height = 20
+ input.value = [ [1, 2], [3, 4], [5, 6] ] # inner tensor
+ Then:
+ input.shape = [3, 2]
+
+ Args:
+ input (Variable): The input can be N-D Tensor or SelectedRows with data type bool, float16, float32, float64, int32, int64.
+ If input variable is type of SelectedRows, returns the shape of it's inner tensor.
+
+ Returns:
+ Variable (Tensor): The shape of the input variable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ inputs = fluid.data(name="x", shape=[3, 100, 100], dtype="float32")
+ output = fluid.layers.shape(inputs)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+
+ img = np.ones((3, 100, 100)).astype(np.float32)
+
+ res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output])
+ print(res) # [array([ 3, 100, 100], dtype=int32)]
+ """
+ if in_dygraph_mode():
+ out = _C_ops.shape(input)
+ out.stop_gradient = True
+ return out
+ if _in_legacy_dygraph():
+ out = _legacy_C_ops.shape(input)
+ out.stop_gradient = True
+ return out
+
+ check_variable_and_dtype(
+ input,
+ 'input',
+ [
+ 'bool',
+ 'float16',
+ 'float32',
+ 'float64',
+ 'int32',
+ 'int64',
+ 'complex64',
+ 'complex128',
+ ],
+ 'shape',
+ )
+ helper = LayerHelper('shape', **locals())
+ out = helper.create_variable_for_type_inference(dtype='int32')
+ helper.append_op(
+ type='shape',
+ inputs={'Input': input},
+ outputs={'Out': out},
+ stop_gradient=True,
+ )
+
+ return out
+
+
+def rank(input):
+ """
+
+ The OP returns the number of dimensions for a tensor, which is a 0-D int32 Tensor.
+
+ Args:
+ input (Tensor): The input N-D tensor with shape of :math:`[N_1, N_2, ..., N_k]`, the data type is arbitrary.
+
+ Returns:
+ Tensor, the output data type is int32.: The 0-D tensor with the dimensions of the input Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ input = paddle.rand((3, 100, 100))
+ rank = paddle.rank(input)
+ print(rank)
+ # 3
+ """
+ check_type(input, 'input', (Variable), 'input')
+ ndims = len(input.shape)
+ out = assign(np.array(ndims, 'int32'))
+
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.numel")
+def size(input):
+ """
+ **Size Layer**
+
+ Returns the number of elements for a tensor, which is a int64 Tensor with shape [1].
+
+ Args:
+ input (Tensor): The input Tensor, it's data type can be bool, float16, float32, float64, int32, int64.
+
+ Returns:
+ Tensor: The number of elements for the input Tensor.
+
+ Raises:
+ TypeError: ``input`` must be a Tensor and the data type of ``input`` must be one of bool, float16, float32, float64, int32, int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid.layers as layers
+ paddle.enable_static()
+
+ input = layers.data(
+ name="input", shape=[3, 100], dtype="float32", append_batch_size=False)
+ rank = layers.size(input) # 300
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.size(input)
+
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.size(input)
+
+ check_variable_and_dtype(
+ input,
+ 'input',
+ ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
+ "size",
+ )
+ helper = LayerHelper('size', **locals())
+ out = helper.create_variable_for_type_inference(dtype='int64')
+ helper.append_op(type='size', inputs={'Input': input}, outputs={'Out': out})
+
+ return out
+
+
+def _elementwise_op(helper):
+ op_type = helper.layer_type
+ x = helper.kwargs.get('x', None)
+ y = helper.kwargs.get('y', None)
+
+ assert x is not None, 'x cannot be None in {}'.format(op_type)
+ assert y is not None, 'y cannot be None in {}'.format(op_type)
+ check_variable_and_dtype(
+ x,
+ 'x',
+ ['float16', 'uint16', 'float32', 'float64', 'int32', 'int64'],
+ op_type,
+ )
+ check_variable_and_dtype(
+ y,
+ 'y',
+ ['float16', 'uint16', 'float32', 'float64', 'int32', 'int64'],
+ op_type,
+ )
+
+ axis = helper.kwargs.get('axis', -1)
+ use_mkldnn = helper.kwargs.get('use_mkldnn', False)
+ name = helper.kwargs.get('name', None)
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type=op_type,
+ inputs={'X': x, 'Y': y},
+ outputs={'Out': out},
+ attrs={'axis': axis, 'use_mkldnn': use_mkldnn},
+ )
+ return helper.append_activation(out)
+
+
+def scale(x, scale=1.0, bias=0.0, bias_after_scale=True, act=None, name=None):
+ """
+
+ Putting scale and bias to the input Tensor as following:
+
+ ``bias_after_scale`` is True:
+
+ .. math::
+ Out=scale*X+bias
+
+ ``bias_after_scale`` is False:
+
+ .. math::
+ Out=scale*(X+bias)
+
+ Args:
+ x(Tensor): Input N-D Tensor of scale operator. Data type can be float32, float64, int8, int16, int32, int64, uint8.
+ scale(float|Tensor): The scale factor of the input, it should be a float number or a Tensor with shape [1] and data type as float32.
+ bias(float): The bias to be put on the input.
+ bias_after_scale(bool): Apply bias addition after or before scaling. It is useful for numeric stability in some circumstances.
+ act(str, optional): Activation applied to the output such as tanh, softmax, sigmoid, relu.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Tensor: Output tensor of scale operator, with shape and data type same as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ # scale as a float32 number
+ import paddle
+
+ data = paddle.randn(shape=[2,3], dtype='float32')
+ res = paddle.scale(data, scale=2.0, bias=1.0)
+
+ .. code-block:: python
+
+ # scale with parameter scale as a Tensor
+ import paddle
+
+ data = paddle.randn(shape=[2, 3], dtype='float32')
+ factor = paddle.to_tensor([2], dtype='float32')
+ res = paddle.scale(data, scale=factor, bias=1.0)
+
+ """
+
+ if in_dygraph_mode():
+ out = _C_ops.scale(x, scale, float(bias), bias_after_scale)
+ return dygraph_utils._append_activation_in_dygraph(out)
+ if _non_static_mode():
+ _scale = scale.numpy().item(0) if isinstance(scale, Variable) else scale
+ out = _legacy_C_ops.scale(
+ x,
+ 'scale',
+ float(_scale),
+ 'bias',
+ float(bias),
+ 'bias_after_scale',
+ bias_after_scale,
+ )
+ return dygraph_utils._append_activation_in_dygraph(out)
+
+ check_variable_and_dtype(
+ x,
+ "x",
+ [
+ 'float16',
+ 'uint16',
+ 'float32',
+ 'float64',
+ 'int8',
+ 'int16',
+ 'int32',
+ 'int64',
+ 'uint8',
+ ],
+ "scale",
+ )
+ inputs = {'X': [x]}
+ attrs = {
+ 'bias': float(bias),
+ 'bias_after_scale': bias_after_scale,
+ }
+ if isinstance(scale, Variable):
+ inputs['ScaleTensor'] = [scale]
+ else:
+ attrs['scale'] = float(scale)
+ helper = LayerHelper('scale', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type='scale', inputs=inputs, outputs={'Out': out}, attrs=attrs
+ )
+ return helper.append_activation(out)
+
+
+def elementwise_add(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_add(x, y)
+ # z = x + y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # [3., 8., 6.]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_add(x, y, axis=1)
+ # z = x + y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # z.shape=[2,3,4,5]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
+ "y": np.random.randint(1, 5, size=[5]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[5], dtype='float32')
+ z = fluid.layers.elementwise_add(x, y, axis=3)
+ # z = x + y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+ print(z_value) # z.shape=[2,3,4,5]
+
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x,
+ y,
+ axis=axis,
+ act=act,
+ op_name='elementwise_add',
+ use_mkldnn=_global_flags()["FLAGS_use_mkldnn"],
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_add', **locals()))
+
+
+@deprecated(since="2.0.0", update_to="paddle.divide")
+def elementwise_div(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_div(x, y)
+ # z = x / y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # [2., 0.6, 2.]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_div(x, y, axis=1)
+ # z = x / y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # z.shape=[2,3,4,5]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
+ "y": np.random.randint(1, 5, size=[5]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[5], dtype='float32')
+ z = fluid.layers.elementwise_div(x, y, axis=3)
+ # z = x / y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+ print(z_value) # z.shape=[2,3,4,5]
+
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_div'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_div', **locals()))
+
+
+def elementwise_sub(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_sub(x, y)
+ # z = x - y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # [1., -2., 2.]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_sub(x, y, axis=1)
+ # z = x - y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # z.shape=[2,3,4,5]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
+ "y": np.random.randint(1, 5, size=[5]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[5], dtype='float32')
+ z = fluid.layers.elementwise_sub(x, y, axis=3)
+ # z = x - y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+ print(z_value) # z.shape=[2,3,4,5]
+
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_sub'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_sub', **locals()))
+
+
+@deprecated(since="2.0.0", update_to="paddle.multiply")
+def elementwise_mul(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_mul(x, y)
+ # z = x * y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # [2., 15., 8.]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_mul(x, y, axis=1)
+ # z = x * y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) # z.shape=[2,3,4,5]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
+ "y": np.random.randint(1, 5, size=[5]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[5], dtype='float32')
+ z = fluid.layers.elementwise_mul(x, y, axis=3)
+ # z = x * y
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+ print(z_value) # z.shape=[2,3,4,5]
+
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_mul'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_mul', **locals()))
+
+
+def elementwise_max(x, y, axis=-1, act=None, name=None):
+ """
+ :alias_main: paddle.elementwise_max
+ :alias: paddle.elementwise_max,paddle.tensor.elementwise_max,paddle.tensor.math.elementwise_max
+ :old_api: paddle.fluid.layers.elementwise_max
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_max(x, y)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) #[2, 5, 4]
+
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_max(x, y, axis=1)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value)#[[[[1., 1., 1., 1., 1.] .... [1., 1., 1., 1., 1.]]]]
+
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_max'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_max', **locals()))
+
+
+def elementwise_min(x, y, axis=-1, act=None, name=None):
+ """
+ :alias_main: paddle.elementwise_min
+ :alias: paddle.elementwise_min,paddle.tensor.elementwise_min,paddle.tensor.math.elementwise_min
+ :old_api: paddle.fluid.layers.elementwise_min
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_min(x, y)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) #[1, 3, 2]
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.ones((2, 3, 4, 5)).astype('float32'),
+ "y": np.zeros((3, 4)).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[2,3,4,5], dtype='float32')
+ y = fluid.data(name="y", shape=[3,4], dtype='float32')
+ z = fluid.layers.elementwise_min(x, y, axis=1)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value)#[[[[0., 0., 0., 0., 0.] .... [0., 0., 0., 0., 0.]]]]
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_min'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_min', **locals()))
+
+
+def elementwise_pow(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([2, 3, 4]).astype('float32'),
+ "y": np.array([1, 5, 2]).astype('float32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='float32')
+ y = fluid.data(name="y", shape=[3], dtype='float32')
+ z = fluid.layers.elementwise_pow(x, y)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) #[2, 243, 16]
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_pow'
+ )
+ return _elementwise_op(LayerHelper('elementwise_pow', **locals()))
+
+
+@deprecated(since="2.0.0", update_to="paddle.remainder")
+def elementwise_mod(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([10, 15, 8]).astype('int32'),
+ "y": np.array([3, 6, 5]).astype('int32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='int32')
+ y = fluid.data(name="y", shape=[3], dtype='int32')
+ z = fluid.layers.elementwise_mod(x, y)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) #[1, 3, 3]
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_mod'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_mod', **locals()))
+
+
+@deprecated(since="2.0.0", update_to="paddle.floor_divide")
+def elementwise_floordiv(x, y, axis=-1, act=None, name=None):
+ """
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+
+ def gen_data():
+ return {
+ "x": np.array([10, 15, 8]).astype('int32'),
+ "y": np.array([3, 7, 5]).astype('int32')
+ }
+ paddle.enable_static()
+ x = fluid.data(name="x", shape=[3], dtype='int32')
+ y = fluid.data(name="y", shape=[3], dtype='int32')
+ z = fluid.layers.elementwise_floordiv(x, y)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ z_value = exe.run(feed=gen_data(),
+ fetch_list=[z.name])
+
+ print(z_value) #[3, 2, 1]
+ """
+ if _non_static_mode():
+ return _elementwise_op_in_dygraph(
+ x, y, axis=axis, act=act, op_name='elementwise_floordiv'
+ )
+
+ return _elementwise_op(LayerHelper('elementwise_floordiv', **locals()))
+
+
+for func in [
+ elementwise_add,
+ elementwise_div,
+ elementwise_sub,
+ elementwise_mul,
+ elementwise_max,
+ elementwise_pow,
+ elementwise_min,
+ elementwise_mod,
+ elementwise_floordiv,
+]:
+ op_proto = OpProtoHolder.instance().get_op_proto(func.__name__)
+
+ # insert the c++ doc string on top of python doc string
+ func.__doc__ = (
+ _generate_doc_string_(
+ op_proto,
+ additional_args_lines=[
+ "axis (int32, optional): If X.dimension != Y.dimension, \
+ Y.dimension must be a subsequence of x.dimension. \
+ And axis is the start dimension index for broadcasting Y onto X. ",
+ "act (string, optional): Activation applied to the output. \
+ Default is None. Details: :ref:`api_guide_activations_en` ",
+ "name (string, optional): Name of the output. \
+ Default is None. It's used to print debug info for developers. Details: \
+ :ref:`api_guide_Name` ",
+ ],
+ skip_attrs_set={
+ "x_data_format",
+ "y_data_format",
+ "axis",
+ "use_quantizer",
+ "mkldnn_data_type",
+ "Scale_x",
+ "Scale_y",
+ "Scale_out",
+ },
+ )
+ + """\n"""
+ + str(func.__doc__)
+ )
+
+ doc_list = func.__doc__.splitlines()
+
+ for idx, val in enumerate(doc_list):
+ if (
+ val.startswith("Warning: ")
+ and val.endswith(" instead.")
+ and "and will be removed in future versions." in val
+ ):
+ doc_list.insert(0, doc_list.pop(idx))
+ func.__doc__ = "\n" + "\n".join(i for i in doc_list)
+ break
+
+for func in []:
+ op_proto = OpProtoHolder.instance().get_op_proto(func.__name__)
+ func.__doc__ = _generate_doc_string_(
+ op_proto,
+ additional_args_lines=[
+ "act (basestring|None): Activation applied to the output.",
+ "name (basestring|None): Name of the output.",
+ ],
+ )
+ func.__doc__ = (
+ func.__doc__
+ + """
+
+Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ # example 1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
+ x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
+ y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
+ z0 = fluid.layers.%s(x0, y0)
+
+ # example 2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
+ x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
+ y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
+ z1 = fluid.layers.%s(x1, y1)
+
+ # example 3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
+ x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
+ y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
+ z2 = fluid.layers.%s(x2, y2, axis=2)
+
+ # example 4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
+ x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
+ y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
+ z3 = fluid.layers.%s(x3, y3, axis=1)
+
+ # example 5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
+ x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
+ y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
+ z4 = fluid.layers.%s(x4, y4, axis=0)
+
+ # example 6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
+ x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
+ y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
+ z5 = fluid.layers.%s(x5, y5, axis=0)
+ """
+ % (
+ func.__name__,
+ func.__name__,
+ func.__name__,
+ func.__name__,
+ func.__name__,
+ func.__name__,
+ )
+ )
+
+
+def _logical_op(op_name, x, y, out=None, name=None, binary_op=True):
+ if _non_static_mode():
+ op = getattr(_legacy_C_ops, op_name)
+ if binary_op:
+ return op(x, y)
+ else:
+ return op(x)
+ check_variable_and_dtype(
+ x,
+ "x",
+ ["bool", "int8", "int16", "int32", "int64", "float32", "float64"],
+ op_name,
+ )
+ if y is not None:
+ check_variable_and_dtype(
+ y,
+ "y",
+ ["bool", "int8", "int16", "int32", "int64", "float32", "float64"],
+ op_name,
+ )
+ if out is not None:
+ check_type(out, "out", Variable, op_name)
+
+ helper = LayerHelper(op_name, **locals())
+
+ if binary_op and x.dtype != y.dtype:
+ raise ValueError(
+ "(InvalidArgument) The DataType of %s Op's Variable must be consistent, but received %s and %s."
+ % (op_name, x.dtype, y.dtype)
+ )
+
+ if out is None:
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ if binary_op:
+ helper.append_op(
+ type=op_name, inputs={"X": x, "Y": y}, outputs={"Out": out}
+ )
+ else:
+ helper.append_op(type=op_name, inputs={"X": x}, outputs={"Out": out})
+
+ return out
+
+
+def logical_and(x, y, out=None, name=None):
+ r"""
+
+ ``logical_and`` operator computes element-wise logical AND on ``x`` and ``y``, and returns ``out``. ``out`` is N-dim boolean ``Tensor``.
+ Each element of ``out`` is calculated by
+
+ .. math::
+
+ out = x \&\& y
+
+ .. note::
+ ``paddle.logical_and`` supports broadcasting. If you want know more about broadcasting, please refer to :ref:`user_guide_broadcasting`.
+
+ Args:
+ x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ out(Tensor): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output.
+ name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([True])
+ y = paddle.to_tensor([True, False, True, False])
+ res = paddle.logical_and(x, y)
+ print(res) # [True False True False]
+ """
+ if in_dygraph_mode():
+ return _C_ops.logical_and(x, y)
+
+ return _logical_op(
+ op_name="logical_and", x=x, y=y, name=name, out=out, binary_op=True
+ )
+
+
+def logical_or(x, y, out=None, name=None):
+ """
+
+ ``logical_or`` operator computes element-wise logical OR on ``x`` and ``y``, and returns ``out``. ``out`` is N-dim boolean ``Tensor``.
+ Each element of ``out`` is calculated by
+
+ .. math::
+
+ out = x || y
+
+ .. note::
+ ``paddle.logical_or`` supports broadcasting. If you want know more about broadcasting, please refer to :ref:`user_guide_broadcasting`.
+
+ Args:
+ x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ out(Tensor): The ``Variable`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output.
+ name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ x_data = np.array([True, False], dtype=np.bool_).reshape(2, 1)
+ y_data = np.array([True, False, True, False], dtype=np.bool_).reshape(2, 2)
+ x = paddle.to_tensor(x_data)
+ y = paddle.to_tensor(y_data)
+ res = paddle.logical_or(x, y)
+ print(res) # [[ True True] [ True False]]
+ """
+ if in_dygraph_mode():
+ return _C_ops.logical_or(x, y)
+ return _logical_op(
+ op_name="logical_or", x=x, y=y, name=name, out=out, binary_op=True
+ )
+
+
+def logical_xor(x, y, out=None, name=None):
+ r"""
+
+ ``logical_xor`` operator computes element-wise logical XOR on ``x`` and ``y``, and returns ``out``. ``out`` is N-dim boolean ``Tensor``.
+ Each element of ``out`` is calculated by
+
+ .. math::
+
+ out = (x || y) \&\& !(x \&\& y)
+
+ .. note::
+ ``paddle.logical_xor`` supports broadcasting. If you want know more about broadcasting, please refer to :ref:`user_guide_broadcasting`.
+
+ Args:
+ x (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ y (Tensor): the input tensor, it's data type should be one of bool, int8, int16, in32, in64, float32, float64.
+ out(Tensor): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor`` will be created to save the output.
+ name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ N-D Tensor. A location into which the result is stored. It's dimension equals with ``x``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+
+ x_data = np.array([True, False], dtype=np.bool_).reshape([2, 1])
+ y_data = np.array([True, False, True, False], dtype=np.bool_).reshape([2, 2])
+ x = paddle.to_tensor(x_data)
+ y = paddle.to_tensor(y_data)
+ res = paddle.logical_xor(x, y)
+ print(res) # [[False, True], [ True, False]]
+ """
+ if in_dygraph_mode():
+ return _C_ops.logical_xor(x, y)
+
+ return _logical_op(
+ op_name="logical_xor", x=x, y=y, name=name, out=out, binary_op=True
+ )
+
+
+@templatedoc()
+def logical_not(x, out=None, name=None):
+ """
+
+ ``logical_not`` operator computes element-wise logical NOT on ``x``, and returns ``out``. ``out`` is N-dim boolean ``Variable``.
+ Each element of ``out`` is calculated by
+
+ .. math::
+
+ out = !x
+
+ Args:
+ x(Tensor): Operand of logical_not operator. Must be a Tensor of type bool, int8, int16, in32, in64, float32, or float64.
+ out(Tensor): The ``Tensor`` that specifies the output of the operator, which can be any ``Tensor`` that has been created in the program. The default value is None, and a new ``Tensor` will be created to save the output.
+ name(str|None): The default value is None. Normally there is no need for users to set this property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([True, False, True, False])
+ res = paddle.logical_not(x)
+ print(res) # [False True False True]
+ """
+ if in_dygraph_mode():
+ return _C_ops.logical_not(x)
+ return _logical_op(
+ op_name="logical_not", x=x, y=None, name=name, out=out, binary_op=False
+ )
+
+
+@templatedoc()
+def clip(x, min, max, name=None):
+ """
+ :old_api: paddle.fluid.layers.clip
+
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ min(float): ${min_comment}
+ max(float): ${max_comment}
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ ${out_comment}
+
+ Return Type:
+ ${out_type}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ input = fluid.data(
+ name='data', shape=[1], dtype='float32')
+ reward = fluid.layers.clip(x=input, min=-1.0, max=1.0)
+ """
+
+ helper = LayerHelper("clip", **locals())
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'clip')
+
+ if name is None:
+ name = unique_name.generate_with_ignorable_key(
+ ".".join([helper.name, 'tmp'])
+ )
+
+ out = helper.create_variable(
+ type=x.type, name=name, dtype=x.dtype, persistable=False
+ )
+
+ helper.append_op(
+ type="clip",
+ inputs={"X": x},
+ attrs={"min": min, "max": max},
+ outputs={"Out": out},
+ )
+
+ return out
+
+
+@templatedoc()
+def clip_by_norm(x, max_norm, name=None):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ max_norm(${max_norm_type}): ${max_norm_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Tensor:
+
+ out(${out_type}): ${out_comment}
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ input = paddle.to_tensor([[2.0, 2.0], [2.0, 2.0]], dtype='float32')
+ reward = fluid.layers.clip_by_norm(x=input, max_norm=1.0)
+ # [[0.5, 0.5], [0.5, 0.5]]
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.clip_by_norm(x, max_norm)
+ if _non_static_mode():
+ return _legacy_C_ops.clip_by_norm(x, 'max_norm', max_norm)
+
+ helper = LayerHelper("clip_by_norm", **locals())
+ check_variable_and_dtype(x, 'X', ['float32', 'float16'], 'clip_by_norm')
+ check_type(max_norm, 'max_norm', (float), 'clip_by_norm')
+
+ if name is None:
+ name = unique_name.generate_with_ignorable_key(
+ ".".join([helper.name, 'tmp'])
+ )
+
+ out = helper.create_variable(
+ type=x.type, name=name, dtype=x.dtype, persistable=False
+ )
+
+ helper.append_op(
+ type="clip_by_norm",
+ inputs={"X": x},
+ attrs={"max_norm": max_norm},
+ outputs={"Out": out},
+ )
+
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.mean")
+@templatedoc()
+def mean(x, name=None):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ name(basestring|None): Name of the output.
+
+ Returns:
+ out(${out_type}): ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ input = fluid.layers.data(
+ name='data', shape=[2, 3], dtype='float32')
+ mean = paddle.mean(input)
+ """
+
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.mean(x)
+ if in_dygraph_mode():
+ return _C_ops.mean_all(x)
+
+ helper = LayerHelper("mean", **locals())
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'mean')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type="mean", inputs={"X": x}, attrs={}, outputs={"Out": out}
+ )
+
+ return out
+
+
+@templatedoc()
+def merge_selected_rows(x, name=None):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ name(basestring|None): Name of the output.
+
+ Returns:
+ out(${out_type}): ${out_comment}
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ b = fluid.default_main_program().global_block()
+ var = b.create_var(
+ name="X", dtype="float32", persistable=True,
+ type=fluid.core.VarDesc.VarType.SELECTED_ROWS)
+ y = fluid.layers.merge_selected_rows(var)
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.merge_selected_rows(x)
+
+ helper = LayerHelper("merge_selected_rows", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type="merge_selected_rows",
+ inputs={"X": x},
+ attrs={},
+ outputs={"Out": out},
+ )
+ return out
+
+
+def mul(x, y, x_num_col_dims=1, y_num_col_dims=1, name=None):
+ """
+ Mul Operator.
+ This operator is used to perform matrix multiplication for input $x$ and $y$.
+ The equation is:
+
+ .. math::
+ Out = x * y
+
+ Both the input $x$ and $y$ can carry the LoD (Level of Details) information, or not. But the output only shares the LoD information with input $x$.
+
+ Args:
+ x (Variable): The first input Tensor/LoDTensor of mul_op.
+ y (Variable): The second input Tensor/LoDTensor of mul_op.
+ x_num_col_dims (int, optional): The mul_op can take tensors with more than two dimensions as its inputs. If the input $x$ is a tensor with more than two dimensions, $x$ will be flattened into a two-dimensional matrix first. The flattening rule is: the first `num_col_dims` will be flattened to form the first dimension of the final matrix (the height of the matrix), and the rest `rank(x) - num_col_dims` dimensions are flattened to form the second dimension of the final matrix (the width of the matrix). As a result, height of the flattened matrix is equal to the product of $x$'s first `x_num_col_dims` dimensions' sizes, and width of the flattened matrix is equal to the product of $x$'s last `rank(x) - num_col_dims` dimensions' size. For example, suppose $x$ is a 6-dimensional tensor with the shape [2, 3, 4, 5, 6], and `x_num_col_dims` = 3. Thus, the flattened matrix will have a shape [2 x 3 x 4, 5 x 6] = [24, 30]. Default is 1.
+ y_num_col_dims (int, optional): The mul_op can take tensors with more than two dimensions as its inputs. If the input $y$ is a tensor with more than two dimensions, $y$ will be flattened into a two-dimensional matrix first. The attribute `y_num_col_dims` determines how $y$ is flattened. See comments of `x_num_col_dims` for more details. Default is 1.
+ name (str, optional): Name of the output. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Returns:
+ Variable(Tensor/LoDTensor): The output Tensor/LoDTensor of mul op.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ dataX = fluid.layers.data(name="dataX", append_batch_size = False, shape=[2, 5], dtype="float32")
+ dataY = fluid.layers.data(name="dataY", append_batch_size = False, shape=[5, 3], dtype="float32")
+ output = fluid.layers.mul(dataX, dataY,
+ x_num_col_dims = 1,
+ y_num_col_dims = 1)
+
+
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.mul(
+ x,
+ y,
+ 'x_num_col_dims',
+ x_num_col_dims,
+ 'y_num_col_dims',
+ y_num_col_dims,
+ )
+
+ inputs = {"X": [x], "Y": [y]}
+ attrs = {"x_num_col_dims": x_num_col_dims, "y_num_col_dims": y_num_col_dims}
+ helper = LayerHelper("mul", **locals())
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'], 'mul')
+ check_variable_and_dtype(y, 'y', ['float16', 'float32', 'float64'], 'mul')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type="mul", inputs={"X": x, "Y": y}, attrs=attrs, outputs={"Out": out}
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.maxout")
+@templatedoc()
+def maxout(x, groups, name=None, axis=1):
+ """
+ ${comment}
+
+ Args:
+ x(${x_type}): ${x_comment}
+ groups(int): ${groups_comment}
+ axis(int, optional): ${axis_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable: ${out_comment}
+
+ Raises:
+ ValueError: If `axis` is not 1, -1 or 3.
+ ValueError: If the number of input channels can not be divisible by `groups`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ input = fluid.data(
+ name='data',
+ shape=[None, 256, 32, 32],
+ dtype='float32')
+ out = fluid.layers.maxout(input, groups=2)
+ """
+ return paddle.nn.functional.maxout(**locals())
+
+
+def space_to_depth(x, blocksize, name=None):
+ r"""
+
+ Gives a blocksize to space_to_depth the input LoDtensor with Layout: [batch, channel, height, width]
+
+ This op rearranges blocks of spatial data, into depth. More specifically, this op outputs a copy of \
+ theinput LoDtensor where values from the height and width dimensions are moved to the channel \
+ dimension.
+ The attr blocksize indicates the input block size.
+
+ space_to_depth will reorganize the elements of input with shape[batch, channel, height, width] \
+ according to blocksize to construct output with shape \
+ [batch, channel * blocksize * blocksize, height/blocksize, width/blocksize]:
+
+ - Non-overlapping blocks of size block_size x block size are rearranged into depth at each location.
+ - The Y, X coordinates within each block of the input become the high order component of the output channel index
+ - channel should be divisible by square of blocksize
+ - height, width should be divsible by blocksize
+
+ This OP is useful for resizing the activations between convolutions \
+ (but keeping all data)
+
+ .. code-block:: text
+
+ Given the input x with the shape [1, 1, 4, 4]:
+ x.data = [[[[1, 2, 5, 6],
+ [3, 4, 7, 8],
+ [9, 10, 13, 14],
+ [11, 12, 15, 16]]]]
+ blocksize = 2
+
+ then get the output with the shape [1, 4, 2, 2]:
+ out.data = [[[[1, 2], [3, 4]],
+ [[5, 6], [7, 8]],
+ [[9, 10], [11, 12]],
+ [[13, 14], [15, 16]]]]
+
+ Args:
+ x (Variable): The input, which should be 4 dims Tensor or LodTensor, with the shape \
+ [batch, channel, height, width]
+ blocksize (int): The blocksize to select the element on each feature map should be > 2
+ name(str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ Tensor, The output, which should be 4 dims Tensor or LodTensor, with the shape \
+ [batch, channel * blocksize * blocksize, height/blocksize, width/blocksize]
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import numpy as np
+ import paddle
+
+ paddle.enable_static()
+ data = fluid.data(
+ name='data', shape=[1, 4, 2, 2], dtype='float32')
+ space_to_depthed = fluid.layers.space_to_depth(
+ x=data, blocksize=2)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ data_np = np.arange(0,16).reshape((1,4,2,2)).astype('float32')
+
+ print(data_np)
+ #array([[[[ 0., 1.], [ 2., 3.]],
+ # [[ 4., 5.], [ 6., 7.]],
+ # [[ 8., 9.], [10., 11.]],
+ # [[12., 13.], [14., 15.]]]], dtype=float32)
+
+ out_main = exe.run(fluid.default_main_program(),
+ feed={'data': data_np},
+ fetch_list=[space_to_depthed])
+
+ print(out_main)
+ #[array([[[[ 0.]], [[ 4.]], [[ 1.]], [[ 5.]],
+ # [[ 8.]], [[12.]], [[ 9.]], [[13.]],
+ # [[ 2.]], [[ 6.]], [[ 3.]], [[ 7.]],
+ # [[10.]], [[14.]], [[11.]], [[15.]]]], dtype=float32)]
+
+ """
+
+ helper = LayerHelper("space_to_depth", **locals())
+
+ if not (isinstance(blocksize, int)):
+ raise ValueError("blocksize must be a python Int")
+
+ check_variable_and_dtype(
+ x,
+ 'x',
+ ['float16', 'float32', 'float64', 'int32', 'int64'],
+ 'space_to_depth',
+ )
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type="space_to_depth",
+ inputs={"X": x},
+ attrs={"blocksize": blocksize},
+ outputs={"Out": out},
+ )
+ return out
+
+
+def affine_channel(
+ x, scale=None, bias=None, data_layout='NCHW', name=None, act=None
+):
+ """
+
+ Applies a separate affine transformation to each channel of the input.
+ Useful for replacing spatial batch norm with its equivalent fixed
+ transformation. The input also can be 2D tensor and applies a affine
+ transformation in second dimension.
+
+ Args:
+ x (Variable): Feature map input can be a 4D tensor with order NCHW
+ or NHWC. It also can be a 2D tensor and the affine transformation
+ is applied in the second dimension.The data type is float32 or float64.
+ scale (Variable): 1D input of shape (C), the c-th element is the scale
+ factor of the affine transformation for the c-th channel of
+ the input.The data type is float32 or float64.
+ bias (Variable): 1D input of shape (C), the c-th element is the bias
+ of the affine transformation for the c-th channel of the input.
+ The data type is float32 or float64.
+ data_layout (str, optional): Specify the data format of the input, and the data format of the output
+ will be consistent with that of the input. An optional string from: `"NCHW"`, `"NHWC"`.
+ The default is `"NCHW"`. When it is `"NCHW"`, the data is stored in the order of:
+ `[batch_size, input_channels, input_height, input_width]`. If input is 2D Tensor, you can ignore
+ data_layout.
+ name (str, default None): The name of this layer. For more information,
+ please refer to :ref:`api_guide_Name` .
+ act (str, default None): Activation to be applied to the output of this layer.
+
+ Returns:
+ Variable: A tensor which has the same shape, data layout and data type with x.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ use_gpu = False
+ place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
+ exe = fluid.Executor(place)
+
+ data = fluid.data(name='data', shape=[None, 1, 2, 2], dtype='float32')
+ input_scale = fluid.layers.create_parameter(shape=[1], dtype="float32",
+ default_initializer=fluid.initializer.Constant(2.0))
+ input_bias = fluid.layers.create_parameter(shape=[1],dtype="float32",
+ default_initializer=fluid.initializer.Constant(0.5))
+ out = fluid.layers.affine_channel(data,scale=input_scale,
+ bias=input_bias)
+
+ exe.run(fluid.default_startup_program())
+ test_program = fluid.default_main_program().clone(for_test=True)
+
+ [out_array] = exe.run(test_program,
+ fetch_list=out,
+ feed={'data': np.ones([1,1,2,2]).astype('float32')})
+ # out_array is [[[[2.5, 2.5],
+ # [2.5, 2.5]]]] with shape: [1, 1, 2, 2]
+
+ """
+ helper = LayerHelper("affine_channel", **locals())
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'affine_channel')
+ check_type(scale, 'scale', (Variable, type(None)), 'affine_channel')
+ check_type(bias, 'bias', (Variable, type(None)), 'affine_channel')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(
+ type="affine_channel",
+ inputs={"X": x, 'Scale': scale, 'Bias': bias},
+ attrs={"data_layout": data_layout},
+ outputs={"Out": out},
+ )
+ return helper.append_activation(out)
+
+
+def similarity_focus(input, axis, indexes, name=None):
+ r"""
+ SimilarityFocus Operator
+
+ Generate a similarity focus mask with the same shape of input using the following method:
+
+ 1. Extract the 3-D tensor(here the first dimension is BatchSize) corresponding
+ to the axis according to the indexes. For example, if axis=1 and indexes=[a],
+ it will get the matrix T=X[:, a, :, :]. In this case, if the shape of input X
+ is (BatchSize, A, B, C), the shape of tensor T is (BatchSize, B, C).
+ 2. For each index, find the largest numbers in the tensor T, so that the same
+ row and same column has at most one number(what it means is that if the
+ largest number has been found in the i-th row and the j-th column, then
+ the numbers in the i-th row or j-th column will be skipped. And then the
+ next largest number will be selected from the remaining numbers. Obviously
+ there will be min(B, C) numbers), and mark the corresponding position of the
+ 3-D similarity focus mask as 1, otherwise as 0. Do elementwise-or for
+ each index.
+ 3. Broadcast the 3-D similarity focus mask to the same shape of input X.
+
+ Refer to `Similarity Focus Layer `_
+
+ .. code-block:: text
+
+ * Example :
+
+ Given a 4-D tensor x with the shape (BatchSize, C, A, B), where C is
+ the number of channels and the shape of feature map is (A, B):
+ x.shape = (2, 3, 2, 2)
+ x.data = [[[[0.8, 0.1],
+ [0.4, 0.5]],
+
+ [[0.9, 0.7],
+ [0.9, 0.9]],
+
+ [[0.8, 0.9],
+ [0.1, 0.2]]],
+
+
+ [[[0.2, 0.5],
+ [0.3, 0.4]],
+
+ [[0.9, 0.7],
+ [0.8, 0.4]],
+
+ [[0.0, 0.2],
+ [0.4, 0.7]]]]
+
+ Given axis: 1 (the axis of the channel)
+ Given indexes: [0]
+
+ then we get a 4-D tensor out with the same shape of input x:
+ out.shape = (2, 3, 2, 2)
+ out.data = [[[[1.0, 0.0],
+ [0.0, 1.0]],
+
+ [[1.0, 0.0],
+ [0.0, 1.0]],
+
+ [[1.0, 0.0],
+ [0.0, 1.0]]],
+
+ [[[0.0, 1.0],
+ [1.0, 0.0]],
+
+ [[0.0, 1.0],
+ [1.0, 0.0]],
+
+ [[0.0, 1.0],
+ [1.0, 0.0]]]]
+
+ Args:
+ input(Variable): The input tensor variable(default float). It should
+ be a 4-D tensor with shape [BatchSize, A, B, C]. Data type is
+ float32 or float64.
+ axis(int): Indicating the dimension to be selected. It can only be
+ 1, 2 or 3.
+ indexes(list): Indicating the indexes of the selected dimension.
+
+ Returns:
+ Variable: A tensor variable with the same shape and same type \
+ as the input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ data = fluid.data(
+ name='data', shape=[-1, 3, 2, 2], dtype='float32')
+ fluid.layers.similarity_focus(input=data, axis=1, indexes=[0])
+ """
+ helper = LayerHelper('similarity_focus', **locals())
+ # check attrs
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], "similarity_focus"
+ )
+ check_type(axis, 'axis', int, "similarity_focus")
+ check_type(indexes, 'indexes', list, "similarity_focus")
+ if axis != 1 and axis != 2 and axis != 3:
+ raise ValueError("axis must be 1, 2 or 3.")
+ if len(indexes) == 0:
+ raise ValueError("indexes can not be empty.")
+
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type='similarity_focus',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={"axis": axis, "indexes": indexes},
+ )
+ return out
+
+
+def hash(input, hash_size, num_hash=1, name=None):
+ """
+
+ This OP hash the input to an integer less than the hash_size.
+ The hash algorithm we used was xxHash - Extremely fast hash algorithm
+ (https://github.com/Cyan4973/xxHash/tree/v0.6.5)
+
+ Args:
+ input(Variable): A **Two-Dimensional** LoDTensor with type int32, int64.
+ **Only support LoDTensor**.
+ num_hash(int, optional): The times of hash, default is 1.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Variable: A LoDTensor with the same data type as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ place = fluid.core.CPUPlace()
+
+ x = fluid.data(name="x", shape=[2,2], dtype="int32", lod_level=1)
+ res = fluid.layers.hash(name="res", input=x, hash_size=1000, num_hash=4)
+
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ in1 = np.array([[1,2],[3,4]]).astype("int32")
+ print(in1)
+ x_i = fluid.create_lod_tensor(in1, [[0, 2]], place)
+ res = exe.run(fluid.default_main_program(), feed={'x':x_i}, fetch_list=[res], return_numpy=False)
+ print(np.array(res[0]))
+ # [[[722]
+ # [407]
+ # [337]
+ # [395]]
+ # [[603]
+ # [590]
+ # [386]
+ # [901]]]
+ """
+ check_variable_and_dtype(input, 'input', ['int32', 'int64'], 'hash')
+ check_type(hash_size, 'hash_size', int, 'hash')
+ check_type(num_hash, 'num_hash', int, 'hash')
+ helper = LayerHelper('hash', **locals())
+ out = helper.create_variable_for_type_inference(
+ helper.input_dtype(), stop_gradient=True
+ )
+ helper.append_op(
+ type='hash',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={'num_hash': num_hash, 'mod_by': hash_size},
+ )
+ return out
+
+
+@templatedoc()
+def grid_sampler(x, grid, name=None):
+ """
+
+ This operation samples input X by using bilinear interpolation based on
+ flow field grid, which is usually generated by :code:`affine_grid` . The grid of
+ shape [N, H, W, 2] is the concatenation of (x, y) coordinates
+ with shape [N, H, W] each, where x is indexing the 4th dimension
+ (in width dimension) of input data x and y is indexing the 3rd
+ dimension (in height dimension), finally results is the bilinear
+ interpolation value of 4 nearest corner points. The output tensor
+ shape will be [N, C, H, W].
+
+ .. code-block:: text
+
+ Step 1:
+ Get (x, y) grid coordinates and scale to [0, H-1/W-1].
+
+ .. code-block:: text
+
+ grid_x = 0.5 * (grid[:, :, :, 0] + 1) * (W - 1)
+ grid_y = 0.5 * (grid[:, :, :, 1] + 1) * (H - 1)
+
+ Step 2:
+ Indices input data X with grid (x, y) in each [H, W] area, and bilinear
+ interpolate point value by 4 nearest points.
+
+ wn ------- y_n ------- en
+ | | |
+ | d_n |
+ | | |
+ x_w --d_w-- grid--d_e-- x_e
+ | | |
+ | d_s |
+ | | |
+ ws ------- y_s ------- wn
+
+ x_w = floor(x) // west side x coord
+ x_e = x_w + 1 // east side x coord
+ y_n = floor(y) // north side y coord
+ y_s = y_s + 1 // south side y coord
+
+ d_w = grid_x - x_w // distance to west side
+ d_e = x_e - grid_x // distance to east side
+ d_n = grid_y - y_n // distance to north side
+ d_s = y_s - grid_y // distance to south side
+
+ wn = X[:, :, y_n, x_w] // north-west point value
+ en = X[:, :, y_n, x_e] // north-east point value
+ ws = X[:, :, y_s, x_w] // south-east point value
+ es = X[:, :, y_s, x_w] // north-east point value
+
+ output = wn * d_e * d_s + en * d_w * d_s
+ + ws * d_e * d_n + es * d_w * d_n
+
+ Args:
+ x(Variable): The input tensor, which is a 4-D tensor with shape
+ [N, C, H, W], N is the batch size, C is the channel
+ number, H and W is the feature height and width.
+ The data type is float32 or float64.
+ grid(Variable): Input grid tensor of shape [N, H, W, 2]. The
+ data type is float32 or float64.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable: Output of shape [N, C, H, W] data samples input X
+ using bilnear interpolation based on input grid.
+ The data type is same as input tensor.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid as fluid
+ import paddle
+
+ paddle.enable_static()
+ # use with affine_grid
+ x = fluid.data(name='x', shape=[None, 10, 32, 32], dtype='float32')
+ theta = fluid.layers.data(name='theta', shape=[2, 3], dtype='float32')
+ grid = fluid.layers.affine_grid(theta=theta, out_shape=[3, 10, 32, 32])
+ out = fluid.layers.grid_sampler(x=x, grid=grid)
+
+ """
+ helper = LayerHelper("grid_sampler", **locals())
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'grid_sampler')
+ check_variable_and_dtype(
+ grid, 'grid', ['float32', 'float64'], 'grid_sampler'
+ )
+ if not isinstance(x, Variable):
+ return ValueError("The x should be a Variable")
+
+ if not isinstance(grid, Variable):
+ return ValueError("The grid should be a Variable")
+
+ out = helper.create_variable_for_type_inference(x.dtype)
+ ipts = {'X': x, 'Grid': grid}
+
+ attrs = {'use_cudnn': False} if core.is_compiled_with_rocm() else {}
+
+ helper.append_op(
+ type='grid_sampler', inputs=ipts, outputs={'Output': out}, attrs=attrs
+ )
+ return out
+
+
+def log_loss(input, label, epsilon=1e-4, name=None):
+ r"""
+
+ **Negative Log Loss Layer**
+
+ This layer accepts input predictions and target label and returns the
+ negative log loss.
+
+ .. math::
+
+ Out = -label * \log{(input + \epsilon)}
+ - (1 - label) * \log{(1 - input + \epsilon)}
+
+ Args:
+ input (Tensor|list): A 2-D tensor with shape [N x 1], where N is the
+ batch size. This input is a probability computed
+ by the previous operator. Data type float32.
+ label (Tensor|list): The ground truth which is a 2-D tensor with
+ shape [N x 1], where N is the batch size.
+ Data type float32.
+ epsilon (float, optional): A small number for numerical stability. Default 1e-4.
+ name(str|None): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+
+ Returns:
+ Tensor, which shape is [N x 1], data type is float32.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ label = paddle.randn((10,1))
+ prob = paddle.randn((10,1))
+ cost = F.log_loss(input=prob, label=label)
+ """
+ return paddle.nn.functional.log_loss(input, label, epsilon, name)
+
+
+def add_position_encoding(input, alpha, beta, name=None):
+ r"""
+
+ This operator performs weighted sum of input feature at each position
+ (position in the sequence) and the corresponding position encoding.
+
+ For more details of position encoding, please refer to `Attention Is All You
+ Need `_ .
+
+ The formula is as follows:
+
+ .. math::
+ PE(pos, 2i) &= \\sin{(pos / 10000^{2i / P})} \\\\
+ PE(pos, 2i + 1) &= \\cos{(pos / 10000^{2i / P})} \\\\
+ Out(:, pos, i) &= \\alpha * input(:, pos, i) + \\beta * PE(pos, i)
+
+ Where:
+ - :math:`PE(pos, 2i)` : the value at even index `2i` for encoding of position `pos`.
+ - :math:`PE(pos, 2i + 1)` : the value at odd index `2i+1` for encoding of position `pos`
+
+ Args:
+ input(Variable): A Tensor or LoDTensor (lod level is 1). If it is a
+ Tensor, the shape should be `[N, M, P]`, where `N` stands for
+ batch size, `M` for sequence length, `P` for the size of feature
+ dimension. If it is a LoDTensor, the shape should be `[N, P]`,
+ where `N` stands for the total sequence lengths in this mini-batch,
+ `P` for the size of feature. The data type should be float32 or float64.
+ alpha(float): Indicate the weight coefficient for `input` when performing
+ weighted sum.
+ beta(float): Indicate the weight coefficient for position encoding when
+ performing weighted sum.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ Variable: A Tensor or LoDTensor. It has the same shape, data type and lod as `input`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ tensor = paddle.randn([16, 32, 64])
+ position_tensor = paddle.fluid.layers.add_position_encoding(
+ input=tensor, alpha=1.0, beta=1.0)
+
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.add_position_encoding(
+ input, "alpha", alpha, "beta", beta
+ )
+
+ helper = LayerHelper('add_position_encoding', **locals())
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], "add_position_encoding"
+ )
+ dtype = helper.input_dtype()
+
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+
+ helper.append_op(
+ type="add_position_encoding",
+ inputs={"X": input},
+ outputs={"Out": out},
+ attrs={"alpha": alpha, "beta": beta},
+ )
+ return out
+
+
+def bilinear_tensor_product(
+ x, y, size, act=None, name=None, param_attr=None, bias_attr=None
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Bilinear Tensor Product Layer**
+
+ This layer performs bilinear tensor product on two inputs.
+ For example:
+
+ .. math::
+ out_{i} = x * W_{i} * {y^\mathrm{T}}, i=0,1,...,size-1
+
+ In this formula:
+ - :math:`x`: the first input contains M elements, shape is [batch_size, M].
+ - :math:`y`: the second input contains N elements, shape is [batch_size, N].
+ - :math:`W_{i}`: the i-th learned weight, shape is [M, N].
+ - :math:`out_{i}`: the i-th element of out, shape is [batch_size, size].
+ - :math:`y^\mathrm{T}`: the transpose of :math:`y_{2}`.
+
+ Args:
+ x (Variable): 2-D input tensor with shape [batch_size, M]. Data type
+ is float32 or float64.
+ y (Variable): 2-D input tensor with shape [batch_size, N]. Data type
+ should be same as **x**.
+ size (int): The dimension of this layer.
+ act (str|None): Activation to be applied to the output of this layer. Default None.
+ name(str|None): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+ param_attr (ParamAttr|None): To specify the weight parameter attribute.
+ Default: None, which means the default weight parameter property is
+ used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr|None): To specify the bias parameter attribute.
+ Default: None, which means the default bias parameter property is
+ used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ Returns:
+ Variable: A 2-D Tensor of shape [batch_size, size]. Data type is the same as input **x**.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ layer1 = paddle.static.data("t1", shape=[-1, 5], dtype="float32")
+ layer2 = paddle.static.data("t2", shape=[-1, 4], dtype="float32")
+ tensor = paddle.static.nn.bilinear_tensor_product(x=layer1, y=layer2, size=1000)
+ """
+ helper = LayerHelper('bilinear_tensor_product', **locals())
+ dtype = helper.input_dtype('x')
+
+ param_shape = [size, x.shape[1], y.shape[1]]
+
+ w = helper.create_parameter(
+ attr=helper.param_attr, shape=param_shape, dtype=dtype, is_bias=False
+ )
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+
+ inputs = {"X": x, "Y": y, "Weight": w}
+ if helper.bias_attr:
+ bias_size = [1, size]
+ bias = helper.create_parameter(
+ attr=helper.bias_attr, shape=bias_size, dtype=dtype, is_bias=True
+ )
+ inputs["Bias"] = bias
+ helper.append_op(
+ type="bilinear_tensor_product", inputs=inputs, outputs={"Out": out}
+ )
+
+ # add activation
+ return helper.append_activation(out)
+
+
+@templatedoc()
+def get_tensor_from_selected_rows(x, name=None):
+ """
+ This operator gets tensor data from input with SelectedRows type, and outputs a LoDTensor.
+
+ .. code-block:: text
+
+ input x is SelectedRows:
+ x.rows = [0, 5, 5, 4, 19]
+ x.height = 20
+ x.value = [[1, 1] [2, 2] [2, 2] [3, 3] [6, 6]]
+
+ Output is LoDTensor:
+ out.shape = [5, 2]
+ out.data = [[1, 1],
+ [2, 2],
+ [2, 2],
+ [3, 3],
+ [6, 6]]
+
+ Args:
+ x(SelectedRows): Input with SelectedRows type. The data type is float32, float64, int32 or int64.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: LoDTensor transformed from SelectedRows. The data type is same with input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ b = fluid.default_main_program().global_block()
+ input = b.create_var(name="X", dtype="float32", persistable=True, type=fluid.core.VarDesc.VarType.SELECTED_ROWS)
+ out = fluid.layers.get_tensor_from_selected_rows(input)
+ """
+
+ check_type(x, 'x', Variable, 'get_tensor_from_selected_rows')
+ if x.type != core.VarDesc.VarType.SELECTED_ROWS:
+ raise TypeError(
+ "The type of 'x' in get_tensor_from_selected_rows must be SELECTED_ROWS."
+ )
+ helper = LayerHelper('get_tensor_from_selected_rows', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='get_tensor_from_selected_rows',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={},
+ )
+ return out
+
+
+def shuffle_channel(x, group, name=None):
+ """
+ This operator shuffles the channels of input x.
+ It divide the input channels in each group into :attr:`group` subgroups,
+ and obtain a new order by selecting element from every subgroup one by one.
+
+ Please refer to the paper
+ https://arxiv.org/pdf/1707.01083.pdf
+
+ .. code-block:: text
+
+ Given a 4-D tensor input with the shape (N, C, H, W):
+ input.shape = (1, 4, 2, 2)
+ input.data =[[[[0.1, 0.2],
+ [0.2, 0.3]],
+
+ [[0.3, 0.4],
+ [0.4, 0.5]],
+
+ [[0.5, 0.6],
+ [0.6, 0.7]],
+
+ [[0.7, 0.8],
+ [0.8, 0.9]]]]
+ Given group: 2
+ then we get a 4-D tensor out with the same shape of input:
+ out.shape = (1, 4, 2, 2)
+ out.data = [[[[0.1, 0.2],
+ [0.2, 0.3]],
+
+ [[0.5, 0.6],
+ [0.6, 0.7]],
+
+ [[0.3, 0.4],
+ [0.4, 0.5]],
+
+ [[0.7, 0.8],
+ [0.8, 0.9]]]]
+
+ Args:
+ x(Variable): The input tensor variable. It should be a 4-D tensor with shape [N, C, H, W]
+ group(int): Indicating the counts of subgroups, It should divide the number of channels.
+
+ Returns:
+ out(Variable): the channels shuffling result is a tensor variable with the
+ same shape and same type as the input.
+
+ Raises:
+ ValueError: If group is not an int type variable.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ input = fluid.data(name='input', shape=[None,4,2,2], dtype='float32')
+ out = fluid.layers.shuffle_channel(x=input, group=2)
+ """
+ helper = LayerHelper("shuffle_channel", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ if not isinstance(group, int):
+ raise TypeError("group must be int type")
+
+ helper.append_op(
+ type="shuffle_channel",
+ inputs={"X": x},
+ outputs={"Out": out},
+ attrs={"group": group},
+ )
+ return out
+
+
+@templatedoc()
+def temporal_shift(x, seg_num, shift_ratio=0.25, name=None, data_format="NCHW"):
+ """
+
+ **Temporal Shift Operator**
+
+ ${comment}
+
+ Args:
+ x(Tensor): ${x_comment}
+ seg_num(int): ${seg_num_comment}
+ shift_ratio(float): ${shift_ratio_comment}
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ data_format(str, optional): Data format that specifies the layout of input.
+ It can be "NCHW" or "NHWC". Default: "NCHW".
+
+ Returns:
+ out(Tensor): The temporal shifting result is a tensor with the
+ same shape and same data type as the input.
+
+ Raises:
+ TypeError: seg_num must be int type.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ input = paddle.randn([6, 4, 2, 2])
+ out = F.temporal_shift(x=input, seg_num=2, shift_ratio=0.2)
+ """
+ return paddle.nn.functional.temporal_shift(
+ x, seg_num, shift_ratio, name, data_format
+ )
+
+
+class PyFuncRegistry(object):
+ _register_funcs = []
+
+ def __init__(self, func):
+ if func is None or not callable(func):
+ raise TypeError('func must be a Python function')
+
+ self._func = func
+ # find named args using reflection
+ args = inspect.getargspec(self._func)
+ if len(args[0]) == 0 and args[1] is None and args[2] is None:
+ # Function with no inputs
+ self._named_args = None
+ else:
+ self._named_args = args[0]
+ self._id = core._append_python_callable_object_and_return_id(self)
+ '''
+ Why record self here?
+
+ 1. For debug usage. Users can call
+ :code:`py_func.registered_func(idx)` method
+ to find the registered function corresponding
+ to :code:`idx`.
+
+ 2. For increasing reference count of self.
+ It seems that to release Python object
+ whose reference count is 1 would cause
+ segmentation fault error in C++ side.
+ May be lack of Python GC in C++ side?
+ '''
+ PyFuncRegistry._register_funcs.append(self)
+
+ @classmethod
+ def registered_func(cls, idx):
+ return cls._register_funcs[idx]._func
+
+ @classmethod
+ def registered_func_num(cls):
+ return len(cls._register_funcs)
+
+ @property
+ def id(self):
+ return self._id
+
+ def __call__(self, *args):
+ if self._named_args is None:
+ func_ret = self._func()
+ else:
+ kwargs = dict()
+ idx = 0
+ for arg in self._named_args:
+ kwargs[arg] = args[idx]
+ idx += 1
+ func_ret = self._func(*args[idx:], **kwargs)
+
+ if not isinstance(func_ret, (list, tuple)):
+ func_ret = (func_ret,)
+
+ ret = []
+ for each_ret in func_ret:
+ if each_ret is None or isinstance(each_ret, core.LoDTensor):
+ ret.append(each_ret)
+ continue
+
+ if not isinstance(each_ret, np.ndarray):
+ each_ret = np.array(each_ret)
+
+ tensor = core.LoDTensor()
+ tensor.set(each_ret, core.CPUPlace())
+ ret.append(tensor)
+
+ return tuple(ret)
+
+
+@static_only
+@templatedoc()
+def py_func(func, x, out, backward_func=None, skip_vars_in_backward_input=None):
+ """
+ :api_attr: Static Graph
+
+ This OP is used to register customized Python OP to Paddle. The design
+ principe of py_func is that Tensor and numpy array can be converted to each
+ other easily. So you can use Python and numpy API to register a python OP.
+
+ The forward function of the registered OP is ``func`` and the backward function
+ of that is ``backward_func``. Paddle will call ``func`` at forward runtime and
+ call ``backward_func`` at backward runtime(if ``backward_func`` is not None).
+ ``x`` is the input of ``func``, whose type must be Tensor; ``out`` is
+ the output of ``func``, whose type can be either Tensor or numpy array.
+
+ The input of the backward function ``backward_func`` is ``x``, ``out`` and
+ the gradient of ``out``. If ``out`` have no gradient, the relevant input of
+ ``backward_func`` is None. If ``x`` do not have a gradient, the user should
+ return None in ``backward_func``.
+
+ The data type and shape of ``out`` should also be set correctly before this
+ API is called, and the data type and shape of the gradient of ``out`` and
+ ``x`` will be inferred automatically.
+
+ This API can also be used to debug the neural network by setting the ``func``
+ as a function that only print variables.
+
+ Args:
+ func (callable): The forward function of the registered OP. When the network
+ is running, the forward output ``out`` will be calculated according to this
+ function and the forward input ``x``. In ``func`` , it's suggested that we
+ actively convert Tensor into a numpy array, so that we can use Python and
+ numpy API arbitrarily. If not, some operations of numpy may not be compatible.
+ x (Tensor|tuple(Tensor)|list[Tensor]): The input of the forward function ``func``.
+ It can be Tensor|tuple(Tensor)|list[Tensor]. In addition, Multiple Tensor
+ should be passed in the form of tuple(Tensor) or list[Tensor].
+ out (T|tuple(T)|list[T]): The output of the forward function ``func``, it can be
+ T|tuple(T)|list[T], where T can be either Tensor or numpy array. Since Paddle
+ cannot automatically infer the shape and type of ``out``, you must create
+ ``out`` in advance.
+ backward_func (callable, optional): The backward function of the registered OP.
+ Its default value is None, which means there is no reverse calculation. If
+ it is not None, ``backward_func`` is called to calculate the gradient of
+ ``x`` when the network is at backward runtime.
+ skip_vars_in_backward_input (Tensor, optional): It's used to limit the input
+ list of ``backward_func``, and it can be Tensor|tuple(Tensor)|list[Tensor].
+ It must belong to either ``x`` or ``out``. The default value is None, which means
+ that no tensors need to be removed from ``x`` and ``out``. If it is not None,
+ these tensors will not be the input of ``backward_func``. This parameter is only
+ useful when ``backward_func`` is not None.
+
+ Returns:
+ Tensor|tuple(Tensor)|list[Tensor]: The output ``out`` of the forward function ``func``.
+
+ Examples:
+ .. code-block:: python
+
+ # example 1:
+ import paddle
+ import six
+ import numpy as np
+
+ paddle.enable_static()
+
+ # Creates a forward function, Tensor can be input directly without
+ # being converted into numpy array.
+ def tanh(x):
+ return np.tanh(x)
+
+ # Skip x in backward function and return the gradient of x
+ # Tensor must be actively converted to numpy array, otherwise,
+ # operations such as +/- can't be used.
+ def tanh_grad(y, dy):
+ return np.array(dy) * (1 - np.square(np.array(y)))
+
+ # Creates a forward function for debugging running networks(print value)
+ def debug_func(x):
+ print(x)
+
+ def create_tmp_var(name, dtype, shape):
+ return paddle.static.default_main_program().current_block().create_var(
+ name=name, dtype=dtype, shape=shape)
+
+ def simple_net(img, label):
+ hidden = img
+ for idx in six.moves.range(4):
+ hidden = paddle.static.nn.fc(hidden, size=200)
+ new_hidden = create_tmp_var(name='hidden_{}'.format(idx),
+ dtype=hidden.dtype, shape=hidden.shape)
+
+ # User-defined forward and backward
+ hidden = paddle.static.py_func(func=tanh, x=hidden,
+ out=new_hidden, backward_func=tanh_grad,
+ skip_vars_in_backward_input=hidden)
+
+ # User-defined debug functions that print out the input Tensor
+ paddle.static.py_func(func=debug_func, x=hidden, out=None)
+
+ prediction = paddle.static.nn.fc(hidden, size=10, activation='softmax')
+ ce_loss = paddle.nn.loss.CrossEntropyLoss()
+ return ce_loss(prediction, label)
+
+ x = paddle.static.data(name='x', shape=[1,4], dtype='float32')
+ y = paddle.static.data(name='y', shape=[1,10], dtype='int64')
+ res = simple_net(x, y)
+
+ exe = paddle.static.Executor(paddle.CPUPlace())
+ exe.run(paddle.static.default_startup_program())
+ input1 = np.random.random(size=[1,4]).astype('float32')
+ input2 = np.random.randint(1, 10, size=[1,10], dtype='int64')
+ out = exe.run(paddle.static.default_main_program(),
+ feed={'x':input1, 'y':input2},
+ fetch_list=[res.name])
+ print(out)
+
+ .. code-block:: python
+
+ # example 2:
+ # This example shows how to turn Tensor into numpy array and
+ # use numpy API to register an Python OP
+ import paddle
+ import numpy as np
+
+ paddle.enable_static()
+
+ def element_wise_add(x, y):
+ # Tensor must be actively converted to numpy array, otherwise,
+ # numpy.shape can't be used.
+ x = np.array(x)
+ y = np.array(y)
+
+ if x.shape != y.shape:
+ raise AssertionError("the shape of inputs must be the same!")
+
+ result = np.zeros(x.shape, dtype='int32')
+ for i in range(len(x)):
+ for j in range(len(x[0])):
+ result[i][j] = x[i][j] + y[i][j]
+
+ return result
+
+ def create_tmp_var(name, dtype, shape):
+ return paddle.static.default_main_program().current_block().create_var(
+ name=name, dtype=dtype, shape=shape)
+
+ def py_func_demo():
+ start_program = paddle.static.default_startup_program()
+ main_program = paddle.static.default_main_program()
+
+ # Input of the forward function
+ x = paddle.static.data(name='x', shape=[2,3], dtype='int32')
+ y = paddle.static.data(name='y', shape=[2,3], dtype='int32')
+
+ # Output of the forward function, name/dtype/shape must be specified
+ output = create_tmp_var('output','int32', [3,1])
+
+ # Multiple Variable should be passed in the form of tuple(Variale) or list[Variale]
+ paddle.static.py_func(func=element_wise_add, x=[x,y], out=output)
+
+ exe=paddle.static.Executor(paddle.CPUPlace())
+ exe.run(start_program)
+
+ # Feed numpy array to main_program
+ input1 = np.random.randint(1, 10, size=[2,3], dtype='int32')
+ input2 = np.random.randint(1, 10, size=[2,3], dtype='int32')
+ out = exe.run(main_program,
+ feed={'x':input1, 'y':input2},
+ fetch_list=[output.name])
+ print("{0} + {1} = {2}".format(input1, input2, out))
+
+ py_func_demo()
+
+ # Reference output:
+ # [[5, 9, 9] + [[7, 8, 4] = [array([[12, 17, 13]
+ # [7, 5, 2]] [1, 3, 3]] [8, 8, 5]], dtype=int32)]
+ """
+ helper = LayerHelper('py_func', **locals())
+ check_type(x, 'X', (list, tuple, Variable, type(None)), 'py_func')
+ if x is None:
+ x = []
+ elif isinstance(x, Variable):
+ x = [x]
+ elif isinstance(x, tuple):
+ x = list(x)
+ elif not isinstance(x, (list, tuple, Variable)):
+ raise TypeError('Input must be Variable/list(Variable)/tuple(Variable)')
+ check_type(out, 'Out', (list, tuple, Variable, type(None)), 'py_func')
+ if out is None:
+ out_list = []
+ elif isinstance(out, Variable):
+ out_list = [out]
+ elif isinstance(out, tuple):
+ out_list = list(out)
+ elif isinstance(out, list):
+ out_list = out
+ else:
+ raise TypeError(
+ 'Output must be Variable/list(Variable)/tuple(Variable)'
+ )
+
+ fwd_func_id = PyFuncRegistry(func).id
+ bwd_func_id = (
+ PyFuncRegistry(backward_func).id if backward_func is not None else -1
+ )
+
+ for each_out in out_list:
+ if len(each_out.shape) == 0:
+ raise ValueError(
+ 'Output shapes of py_func op should be provided by users manually'
+ )
+
+ backward_skip_vars = set()
+ if backward_func is not None and skip_vars_in_backward_input is not None:
+ if isinstance(skip_vars_in_backward_input, Variable):
+ skip_vars_in_backward_input = [skip_vars_in_backward_input]
+
+ fwd_in_out = [v.name for v in x]
+ fwd_in_out.extend([v.name for v in out_list])
+ fwd_in_out = set(fwd_in_out)
+ backward_skip_vars = set()
+ for v in skip_vars_in_backward_input:
+ if not v.name in fwd_in_out:
+ raise ValueError(
+ 'Variable {} is not found in forward inputs and outputs'.format(
+ v.name
+ )
+ )
+ backward_skip_vars.add(v.name)
+
+ helper.append_op(
+ type='py_func',
+ inputs={'X': x},
+ outputs={'Out': out_list},
+ attrs={
+ 'forward_callable_id': fwd_func_id,
+ 'backward_callable_id': bwd_func_id,
+ 'backward_skip_vars': list(backward_skip_vars),
+ },
+ )
+ return out
+
+
+# For debug usage
+py_func.registered_func = PyFuncRegistry.registered_func
+py_func.registered_func_num = PyFuncRegistry.registered_func_num
+
+
+@templatedoc()
+def psroi_pool(
+ input,
+ rois,
+ output_channels,
+ spatial_scale,
+ pooled_height,
+ pooled_width,
+ name=None,
+):
+ """
+
+ ${comment}
+
+ Parameters:
+ input (Variable): ${x_comment}
+ rois (Variable): LoDTensor, ROIs (Regions of Interest) to pool over.It should be
+ a 2-D LoDTensor of shape (num_rois, 4), the lod level
+ is 1. Given as [[x1, y1, x2, y2], ...], (x1, y1) is
+ the top left coordinates, and (x2, y2) is the bottom
+ right coordinates. The data type is the same as `input`
+ output_channels (int): ${output_channels_comment}
+ spatial_scale (float): ${spatial_scale_comment} Default: 1.0
+ pooled_height (int): ${pooled_height_comment} Default: 1
+ pooled_width (int): ${pooled_width_comment} Default: 1
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ ${out_comment}.
+
+ Return Type:
+ Variable
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ x = fluid.data(name='x', shape=[100, 490, 28, 28], dtype='float32')
+ rois = fluid.data(name='rois', shape=[None, 4], lod_level=1, dtype='float32')
+ pool_out = fluid.layers.psroi_pool(x, rois, 10, 1.0, 7, 7)
+ """
+ helper = LayerHelper('psroi_pool', **locals())
+ # check attrs
+ if not isinstance(output_channels, int):
+ raise TypeError("output_channels must be int type")
+ if not isinstance(spatial_scale, float):
+ raise TypeError("spatial_scale must be float type")
+ if not isinstance(pooled_height, int):
+ raise TypeError("pooled_height must be int type")
+ if not isinstance(pooled_width, int):
+ raise TypeError("pooled_width must be int type")
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type='psroi_pool',
+ inputs={'X': input, 'ROIs': rois},
+ outputs={'Out': out},
+ attrs={
+ 'output_channels': output_channels,
+ 'spatial_scale': spatial_scale,
+ 'pooled_height': pooled_height,
+ 'pooled_width': pooled_width,
+ },
+ )
+ return out
+
+
+@templatedoc()
+def prroi_pool(
+ input,
+ rois,
+ spatial_scale=1.0,
+ pooled_height=1,
+ pooled_width=1,
+ batch_roi_nums=None,
+ name=None,
+):
+ """
+
+ The precise roi pooling implementation for paddle. Reference: https://arxiv.org/pdf/1807.11590.pdf
+
+ Args:
+ input (Variable):The input of precise roi pooliing.The shape of input tensor is
+ [N,C,H,W]. Where N is batch size,C is number of input channels,H
+ is height of the feature, and W is the width of the feature.
+ rois (Variable): ROIs (Regions of Interest) to pool over.It should be
+ a 2-D LoDTensor or Tensor of shape (num_rois, 4), the lod level
+ is 1 when it is LoDTensor. The LoD include the rois's batch index
+ information. If rois is Tensor, its batch index information should
+ be provided by batch_index.
+ Given as [[x1, y1, x2, y2], ...], (x1, y1) is
+ the top left coordinates, and (x2, y2) is the bottom
+ right coordinates.
+ spatial_scale (float): Ratio of input feature map height (or width) to raw image height (or width).
+ Equals the reciprocal of total stride in convolutional layers, Default: 1.0.
+ pooled_height (integer): The pooled output height. Default: 1.
+ pooled_width (integer): The pooled output width. Default: 1.
+ batch_roi_nums (Variable): The number of roi for each image in batch. It
+ should be 1-D Tensor, with shape [N] and dtype int64,
+ where N is the batch size. Default: None. Be note: The lod of input should be
+ empty when batch_roi_nums has values;
+ name (str, default None): The name of this operation.
+
+ Returns:
+ Variable(Tensor):The shape of the returned Tensor is (N, C, pooled_height, pooled_width), with value type float32,float16. N, C denote batch_size and channels of input respectively.
+
+ Examples:
+ .. code-block:: python
+
+ ## prroi_pool without batch_roi_num
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', shape=[None, 490, 28, 28], dtype='float32')
+ rois = fluid.data(name='rois', shape=[None, 4], lod_level=1, dtype='float32')
+ pool_out = fluid.layers.prroi_pool(x, rois, 1.0, 7, 7)
+
+ ## prroi_pool with batch_roi_num
+ batchsize=4
+ x2 = fluid.data(name='x2', shape=[batchsize, 490, 28, 28], dtype='float32')
+ rois2 = fluid.data(name='rois2', shape=[batchsize, 4], dtype='float32')
+ batch_rois_num = fluid.data(name='rois_nums', shape=[batchsize], dtype='int64')
+ pool_out2 = fluid.layers.prroi_pool(x2, rois2, 1.0, 7, 7, batch_roi_nums=batch_rois_num)
+
+
+ """
+ check_variable_and_dtype(input, 'input', ['float32'], 'prroi_pool')
+ check_variable_and_dtype(rois, 'rois', ['float32'], 'prroi_pool')
+ helper = LayerHelper('prroi_pool', **locals())
+ # check attrs
+ if not isinstance(spatial_scale, float):
+ raise TypeError("spatial_scale must be float type")
+ if not isinstance(pooled_height, int):
+ raise TypeError("pooled_height must be int type")
+ if not isinstance(pooled_width, int):
+ raise TypeError("pooled_width must be int type")
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ inputs_op = {'X': input, 'ROIs': rois}
+ if batch_roi_nums is not None:
+ inputs_op['BatchRoINums'] = batch_roi_nums
+ helper.append_op(
+ type='prroi_pool',
+ inputs=inputs_op,
+ outputs={'Out': out},
+ attrs={
+ 'spatial_scale': spatial_scale,
+ 'pooled_height': pooled_height,
+ 'pooled_width': pooled_width,
+ },
+ )
+ return out
+
+
+def pixel_shuffle(x, upscale_factor):
+ """
+
+ This op rearranges elements in a tensor of shape [N, C, H, W]
+ to a tensor of shape [N, C/r**2, H*r, W*r].
+ This is useful for implementing efficient sub-pixel convolution
+ with a stride of 1/r.
+ Please refer to the paper: `Real-Time Single Image and Video Super-Resolution
+ Using an Efficient Sub-Pixel Convolutional Neural Network `_ .
+ by Shi et. al (2016) for more details.
+
+ Parameters:
+
+ x(Variable): 4-D tensor, the data type should be float32 or float64.
+ upscale_factor(int): factor to increase spatial resolution.
+
+ Returns:
+ Out(Variable): Reshaped tensor according to the new dimension.
+
+ Raises:
+ ValueError: If the square of upscale_factor cannot divide the channels of input.
+
+ Examples:
+ .. code-block:: python
+
+ # declarative mode
+ import paddle.fluid as fluid
+ import numpy as np
+ input = fluid.data(name="input", shape=[2,9,4,4])
+ output = fluid.layers.pixel_shuffle(x=input, upscale_factor=3)
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ input_data = np.random.rand(2,9,4,4).astype("float32")
+ output_data = exe.run(fluid.default_main_program(),
+ feed={"input":input_data},
+ fetch_list=[output],
+ return_numpy=True)
+
+ # print(output.shape)
+ # (2L, 1L, 12L, 12L)
+
+ """
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'pixel_shuffle')
+ helper = LayerHelper("pixel_shuffle", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ if not isinstance(upscale_factor, int):
+ raise TypeError("upscale factor must be int type")
+
+ helper.append_op(
+ type="pixel_shuffle",
+ inputs={"X": x},
+ outputs={"Out": out},
+ attrs={"upscale_factor": upscale_factor},
+ )
+ return out
+
+
+def fsp_matrix(x, y):
+ """
+
+ **FSP matrix op**
+
+ This op is used to calculate the flow of solution procedure (FSP) matrix of two 4-D Tensor feature maps.
+ Given feature map x with shape [x_channel, h, w] and feature map y with shape
+ [y_channel, h, w], we can get the fsp matrix of x and y in two steps:
+
+ 1. reshape x into matrix with shape [x_channel, h * w] and reshape and
+ transpose y into matrix with shape [h * w, y_channel].
+ 2. multiply x and y to get fsp matrix with shape [x_channel, y_channel].
+
+ The output is a batch of fsp matrices.
+
+ Args:
+
+ x (Variable): A 4-D Tensor feature map with shape [batch_size, x_channel, height, width].
+ A Tensor with type float32, float64.
+ y (Variable): A 4-D Tensor feature map with shape [batch_size, y_channel, height, width].
+ The y_channel can be different with the x_channel of Input(X)
+ while the other dimensions must be the same with Input(X)'s. A Tensor with
+ type float32, float64.
+
+ Returns:
+
+ fsp matrix (Variable): The output of FSP op with shape [batch_size, x_channel, y_channel].
+ The x_channel is the channel of x and the y_channel is the channel of y. A Tensor with
+ type float32, float64.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.data(name='data', shape=[None, 3, 32, 32])
+ feature_map_0 = fluid.layers.conv2d(data, num_filters=2,
+ filter_size=3)
+ feature_map_1 = fluid.layers.conv2d(feature_map_0, num_filters=2,
+ filter_size=1)
+ loss = fluid.layers.fsp_matrix(feature_map_0, feature_map_1)
+
+ """
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'fsp_matrix')
+ check_variable_and_dtype(y, 'y', ['float32', 'float64'], 'fsp_matrix')
+ helper = LayerHelper('fsp_matrix', **locals())
+ out = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype(input_param_name='x')
+ )
+ helper.append_op(type='fsp', inputs={'X': x, 'Y': y}, outputs={'Out': out})
+ return out
+
+
+def continuous_value_model(input, cvm, use_cvm=True):
+ r"""
+
+ **continuous_value_model layers**
+
+ Now, this OP is used in CTR project to remove or dispose show and click value in :attr:`input`.
+
+ :attr:`input` is an embedding vector including show and click value, whose shape is :math:`[N, D]` (N is batch size. D is `2 + embedding dim` ).
+ Show and click at first two dims of embedding vector D.
+ If :attr:`use_cvm` is True, it will calculate :math:`log(show)` and :math:`log(click)` , and output shape is :math:`[N, D]` .
+ If :attr:`use_cvm` is False, it will remove show and click from :attr:`input` , and output shape is :math:`[N, D - 2]` .
+ :attr:`cvm` is show_click info, whose shape is :math:`[N, 2]` .
+
+ Args:
+ input (Variable): The input variable. A 2-D LoDTensor with shape :math:`[N, D]` , where N is the batch size, D is `2 + the embedding dim` . `lod level = 1` .
+ A Tensor with type float32, float64.
+ cvm (Variable): Show and click variable. A 2-D Tensor with shape :math:`[N, 2]` , where N is the batch size, 2 is show and click.
+ A Tensor with type float32, float64.
+ use_cvm (bool): Use show_click or not. if use, the output dim is the same as input.
+ if not use, the output dim is `input dim - 2` (remove show and click)
+
+ Returns:
+
+ Variable: A 2-D LodTensor with shape :math:`[N, M]` . if :attr:`use_cvm` = True, M is equal to input dim D. if False, M is equal to `D - 2`. \
+ A Tensor with same type as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ input = fluid.data(name="input", shape=[64, 1], dtype="int64")
+ label = fluid.data(name="label", shape=[64, 1], dtype="int64")
+ embed = fluid.layers.embedding(
+ input=input,
+ size=[100, 11],
+ dtype='float32')
+ ones = fluid.layers.fill_constant_batch_size_like(input=label, shape=[-1, 1], dtype="int64", value=1)
+ show_clk = fluid.layers.cast(fluid.layers.concat([ones, label], axis=1), dtype='float32')
+ show_clk.stop_gradient = True
+ input_with_cvm = fluid.layers.continuous_value_model(embed, show_clk, True)
+
+ """
+ helper = LayerHelper('cvm', **locals())
+ out = helper.create_variable(dtype=input.dtype)
+ check_variable_and_dtype(
+ input, 'input', ['float16', 'float32', 'float64'], 'cvm'
+ )
+ helper.append_op(
+ type='cvm',
+ inputs={'X': [input], 'CVM': [cvm]},
+ outputs={'Y': [out]},
+ attrs={"use_cvm": use_cvm},
+ )
+ return out
+
+
+def where(condition):
+ """
+ Return an int64 tensor with rank 2, specifying the coordinate of true element in `condition`.
+
+ Args:
+ condition(Variable): A bool tensor with rank at least 1, the data type is bool.
+
+ Returns:
+ Variable, the output data type is int64. : The tensor variable storing a 2-D tensor, which involves all coordinate.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ import numpy as np
+
+ # condition is a tensor [True, False, True]
+ condition = layers.assign(np.array([1, 0, 1], dtype='int32'))
+ condition = layers.cast(condition, 'bool')
+ out = layers.where(condition) # [[0], [2]]
+
+ # condition is a tensor [[True, False], [False, True]]
+ condition = layers.assign(np.array([[1, 0], [0, 1]], dtype='int32'))
+ condition = layers.cast(condition, 'bool')
+ out = layers.where(condition) # [[0, 0], [1, 1]]
+
+ # condition is a tensor [False, False, False]
+ condition = layers.assign(np.array([0, 0, 0], dtype='int32'))
+ condition = layers.cast(condition, 'bool')
+ out = layers.where(condition) # [[]]
+
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.where_index(condition)
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.where_index(condition)
+
+ helper = LayerHelper("where_index", **locals())
+
+ out = helper.create_variable_for_type_inference(
+ dtype=core.VarDesc.VarType.INT64
+ )
+
+ helper.append_op(
+ type='where_index',
+ inputs={'Condition': condition},
+ outputs={'Out': [out]},
+ )
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.sign")
+def sign(x):
+ r"""
+ This OP returns sign of every element in `x`: 1 for positive, -1 for negative and 0 for zero.
+
+ Args:
+ x(Variable|numpy.ndarray): The input variable could be N-D tensor or N-D numpy array, \
+ the input data type is float32 or float64.
+
+ Returns:
+ Variable, the output data type is the same as input data type. : The output sign tensor with identical shape to input :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ # [1.0, 0.0, -1.0]
+ data = fluid.layers.sign(np.array([3.0, 0.0, -2.0], dtype='float32'))
+ """
+
+ helper = LayerHelper("sign", **locals())
+ check_type(x, 'x', (Variable, np.ndarray), 'sign')
+ if isinstance(x, np.ndarray):
+ x = assign(x)
+ check_dtype(x.dtype, 'x', ['float16', 'float32', 'float64'], 'sign')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(type='sign', inputs={'X': [x]}, outputs={'Out': [out]})
+
+ return out
+
+
+def unique(x, dtype='int32'):
+ r"""
+ Return a unique tensor for `x` and an index tensor pointing to this unique tensor.
+
+ Args:
+ x(Tensor): A 1-D input tensor, it's data type should be float32, float64, int32, int64.
+ dtype(np.dtype|str, optional): The type of index tensor: int32, int64. Default: int32.
+
+ Returns:
+ tuple: (out, index). `out` is the unique tensor for `x`, with identical dtype to `x`, and \
+ `index` is an index tensor pointing to `out`, by which user can recover the original `x` tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+ x = fluid.layers.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32'))
+ out, index = fluid.layers.unique(x) # out is [2, 3, 1, 5]; index is [0, 1, 1, 2, 3, 1]
+ """
+
+ check_variable_and_dtype(
+ x, "x", ['float32', 'float64', 'int32', 'int64'], "unique"
+ )
+ helper = LayerHelper("unique", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ index = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type='unique',
+ inputs={'X': x},
+ attrs={'dtype': convert_np_dtype_to_dtype_(dtype)},
+ outputs={'Out': [out], 'Index': [index]},
+ )
+
+ return out, index
+
+
+def unique_with_counts(x, dtype='int32'):
+ r"""
+ This OP return a unique tensor for `x` , and count tensor that the count of unique result in raw input, \
+ and an index tensor pointing to this unique tensor.
+
+ **NOTICE**: This op support the variable type of Tensor only.
+
+ Args:
+ x(Variable): A 1-D input tensor with input shape of :math:`[N]` , the input data type is float32, float64, int32, int64.
+ dtype(np.dtype|core.VarDesc.VarType|str): The type of count and index tensor, it could be int32, int64. Default value is int32.
+
+ Returns:
+ tuple, the variable type in tuple is Tensor, the output :attr:`out` data type is the same as input :attr:`x`, \
+ and data type of output :attr:`index` and :attr:`count` will be int32 or int64.: The :attr:`out` is unique tensor for input :attr:`x`,\
+ the data shape is :math:`[K]`, the `K` may be different to the `N` in shape of :attr:`x`. :attr:`index` is an index tensor pointing\
+ to :attr:`out`, the data shape is :math:`[N]` , the data shape is the same as input :attr:`x`. :attr:`count` is count of unique element in\
+ the :attr:`x`, the data shape is :math:`[K]`, the data shape is the same as output :attr:`out`.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+ x = fluid.layers.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32'))
+ out, index, count = fluid.layers.unique_with_counts(x) # out is [2, 3, 1, 5]; index is [0, 1, 1, 2, 3, 1]
+ # count is [1, 3, 1, 1]
+ # x.shape=(6,) out.shape=(4,), index.shape=(6,), count.shape=(4,)
+ """
+ check_variable_and_dtype(
+ x, "x", ['float32', 'float64', 'int32', 'int64'], "unique_with_counts"
+ )
+ if not (dtype == 'int32' or dtype == 'int64'):
+ raise TypeError(
+ "Op unique_with_counts, index dtype must be int32 or int64"
+ )
+
+ if x is None or len(x.shape) != 1:
+ raise ValueError(
+ "Op unique_with_counts, x must not be null and size of dim must be 1"
+ )
+
+ helper = LayerHelper("unique_with_counts", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ index = helper.create_variable_for_type_inference(dtype)
+
+ count = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(
+ type='unique_with_counts',
+ inputs={'X': x},
+ attrs={'dtype': convert_np_dtype_to_dtype_(dtype)},
+ outputs={'Out': [out], 'Index': [index], 'Count': [count]},
+ )
+
+ return out, index, count
+
+
+def deformable_conv(
+ input,
+ offset,
+ mask,
+ num_filters,
+ filter_size,
+ stride=1,
+ padding=0,
+ dilation=1,
+ groups=None,
+ deformable_groups=None,
+ im2col_step=None,
+ param_attr=None,
+ bias_attr=None,
+ modulated=True,
+ name=None,
+):
+ r"""
+ :api_attr: Static Graph
+
+ **Deformable Convolution op**
+
+ Compute 2-D deformable convolution on 4-D input.
+ Given input image x, output feature map y, the deformable convolution operation can be expressed as follow:
+
+
+ Deformable Convolution v2:
+
+ .. math::
+
+ y(p) = \sum_{k=1}^{K}{w_k * x(p + p_k + \Delta p_k) * \Delta m_k}
+
+ Deformable Convolution v1:
+
+ .. math::
+
+ y(p) = \sum_{k=1}^{K}{w_k * x(p + p_k + \Delta p_k)}
+
+ Where :math:`\Delta p_k` and :math:`\Delta m_k` are the learnable offset and modulation scalar for the k-th location,
+ Which :math:`\Delta m_k` is one in deformable convolution v1. Please refer to `Deformable ConvNets v2: More Deformable, Better Results
+ `_ and `Deformable Convolutional Networks `_.
+
+ Example:
+ - Input:
+
+ Input shape: :math:`(N, C_{in}, H_{in}, W_{in})`
+
+ Filter shape: :math:`(C_{out}, C_{in}, H_f, W_f)`
+
+ Offset shape: :math:`(N, 2 * deformable\_groups * H_f * H_w, H_{in}, W_{in})`
+
+ Mask shape: :math:`(N, deformable\_groups * H_f * H_w, H_{in}, W_{in})`
+
+ - Output:
+
+ Output shape: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+ Where
+
+ .. math::
+
+ H_{out}&= \\frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (H_f - 1) + 1))}{strides[0]} + 1 \\\\
+ W_{out}&= \\frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (W_f - 1) + 1))}{strides[1]} + 1
+
+ Args:
+ input (Variable): The input image with [N, C, H, W] format. A Tensor with type
+ float32, float64.
+ offset (Variable): The input coordinate offset of deformable convolution layer.
+ A Tensor with type float32, float64.
+ Mask (Variable, Optional): The input mask of deformable convolution layer.
+ A Tensor with type float32, float64. It should be None when you use
+ deformable convolution v1.
+ num_filters(int): The number of filter. It is as same as the output
+ image channel.
+ filter_size (int|tuple): The filter size. If filter_size is a tuple,
+ it must contain two integers, (filter_size_H, filter_size_W).
+ Otherwise, the filter will be a square.
+ stride (int|tuple): The stride size. If stride is a tuple, it must
+ contain two integers, (stride_H, stride_W). Otherwise, the
+ stride_H = stride_W = stride. Default: stride = 1.
+ padding (int|tuple): The padding size. If padding is a tuple, it must
+ contain two integers, (padding_H, padding_W). Otherwise, the
+ padding_H = padding_W = padding. Default: padding = 0.
+ dilation (int|tuple): The dilation size. If dilation is a tuple, it must
+ contain two integers, (dilation_H, dilation_W). Otherwise, the
+ dilation_H = dilation_W = dilation. Default: dilation = 1.
+ groups (int): The groups number of the deformable conv layer. According to
+ grouped convolution in Alex Krizhevsky's Deep CNN paper: when group=2,
+ the first half of the filters is only connected to the first half
+ of the input channels, while the second half of the filters is only
+ connected to the second half of the input channels. Default: groups=1.
+ deformable_groups (int): The number of deformable group partitions.
+ Default: deformable_groups = 1.
+ im2col_step (int): Maximum number of images per im2col computation;
+ The total batch size should be devisable by this value or smaller
+ than this value; if you face out of memory problem, you can try
+ to use a smaller value here.
+ Default: im2col_step = 64.
+ param_attr (ParamAttr, Optional): The parameter attribute for learnable parameters/weights
+ of deformable conv. If it is set to None or one attribute of ParamAttr,
+ deformable conv will create ParamAttr as param_attr.
+ If the Initializer of the param_attr is not set, the parameter is
+ initialized with :math:`Normal(0.0, std)`, and the
+ :math:`std` is :math:`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`. Default: None.
+ bias_attr (ParamAttr|bool, Optional): The parameter attribute for the bias of
+ deformable conv layer. If it is set to False, no bias will be added
+ to the output units. If it is set to None or one attribute of ParamAttr, conv2d
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ modulated (bool): Make sure which version should be used between v1 and v2, where v2 is \
+ used while True. Default: True.
+ name(str, Optional): For details, please refer to :ref:`api_guide_Name`.
+ Generally, no setting is required. Default: None.
+ Returns:
+ Variable: The tensor variable storing the deformable convolution \
+ result. A Tensor with type float32, float64.
+ Raises:
+ ValueError: If the shapes of input, filter_size, stride, padding and
+ groups mismatch.
+ Examples:
+ .. code-block:: python
+
+ #deformable conv v2:
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ C_in, H_in, W_in = 3, 32, 32
+ filter_size, deformable_groups = 3, 1
+ data = fluid.data(name='data', shape=[None, C_in, H_in, W_in], dtype='float32')
+ offset = fluid.data(name='offset', shape=[None, 2*deformable_groups*filter_size**2, H_in, W_in], dtype='float32')
+ mask = fluid.data(name='mask', shape=[None, deformable_groups*filter_size**2, H_in, W_in], dtype='float32')
+ out = fluid.layers.deformable_conv(input=data, offset=offset, mask=mask,
+ num_filters=2, filter_size=filter_size, padding=1, modulated=True)
+
+ #deformable conv v1:
+
+ import paddle.fluid as fluid
+ C_in, H_in, W_in = 3, 32, 32
+ filter_size, deformable_groups = 3, 1
+ data = fluid.data(name='data', shape=[None, C_in, H_in, W_in], dtype='float32')
+ offset = fluid.data(name='offset', shape=[None, 2*deformable_groups*filter_size**2, H_in, W_in], dtype='float32')
+ out = fluid.layers.deformable_conv(input=data, offset=offset, mask=None,
+ num_filters=2, filter_size=filter_size, padding=1, modulated=False)
+ """
+
+ check_variable_and_dtype(
+ input, "input", ['float32', 'float64'], 'deformable_conv'
+ )
+ check_variable_and_dtype(
+ offset, "offset", ['float32', 'float64'], 'deformable_conv'
+ )
+ check_type(mask, 'mask', (Variable, type(None)), 'deformable_conv')
+
+ num_channels = input.shape[1]
+ assert param_attr is not False, "param_attr should not be False here."
+
+ helper = LayerHelper('deformable_conv', **locals())
+ dtype = helper.input_dtype()
+
+ if not isinstance(input, Variable):
+ raise TypeError("Input of deformable_conv must be Variable")
+ if not isinstance(offset, Variable):
+ raise TypeError("Input Offset of deformable_conv must be Variable")
+
+ if groups is None:
+ num_filter_channels = num_channels
+ else:
+ if num_channels % groups != 0:
+ raise ValueError("num_channels must be divisible by groups.")
+ num_filter_channels = num_channels // groups
+
+ filter_size = utils.convert_to_list(filter_size, 2, 'filter_size')
+ stride = utils.convert_to_list(stride, 2, 'stride')
+ padding = utils.convert_to_list(padding, 2, 'padding')
+ dilation = utils.convert_to_list(dilation, 2, 'dilation')
+
+ input_shape = input.shape
+ filter_shape = [num_filters, int(num_filter_channels)] + filter_size
+
+ def _get_default_param_initializer():
+ filter_elem_num = filter_size[0] * filter_size[1] * num_channels
+ if filter_elem_num <= 0:
+ raise ValueError(
+ "Invalid filter number, excepted number is larger than 0, but"
+ " received {}, please check the input shape and "
+ "filter size.".format(filter_elem_num)
+ )
+ std = (2.0 / filter_elem_num) ** 0.5
+ return Normal(0.0, std, 0)
+
+ filter_param = helper.create_parameter(
+ attr=helper.param_attr,
+ shape=filter_shape,
+ dtype=dtype,
+ default_initializer=_get_default_param_initializer(),
+ )
+
+ pre_bias = helper.create_variable_for_type_inference(dtype)
+
+ if modulated:
+ helper.append_op(
+ type='deformable_conv',
+ inputs={
+ 'Input': input,
+ 'Filter': filter_param,
+ 'Offset': offset,
+ 'Mask': mask,
+ },
+ outputs={"Output": pre_bias},
+ attrs={
+ 'strides': stride,
+ 'paddings': padding,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'deformable_groups': deformable_groups,
+ 'im2col_step': im2col_step,
+ },
+ )
+
+ else:
+ helper.append_op(
+ type='deformable_conv_v1',
+ inputs={
+ 'Input': input,
+ 'Filter': filter_param,
+ 'Offset': offset,
+ },
+ outputs={"Output": pre_bias},
+ attrs={
+ 'strides': stride,
+ 'paddings': padding,
+ 'dilations': dilation,
+ 'groups': groups,
+ 'deformable_groups': deformable_groups,
+ 'im2col_step': im2col_step,
+ },
+ )
+
+ output = helper.append_bias_op(pre_bias, dim_start=1, dim_end=2)
+ return output
+
+
+def unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None):
+ r"""
+
+ This op returns a col buffer of sliding local blocks of input x, also known
+ as im2col for batched 2D image tensors. For each block under the convolution filter,
+ all element will be rearranged as a column. While the convolution filter sliding over
+ the input feature map, a series of such columns will be formed.
+
+ For each input :math:`x` with shape [N, C, H, W], the output shape [N, Cout, Lout]
+ can be calculated as following.
+
+ .. math::
+
+ dkernel[0] &= dilations[0] \times (kernel\_sizes[0] - 1) + 1
+
+ dkernel[1] &= dilations[1] \times (kernel\_sizes[1] - 1) + 1
+
+ hout &= \frac{H + paddings[0] + paddings[2] - dkernel[0]}{strides[0]} + 1
+
+ wout &= \frac{W + paddings[1] + paddings[3] - dkernel[1]}{strides[1]} + 1
+
+ Cout &= C \times kernel\_sizes[0] \times kernel\_sizes[1]
+
+ Lout &= hout \times wout
+
+
+ Parameters:
+ x(Tensor): 4-D Tensor, input tensor of format [N, C, H, W],
+ data type can be float32 or float64
+ kernel_sizes(int|list): The size of convolution kernel, should be [k_h, k_w]
+ or an integer k treated as [k, k].
+ strides(int|list): The strides, should be [stride_h, stride_w]
+ or an integer stride treated as [sride, stride].
+ For default, strides will be [1, 1].
+ paddings(int|list): The paddings of each dimension, should be
+ [padding_top, padding_left, padding_bottom, padding_right]
+ or [padding_h, padding_w] or an integer padding.
+ If [padding_h, padding_w] was given, it will expanded to
+ [padding_h, padding_w, padding_h, padding_w]. If an integer
+ padding was given, [padding, padding, padding, padding] will
+ be used. For default, paddings will be [0, 0, 0, 0]
+ dilations(int|list): the dilations of convolution kernel, should be
+ [dilation_h, dilation_w], or an integer dilation treated as
+ [dilation, dilation]. For default, it will be [1, 1].
+ name(str, optional): The default value is None.
+ Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+
+ Returns:
+ The tensor corresponding to the sliding local blocks.
+ The output shape is [N, Cout, Lout] as decriabled above.
+ Cout is the total number of values within each block,
+ and Lout is the total number of such blocks.
+ The data type of output is the same as the input :math:`x`
+
+ Return Type:
+ Tensor
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.randn((100,3,224,224))
+ y = F.unfold(x, [3, 3], 1, 1, 1)
+ """
+
+ return paddle.nn.functional.unfold(
+ x, kernel_sizes, strides, paddings, dilations, name
+ )
+
+
+def deformable_roi_pooling(
+ input,
+ rois,
+ trans,
+ no_trans=False,
+ spatial_scale=1.0,
+ group_size=[1, 1],
+ pooled_height=1,
+ pooled_width=1,
+ part_size=None,
+ sample_per_part=1,
+ trans_std=0.1,
+ position_sensitive=False,
+ name=None,
+):
+ r"""
+
+ Deformable ROI Pooling Layer
+
+ Performs deformable region-of-interest pooling on inputs. As described
+ in `Deformable Convolutional Networks `_, it will get offset for each bin after
+ roi pooling so that pooling at correct region. Batch_size will change to the number of region bounding boxes after deformable_roi_pooling.
+
+ The operation has three steps:
+
+ 1. Dividing each region proposal into equal-sized sections with the pooled_width and pooled_height.
+
+ 2. Add offset to pixel in ROI to get new location and the new value which are computed directly through
+ bilinear interpolation with four nearest pixel.
+
+ 3. Sample several points in each bin to get average values as output.
+
+
+ Args:
+ input (Variable):The input of deformable roi pooling and it is tensor which value type is float32. The shape of input is
+ [N, C, H, W]. Where N is batch size, C is number of input channels,
+ H is height of the feature, and W is the width of the feature.
+ rois (Variable): ROIs (Regions of Interest) with type float32 to pool over. It should be
+ a 2-D LoDTensor of shape (num_rois, 4), and the lod level
+ is 1. Given as [[x1, y1, x2, y2], ...], (x1, y1) is
+ the top left coordinates, and (x2, y2) is the bottom
+ right coordinates, which value type is float32.
+ trans (Variable): Offset of features on ROIs while pooling which value type is float32. The format is [N, C, H, W], where
+ N is number of ROIs, C is number of channels, which indicate the offset distance
+ in the x and y directions, H is pooled height, and W is pooled width.
+ no_trans (bool): Whether to add offset to get new value or not while roi pooling, which value with type bool is True or False.
+ If value is True, no offset will be added in operation. Default: False.
+ spatial_scale (float): Ratio of input feature map height (or width) to raw image height (or width), which value type is float32.
+ Equals the reciprocal of total stride in convolutional layers, Default: 1.0.
+ group_size (list|tuple): The number of groups which input channels are divided and the input is list or tuple, which value type is int32. (eg.number of input channels
+ is k1 * k2 * (C + 1), which k1 and k2 are group width and height and C+1 is number of output
+ channels.) eg.(4, 6), which 4 is height of group and 6 is width of group. Default: [1, 1].
+ pooled_height (int): The pooled output height which value type is int32. Default: 1.
+ pooled_width (int): The pooled output width which value type is int32. Default: 1.
+ part_size (list|tuple): The height and width of offset which values in list or tuple is int32, eg.(4, 6), which height is 4 and width is 6, and values always equal to pooled_height \
+ and pooled_width. Default: if None, default value is [pooled_height, pooled_width].
+ sample_per_part (int): The number of samples in each bin which value type is int32. If value is bigger, it will consume more performance. Default: 1.
+ trans_std (float): Coefficient of offset which value type is float32. It controls weight of offset. Default: 0.1.
+ position_sensitive (bool): Whether to choose deformable psroi pooling mode or not, and value type is bool(True or False). If value is False, input dimension equals to output dimension. \
+ If value is True, input dimension should be output dimension * pooled_height * pooled_width. Default: False.
+ name (str|None): Name of layer. Default: None.
+ Returns:
+ Variable: Output of deformable roi pooling is that, if position sensitive is False, input dimension equals to output dimension. If position sensitive is True,\
+ input dimension should be the result of output dimension divided by pooled height and pooled width.
+
+ Examples:
+ .. code-block:: python
+
+ # position_sensitive=True
+ import paddle.fluid as fluid
+ input = fluid.data(name="input",
+ shape=[2, 192, 64, 64],
+ dtype='float32')
+ rois = fluid.data(name="rois",
+ shape=[-1, 4],
+ dtype='float32',
+ lod_level=1)
+ trans = fluid.data(name="trans",
+ shape=[2, 384, 64, 64],
+ dtype='float32')
+ x = fluid.layers.deformable_roi_pooling(input=input,
+ rois=rois,
+ trans=trans,
+ no_trans=False,
+ spatial_scale=1.0,
+ group_size=(1, 1),
+ pooled_height=8,
+ pooled_width=8,
+ part_size=(8, 8),
+ sample_per_part=4,
+ trans_std=0.1,
+ position_sensitive=True)
+
+ # position_sensitive=False
+ import paddle.fluid as fluid
+ input = fluid.data(name="input",
+ shape=[2, 192, 64, 64],
+ dtype='float32')
+ rois = fluid.data(name="rois",
+ shape=[-1, 4],
+ dtype='float32',
+ lod_level=1)
+ trans = fluid.data(name="trans",
+ shape=[2, 384, 64, 64],
+ dtype='float32')
+ x = fluid.layers.deformable_roi_pooling(input=input,
+ rois=rois,
+ trans=trans,
+ no_trans=False,
+ spatial_scale=1.0,
+ group_size=(1, 1),
+ pooled_height=8,
+ pooled_width=8,
+ part_size=(8, 8),
+ sample_per_part=4,
+ trans_std=0.1,
+ position_sensitive=False)
+ """
+
+ check_variable_and_dtype(
+ input, 'input', ['float32', 'float64'], 'deformable_roi_pooling'
+ )
+ check_variable_and_dtype(
+ rois, 'rois', ['float32', 'float64'], 'deformable_roi_pooling'
+ )
+ check_variable_and_dtype(
+ trans, 'trans', ['float32', 'float64'], 'deformable_roi_pooling'
+ )
+ check_type(
+ group_size, 'group_size', (list, tuple), 'deformable_roi_pooling'
+ )
+ if part_size is not None:
+ check_type(
+ part_size, 'part_size', (list, tuple), 'deformable_roi_pooling'
+ )
+
+ input_channels = input.shape[1]
+ if position_sensitive == False:
+ output_channels = input_channels
+ else:
+ output_channels = input_channels / pooled_height / pooled_width
+
+ if part_size is None:
+ part_height = pooled_height
+ part_width = pooled_width
+ part_size = [part_height, part_width]
+ part_size = utils.convert_to_list(part_size, 2, 'part_size')
+ group_size = utils.convert_to_list(group_size, 2, 'group_size')
+ helper = LayerHelper('deformable_psroi_pooling', **locals())
+ dtype = helper.input_dtype()
+ output = helper.create_variable_for_type_inference(dtype)
+ top_count = helper.create_variable_for_type_inference(dtype='int32')
+ helper.append_op(
+ type="deformable_psroi_pooling",
+ inputs={"Input": input, "ROIs": rois, "Trans": trans},
+ outputs={"Output": output, "TopCount": top_count},
+ attrs={
+ "no_trans": no_trans,
+ "spatial_scale": spatial_scale,
+ "output_dim": output_channels,
+ "group_size": group_size,
+ "pooled_height": pooled_height,
+ "pooled_width": pooled_width,
+ "part_size": part_size,
+ "sample_per_part": sample_per_part,
+ "trans_std": trans_std,
+ },
+ )
+ return output
+
+
+@deprecated(since="2.0.0", update_to="paddle.shard_index")
+def shard_index(input, index_num, nshards, shard_id, ignore_value=-1):
+ """
+ Reset the values of `input` according to the shard it beloning to.
+ Every value in `input` must be a non-negative integer, and
+ the parameter `index_num` represents the integer above the maximum
+ value of `input`. Thus, all values in `input` must be in the range
+ [0, index_num) and each value can be regarded as the offset to the beginning
+ of the range. The range is further split into multiple shards. Specifically,
+ we first compute the `shard_size` according to the following formula,
+ which represents the number of integers each shard can hold. So for the
+ i'th shard, it can hold values in the range [i*shard_size, (i+1)*shard_size).
+ ::
+
+ shard_size = (index_num + nshards - 1) // nshards
+
+ For each value `v` in `input`, we reset it to a new value according to the
+ following formula:
+ ::
+
+ v = v - shard_id * shard_size if shard_id * shard_size <= v < (shard_id+1) * shard_size else ignore_value
+
+ That is, the value `v` is set to the new offset within the range represented by the shard `shard_id`
+ if it in the range. Otherwise, we reset it to be `ignore_value`.
+
+ Args:
+ input (Tensor): Input tensor with data type int64 or int32. It's last dimension must be 1.
+ index_num (int): An integer represents the integer above the maximum value of `input`.
+ nshards (int): The number of shards.
+ shard_id (int): The index of the current shard.
+ ignore_value (int): An integer value out of sharded index range.
+
+ Returns:
+ Tensor.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ label = paddle.to_tensor([[16], [1]], "int64")
+ shard_label = paddle.shard_index(input=label,
+ index_num=20,
+ nshards=2,
+ shard_id=0)
+ print(shard_label)
+ # [[-1], [1]]
+ """
+ if in_dygraph_mode():
+ return _C_ops.shard_index(
+ input, index_num, nshards, shard_id, ignore_value
+ )
+
+ check_variable_and_dtype(input, 'input', ['int64', 'int32'], 'shard_index')
+ op_type = 'shard_index'
+ helper = LayerHelper(op_type, **locals())
+ if shard_id < 0 or shard_id >= nshards:
+ raise ValueError(
+ 'The shard_id(%d) should be in [0, %d)' % (shard_id, nshards)
+ )
+
+ out = helper.create_variable_for_type_inference(dtype=input.dtype)
+ helper.append_op(
+ type=op_type,
+ inputs={'X': [input]},
+ outputs={'Out': out},
+ attrs={
+ 'index_num': index_num,
+ 'nshards': nshards,
+ 'shard_id': shard_id,
+ 'ignore_value': ignore_value,
+ },
+ stop_gradient=True,
+ )
+ return out
+
+
+@templatedoc()
+def hard_swish(x, threshold=6.0, scale=6.0, offset=3.0, name=None):
+ r"""
+ This operator implements the hard_swish activation function.
+ Hard_swish is proposed in MobileNetV3, and performs better in computational stability and efficiency compared to swish function.
+ For more details please refer to: https://arxiv.org/pdf/1905.02244.pdf
+
+ The formula is as follows:
+
+ .. math::
+
+ out = \\frac{x * (min(max(0, x+offset), threshold))}{scale}
+
+ In the above equation:
+
+ ``threshold`` and ``scale`` should be positive, ``offset`` can be positive or negative. It is recommended to use default parameters.
+
+ Args:
+ x (Variable): Input feature, multi-dimensional Tensor. The data type should be float32 or float64.
+ threshold (float, optional): The threshold in Relu function. Default: 6.0
+ scale (float, optional): The scale factor. Default: 6.0
+ offset (float, optional): The offset factor. Default: 3.0
+ name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: The output tensor with the same shape and data type as input.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ import numpy as np
+ paddle.enable_static()
+
+ DATATYPE='float32'
+
+ x_data = np.array([i for i in range(1,5)]).reshape([1,1,4]).astype(DATATYPE)
+
+ x = fluid.data(name="x", shape=[None,1,4], dtype=DATATYPE)
+ y = fluid.layers.hard_swish(x)
+
+ place = fluid.CPUPlace()
+ #place = fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+ out, = exe.run(feed={'x':x_data}, fetch_list=[y.name])
+ print(out) # [[0.66666667, 1.66666667,3., 4.]]
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.hard_swish(
+ x, 'threshold', threshold, 'scale', scale, 'offset', offset
+ )
+
+ check_variable_and_dtype(
+ x, 'x', ['float16', 'float32', 'float64'], 'hard_swish'
+ )
+
+ helper = LayerHelper('hard_swish', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='hard_swish',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'threshold': threshold, 'scale': scale, 'offset': offset},
+ )
+ return out
+
+
+@templatedoc()
+def mish(x, threshold=20, name=None):
+ r"""
+ This operator implements the mish activation function.
+ Refer to `Mish: A Self Regularized Non-Monotonic Neural
+ Activation Function `_
+
+
+ The formula is as follows if :attr:`threshold` is :code:`None` or negative:
+
+ .. math::
+
+ out = x * \\tanh(\\ln(1 + e^{x}))
+
+ The formula is as follows if :attr:`threshold` is set as positive value:
+
+ .. math::
+
+ out = \\begin{cases}
+ x \\ast \\tanh(x), \\text{if } x > \\text{threshold} \\\\
+ x \\ast \\tanh(e^{x}), \\text{if } x < -\\text{threshold} \\\\
+ x \\ast \\tanh(\\ln(1 + e^{x})), \\text{otherwise}
+ \\end{cases}
+
+ Args:
+ x (Variable): Input feature, multi-dimensional Tensor. The data type
+ should be float16, float32 or float64.
+ threshold (float|None): threshold for softplus in Mish operator.
+ Approximate value of softplus will be used if absolute value
+ of input is greater than :attr:threshold and :attr:threshold
+ is set as positive value. For none or negative threshold,
+ approximate value is not used. Default 20.
+ name (str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: The output tensor with the same shape and data type as input.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ DATATYPE='float32'
+
+ x_data = np.array([i for i in range(1,5)]).reshape([1,1,4]).astype(DATATYPE)
+
+ x = fluid.data(name="x", shape=[None,1,4], dtype=DATATYPE)
+ y = fluid.layers.mish(x)
+
+ place = fluid.CPUPlace()
+ # place = fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+ out, = exe.run(feed={'x':x_data}, fetch_list=[y.name])
+ print(out) # [[0.66666667, 1.66666667, 3., 4.]]
+ """
+ if in_dygraph_mode():
+ return _C_ops.mish(x, threshold)
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.mish(x, 'threshold', threshold)
+
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'mish')
+ check_type(threshold, 'threshold', (float, int), 'mish')
+ assert (
+ threshold > 0
+ ), "threshold of mish should be greater than 0, " "but got {}".format(
+ threshold
+ )
+
+ helper = LayerHelper('mish', **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type='mish',
+ inputs={'X': x},
+ outputs={'Out': out},
+ attrs={'threshold': threshold},
+ )
+ return out
+
+
+def gather_tree(ids, parents):
+ r"""
+ To be used after beam search. After beam search, we get selected ids at
+ each time step and the corresponding parents in the search tree. Both ids
+ and parents have the layout :attr:`[max_time, batch_size, beam_size]`. Then
+ :attr:`gather_tree` is used to backtrace from the last time step and
+ generate the full sequences by collecting selected ids.
+
+ Here is an example:
+
+ .. code-block:: text
+
+ Given:
+ ids = [[[2 2]
+ [6 1]]
+ [[3 9]
+ [6 1]]
+ [[0 1]
+ [9 0]]]
+ parents = [[[0 0]
+ [1 1]]
+ [[1 0]
+ [1 0]]
+ [[0 0]
+ [0 1]]]
+
+ Then:
+ gather_tree(ids, parents)
+ = [[[2 2]
+ [1 6]]
+ [[3 3]
+ [6 1]]
+ [[0 1]
+ [9 0]]]
+
+ Args:
+ ids(Tensor): A Tensor with shape :attr:`[length, batch_size, beam_size]`
+ and data type :attr:`int32` or :attr:`int64`. It contains the selected
+ ids of all time steps.
+ parents(Tensor): A Tensor with the same shape and data type as :attr:`ids`,
+ It contains the parents corresponding to selected ids when searching
+ among beams.
+
+ Returns:
+ A Tensor with the same shape and data type as :attr:`ids`. \
+ It contains the full sequences. The sequences are collected from \
+ :attr:`ids` by backtracing according to :attr:`parents`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ ids = paddle.to_tensor([[[2, 2], [6, 1]], [[3, 9], [6, 1]], [[0, 1], [9, 0]]])
+
+ parents = paddle.to_tensor([[[0, 0], [1, 1]], [[1, 0], [1, 0]], [[0, 0], [0, 1]]])
+
+ final_sequences = paddle.nn.functional.gather_tree(ids, parents)
+ # [[[2, 2], [1, 6]], [[3, 3], [6, 1]], [[0, 1], [9, 0]]]
+
+ """
+ return paddle.nn.functional.gather_tree(ids, parents)
+
+
+@deprecated(since="2.0.0", update_to="paddle.uniform")
+@templatedoc()
+def uniform_random(
+ shape, dtype='float32', min=-1.0, max=1.0, seed=0, name=None
+):
+ """
+ This OP returns a Tensor filled with random values sampled from a uniform
+ distribution in the range [``min``, ``max``), with ``shape`` and ``dtype``.
+
+ Examples:
+ ::
+
+ Input:
+ shape = [1, 2]
+
+ Output:
+ result=[[0.8505902, 0.8397286]]
+
+ Args:
+ shape(list|tuple|Tensor): The shape of the output Tensor. If ``shape``
+ is a list or tuple, the elements of it should be integers or Tensors
+ (with the shape [1], and the data type int32 or int64). If ``shape``
+ is a Tensor, it should be a 1-D Tensor(with the data type int32 or
+ int64).
+ dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of
+ the output Tensor. Supported data types: float32, float64.
+ Default is float32.
+ min(float|int, optional): The lower bound on the range of random values
+ to generate, ``min`` is included in the range. Default is -1.0.
+ max(float|int, optional): The upper bound on the range of random values
+ to generate, ``max`` is excluded in the range. Default is 1.0.
+ seed(int, optional): Random seed used for generating samples. 0 means
+ use a seed generated by the system. Note that if seed is not 0,
+ this operator will always generate the same random numbers every
+ time. Default is 0.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: A Tensor filled with random values sampled from a uniform
+ distribution in the range [``min``, ``max``), with ``shape`` and ``dtype``.
+
+ Raises:
+ TypeError: If ``shape`` is not list, tuple, Tensor.
+ TypeError: If ``dtype`` is not float32, float64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+
+ # example 1:
+ # attr shape is a list which doesn't contain Tensor.
+ result_1 = fluid.layers.uniform_random(shape=[3, 4])
+ # [[ 0.84524226, 0.6921872, 0.56528175, 0.71690357],
+ # [-0.34646994, -0.45116323, -0.09902662, -0.11397249],
+ # [ 0.433519, 0.39483607, -0.8660099, 0.83664286]]
+
+ # example 2:
+ # attr shape is a list which contains Tensor.
+ dim_1 = fluid.layers.fill_constant([1], "int64", 2)
+ dim_2 = fluid.layers.fill_constant([1], "int32", 3)
+ result_2 = fluid.layers.uniform_random(shape=[dim_1, dim_2])
+ # [[-0.9951253, 0.30757582, 0.9899647 ],
+ # [ 0.5864527, 0.6607096, -0.8886161 ]]
+
+ # example 3:
+ # attr shape is a Tensor, the data type must be int64 or int32.
+ var_shape = fluid.data(name='var_shape', shape=[2], dtype="int64")
+ result_3 = fluid.layers.uniform_random(var_shape)
+ # if var_shape's value is [2, 3]
+ # result_3 is:
+ # [[-0.8517412, -0.4006908, 0.2551912 ],
+ # [ 0.3364414, 0.36278176, -0.16085452]]
+
+ """
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+
+ if in_dygraph_mode():
+ shape = utils.convert_shape_to_list(shape)
+ return _C_ops.uniform_random(
+ shape,
+ dtype,
+ float(min),
+ float(max),
+ seed,
+ _current_expected_place(),
+ )
+ elif _in_legacy_dygraph():
+ shape = utils.convert_shape_to_list(shape)
+ return _legacy_C_ops.uniform_random(
+ 'shape',
+ shape,
+ 'min',
+ float(min),
+ 'max',
+ float(max),
+ 'seed',
+ seed,
+ 'dtype',
+ dtype,
+ )
+
+ check_type(shape, 'shape', (list, tuple, Variable), 'uniform_random/rand')
+ check_dtype(
+ dtype, 'dtype', ('float32', 'float64', 'uint16'), 'uniform_random/rand'
+ )
+ check_type(min, 'min', (float, int, Variable), 'uniform_random/rand')
+ check_type(max, 'max', (float, int, Variable), 'uniform_random/rand')
+
+ inputs = dict()
+ attrs = {'seed': seed, 'min': min, 'max': max, 'dtype': dtype}
+ utils.get_shape_tensor_inputs(
+ inputs=inputs, attrs=attrs, shape=shape, op_type='uniform_random/rand'
+ )
+
+ helper = LayerHelper("uniform_random", **locals())
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(
+ type="uniform_random", inputs=inputs, attrs=attrs, outputs={"Out": out}
+ )
+ utils.try_set_static_shape_tensor(out, shape)
+ return out
+
+
+def unbind(input, axis=0):
+ """
+ Removes a tensor dimension, then split the input tensor into multiple sub-Tensors.
+ Args:
+ input (Variable): The input variable which is an N-D Tensor, data type being float32, float64, int32 or int64.
+
+ axis (int32|int64, optional): A scalar with type ``int32|int64`` shape [1]. The dimension along which to unbind. If :math:`axis < 0`, the
+ dimension to unbind along is :math:`rank(input) + axis`. Default is 0.
+ Returns:
+ list(Variable): The list of segmented Tensor variables.
+
+ Example:
+ .. code-block:: python
+ import paddle
+ # input is a variable which shape is [3, 4, 5]
+ input = paddle.fluid.data(
+ name="input", shape=[3, 4, 5], dtype="float32")
+ [x0, x1, x2] = paddle.tensor.unbind(input, axis=0)
+ # x0.shape [4, 5]
+ # x1.shape [4, 5]
+ # x2.shape [4, 5]
+ [x0, x1, x2, x3] = paddle.tensor.unbind(input, axis=1)
+ # x0.shape [3, 5]
+ # x1.shape [3, 5]
+ # x2.shape [3, 5]
+ # x3.shape [3, 5]
+
+ """
+ helper = LayerHelper("unbind", **locals())
+ check_type(input, 'input', (Variable), 'unbind')
+ dtype = helper.input_dtype()
+ check_dtype(
+ dtype, 'unbind', ['float32', 'float64', 'int32', 'int64'], 'unbind'
+ )
+ if not isinstance(axis, (int)):
+ raise TypeError(
+ "The type of 'axis' must be int, but received %s." % (type(axis))
+ )
+ if isinstance(axis, np.generic):
+ axis = np.asscalar(axis)
+ input_shape = input.shape
+ axis_ = axis if axis >= 0 else len(input_shape) + axis
+ num = input_shape[axis_]
+ outs = [
+ helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ for i in range(num)
+ ]
+
+ helper.append_op(
+ type="unbind",
+ inputs={"X": input},
+ outputs={"Out": outs},
+ attrs={"axis": axis},
+ )
+ return outs
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/ops.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..51b72267329cf3b0725e381c32fef96127d31d73
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/ops.py
@@ -0,0 +1,884 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import os
+from .layer_function_generator import generate_layer_fn, generate_activation_fn, generate_inplace_fn, add_sample_code
+from .. import core
+from ..framework import convert_np_dtype_to_dtype_, Variable, in_dygraph_mode
+from ..data_feeder import convert_dtype, check_variable_and_dtype, check_type, check_dtype
+from paddle.utils import deprecated
+from paddle import _C_ops, _legacy_C_ops
+import paddle
+
+__deprecated_func_name__ = {
+ 'tanh_shrink': 'tanhshrink',
+ 'logsigmoid': 'log_sigmoid'
+}
+
+__activations_noattr__ = [
+ 'sigmoid',
+ 'silu',
+ 'logsigmoid',
+ 'tanh_shrink',
+ 'softsign',
+ 'tanh',
+]
+
+__unary_func__ = [
+ 'exp', 'expm1', 'atan', 'sqrt', 'rsqrt', 'abs', 'ceil', 'floor', 'cos',
+ 'tan', 'acos', 'sin', 'sinh', 'asin', 'cosh', 'round', 'reciprocal',
+ 'square', 'acosh', 'asinh', 'atanh', 'lgamma'
+]
+
+__inplace_unary_func__ = [
+ 'exp_',
+ 'sqrt_',
+ 'rsqrt_',
+ 'ceil_',
+ 'floor_',
+ 'round_',
+ 'reciprocal_',
+]
+
+__all__ = [
+ 'softplus',
+ 'softshrink',
+ 'hard_shrink',
+ 'cumsum',
+ 'thresholded_relu',
+ 'gelu',
+ 'erf',
+]
+
+for _OP in set(__all__):
+ globals()[_OP] = generate_layer_fn(_OP)
+
+# It is a hot fix in some unittest using:
+# fluid.layers.scale(x=x, scale=10.0, out=out_var)
+# e.g.: test_program_code.py, test_dist_train.py
+globals()['_scale'] = generate_layer_fn('scale')
+
+globals()['_elementwise_div'] = generate_layer_fn('elementwise_div')
+
+__all__ += __activations_noattr__
+__all__ += __unary_func__
+__all__ += __inplace_unary_func__
+
+for _OP in set(__activations_noattr__):
+ _new_OP = _OP
+ if _OP in __deprecated_func_name__:
+ _new_OP = __deprecated_func_name__[_OP]
+ _func = generate_activation_fn(_OP)
+ _func = deprecated(since="2.0.0",
+ update_to="paddle.nn.functional.%s" % (_new_OP))(_func)
+ globals()[_OP] = _func
+
+for _OP in set(__unary_func__):
+ _new_OP = _OP
+ if _OP in __deprecated_func_name__:
+ _new_OP = __deprecated_func_name__[_OP]
+ _func = generate_activation_fn(_OP)
+ _func = deprecated(since="2.0.0", update_to="paddle.%s" % (_new_OP))(_func)
+ globals()[_OP] = _func
+
+for _OP in set(__inplace_unary_func__):
+ _new_OP = _OP
+ if _OP in __deprecated_func_name__:
+ _new_OP = __deprecated_func_name__[_OP]
+ _func = generate_inplace_fn(_OP)
+ _func = deprecated(since="2.0.0", update_to="paddle.%s" % (_new_OP))(_func)
+ globals()[_OP] = _func
+
+add_sample_code(
+ globals()["sigmoid"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = F.sigmoid(x)
+ print(out)
+ # [0.40131234 0.450166 0.52497919 0.57444252]
+
+""")
+
+add_sample_code(
+ globals()["silu"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
+ out = F.silu(x)
+ print(out)
+ # [ 0.7310586 1.7615942 2.8577224, 3.9280552 ]
+
+""")
+
+add_sample_code(
+ globals()["logsigmoid"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = F.log_sigmoid(x)
+ print(out)
+ # [-0.91301525 -0.79813887 -0.64439666 -0.55435524]
+
+""")
+
+add_sample_code(
+ globals()["exp"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.exp(x)
+ print(out)
+ # [0.67032005 0.81873075 1.10517092 1.34985881]
+
+""")
+
+add_sample_code(
+ globals()["expm1"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.expm1(x)
+ print(out)
+ # [-0.32967997, -0.18126924, 0.10517092, 0.34985882]
+
+""")
+
+add_sample_code(
+ globals()["tanh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.tanh(x)
+ print(out)
+ # [-0.37994896 -0.19737532 0.09966799 0.29131261]
+
+""")
+
+add_sample_code(
+ globals()["atan"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.atan(x)
+ print(out)
+ # [-0.38050638 -0.19739556 0.09966865 0.29145679]
+
+""")
+
+add_sample_code(
+ globals()["tanh_shrink"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = F.tanhshrink(x)
+ print(out)
+ # [-0.020051, -0.00262468, 0.000332005, 0.00868739]
+
+""")
+
+add_sample_code(
+ globals()["sqrt"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([0.1, 0.2, 0.3, 0.4])
+ out = paddle.sqrt(x)
+ print(out)
+ # [0.31622777 0.4472136 0.54772256 0.63245553]
+
+""")
+
+add_sample_code(
+ globals()["rsqrt"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([0.1, 0.2, 0.3, 0.4])
+ out = paddle.rsqrt(x)
+ print(out)
+ # [3.16227766 2.23606798 1.82574186 1.58113883]
+
+""")
+
+add_sample_code(
+ globals()["abs"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.abs(x)
+ print(out)
+ # [0.4 0.2 0.1 0.3]
+
+""")
+
+add_sample_code(
+ globals()["ceil"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.ceil(x)
+ print(out)
+ # [-0. -0. 1. 1.]
+
+""")
+
+add_sample_code(
+ globals()["floor"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.floor(x)
+ print(out)
+ # [-1. -1. 0. 0.]
+
+""")
+
+add_sample_code(
+ globals()["cos"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.cos(x)
+ print(out)
+ # [0.92106099 0.98006658 0.99500417 0.95533649]
+
+""")
+
+add_sample_code(
+ globals()["tan"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.tan(x)
+ print(out)
+ # [-0.42279324, -0.20271005, 0.10033467, 0.30933627]
+
+""")
+
+add_sample_code(
+ globals()["acos"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.acos(x)
+ print(out)
+ # [1.98231317 1.77215425 1.47062891 1.26610367]
+
+""")
+
+add_sample_code(
+ globals()["sin"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.sin(x)
+ print(out)
+ # [-0.38941834 -0.19866933 0.09983342 0.29552021]
+
+""")
+
+add_sample_code(
+ globals()["asin"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.asin(x)
+ print(out)
+ # [-0.41151685 -0.20135792 0.10016742 0.30469265]
+
+""")
+
+add_sample_code(
+ globals()["cosh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.cosh(x)
+ print(out)
+ # [1.08107237 1.02006676 1.00500417 1.04533851]
+
+""")
+
+add_sample_code(
+ globals()["sinh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.sinh(x)
+ print(out)
+ # [-0.41075233 -0.201336 0.10016675 0.30452029]
+
+""")
+
+add_sample_code(
+ globals()["asinh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.asinh(x)
+ print(out)
+ # [-0.39003533, -0.19869010, 0.09983408, 0.29567307]
+
+""")
+
+add_sample_code(
+ globals()["acosh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([1., 3., 4., 5.])
+ out = paddle.acosh(x)
+ print(out)
+ # [0. , 1.76274729, 2.06343699, 2.29243159]
+
+""")
+
+add_sample_code(
+ globals()["atanh"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.atanh(x)
+ print(out)
+ # [-0.42364895, -0.20273256, 0.10033535, 0.30951962]
+
+""")
+
+add_sample_code(
+ globals()["round"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.5, -0.2, 0.6, 1.5])
+ out = paddle.round(x)
+ print(out)
+ # [-1. -0. 1. 2.]
+
+""")
+
+add_sample_code(
+ globals()["reciprocal"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.reciprocal(x)
+ print(out)
+ # [-2.5 -5. 10. 3.33333333]
+
+""")
+
+add_sample_code(
+ globals()["square"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.square(x)
+ print(out)
+ # [0.16 0.04 0.01 0.09]
+
+""")
+
+_softplus_ = generate_layer_fn('softplus')
+
+
+def softplus(x, beta: float = 1.0, threshold: float = 20.0, name=None):
+ check_variable_and_dtype(x, 'x', ['float32', 'float64'], 'softplus')
+ locals_val = locals().copy()
+ kwargs = dict()
+ for name, val in locals_val.items():
+ if val is not None:
+ kwargs[name] = val
+ return _softplus_(**kwargs)
+
+
+softplus.__doc__ = r"""
+ :alias_main: paddle.nn.functional.softplus
+ :alias: paddle.nn.functional.softplus, paddle.nn.functional.activation.softplus
+ :old_api: paddle.fluid.layers.softplus
+
+:strong:`Softplus Activation Operator`
+
+Equation:
+ .. math::
+ out = \\frac{1}{beta} * log(1 + e^{beta * x})
+ For numerical stability, the implementation reverts to the linear function when: beta * x > threshold.
+
+Args:
+ x(Tensor): Input of Softplus op, Tensor, dtype: float32 or float64
+ beta(float, optional): The value of beta for softplus. Default is 1
+ threshold (float, optional): The value of threshold for softplus. Default is 20
+ name(str, optional): Name for the operation (optional, default is None)
+
+Returns:
+ Variable: The output of Softplus op, Tensor, dtype: float32 or float64
+
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = F.softplus(x)
+ print(out)
+ # [0.513015, 0.598139, 0.744397, 0.854355]
+"""
+
+add_sample_code(
+ globals()["softsign"], r"""
+Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn.functional as F
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = F.softsign(x)
+ print(out)
+ # [-0.285714, -0.166667, 0.0909091, 0.230769]
+
+""")
+
+_softshrink_ = generate_layer_fn('softshrink')
+
+
+def softshrink(x, alpha=None):
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
+ 'softshrink')
+
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ if name == 'alpha':
+ kwargs['lambda'] = val
+ else:
+ kwargs[name] = val
+ return _softshrink_(**kwargs)
+
+
+softshrink.__doc__ = r"""
+ :alias_main: paddle.nn.functional.softshrink
+ :alias: paddle.nn.functional.softshrink,paddle.nn.functional.activation.softshrink
+ :old_api: paddle.fluid.layers.softshrink
+
+:strong:`Softshrink Activation Operator`
+
+.. math::
+ out = \\begin{cases}
+ x - \\alpha, \\text{if } x > \\alpha \\\\
+ x + \\alpha, \\text{if } x < -\\alpha \\\\
+ 0, \\text{otherwise}
+ \\end{cases}
+
+
+Args:
+ x: Input of Softshrink operator, an N-D Tensor, with data type float32, float64 or float16.
+ alpha (float): non-negative offset
+
+Returns:
+ Output of Softshrink operator with the same type of input.
+
+Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.data(name="input", shape=[None, 784])
+ result = fluid.layers.softshrink(x=data, alpha=0.3)
+"""
+
+_hard_shrink_ = generate_layer_fn('hard_shrink')
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.hardshrink")
+def hard_shrink(x, threshold=None):
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
+ 'hard_shrink')
+
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ kwargs[name] = val
+ return _hard_shrink_(**kwargs)
+
+
+hard_shrink.__doc__ = _hard_shrink_.__doc__ + """
+Examples:
+
+ >>> import paddle.fluid as fluid
+ >>> data = fluid.layers.data(name="input", shape=[784])
+ >>> result = fluid.layers.hard_shrink(x=data, threshold=0.3)
+"""
+
+_cum_sum_ = generate_layer_fn('cumsum')
+
+
+@deprecated(since="2.0.0",
+ update_to="paddle.cumsum",
+ reason="New APIs for Paddle 2.0 are coming.")
+def cumsum(x, axis=None, exclusive=None, reverse=None):
+ check_type(x, 'x', (Variable), 'cumsum')
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ kwargs[name] = val
+ return _cum_sum_(**kwargs)
+
+
+cumsum.__doc__ = """
+ :alias_main: paddle.cumsum
+ :alias: paddle.cumsum,paddle.tensor.cumsum,paddle.tensor.math.cumsum
+ :old_api: paddle.fluid.layers.cumsum
+
+The cumulative sum of the elements along a given axis. By default, the first element of the result is the same of the first element of the input. If exlusive is true, the first element of the result is 0.
+
+Args:
+ x (Variable): Input of cumsum operator, the Tensor/LoDTensor needed to be cumsumed.
+ axis (int, optional): The dimension to accumulate along. -1 means the last dimension. Default is -1.
+ exclusive (bool, optional): Whether to perform exclusive cumsum. Default is False.
+ reverse (bool, optional): If true, the cumsum is performed in the reversed direction. Default is False.
+
+Returns:
+ Variable(Tensor/LoDTensor): The result of cumsum operator, output of cumsum operator.
+
+Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.data(name="input", shape=[32, 784])
+ result = fluid.layers.cumsum(data, axis=0)
+"""
+
+_thresholded_relu_ = generate_layer_fn('thresholded_relu')
+
+
+def thresholded_relu(x, threshold=None):
+ check_variable_and_dtype(x, 'x', ['float16', 'float32', 'float64'],
+ 'thresholded_relu')
+
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ kwargs[name] = val
+
+ return _thresholded_relu_(**kwargs)
+
+
+thresholded_relu.__doc__ = r"""
+ :alias_main: paddle.nn.functional.thresholded_relu
+ :alias: paddle.nn.functional.thresholded_relu,paddle.nn.functional.activation.thresholded_relu
+ :old_api: paddle.fluid.layers.thresholded_relu
+
+:strong:`Thresholded ReLU Activation Operator`
+
+Equation:
+ .. math::
+ out = \\begin{cases}
+ x, &if x > threshold \\\\
+ 0, &otherwise
+ \\end{cases}
+
+Args:
+ x(Variable): The input of Thresholded ReLU op, Tensor or LoDTensor, dtype: float32 or float64.
+
+ threshold(float, optional): The threshold value. Note that if the arg `threshold` is not set, the threshold in the equation is 1.0.
+
+Returns:
+
+ Variable: The output of Thresholded ReLU op, Tensor or LoDTensor, dtype: float32 or float64, the same as the input, shape: the same as the input.
+
+Examples:
+
+ .. code-block:: python
+
+ # declarative mode
+ import numpy as np
+ from paddle import fluid
+
+ x = fluid.data(name="x", shape=(-1, 3), dtype="float32")
+ y = fluid.layers.thresholded_relu(x, threshold=0.1)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ start = fluid.default_startup_program()
+ main = fluid.default_main_program()
+
+ data = np.random.randn(2, 3).astype("float32")
+ exe.run(start)
+
+ y_np, = exe.run(main, feed={"x": data}, fetch_list=[y])
+
+ data
+ # array([[ 0.21134382, -1.1805999 , 0.32876605],
+ # [-1.2210793 , -0.7365624 , 1.0013918 ]], dtype=float32)
+ y_np
+ # array([[ 0.21134382, -0. , 0.32876605],
+ # [-0. , -0. , 1.0013918 ]], dtype=float32)
+
+ .. code-block:: python
+
+ # imperative mode
+ import numpy as np
+ from paddle import fluid
+ import paddle.fluid.dygraph as dg
+
+ data = np.random.randn(2, 3).astype("float32")
+ place = fluid.CPUPlace()
+ with dg.guard(place) as g:
+ x = dg.to_variable(data)
+ y = fluid.layers.thresholded_relu(x, threshold=0.1)
+ y_np = y.numpy()
+ data
+ # array([[ 0.21134382, -1.1805999 , 0.32876605],
+ # [-1.2210793 , -0.7365624 , 1.0013918 ]], dtype=float32)
+ y_np
+ # array([[ 0.21134382, -0. , 0.32876605],
+ # [-0. , -0. , 1.0013918 ]], dtype=float32)
+"""
+
+_gelu_ = generate_layer_fn('gelu')
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.gelu")
+def gelu(x, approximate=False):
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ kwargs[name] = val
+ return _gelu_(**kwargs)
+
+
+gelu.__doc__ = r"""
+:strong:`GeLU Activation Operator`
+For more details, see [Gaussian Error Linear Units](https://arxiv.org/abs/1606.08415).
+
+Equation:
+ if approximate is True
+ .. math::
+ out = 0.5 * x * (1 + tanh(\\sqrt{\\frac{2}{\\pi}} * (x + 0.044715x^{3})))
+
+ else
+ .. math::
+ out = 0.5 * x * (1 + erf(\\frac{x}{\\sqrt{2}}))
+
+Args:
+
+ x(Variable): The input of GeLU op, Tensor or LoDTensor, dtype: float32 or float64.
+
+Returns:
+
+ Variable: The output of GeLU op, Tensor or LoDTensor, dtype: float32 or float64, the same as the input, shape: the same as the input.
+
+Examples:
+
+ .. code-block:: python
+
+ # declarative mode
+ import numpy as np
+ from paddle import fluid
+
+ x = fluid.data(name="x", shape=(-1, 3), dtype="float32")
+ y = fluid.layers.gelu(x)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ start = fluid.default_startup_program()
+ main = fluid.default_main_program()
+
+ data = np.random.randn(2, 3).astype("float32")
+ exe.run(start)
+
+ y_np, = exe.run(main, feed={"x": data}, fetch_list=[y])
+
+ data
+ # array([[ 0.87165993, -1.0541513 , -0.37214822],
+ # [ 0.15647964, 0.32496083, 0.33045998]], dtype=float32)
+ y_np
+ # array([[ 0.70456535, -0.15380788, -0.13207214],
+ # [ 0.08796856, 0.20387867, 0.2080159 ]], dtype=float32)
+
+ .. code-block:: python
+
+ # imperative mode
+ import numpy as np
+ from paddle import fluid
+ import paddle.fluid.dygraph as dg
+
+ data = np.random.randn(2, 3).astype("float32")
+ place = fluid.CPUPlace()
+ with dg.guard(place) as g:
+ x = dg.to_variable(data)
+ y = fluid.layers.gelu(x)
+ y_np = y.numpy()
+ data
+ # array([[ 0.87165993, -1.0541513 , -0.37214822],
+ # [ 0.15647964, 0.32496083, 0.33045998]], dtype=float32)
+ y_np
+ # array([[ 0.70456535, -0.15380788, -0.13207214],
+ # [ 0.08796856, 0.20387867, 0.2080159 ]], dtype=float32)
+"""
+
+_erf_ = generate_layer_fn('erf')
+
+
+def erf(x, name=None):
+ if in_dygraph_mode():
+ return _C_ops.erf(x)
+
+ locals_var = locals().copy()
+ kwargs = dict()
+ for name, val in locals_var.items():
+ if val is not None:
+ kwargs[name] = val
+ return _erf_(**kwargs)
+
+
+erf.__doc__ = r"""
+:strong:`Erf Operator`
+For more details, see [Error function](https://en.wikipedia.org/wiki/Error_function).
+
+Equation:
+ .. math::
+ out = \\frac{2}{\\sqrt{\\pi}} \\int_{0}^{x}e^{- \\eta^{2}}d\\eta
+
+Args:
+
+ x (Tensor): The input tensor, it's data type should be float32, float64.
+
+Returns:
+
+ Tensor: The output of Erf op, dtype: float32 or float64, the same as the input, shape: the same as the input.
+
+Examples:
+
+ .. code-block:: python
+
+ import paddle
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.erf(x)
+ print(out)
+ # [-0.42839236 -0.22270259 0.11246292 0.32862676]
+"""
+
+
+def lgamma(x, name=None):
+ r"""
+ Calculates the lgamma of the given input tensor, element-wise.
+
+ This operator performs elementwise lgamma for input $X$.
+ :math:`out = log\Gamma(x)`
+
+
+ Args:
+ x (Tensor): Input Tensor. Must be one of the following types: float32, float64.
+ name (str, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor, the lgamma of the input Tensor, the shape and data type is the same with input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+ out = paddle.lgamma(x)
+ print(out)
+ # [1.31452441, 1.76149750, 2.25271273, 1.09579802]
+ """
+ return paddle.Tensor.lgamma(x)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/rnn.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/rnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b51721aafc41a1b96dc1c3c23aca3848056fc2a
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/rnn.py
@@ -0,0 +1,3564 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import sys
+from functools import partial, reduce
+import warnings
+
+import paddle
+from paddle.utils import deprecated
+from . import nn
+from . import tensor
+from . import control_flow
+from . import utils
+from . import sequence_lod
+from .utils import *
+from .. import core
+from ..framework import default_main_program
+from ..data_feeder import convert_dtype
+from ..layer_helper import LayerHelper
+from ..framework import _non_static_mode
+from ..param_attr import ParamAttr
+from ..data_feeder import check_variable_and_dtype, check_type, check_dtype
+try:
+ from collections.abc import Sequence
+except:
+ from collections import Sequence
+
+__all__ = [
+ 'RNNCell',
+ 'GRUCell',
+ 'LSTMCell',
+ 'Decoder',
+ 'BeamSearchDecoder',
+ 'rnn',
+ 'birnn',
+ 'dynamic_decode',
+ 'DecodeHelper',
+ 'TrainingHelper',
+ 'GreedyEmbeddingHelper',
+ 'SampleEmbeddingHelper',
+ 'BasicDecoder',
+ 'dynamic_lstm',
+ 'dynamic_lstmp',
+ 'dynamic_gru',
+ 'gru_unit',
+ 'lstm_unit',
+ 'lstm',
+ 'beam_search',
+ 'beam_search_decode',
+]
+
+
+class RNNCell(object):
+ """
+ :api_attr: Static Graph
+
+ RNNCell is the base class for abstraction representing the calculations
+ mapping the input and state to the output and new state. It is suitable to
+ and mostly used in RNN.
+ """
+
+ def call(self, inputs, states, **kwargs):
+ r"""
+ Every cell must implement this method to do the calculations mapping the
+ inputs and states to the output and new states.
+
+ To be more flexible, both inputs and states can be a tensor variable or
+ a nested structure (list|tuple|namedtuple|dict) of tensor variable, that
+ is, a (possibly nested structure of) tensor variable[s].
+
+ Parameters:
+ inputs: A (possibly nested structure of) tensor variable[s].
+ states: A (possibly nested structure of) tensor variable[s].
+ **kwargs: Additional keyword arguments, provided by the caller.
+
+ Returns:
+ tuple: outputs and new_states pair. outputs and new_states both \
+ can be nested structure of tensor variables. new_states must \
+ have the same structure with states.
+
+ """
+ raise NotImplementedError("RNNCell must implent the call function.")
+
+ def __call__(self, inputs, states, **kwargs):
+ return self.call(inputs, states, **kwargs)
+
+ def get_initial_states(self,
+ batch_ref,
+ shape=None,
+ dtype='float32',
+ init_value=0,
+ batch_dim_idx=0):
+ r"""
+ Generate initialized states according to provided shape, data type and
+ value.
+
+ Parameters:
+ batch_ref: A (possibly nested structure of) tensor variable[s].
+ The first dimension of the tensor will be used as batch size to
+ initialize states.
+ shape: A (possibly nested structure of) shape[s], where a shape is
+ represented as a list/tuple of integer). -1(for batch size) will
+ beautomatically inserted if shape is not started with it. If None,
+ property `state_shape` will be used. The default value is None.
+ dtype: A (possibly nested structure of) data type[s]. The structure
+ must be same as that of `shape`, except when all tensors' in states
+ has the same data type, a single data type can be used. If
+ property `cell.state_shape` is not available, float32 will be used
+ as the data type. The default value is float32.
+ init_value: A float value used to initialize states.
+ batch_dim_idx: An integer indicating which dimension of the tensor in
+ inputs represents batch size. The default value is 0.
+
+ Returns:
+ Variable: tensor variable[s] packed in the same structure provided \
+ by shape, representing the initialized states.
+ """
+ if sys.version_info < (3, ):
+ integer_types = (
+ int,
+ long,
+ )
+ else:
+ integer_types = (int, )
+ check_variable_and_dtype(batch_ref, 'batch_ref',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'RNNCell')
+ check_type(shape, 'shape', (list, tuple, type(None), integer_types),
+ 'RNNCell')
+ if isinstance(shape, (list, tuple)):
+ shapes = map_structure(lambda x: x, shape)
+ if isinstance(shape, list):
+ for i, _shape in enumerate(shapes):
+ check_type(_shape, 'shapes[' + str(i) + ']', integer_types,
+ 'RNNCell')
+ else:
+ check_type(shapes, 'shapes', integer_types, 'RNNCell')
+ check_dtype(dtype, 'dtype', ['float32', 'float64'], 'RNNCell')
+
+ # TODO: use inputs and batch_size
+ batch_ref = flatten(batch_ref)[0]
+
+ def _is_shape_sequence(seq):
+ if sys.version_info < (3, ):
+ integer_types = (
+ int,
+ long,
+ )
+ else:
+ integer_types = (int, )
+ """For shape, list/tuple of integer is the finest-grained objection"""
+ if (isinstance(seq, list) or isinstance(seq, tuple)):
+ if reduce(lambda flag, x: isinstance(x, integer_types) and flag,
+ seq, True):
+ return False
+ # TODO: Add check for the illegal
+ if isinstance(seq, dict):
+ return True
+ return (isinstance(seq, Sequence)
+ and not isinstance(seq, six.string_types))
+
+ class Shape(object):
+
+ def __init__(self, shape):
+ self.shape = shape if shape[0] == -1 else ([-1] + list(shape))
+
+ # nested structure of shapes
+ states_shapes = self.state_shape if shape is None else shape
+ is_sequence_ori = utils.is_sequence
+ utils.is_sequence = _is_shape_sequence
+ states_shapes = map_structure(lambda shape: Shape(shape), states_shapes)
+ utils.is_sequence = is_sequence_ori
+
+ # nested structure of dtypes
+ try:
+ states_dtypes = self.state_dtype if dtype is None else dtype
+ except NotImplementedError: # use fp32 as default
+ states_dtypes = "float32"
+ if len(flatten(states_dtypes)) == 1:
+ dtype = flatten(states_dtypes)[0]
+ states_dtypes = map_structure(lambda shape: dtype, states_shapes)
+
+ init_states = map_structure(
+ lambda shape, dtype: tensor.fill_constant_batch_size_like(
+ input=batch_ref,
+ shape=shape.shape,
+ dtype=dtype,
+ value=init_value,
+ input_dim_idx=batch_dim_idx), states_shapes, states_dtypes)
+ return init_states
+
+ @property
+ def state_shape(self):
+ """
+ Abstract method (property).
+ Used to initialize states.
+ A (possibly nested structure of) shape[s], where a shape is represented
+ as a list/tuple of integers (-1 for batch size would be automatically
+ inserted into a shape if shape is not started with it).
+ Not necessary to be implemented if states are not initialized by
+ `get_initial_states` or the `shape` argument is provided when using
+ `get_initial_states`.
+ """
+ raise NotImplementedError(
+ "Please add implementaion for `state_shape` in the used cell.")
+
+ @property
+ def state_dtype(self):
+ """
+ Abstract method (property).
+ Used to initialize states.
+ A (possibly nested structure of) data types[s]. The structure must be
+ same as that of `shape`, except when all tensors' in states has the same
+ data type, a single data type can be used.
+ Not necessary to be implemented if states are not initialized
+ by `get_initial_states` or the `dtype` argument is provided when using
+ `get_initial_states`.
+ """
+ raise NotImplementedError(
+ "Please add implementaion for `state_dtype` in the used cell.")
+
+
+class GRUCell(RNNCell):
+ r"""
+ :api_attr: Static Graph
+
+ Gated Recurrent Unit cell. It is a wrapper for
+ `fluid.contrib.layers.rnn_impl.BasicGRUUnit` to make it adapt to RNNCell.
+
+ The formula used is as follow:
+
+ .. math::
+
+ u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)
+
+ r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)
+
+ \\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)
+
+ h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \\tilde{h_t}
+
+ For more details, please refer to `Learning Phrase Representations using
+ RNN Encoder Decoder for Statistical Machine Translation `_
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid.layers as layers
+ cell = layers.GRUCell(hidden_size=256)
+ """
+
+ def __init__(self,
+ hidden_size,
+ param_attr=None,
+ bias_attr=None,
+ gate_activation=None,
+ activation=None,
+ dtype="float32",
+ name="GRUCell"):
+ """
+ Constructor of GRUCell.
+
+ Parameters:
+ hidden_size (int): The hidden size in the GRU cell.
+ param_attr(ParamAttr, optional): The parameter attribute for the learnable
+ weight matrix. Default: None.
+ bias_attr (ParamAttr, optional): The parameter attribute for the bias
+ of GRU. Default: None.
+ gate_activation (function, optional): The activation function for :math:`act_g`.
+ Default: `fluid.layers.sigmoid`.
+ activation (function, optional): The activation function for :math:`act_c`.
+ Default: `fluid.layers.tanh`.
+ dtype(string, optional): The data type used in this cell. Default float32.
+ name(string, optional) : The name scope used to identify parameters and biases.
+ """
+ check_type(hidden_size, 'hidden_size', (int), 'GRUCell')
+ check_dtype(dtype, 'dtype', ['float32', 'float64'], 'GRUCell')
+ self.hidden_size = hidden_size
+ from .. import contrib # TODO: resolve recurrent import
+ self.gru_unit = contrib.layers.rnn_impl.BasicGRUUnit(
+ name, hidden_size, param_attr, bias_attr, gate_activation,
+ activation, dtype)
+
+ def call(self, inputs, states):
+ r"""
+ Perform calculations of GRU.
+
+ Parameters:
+ inputs(Variable): A tensor with shape `[batch_size, input_size]`,
+ corresponding to :math:`x_t` in the formula. The data type
+ should be float32 or float64.
+ states(Variable): A tensor with shape `[batch_size, hidden_size]`.
+ corresponding to :math:`h_{t-1}` in the formula. The data type
+ should be float32 or float64.
+
+ Returns:
+ tuple: A tuple( :code:`(outputs, new_states)` ), where `outputs` and \
+ `new_states` is the same tensor shaped `[batch_size, hidden_size]`, \
+ corresponding to :math:`h_t` in the formula. The data type of the \
+ tensor is same as that of `states`.
+ """
+
+ check_variable_and_dtype(inputs, 'inputs', ['float32', 'float64'],
+ 'GRUCell')
+ check_variable_and_dtype(states, 'states', ['float32', 'float64'],
+ 'GRUCell')
+ new_hidden = self.gru_unit(inputs, states)
+ return new_hidden, new_hidden
+
+ @property
+ def state_shape(self):
+ """
+ The `state_shape` of GRUCell is a shape `[hidden_size]` (-1 for batch
+ size would be automatically inserted into shape). The shape corresponds
+ to :math:`h_{t-1}`.
+ """
+ return [self.hidden_size]
+
+
+class LSTMCell(RNNCell):
+ r"""
+ :api_attr: Static Graph
+
+ Long-Short Term Memory cell. It is a wrapper for
+ `fluid.contrib.layers.rnn_impl.BasicLSTMUnit` to make it adapt to RNNCell.
+
+ The formula used is as follow:
+
+ .. math::
+
+ i_{t} & = act_g(W_{x_{i}}x_{t} + W_{h_{i}}h_{t-1} + b_{i})
+
+ f_{t} & = act_g(W_{x_{f}}x_{t} + W_{h_{f}}h_{t-1} + b_{f} + forget\\_bias)
+
+ c_{t} & = f_{t}c_{t-1} + i_{t} act_c (W_{x_{c}}x_{t} + W_{h_{c}}h_{t-1} + b_{c})
+
+ o_{t} & = act_g(W_{x_{o}}x_{t} + W_{h_{o}}h_{t-1} + b_{o})
+
+ h_{t} & = o_{t} act_c (c_{t})
+
+ For more details, please refer to `RECURRENT NEURAL NETWORK REGULARIZATION `_
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid.layers as layers
+ cell = layers.LSTMCell(hidden_size=256)
+ """
+
+ def __init__(self,
+ hidden_size,
+ param_attr=None,
+ bias_attr=None,
+ gate_activation=None,
+ activation=None,
+ forget_bias=1.0,
+ dtype="float32",
+ name="LSTMCell"):
+ """
+ Constructor of LSTMCell.
+
+ Parameters:
+ hidden_size (int): The hidden size in the LSTM cell.
+ param_attr(ParamAttr, optional): The parameter attribute for the learnable
+ weight matrix. Default: None.
+ bias_attr (ParamAttr, optional): The parameter attribute for the bias
+ of LSTM. Default: None.
+ gate_activation (function, optional): The activation function for :math:`act_g`.
+ Default: 'fluid.layers.sigmoid'.
+ activation (function, optional): The activation function for :math:`act_h`.
+ Default: 'fluid.layers.tanh'.
+ forget_bias(float, optional): forget bias used when computing forget gate.
+ Default 1.0
+ dtype(string, optional): The data type used in this cell. Default float32.
+ name(string, optional) : The name scope used to identify parameters and biases.
+ """
+
+ check_type(hidden_size, 'hidden_size', (int), 'LSTMCell')
+ check_dtype(dtype, 'dtype', ['float32', 'float64'], 'LSTMCell')
+ self.hidden_size = hidden_size
+ from .. import contrib # TODO: resolve recurrent import
+ self.lstm_unit = contrib.layers.rnn_impl.BasicLSTMUnit(
+ name, hidden_size, param_attr, bias_attr, gate_activation,
+ activation, forget_bias, dtype)
+
+ def call(self, inputs, states):
+ r"""
+ Perform calculations of LSTM.
+
+ Parameters:
+ inputs(Variable): A tensor with shape `[batch_size, input_size]`,
+ corresponding to :math:`x_t` in the formula. The data type
+ should be float32 or float64.
+ states(Variable): A list of containing two tensors, each shaped
+ `[batch_size, hidden_size]`, corresponding to :math:`h_{t-1}, c_{t-1}`
+ in the formula. The data type should be float32 or float64.
+
+ Returns:
+ tuple: A tuple( :code:`(outputs, new_states)` ), where `outputs` is \
+ a tensor with shape `[batch_size, hidden_size]`, corresponding \
+ to :math:`h_{t}` in the formula; `new_states` is a list containing \
+ two tenser variables shaped `[batch_size, hidden_size]`, corresponding \
+ to :math:`h_{t}, c_{t}` in the formula. The data type of these \
+ tensors all is same as that of `states`.
+ """
+
+ check_variable_and_dtype(inputs, 'inputs', ['float32', 'float64'],
+ 'LSTMCell')
+ check_type(states, 'states', list, 'LSTMCell')
+ if isinstance(states, list):
+ for i, state in enumerate(states):
+ check_variable_and_dtype(state, 'state[' + str(i) + ']',
+ ['float32', 'float64'], 'LSTMCell')
+
+ pre_hidden, pre_cell = states
+ new_hidden, new_cell = self.lstm_unit(inputs, pre_hidden, pre_cell)
+ return new_hidden, [new_hidden, new_cell]
+
+ @property
+ def state_shape(self):
+ """
+ The `state_shape` of LSTMCell is a list with two shapes: `[[hidden_size], [hidden_size]]`
+ (-1 for batch size would be automatically inserted into shape). These two
+ shapes correspond to :math:`h_{t-1}` and :math:`c_{t-1}` separately.
+ """
+ return [[self.hidden_size], [self.hidden_size]]
+
+
+def rnn(cell,
+ inputs,
+ initial_states=None,
+ sequence_length=None,
+ time_major=False,
+ is_reverse=False,
+ **kwargs):
+ """
+ rnn creates a recurrent neural network specified by RNNCell `cell`,
+ which performs :code:`cell.call()` (for dygraph mode :code:`cell.forward`)
+ repeatedly until reaches to the maximum length of `inputs`.
+
+ Arguments:
+ cell(RNNCellBase): An instance of `RNNCellBase`.
+ inputs(Tensor): the input sequences.
+ If time_major is True, the shape is
+ `[time_steps, batch_size, input_size]`
+ else the shape is `[batch_size, time_steps, input_size]`.
+ initial_states(Tensor|tuple|list, optional): the initial state of the
+ rnn cell. Tensor or a possibly nested structure of tensors. If not
+ provided, `cell.get_initial_states` would be called to produce
+ the initial state. Defaults to None.
+ sequence_length (Tensor, optional): shape `[batch_size]`, dtype: int64
+ or int32. The valid lengths of input sequences. Defaults to None.
+ If `sequence_length` is not None, the inputs are treated as
+ padded sequences. In each input sequence, elements whose time step
+ index are not less than the valid length are treated as paddings.
+ time_major (bool): Whether the first dimension of the input means the
+ time steps. Defaults to False.
+ is_reverse (bool, optional): Indicate whether to calculate in the reverse
+ order of input sequences. Defaults to False.
+ **kwargs: Additional keyword arguments to pass to `forward` of the cell.
+
+ Returns:
+ (outputs, final_states)
+ outputs (Tensor|list|tuple): the output sequence. Tensor or nested
+ structure of Tensors.
+ If `time_major` is True, the shape of each tensor in outpus is
+ `[time_steps, batch_size, hidden_size]`, else
+ `[batch_size, time_steps, hidden_size]`.
+ final_states (Tensor|list|tuple): final states. A (possibly nested structure of)
+ tensor[s], representing the final state for RNN. It has the same
+ structure of intial state. Each tensor in final states has the same
+ shape and dtype as the corresponding tensor in initial states.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.disable_static()
+
+ cell = paddle.nn.SimpleRNNCell(16, 32)
+
+ inputs = paddle.rand((4, 23, 16))
+ prev_h = paddle.randn((4, 32))
+ outputs, final_states = paddle.fluid.layers.rnn(cell, inputs, prev_h)
+
+ """
+ if _non_static_mode():
+ return _rnn_dynamic_graph(cell, inputs, initial_states, sequence_length,
+ time_major, is_reverse, **kwargs)
+ else:
+ return _rnn_static_graph(cell, inputs, initial_states, sequence_length,
+ time_major, is_reverse, **kwargs)
+
+
+class ArrayWrapper(object):
+
+ def __init__(self, x):
+ self.array = [x]
+
+ def append(self, x):
+ self.array.append(x)
+ return self
+
+ def __getitem__(self, item):
+ return self.array.__getitem__(item)
+
+
+def _maybe_copy(state, new_state, step_mask):
+ """update rnn state or just pass the old state through"""
+ new_state = nn.elementwise_mul(new_state, step_mask, axis=0) \
+ + nn.elementwise_mul(state, (1 - step_mask), axis=0)
+ return new_state
+
+
+def _transpose_batch_time(x):
+ perm = [1, 0] + list(range(2, len(x.shape)))
+ return nn.transpose(x, perm)
+
+
+def _rnn_dynamic_graph(cell,
+ inputs,
+ initial_states=None,
+ sequence_length=None,
+ time_major=False,
+ is_reverse=False,
+ **kwargs):
+ time_step_index = 0 if time_major else 1
+ flat_inputs = flatten(inputs)
+ time_steps = flat_inputs[0].shape[time_step_index]
+
+ if initial_states is None:
+ initial_states = cell.get_initial_states(
+ batch_ref=inputs, batch_dim_idx=1 if time_major else 0)
+
+ if not time_major:
+ inputs = map_structure(_transpose_batch_time, inputs)
+
+ if sequence_length is not None:
+ mask = sequence_lod.sequence_mask(sequence_length,
+ maxlen=time_steps,
+ dtype=inputs.dtype)
+ mask = nn.transpose(mask, [1, 0])
+
+ if is_reverse:
+ inputs = map_structure(lambda x: tensor.reverse(x, axis=[0]), inputs)
+ mask = tensor.reverse(mask, axis=[0]) \
+ if sequence_length is not None else None
+
+ states = initial_states
+ outputs = []
+ for i in range(time_steps):
+ step_inputs = map_structure(lambda x: x[i], inputs)
+ step_outputs, new_states = cell(step_inputs, states, **kwargs)
+ if sequence_length is not None:
+ new_states = map_structure(partial(_maybe_copy, step_mask=mask[i]),
+ states, new_states)
+ states = new_states
+ outputs = map_structure(lambda x: ArrayWrapper(x),
+ step_outputs) if i == 0 else map_structure(
+ lambda x, x_array: x_array.append(x),
+ step_outputs, outputs)
+
+ final_outputs = map_structure(
+ lambda x: nn.stack(x.array, axis=time_step_index), outputs)
+
+ if is_reverse:
+ final_outputs = map_structure(
+ lambda x: tensor.reverse(x, axis=time_step_index), final_outputs)
+
+ final_states = new_states
+ return final_outputs, final_states
+
+
+def _rnn_static_graph(cell,
+ inputs,
+ initial_states=None,
+ sequence_length=None,
+ time_major=False,
+ is_reverse=False,
+ **kwargs):
+ check_type(inputs, 'inputs', (Variable, list, tuple), 'rnn')
+ if isinstance(inputs, (list, tuple)):
+ for i, input_x in enumerate(inputs):
+ check_variable_and_dtype(input_x, 'inputs[' + str(i) + ']',
+ ['float32', 'float64'], 'rnn')
+ check_type(initial_states, 'initial_states',
+ (Variable, list, tuple, type(None)), 'rnn')
+
+ check_type(sequence_length, 'sequence_length', (Variable, type(None)),
+ 'rnn')
+
+ def _switch_grad(x, stop=False):
+ x.stop_gradient = stop
+ return x
+
+ if initial_states is None:
+ initial_states = cell.get_initial_states(
+ batch_ref=inputs, batch_dim_idx=1 if time_major else 0)
+ initial_states = map_structure(_switch_grad, initial_states)
+
+ if not time_major:
+ inputs = map_structure(_transpose_batch_time, inputs)
+
+ if sequence_length:
+ max_seq_len = nn.shape(flatten(inputs)[0])[0]
+ mask = sequence_lod.sequence_mask(
+ sequence_length,
+ maxlen=max_seq_len,
+ dtype=flatten(initial_states)[0].dtype)
+ mask = nn.transpose(mask, [1, 0])
+ if is_reverse:
+ inputs = map_structure(lambda x: tensor.reverse(x, axis=[0]), inputs)
+ mask = tensor.reverse(mask, axis=[0]) if sequence_length else None
+
+ # StaticRNN
+ rnn = control_flow.StaticRNN()
+ with rnn.step():
+ inputs = map_structure(rnn.step_input, inputs)
+ states = map_structure(rnn.memory, initial_states)
+ copy_states = map_structure(lambda x: x, states)
+ outputs, new_states = cell(inputs, copy_states, **kwargs)
+ assert_same_structure(states, new_states)
+ if sequence_length:
+ step_mask = rnn.step_input(mask)
+ new_states = map_structure(
+ partial(_maybe_copy, step_mask=step_mask), states, new_states)
+
+ map_structure(rnn.update_memory, states, new_states)
+ flat_outputs = flatten(outputs)
+ map_structure(rnn.step_output, outputs)
+ map_structure(rnn.step_output, new_states)
+
+ rnn_out = rnn()
+ final_outputs = rnn_out[:len(flat_outputs)]
+ final_outputs = pack_sequence_as(outputs, final_outputs)
+ final_states = map_structure(lambda x: x[-1], rnn_out[len(flat_outputs):])
+ final_states = pack_sequence_as(new_states, final_states)
+
+ if is_reverse:
+ final_outputs = map_structure(lambda x: tensor.reverse(x, axis=[0]),
+ final_outputs)
+
+ if not time_major:
+ final_outputs = map_structure(_transpose_batch_time, final_outputs)
+
+ return (final_outputs, final_states)
+
+
+def birnn(cell_fw,
+ cell_bw,
+ inputs,
+ initial_states=None,
+ sequence_length=None,
+ time_major=False,
+ **kwargs):
+ """
+ birnn creates a bidirectional recurrent neural network specified by
+ RNNCell `cell_fw` and `cell_bw`, which performs :code:`cell.call()`
+ (for dygraph mode :code:`cell.forward`) repeatedly until reaches to
+ the maximum length of `inputs` and then concat the outputs for both RNNs
+ along the last axis.
+
+ Arguments:
+ cell_fw(RNNCellBase): An instance of `RNNCellBase`.
+ cell_bw(RNNCellBase): An instance of `RNNCellBase`.
+ inputs(Tensor): the input sequences.
+ If time_major is True, the shape is
+ `[time_steps, batch_size, input_size]`
+ else the shape is `[batch_size, time_steps, input_size]`.
+ initial_states(tuple, optional): A tuple of initial states of
+ `cell_fw` and `cell_bw`.
+ If not provided, `cell.get_initial_states` would be called to
+ produce initial state for each cell. Defaults to None.
+ sequence_length (Tensor, optional): shape `[batch_size]`, dtype: int64
+ or int32. The valid lengths of input sequences. Defaults to None.
+ If `sequence_length` is not None, the inputs are treated as
+ padded sequences. In each input sequence, elements whose time step
+ index are not less than the valid length are treated as paddings.
+ time_major (bool): Whether the first dimension of the input means the
+ time steps. Defaults to False.
+ **kwargs: Additional keyword arguments to pass to `forward` of each cell.
+
+ Returns:
+ (outputs, final_states)
+ outputs (Tensor): the outputs of the bidirectional RNN. It is the
+ concatenation of the outputs from the forward RNN and backward
+ RNN along the last axis.
+ If time major is True, the shape is `[time_steps, batch_size, size]`,
+ else the shape is `[batch_size, time_steps, size]`, where size is
+ `cell_fw.hidden_size + cell_bw.hidden_size`.
+ final_states (tuple): A tuple of the final states of the forward
+ cell and backward cell.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.disable_static()
+
+ cell_fw = paddle.nn.LSTMCell(16, 32)
+ cell_bw = paddle.nn.LSTMCell(16, 32)
+
+ inputs = paddle.rand((4, 23, 16))
+ hf, cf = paddle.rand((4, 32)), paddle.rand((4, 32))
+ hb, cb = paddle.rand((4, 32)), paddle.rand((4, 32))
+ initial_states = ((hf, cf), (hb, cb))
+ outputs, final_states = paddle.fluid.layers.birnn(
+ cell_fw, cell_bw, inputs, initial_states)
+
+ """
+ if initial_states is None:
+ states_fw = cell_fw.get_initial_states(
+ batch_ref=inputs, batch_dim_idx=1 if time_major else 0)
+ states_bw = cell_fw.get_initial_states(
+ batch_ref=inputs, batch_dim_idx=1 if time_major else 0)
+ else:
+ states_fw, states_bw = initial_states
+ outputs_fw, states_fw = rnn(cell_fw,
+ inputs,
+ states_fw,
+ sequence_length,
+ time_major=time_major,
+ **kwargs)
+
+ outputs_bw, states_bw = rnn(cell_bw,
+ inputs,
+ states_bw,
+ sequence_length,
+ time_major=time_major,
+ is_reverse=True,
+ **kwargs)
+
+ outputs = map_structure(lambda x, y: tensor.concat([x, y], -1), outputs_fw,
+ outputs_bw)
+
+ final_states = (states_fw, states_bw)
+ return outputs, final_states
+
+
+class Decoder(object):
+ """
+ :api_attr: Static Graph
+
+ Decoder is the base class for any decoder instance used in `dynamic_decode`.
+ It provides interface for output generation for one time step, which can be
+ used to generate sequences.
+
+ The key abstraction provided by Decoder is:
+
+ 1. :code:`(initial_input, initial_state, finished) = initialize(inits)` ,
+ which generates the input and state for the first decoding step, and gives the
+ initial status telling whether each sequence in the batch is finished.
+ It would be called once before the decoding iterations.
+
+ 2. :code:`(output, next_state, next_input, finished) = step(time, input, state)` ,
+ which transforms the input and state to the output and new state, generates
+ input for the next decoding step, and emits the flag indicating finished status.
+ It is the main part for each decoding iteration.
+
+ 3. :code:`(final_outputs, final_state) = finalize(outputs, final_state, sequence_lengths)` ,
+ which revises the outputs(stack of all time steps' output) and final state(state from the
+ last decoding step) to get the counterpart for special usage.
+ Not necessary to be implemented if no need to revise the stacked outputs and
+ state from the last decoding step. If implemented, it would be called after
+ the decoding iterations.
+
+ Decoder is more general compared to RNNCell, since the returned `next_input`
+ and `finished` make it can determine the input and when to finish by itself
+ when used in dynamic decoding. Decoder always wraps a RNNCell instance though
+ not necessary.
+ """
+
+ def initialize(self, inits):
+ r"""
+ Called once before the decoding iterations.
+
+ Parameters:
+ inits: Argument provided by the caller.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_states, finished)` ). \
+ `initial_inputs` and `initial_states` both are a (possibly nested \
+ structure of) tensor variable[s], and `finished` is a tensor with \
+ bool data type.
+ """
+ raise NotImplementedError
+
+ def step(self, time, inputs, states, **kwargs):
+ r"""
+ Called per step of decoding.
+
+ Parameters:
+ time(Variable): A Tensor with shape :math:`[1]` provided by the caller.
+ The data type is int64.
+ inputs(Variable): A (possibly nested structure of) tensor variable[s].
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ **kwargs: Additional keyword arguments, provided by the caller.
+
+ Returns:
+ tuple: A tuple( :code:(outputs, next_states, next_inputs, finished)` ). \
+ `next_inputs` and `next_states` both are a (possibly nested \
+ structure of) tensor variable[s], and the structure, shape and \
+ data type must be same as the counterpart from input arguments. \
+ `outputs` is a (possibly nested structure of) tensor variable[s]. \
+ `finished` is a Tensor with bool data type.
+ """
+ raise NotImplementedError
+
+ def finalize(self, outputs, final_states, sequence_lengths):
+ r"""
+ Called once after the decoding iterations if implemented.
+
+ Parameters:
+ outputs(Variable): A (possibly nested structure of) tensor variable[s].
+ The structure and data type is same as `output_dtype`.
+ The tensor stacks all time steps' output thus has shape
+ :math:`[time\_step, batch\_size, ...]` , which is done by the caller.
+ final_states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is the `next_states` returned by `decoder.step` at last decoding step,
+ thus has the same structure, shape and data type with states at any time
+ step.
+
+ Returns:
+ tuple: A tuple( :code:`(final_outputs, final_states)` ). \
+ `final_outputs` and `final_states` both are a (possibly nested \
+ structure of) tensor variable[s].
+ """
+ raise NotImplementedError
+
+ @property
+ def tracks_own_finished(self):
+ """
+ Describes whether the Decoder keeps track of finished states by itself.
+
+ `decoder.step()` would emit a bool `finished` value at each decoding
+ step. The emited `finished` can be used to determine whether every
+ batch entries is finished directly, or it can be combined with the
+ finished tracker keeped in `dynamic_decode` by performing a logical OR
+ to take the already finished into account.
+
+ If `False`, the latter would be took when performing `dynamic_decode`,
+ which is the default. Otherwise, the former would be took, which uses
+ the finished value emited by the decoder as all batch entry finished
+ status directly, and it is the case when batch entries might be
+ reordered such as beams in BeamSearchDecoder.
+
+ Returns:
+ bool: A python bool `False`.
+ """
+ return False
+
+
+class BeamSearchDecoder(Decoder):
+ """
+ Decoder with beam search decoding strategy. It wraps a cell to get probabilities,
+ and follows a beam search step to calculate scores and select candidate
+ token ids for each decoding step.
+
+ Please refer to `Beam search `_
+ for more details.
+
+ **NOTE** When decoding with beam search, the `inputs` and `states` of cell
+ would be tiled to `beam_size` (unsqueeze and tile), resulting to shapes like
+ `[batch_size * beam_size, ...]` , which is built into `BeamSearchDecoder` and
+ done automatically. Thus any other tensor with shape `[batch_size, ...]` used
+ in `cell.call` needs to be tiled manually first, which can be completed by using
+ :code:`BeamSearchDecoder.tile_beam_merge_with_batch` . The most common case
+ for this is the encoder output in attention mechanism.
+
+ Returns:
+ BeamSearchDecoder: An instance of decoder which can be used in \
+ `paddle.nn.dynamic_decode` to implement decoding.
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy as np
+ import paddle
+ from paddle.nn import BeamSearchDecoder, dynamic_decode
+ from paddle.nn import GRUCell, Linear, Embedding
+ trg_embeder = Embedding(100, 32)
+ output_layer = Linear(32, 32)
+ decoder_cell = GRUCell(input_size=32, hidden_size=32)
+ decoder = BeamSearchDecoder(decoder_cell,
+ start_token=0,
+ end_token=1,
+ beam_size=4,
+ embedding_fn=trg_embeder,
+ output_fn=output_layer)
+
+ """
+
+ def __init__(self,
+ cell,
+ start_token,
+ end_token,
+ beam_size,
+ embedding_fn=None,
+ output_fn=None):
+ """
+ Constructor of BeamSearchDecoder.
+
+ Parameters:
+ cell(RNNCellBase): An instance of `RNNCellBase` or object with the same interface.
+ start_token(int): The start token id.
+ end_token(int): The end token id.
+ beam_size(int): The beam width used in beam search.
+ embedding_fn(optional): A callable to apply to selected candidate ids.
+ Mostly it is an embedding layer to transform ids to embeddings,
+ and the returned value acts as the `input` argument for `cell.call`.
+ If not provided, the id to embedding transformation must be built into
+ `cell.call`. Default None.
+ output_fn(optional): A callable to apply to the cell's output prior to
+ calculate scores and select candidate token ids. Default None.
+ """
+ self.cell = cell
+ self.embedding_fn = embedding_fn
+ self.output_fn = output_fn
+ self.start_token = start_token
+ self.end_token = end_token
+ self.beam_size = beam_size
+
+ @staticmethod
+ def tile_beam_merge_with_batch(x, beam_size):
+ r"""
+ Tile the batch dimension of a tensor. Specifically, this function takes
+ a tensor t shaped `[batch_size, s0, s1, ...]` composed of minibatch
+ entries `t[0], ..., t[batch_size - 1]` and tiles it to have a shape
+ `[batch_size * beam_size, s0, s1, ...]` composed of minibatch entries
+ `t[0], t[0], ..., t[1], t[1], ...` where each minibatch entry is repeated
+ `beam_size` times.
+
+ Parameters:
+ x(Variable): A tensor with shape `[batch_size, ...]`. The data type
+ should be float32, float64, int32, int64 or bool.
+ beam_size(int): The beam width used in beam search.
+
+ Returns:
+ Variable: A tensor with shape `[batch_size * beam_size, ...]`, whose \
+ data type is same as `x`.
+ """
+ check_type(x, 'x', (Variable),
+ 'BeamSearchDecoder.tile_beam_merge_with_batch')
+ x = nn.unsqueeze(x, [1]) # [batch_size, 1, ...]
+ expand_times = [1] * len(x.shape)
+ expand_times[1] = beam_size
+ x = paddle.tile(x, expand_times) # [batch_size, beam_size, ...]
+ x = nn.transpose(x,
+ list(range(2, len(x.shape))) +
+ [0, 1]) # [..., batch_size, beam_size]
+ # use 0 to copy to avoid wrong shape
+ x = nn.reshape(x, shape=[0] * (len(x.shape) - 2) +
+ [-1]) # [..., batch_size * beam_size]
+ x = nn.transpose(
+ x, [len(x.shape) - 1] +
+ list(range(0,
+ len(x.shape) - 1))) # [batch_size * beam_size, ...]
+ return x
+
+ def _split_batch_beams(self, x):
+ r"""
+ Reshape a tensor with shape `[batch_size * beam_size, ...]` to a new
+ tensor with shape `[batch_size, beam_size, ...]`.
+
+ Parameters:
+ x(Variable): A tensor with shape `[batch_size * beam_size, ...]`. The
+ data type should be float32, float64, int32, int64 or bool.
+
+ Returns:
+ Variable: A tensor with shape `[batch_size, beam_size, ...]`, whose \
+ data type is same as `x`.
+ """
+ check_type(x, 'x', (Variable), 'BeamSearchDecoder._split_batch_beams')
+ # TODO: avoid fake shape in compile-time like tile_beam_merge_with_batch
+ return nn.reshape(x, shape=[-1, self.beam_size] + list(x.shape[1:]))
+
+ def _merge_batch_beams(self, x):
+ r"""
+ Reshape a tensor with shape `[batch_size, beam_size, ...]` to a new
+ tensor with shape `[batch_size * beam_size, ...]`.
+
+ Parameters:
+ x(Variable): A tensor with shape `[batch_size, beam_size, ...]`. The
+ data type should be float32, float64, int32, int64 or bool.
+
+ Returns:
+ Variable: A tensor with shape `[batch_size * beam_size, ...]`, whose \
+ data type is same as `x`.
+ """
+ check_type(x, 'x', (Variable), 'BeamSearchDecoder._merge_batch_beams')
+ # TODO: avoid fake shape in compile-time like tile_beam_merge_with_batch
+ return nn.reshape(x, shape=[-1] + list(x.shape[2:]))
+
+ def _expand_to_beam_size(self, x):
+ r"""
+ This function takes a tensor t shaped `[batch_size, s0, s1, ...]` composed
+ of minibatch entries `t[0], ..., t[batch_size - 1]` and tiles it to have a
+ shape `[batch_size, beam_size, s0, s1, ...]` composed of minibatch entries
+ `t[0], t[0], ..., t[1], t[1], ...` where each minibatch entry is repeated
+ `beam_size` times.
+
+ Parameters:
+ x(Variable): A tensor with shape `[batch_size, ...]`, The data type
+ should be float32, float64, int32, int64 or bool.
+
+ Returns:
+ Variable: A tensor with shape `[batch_size, beam_size, ...]`, whose \
+ data type is same as `x`.
+ """
+ check_type(x, 'x', (Variable), 'BeamSearchDecoder._expand_to_beam_size')
+ x = nn.unsqueeze(x, [1])
+ expand_times = [1] * len(x.shape)
+ expand_times[1] = self.beam_size
+ x = paddle.tile(x, expand_times)
+ return x
+
+ def _mask_probs(self, probs, finished):
+ r"""
+ Mask log probabilities. It forces finished beams to allocate all probability
+ mass to eos and unfinished beams to remain unchanged.
+
+ Parameters:
+ probs(Variable): A tensor with shape `[batch_size, beam_size, vocab_size]`,
+ representing the log probabilities. Its data type should be float32 or float64.
+ finished(Variable): A tensor with shape `[batch_size, beam_size]`,
+ representing the finished status for all beams. Its data type
+ should be bool.
+
+ Returns:
+ Variable: A tensor with the same shape and data type as `x`, \
+ where unfinished beams stay unchanged and finished beams are \
+ replaced with a tensor with all probability on the EOS token.
+ """
+ check_type(probs, 'probs', (Variable), 'BeamSearchDecoder._mask_probs')
+ check_type(finished, 'finished', (Variable),
+ 'BeamSearchDecoder._mask_probs')
+ # TODO: use where_op
+ finished = tensor.cast(finished, dtype=probs.dtype)
+ probs = nn.elementwise_mul(
+ paddle.tile(nn.unsqueeze(finished, [2]), [1, 1, self.vocab_size]),
+ self.noend_mask_tensor,
+ axis=-1) - nn.elementwise_mul(probs, (finished - 1), axis=0)
+ return probs
+
+ def _gather(self, x, indices, batch_size):
+ r"""
+ Gather from the tensor `x` using `indices`.
+
+ Parameters:
+ x(Variable): A tensor with shape `[batch_size, beam_size, ...]`.
+ indices(Variable): A `int64` tensor with shape `[batch_size, beam_size]`,
+ representing the indices that we use to gather.
+ batch_size(Variable): A tensor with shape `[1]`. Its data type should
+ be int32 or int64.
+
+ Returns:
+ Variable: A tensor with the same shape and data type as `x`, \
+ representing the gathered tensor.
+ """
+ check_type(x, 'x', (Variable), 'BeamSearchDecoder._gather')
+ check_type(indices, 'indices', (Variable), 'BeamSearchDecoder._gather')
+ check_type(batch_size, 'batch_size', (Variable),
+ 'BeamSearchDecoder._gather')
+ # TODO: compatibility of int32 and int64
+ batch_size = tensor.cast(
+ batch_size,
+ indices.dtype) if batch_size.dtype != indices.dtype else batch_size
+ batch_size.stop_gradient = True # TODO: remove this
+ batch_pos = paddle.tile(
+ nn.unsqueeze(tensor.range(0, batch_size, 1, dtype=indices.dtype),
+ [1]), [1, self.beam_size])
+ topk_coordinates = nn.stack([batch_pos, indices], axis=2)
+ topk_coordinates.stop_gradient = True
+ return nn.gather_nd(x, topk_coordinates)
+
+ class OutputWrapper(
+ collections.namedtuple("OutputWrapper",
+ ("scores", "predicted_ids", "parent_ids"))):
+ """
+ The structure for the returned value `outputs` of `decoder.step`.
+ A namedtuple includes scores, predicted_ids, parent_ids as fields.
+ """
+ pass
+
+ class StateWrapper(
+ collections.namedtuple(
+ "StateWrapper",
+ ("cell_states", "log_probs", "finished", "lengths"))):
+ """
+ The structure for the argument `states` of `decoder.step`.
+ A namedtuple includes cell_states, log_probs, finished, lengths as fields.
+ """
+ pass
+
+ def initialize(self, initial_cell_states):
+ r"""
+ Initialize the BeamSearchDecoder.
+
+ Parameters:
+ initial_cell_states(Variable): A (possibly nested structure of)
+ tensor variable[s]. An argument provided by the caller.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_states, finished)` ). \
+ `initial_inputs` is a tensor t filled by `start_token` with shape \
+ `[batch_size, beam_size]` when `embedding_fn` is None, or the \
+ returned value of `embedding_fn(t)` when `embedding_fn` is provided. \
+ `initial_states` is a nested structure(namedtuple including cell_states, \
+ log_probs, finished, lengths as fields) of tensor variables, where \
+ `log_probs, finished, lengths` all has a tensor value shaped \
+ `[batch_size, beam_size]` with data type `float32, bool, int64`. \
+ cell_states has a value with the same structure as the input \
+ argument `initial_cell_states` but with tiled shape `[batch_size, beam_size, ...]`. \
+ `finished` is a `bool` tensor filled by False with shape `[batch_size, beam_size]`.
+ """
+ self.kinf = 1e9
+ state = flatten(initial_cell_states)[0]
+ self.batch_size = nn.shape(state)[0]
+
+ self.start_token_tensor = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=self.start_token)
+ self.end_token_tensor = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=self.end_token)
+
+ init_cell_states = map_structure(self._expand_to_beam_size,
+ initial_cell_states)
+ init_inputs = paddle.full(shape=[self.batch_size, self.beam_size],
+ fill_value=self.start_token_tensor,
+ dtype=self.start_token_tensor.dtype)
+ log_probs = paddle.tile(
+ tensor.assign(
+ np.array([[0.] + [-self.kinf] * (self.beam_size - 1)],
+ dtype="float32")), [self.batch_size, 1])
+ if paddle.get_default_dtype() == "float64":
+ log_probs = tensor.cast(log_probs, "float64")
+ # TODO: remove the restriction of force_cpu
+ init_finished = tensor.fill_constant_batch_size_like(
+ input=state,
+ shape=[-1, self.beam_size],
+ dtype="bool",
+ value=False,
+ force_cpu=True)
+ init_lengths = tensor.zeros_like(init_inputs)
+ init_inputs = self.embedding_fn(
+ init_inputs) if self.embedding_fn else init_inputs
+ return init_inputs, self.StateWrapper(init_cell_states, log_probs,
+ init_finished,
+ init_lengths), init_finished
+
+ def _beam_search_step(self, time, logits, next_cell_states, beam_state):
+ r"""
+ Calculate scores and select candidate token ids.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the caller,
+ representing the current time step number of decoding.
+ logits(Variable): A tensor with shape `[batch_size, beam_size, vocab_size]`,
+ representing the logits at the current time step. Its data type is float32.
+ next_cell_states(Variable): A (possibly nested structure of) tensor variable[s].
+ It has the same structure, shape and data type as the `cell_states` of
+ `initial_states` returned by `initialize()`. It represents the next state
+ from the cell.
+ beam_state(Variable): A structure of tensor variables.
+ It is same as the `initial_states` returned by `initialize()` for
+ the first decoding step and `beam_search_state` returned by
+ `step()` for the others.
+
+ Returns:
+ tuple: A tuple( :code:`(beam_search_output, beam_search_state)` ). \
+ `beam_search_output` is a namedtuple(including scores, predicted_ids, \
+ parent_ids as fields) of tensor variables, where \
+ `scores, predicted_ids, parent_ids` all has a tensor value shaped \
+ `[batch_size, beam_size]` with data type `float32, int64, int64`.
+ `beam_search_state` has the same structure, shape and data type \
+ as the input argument `beam_state`.
+
+ """
+ self.vocab_size = logits.shape[-1]
+ self.vocab_size_tensor = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=self.vocab_size)
+ noend_array = [-self.kinf] * self.vocab_size
+ noend_array[self.end_token] = 0
+
+ self.noend_mask_tensor = tensor.assign(np.array(noend_array, "float32"))
+ if paddle.get_default_dtype() == "float64":
+ self.noend_mask_tensor = tensor.cast(self.noend_mask_tensor,
+ "float64")
+
+ step_log_probs = nn.log(nn.softmax(logits))
+ step_log_probs = self._mask_probs(step_log_probs, beam_state.finished)
+ log_probs = nn.elementwise_add(x=step_log_probs,
+ y=beam_state.log_probs,
+ axis=0)
+ # TODO: length penalty
+ scores = log_probs
+ scores = nn.reshape(scores, [-1, self.beam_size * self.vocab_size])
+ # TODO: add grad for topk then this beam search can be used to train
+ topk_scores, topk_indices = paddle.topk(x=scores, k=self.beam_size)
+ beam_indices = nn.elementwise_floordiv(topk_indices,
+ self.vocab_size_tensor)
+ token_indices = nn.elementwise_mod(topk_indices, self.vocab_size_tensor)
+ next_log_probs = self._gather(
+ nn.reshape(log_probs, [-1, self.beam_size * self.vocab_size]),
+ topk_indices, self.batch_size)
+ next_cell_states = map_structure(
+ lambda x: self._gather(x, beam_indices, self.batch_size),
+ next_cell_states)
+ next_finished = self._gather(beam_state.finished, beam_indices,
+ self.batch_size)
+ next_lengths = self._gather(beam_state.lengths, beam_indices,
+ self.batch_size)
+ next_lengths = next_lengths + tensor.cast(nn.logical_not(next_finished),
+ beam_state.lengths.dtype)
+ next_finished = control_flow.logical_or(
+ next_finished,
+ control_flow.equal(token_indices, self.end_token_tensor))
+
+ beam_search_output = self.OutputWrapper(topk_scores, token_indices,
+ beam_indices)
+ beam_search_state = self.StateWrapper(next_cell_states, next_log_probs,
+ next_finished, next_lengths)
+ return beam_search_output, beam_search_state
+
+ def step(self, time, inputs, states, **kwargs):
+ r"""
+ Perform a beam search decoding step, which uses `cell` to get probabilities,
+ and follows a beam search step to calculate scores and select candidate
+ token ids.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the caller,
+ representing the current time step number of decoding.
+ inputs(Variable): A tensor variable. It is same as `initial_inputs`
+ returned by `initialize()` for the first decoding step and
+ `next_inputs` returned by `step()` for the others.
+ states(Variable): A structure of tensor variables.
+ It is same as the `initial_states` returned by `initialize()` for
+ the first decoding step and `beam_search_state` returned by
+ `step()` for the others.
+ **kwargs: Additional keyword arguments, provided by the caller.
+
+ Returns:
+ tuple: A tuple( :code:`(beam_search_output, beam_search_state, next_inputs, finished)` ). \
+ `beam_search_state` and `next_inputs` have the same structure, \
+ shape and data type as the input arguments `states` and `inputs` separately. \
+ `beam_search_output` is a namedtuple(including scores, predicted_ids, \
+ parent_ids as fields) of tensor variables, where \
+ `scores, predicted_ids, parent_ids` all has a tensor value shaped \
+ `[batch_size, beam_size]` with data type `float32, int64, int64`. \
+ `finished` is a `bool` tensor with shape `[batch_size, beam_size]`.
+ """
+ inputs = map_structure(self._merge_batch_beams, inputs)
+ cell_states = map_structure(self._merge_batch_beams, states.cell_states)
+ cell_outputs, next_cell_states = self.cell(inputs, cell_states,
+ **kwargs)
+ cell_outputs = map_structure(self._split_batch_beams, cell_outputs)
+ next_cell_states = map_structure(self._split_batch_beams,
+ next_cell_states)
+
+ if self.output_fn is not None:
+ cell_outputs = self.output_fn(cell_outputs)
+
+ beam_search_output, beam_search_state = self._beam_search_step(
+ time=time,
+ logits=cell_outputs,
+ next_cell_states=next_cell_states,
+ beam_state=states)
+ finished = beam_search_state.finished
+ sample_ids = beam_search_output.predicted_ids
+ sample_ids.stop_gradient = True
+ next_inputs = self.embedding_fn(
+ sample_ids) if self.embedding_fn else sample_ids
+
+ return (beam_search_output, beam_search_state, next_inputs, finished)
+
+ def finalize(self, outputs, final_states, sequence_lengths):
+ r"""
+ Use `gather_tree` to backtrace along the beam search tree and construct
+ the full predicted sequences.
+
+ Parameters:
+ outputs(Variable): A structure(namedtuple) of tensor variables,
+ The structure and data type is same as `output_dtype`.
+ The tensor stacks all time steps' output thus has shape
+ `[time_step, batch_size, ...]`, which is done by the caller.
+ final_states(Variable): A structure(namedtuple) of tensor variables.
+ It is the `next_states` returned by `decoder.step` at last
+ decoding step, thus has the same structure, shape and data type
+ with states at any time step.
+ sequence_lengths(Variable): An `int64` tensor shaped `[batch_size, beam_size]`.
+ It contains sequence lengths for each beam determined during
+ decoding.
+
+ Returns:
+ tuple: A tuple( :code:`(predicted_ids, final_states)` ). \
+ `predicted_ids` is an `int64` tensor shaped \
+ `[time_step, batch_size, beam_size]`. `final_states` is the same \
+ as the input argument `final_states`.
+ """
+ predicted_ids = nn.gather_tree(outputs.predicted_ids,
+ outputs.parent_ids)
+ # TODO: use FinalBeamSearchDecoderOutput as output
+ return predicted_ids, final_states
+
+ @property
+ def tracks_own_finished(self):
+ """
+ BeamSearchDecoder reorders its beams and their finished state. Thus it
+ conflicts with `dynamic_decode` function's tracking of finished states.
+ Setting this property to true to avoid early stopping of decoding due
+ to mismanagement of the finished state.
+
+ Returns:
+ bool: A python bool `True`.
+ """
+ return True
+
+
+def _dynamic_decode_imperative(decoder,
+ inits=None,
+ max_step_num=None,
+ output_time_major=False,
+ impute_finished=False,
+ is_test=False,
+ return_length=False,
+ **kwargs):
+
+ def _maybe_copy(state, new_state, step_mask):
+ # TODO: use where_op
+ state_dtype = state.dtype
+ if convert_dtype(state_dtype) in ["bool"]:
+ state = tensor.cast(state, dtype="float32")
+ new_state = tensor.cast(new_state, dtype="float32")
+ if step_mask.dtype != state.dtype:
+ step_mask = tensor.cast(step_mask, dtype=state.dtype)
+ # otherwise, renamed bool gradients of would be summed up leading
+ # to sum(bool) error.
+ step_mask.stop_gradient = True
+ new_state = nn.elementwise_mul(
+ state, step_mask, axis=0) - nn.elementwise_mul(new_state,
+ (step_mask - 1),
+ axis=0)
+ if convert_dtype(state_dtype) in ["bool"]:
+ new_state = tensor.cast(new_state, dtype=state_dtype)
+ return new_state
+
+ initial_inputs, initial_states, initial_finished = decoder.initialize(inits)
+ inputs, states, finished = (initial_inputs, initial_states,
+ initial_finished)
+ cond = control_flow.logical_not((nn.reduce_all(initial_finished)))
+ sequence_lengths = tensor.cast(tensor.zeros_like(initial_finished), "int64")
+ outputs = None
+
+ step_idx = 0
+ step_idx_tensor = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=step_idx)
+ while cond.numpy():
+ (step_outputs, next_states, next_inputs,
+ next_finished) = decoder.step(step_idx_tensor, inputs, states,
+ **kwargs)
+ if not decoder.tracks_own_finished:
+ # BeamSearchDecoder would track it own finished, since
+ # beams would be reordered and the finished status of each
+ # entry might change. Otherwise, perform logical OR which
+ # would not change the already finished.
+ next_finished = control_flow.logical_or(next_finished, finished)
+ # To confirm states.finished/finished be consistent with
+ # next_finished.
+ tensor.assign(next_finished, finished)
+ next_sequence_lengths = nn.elementwise_add(
+ sequence_lengths,
+ tensor.cast(control_flow.logical_not(finished),
+ sequence_lengths.dtype))
+ if impute_finished: # rectify the states for the finished.
+ next_states = map_structure(
+ lambda x, y: _maybe_copy(x, y, finished), states,
+ next_states)
+ else:
+ warnings.warn(
+ "`next_states` has no `lengths` attribute, the returned `sequence_lengths` would be all zeros."
+ ) if not hasattr(next_states, "lengths") else None
+ next_sequence_lengths = getattr(next_states, "lengths",
+ sequence_lengths)
+
+ outputs = map_structure(
+ lambda x: ArrayWrapper(x),
+ step_outputs) if step_idx == 0 else map_structure(
+ lambda x, x_array: x_array.append(x), step_outputs, outputs)
+ inputs, states, finished, sequence_lengths = (next_inputs, next_states,
+ next_finished,
+ next_sequence_lengths)
+
+ control_flow.increment(x=step_idx_tensor, value=1.0, in_place=True)
+ step_idx += 1
+
+ cond = control_flow.logical_not(nn.reduce_all(finished))
+ if max_step_num is not None and step_idx > max_step_num:
+ break
+
+ final_outputs = map_structure(lambda x: nn.stack(x.array, axis=0), outputs)
+ final_states = states
+
+ try:
+ final_outputs, final_states = decoder.finalize(final_outputs,
+ final_states,
+ sequence_lengths)
+ except NotImplementedError:
+ pass
+
+ if not output_time_major:
+ final_outputs = map_structure(
+ lambda x: nn.transpose(x, [1, 0] + list(range(2, len(x.shape)))),
+ final_outputs)
+
+ return (final_outputs, final_states,
+ sequence_lengths) if return_length else (final_outputs,
+ final_states)
+
+
+def _dynamic_decode_declarative(decoder,
+ inits=None,
+ max_step_num=None,
+ output_time_major=False,
+ impute_finished=False,
+ is_test=False,
+ return_length=False,
+ **kwargs):
+ initial_inputs, initial_states, initial_finished = decoder.initialize(inits)
+ global_inputs, global_states, global_finished = (initial_inputs,
+ initial_states,
+ initial_finished)
+ global_finished.stop_gradient = True
+ step_idx = tensor.fill_constant(shape=[1], dtype="int64", value=0)
+
+ cond = control_flow.logical_not((nn.reduce_all(initial_finished)))
+ if max_step_num is not None:
+ max_step_num = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=max_step_num)
+ while_op = control_flow.While(cond, is_test=is_test)
+
+ sequence_lengths = tensor.cast(tensor.zeros_like(initial_finished), "int64")
+ sequence_lengths.stop_gradient = True
+
+ if is_test:
+ # for test, reuse inputs and states variables to save memory
+ inputs = map_structure(lambda x: x, initial_inputs)
+ states = map_structure(lambda x: x, initial_states)
+ else:
+ # inputs and states of all steps must be saved for backward and training
+ inputs_arrays = map_structure(
+ lambda x: control_flow.array_write(x, step_idx), initial_inputs)
+ states_arrays = map_structure(
+ lambda x: control_flow.array_write(x, step_idx), initial_states)
+
+ def _maybe_copy(state, new_state, step_mask):
+ # TODO: use where_op
+ state_dtype = state.dtype
+ if convert_dtype(state_dtype) in ["bool"]:
+ state = tensor.cast(state, dtype="float32")
+ new_state = tensor.cast(new_state, dtype="float32")
+ if step_mask.dtype != state.dtype:
+ step_mask = tensor.cast(step_mask, dtype=state.dtype)
+ # otherwise, renamed bool gradients of would be summed up leading
+ # to sum(bool) error.
+ step_mask.stop_gradient = True
+ new_state = nn.elementwise_mul(
+ state, step_mask, axis=0) - nn.elementwise_mul(new_state,
+ (step_mask - 1),
+ axis=0)
+ if convert_dtype(state_dtype) in ["bool"]:
+ new_state = tensor.cast(new_state, dtype=state_dtype)
+ return new_state
+
+ def _transpose_batch_time(x):
+ return nn.transpose(x, [1, 0] + list(range(2, len(x.shape))))
+
+ def _create_array_out_of_while(dtype):
+ current_block_idx = default_main_program().current_block_idx
+ default_main_program().current_block_idx = default_main_program(
+ ).current_block().parent_idx
+ tensor_array = control_flow.create_array(dtype)
+ default_main_program().current_block_idx = current_block_idx
+ return tensor_array
+
+ # While
+ with while_op.block():
+ if not is_test:
+ inputs = map_structure(
+ lambda array: control_flow.array_read(array, step_idx),
+ inputs_arrays)
+ states = map_structure(
+ lambda array: control_flow.array_read(array, step_idx),
+ states_arrays)
+ (outputs, next_states, next_inputs,
+ next_finished) = decoder.step(step_idx, inputs, states, **kwargs)
+ if not decoder.tracks_own_finished:
+ # BeamSearchDecoder would track it own finished, since beams would
+ # be reordered and the finished status of each entry might change.
+ # Otherwise, perform logical OR which would not change the already
+ # finished.
+ next_finished = control_flow.logical_or(next_finished,
+ global_finished)
+ next_sequence_lengths = nn.elementwise_add(
+ sequence_lengths,
+ tensor.cast(control_flow.logical_not(global_finished),
+ sequence_lengths.dtype))
+ if impute_finished: # rectify the states for the finished.
+ next_states = map_structure(
+ lambda x, y: _maybe_copy(x, y, global_finished),
+ states,
+ next_states,
+ )
+ else:
+ warnings.warn(
+ "`next_states` has no `lengths` attribute, the returned `sequence_lengths` would be all zeros."
+ ) if not hasattr(next_states, "lengths") else None
+ next_sequence_lengths = getattr(next_states, "lengths",
+ sequence_lengths)
+
+ # create tensor array in global block after dtype[s] of outputs can be got
+ outputs_arrays = map_structure(
+ lambda x: _create_array_out_of_while(x.dtype), outputs)
+
+ map_structure(
+ lambda x, x_array: control_flow.array_write(
+ x, i=step_idx, array=x_array), outputs, outputs_arrays)
+ control_flow.increment(x=step_idx, value=1.0, in_place=True)
+ # update the global_finished first, since it might be also in states of
+ # decoder, which otherwise would write a stale finished status to array
+ tensor.assign(next_finished, global_finished)
+ tensor.assign(next_sequence_lengths, sequence_lengths)
+ if is_test:
+ map_structure(tensor.assign, next_inputs, global_inputs)
+ map_structure(tensor.assign, next_states, global_states)
+ else:
+ map_structure(
+ lambda x, x_array: control_flow.array_write(
+ x, i=step_idx, array=x_array), next_inputs, inputs_arrays)
+ map_structure(
+ lambda x, x_array: control_flow.array_write(
+ x, i=step_idx, array=x_array), next_states, states_arrays)
+ if max_step_num is not None:
+ control_flow.logical_and(
+ control_flow.logical_not(nn.reduce_all(global_finished)),
+ control_flow.less_equal(step_idx, max_step_num), cond)
+ else:
+ control_flow.logical_not(nn.reduce_all(global_finished), cond)
+
+ final_outputs = map_structure(
+ lambda array: tensor.tensor_array_to_tensor(
+ array, axis=0, use_stack=True)[0], outputs_arrays)
+ if is_test:
+ final_states = global_states
+ else:
+ final_states = map_structure(
+ lambda array: control_flow.array_read(array, step_idx),
+ states_arrays)
+
+ try:
+ final_outputs, final_states = decoder.finalize(final_outputs,
+ final_states,
+ sequence_lengths)
+ except NotImplementedError:
+ pass
+
+ if not output_time_major:
+ final_outputs = map_structure(_transpose_batch_time, final_outputs)
+
+ return (final_outputs, final_states,
+ sequence_lengths) if return_length else (final_outputs,
+ final_states)
+
+
+def dynamic_decode(decoder,
+ inits=None,
+ max_step_num=None,
+ output_time_major=False,
+ impute_finished=False,
+ is_test=False,
+ return_length=False,
+ **kwargs):
+ r"""
+ Dynamic decoding performs :code:`decoder.step()` repeatedly until the returned
+ Tensor indicating finished status contains all True values or the number of
+ decoding step reaches to :attr:`max_step_num`.
+
+ :code:`decoder.initialize()` would be called once before the decoding loop.
+ If the `decoder` has implemented `finalize` method, :code:`decoder.finalize()`
+ would be called once after the decoding loop.
+
+ Parameters:
+ decoder(Decoder): An instance of `Decoder`.
+ inits(object, optional): Argument passed to `decoder.initialize`.
+ Default `None`.
+ max_step_num(int, optional): The maximum number of steps. If not provided,
+ decode until the decoder is fully done, or in other words, the returned
+ Tensor by :code:`decoder.step()` indicating finished status contains
+ all True. Default `None`.
+ output_time_major(bool, optional): Indicate the data layout of Tensor included
+ in the final outputs(the first returned value of this method). If
+ attr:`False`, the data layout would be batch major with shape
+ `[batch_size, seq_len, ...]`. If attr:`True`, the data layout would
+ be time major with shape `[seq_len, batch_size, ...]`. Default: `False`.
+ impute_finished(bool, optional): If `True` and `decoder.tracks_own_finished`
+ is False, then states get copied through for batch entries which are
+ marked as finished, which differs with the unfinished using the new states
+ returned by :code:`decoder.step()` and ensures that the final states have
+ the correct values. Otherwise, states wouldn't be copied through when
+ finished. If the returned `final_states` is needed, it should be set as
+ True, which causes some slowdown. Default `False`.
+ is_test(bool, optional): A flag indicating whether to use test mode. In
+ test mode, it is more memory saving. Default `False`.
+ return_length(bool, optional): A flag indicating whether to return an
+ extra Tensor variable in the output tuple, which stores the actual
+ lengths of all decoded sequences. Default `False`.
+ **kwargs: Additional keyword arguments. Arguments passed to `decoder.step`.
+
+ Returns:
+ tuple: A tuple( :code:`(final_outputs, final_states, sequence_lengths)` ) \
+ when `return_length` is True, otherwise a tuple( :code:`(final_outputs, final_states)` ). \
+ The final outputs and states, both are Tensor or nested structure of Tensor. \
+ `final_outputs` has the same structure and data types as the :code:`outputs` \
+ returned by :code:`decoder.step()` , and each Tenser in `final_outputs` \
+ is the stacked of all decoding steps' outputs, which might be revised \
+ by :code:`decoder.finalize()` if the decoder has implemented `finalize`. \
+ `final_states` is the counterpart at last time step of initial states \
+ returned by :code:`decoder.initialize()` , thus has the same structure \
+ with it and has tensors with same shapes and data types. `sequence_lengths` \
+ is an `int64` tensor with the same shape as `finished` returned \
+ by :code:`decoder.initialize()` , and it stores the actual lengths of \
+ all decoded sequences.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy as np
+ import paddle
+ from paddle.nn import BeamSearchDecoder, dynamic_decode
+ from paddle.nn import GRUCell, Linear, Embedding
+ trg_embeder = Embedding(100, 32)
+ output_layer = Linear(32, 32)
+ decoder_cell = GRUCell(input_size=32, hidden_size=32)
+ decoder = BeamSearchDecoder(decoder_cell,
+ start_token=0,
+ end_token=1,
+ beam_size=4,
+ embedding_fn=trg_embeder,
+ output_fn=output_layer)
+ encoder_output = paddle.ones((4, 8, 32), dtype=paddle.get_default_dtype())
+ outputs = dynamic_decode(decoder=decoder,
+ inits=decoder_cell.get_initial_states(encoder_output),
+ max_step_num=10)
+ """
+ if _non_static_mode():
+ return _dynamic_decode_imperative(decoder, inits, max_step_num,
+ output_time_major, impute_finished,
+ is_test, return_length, **kwargs)
+ else:
+ return _dynamic_decode_declarative(decoder, inits, max_step_num,
+ output_time_major, impute_finished,
+ is_test, return_length, **kwargs)
+
+
+class DecodeHelper(object):
+ """
+ DecodeHelper is the base class for any helper instance used in `BasicDecoder`.
+ It provides interface to implement sampling and produce inputs for the next
+ time step in dynamic decoding.
+ """
+
+ def initialize(self):
+ r"""
+ DecodeHelper initialization to produce inputs for the first decoding step
+ and give the initial status telling whether each sequence in the batch
+ is finished. It is the partial of the initialization of `BasicDecoder`.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_finished)` ). \
+ `initial_inputs` is a (possibly nested structure of) tensor \
+ variable[s], and the tensor's shape is `[batch_size, ...]`. \
+ `initial_finished` is a bool tensor with shape `[batch_size]`.
+ """
+ pass
+
+ def sample(self, time, outputs, states):
+ """
+ Perform sampling with some strategies according to `outputs`. It is the
+ partial of `BasicDecoder.step`.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the caller,
+ representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+
+ Returns:
+ Variable: An `int64` tensor representing the sampled ids.
+ """
+ pass
+
+ def next_inputs(self, time, outputs, states, sample_ids):
+ r"""
+ Produce the inputs and states for next time step and give status telling
+ whether each minibatch entry is finished. It is called after `sample` in
+ `BasicDecoder.step`. It is the partial of `BasicDecoder.step`.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the caller,
+ representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+ sample_ids(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `sample_ids` returned by `sample()`.
+
+ Returns:
+ tuple: A tuple( :code:`(finished, next_inputs, next_states)` ). \
+ `next_inputs` and `next_states` both are a (possibly nested \
+ structure of) tensor variable[s], and the structure, shape and \
+ data type of `next_states` must be same as the input argument \
+ `states`. `finished` is a bool tensor with shape `[batch_size]`.
+ """
+ pass
+
+
+class TrainingHelper(DecodeHelper):
+ """
+ TrainingHelper is a subclass of DecodeHelper. It is a decoding helper
+ slicing from the full sequence inputs as the inputs for corresponding
+ step. And it uses `argmax` to sample from the outputs of `cell.call()`.
+
+ Since the needs of sequence inputs, it is used mostly for teach-forcing MLE
+ (maximum likelihood) training, and the sampled would not be used.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ trg_emb = fluid.data(name="trg_emb",
+ shape=[None, None, 128],
+ dtype="float32")
+ trg_seq_length = fluid.data(name="trg_seq_length",
+ shape=[None],
+ dtype="int64")
+ helper = layers.TrainingHelper(trg_emb, trg_seq_length)
+ decoder_cell = layers.GRUCell(hidden_size=128)
+ decoder = layers.BasicDecoder(decoder_cell, helper)
+ outputs = layers.dynamic_decode(
+ decoder,
+ inits=decoder_cell.get_initial_states(trg_emb),
+ is_test=False)
+ """
+
+ def __init__(self, inputs, sequence_length, time_major=False):
+ """
+ Constructor of TrainingHelper.
+
+ Parameters:
+ inputs(Variable): A (possibly nested structure of) tensor variable[s].
+ The shape of tensor should be `[batch_size, sequence_length, ...]`
+ for `time_major == False` or `[sequence_length, batch_size, ...]`
+ for `time_major == True`. It represents the inputs to be sliced
+ from at every decoding step.
+ sequence_length(Variable): A tensor with shape `[batch_size]`.
+ It stores real length of each instance in `inputs`, by which we
+ can label the finished status of each instance at every decoding
+ step.
+ time_major(bool, optional): Indicate the data layout of Tensor included
+ in `inputs`. If `False`, the data layout would be batch major with
+ shape `[batch_size, sequence_length, ...]`. If `True`, the data
+ layout would be time major with shape `[sequence_length, batch_size, ...]`.
+ Default: `False`.
+ """
+ self.inputs = inputs
+ self.sequence_length = sequence_length
+ self.time_major = time_major
+ # extend inputs to avoid to slice out of range in `next_inputs`
+ # may be easier and have better performance than condition_op
+ self.inputs_ = map_structure(
+ lambda x: nn.pad(x,
+ paddings=([0, 1] + [0, 0] * (len(x.shape) - 1))
+ if time_major else ([0, 0, 0, 1] + [0, 0] *
+ (len(x.shape) - 2))),
+ self.inputs)
+
+ def initialize(self):
+ r"""
+ TrainingHelper initialization produces inputs for the first decoding
+ step by slicing at the first time step of full sequence inputs, and it
+ gives initial status telling whether each sequence in the batch is
+ finished. It is the partial of the initialization of `BasicDecoder`.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_finished)` ). \
+ `initial_inputs` is a (possibly nested structure of) tensor \
+ variable[s], and the tensor's shape is `[batch_size, ...]`. \
+ `initial_finished` is a bool tensor with shape `[batch_size]`.
+ """
+ init_finished = control_flow.equal(
+ self.sequence_length,
+ tensor.fill_constant(shape=[1],
+ dtype=self.sequence_length.dtype,
+ value=0))
+ # TODO: support zero length
+ init_inputs = map_structure(
+ lambda x: x[0] if self.time_major else x[:, 0], self.inputs)
+ return init_inputs, init_finished
+
+ def sample(self, time, outputs, states):
+ r"""
+ Perform sampling by using `argmax` according to the `outputs`. Mostly
+ the sampled ids would not be used since the inputs for next decoding
+ step would be got by slicing.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the
+ caller, representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+
+ Returns:
+ Variable: An `int64` tensor with shape `[batch_size]`, representing \
+ the sampled ids.
+ """
+ sample_ids = tensor.argmax(outputs, axis=-1)
+ return sample_ids
+
+ def next_inputs(self, time, outputs, states, sample_ids):
+ r"""
+ Generate inputs for the next decoding step by slicing at corresponding
+ step of the full sequence inputs. Simultaneously, produce the states
+ for next time step by directly using the input `states` and emit status
+ telling whether each minibatch entry reaches to the corresponding length.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the
+ caller, representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+ sample_ids(Variable): An `int64` tensor variable shaped `[batch_size]`.
+ It is same as `sample_ids` returned by `sample()`.
+
+ Returns:
+ tuple: A tuple( :code:`(finished, next_inputs, next_states)` ). \
+ `next_inputs` and `next_states` both are a (possibly nested \
+ structure of) tensor variable[s], and the tensor's shape is \
+ `[batch_size, ...]`. `next_states` is identical to the input \
+ argument `states`. `finished` is a `bool` Tensor with \
+ shape `[batch_size]`.
+ """
+ # TODO: compatibility of int32 and int64
+ time = tensor.cast(time, "int32") if convert_dtype(
+ time.dtype) not in ["int32"] else time
+ if self.sequence_length.dtype != time.dtype:
+ self.sequence_length = tensor.cast(self.sequence_length, time.dtype)
+ next_time = time + 1
+ finished = control_flow.less_equal(self.sequence_length, next_time)
+
+ def _slice(x): # TODO: use Variable.__getitem__
+ axes = [0 if self.time_major else 1]
+ return nn.squeeze(nn.slice(x,
+ axes=axes,
+ starts=[next_time],
+ ends=[next_time + 1]),
+ axes=axes)
+
+ next_inputs = map_structure(_slice, self.inputs_)
+ return finished, next_inputs, states
+
+
+class GreedyEmbeddingHelper(DecodeHelper):
+ """
+ GreedyEmbeddingHelper is a subclass of DecodeHelper. It is a decoding helper
+ uses the argmax of the output (treated as logits) and passes the results
+ through an embedding layer to get inputs for the next decoding step.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ trg_emb = fluid.data(name="trg_emb",
+ shape=[None, None, 128],
+ dtype="float32")
+
+ trg_embeder = lambda x: fluid.embedding(
+ x, size=[10000, 128], param_attr=fluid.ParamAttr(name="trg_embedding"))
+ output_layer = lambda x: layers.fc(x,
+ size=10000,
+ num_flatten_dims=len(x.shape) - 1,
+ param_attr=fluid.ParamAttr(name=
+ "output_w"),
+ bias_attr=False)
+ helper = layers.GreedyEmbeddingHelper(trg_embeder, start_tokens=0, end_token=1)
+ decoder_cell = layers.GRUCell(hidden_size=128)
+ decoder = layers.BasicDecoder(decoder_cell, helper, output_fn=output_layer)
+ outputs = layers.dynamic_decode(
+ decoder=decoder, inits=decoder_cell.get_initial_states(encoder_output))
+ """
+
+ def __init__(self, embedding_fn, start_tokens, end_token):
+ r"""
+ Constructor of GreedyEmbeddingHelper.
+
+ Parameters:
+ embedding_fn(callable): A functor to apply on the argmax results.
+ Mostly it is an embedding layer to transform ids to embeddings.
+ **Note that fluid.embedding should be used here rather than
+ fluid.layers.embedding, since shape of ids is [batch_size].
+ when using fluid.layers.embedding, must unsqueeze in embedding_fn.**
+ start_tokens(Variable): A `int64` tensor shaped `[batch_size]`,
+ representing the start tokens.
+ end_token(int): The end token id.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_states, finished)` ). \
+ `initial_inputs` and `initial_states` both are a (possibly nested \
+ structure of) tensor variable[s], and `finished` is a tensor with \
+ bool data type.
+ """
+ self.embedding_fn = embedding_fn
+ self.start_tokens = start_tokens
+ self.end_token = tensor.fill_constant(shape=[1],
+ dtype="int64",
+ value=end_token)
+
+ def initialize(self):
+ r"""
+ GreedyEmbeddingHelper initialization produces inputs for the first decoding
+ step by using `start_tokens` of the constructor, and gives initial
+ status telling whether each sequence in the batch is finished.
+ It is the partial of the initialization of `BasicDecoder`.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_finished)` ). \
+ `initial_inputs` is same as `start_tokens` of the constructor. \
+ `initial_finished` is a `bool` tensor filled by False and has \
+ the same shape as `start_tokens`.
+ """
+ # TODO: remove the restriction of force_cpu
+ init_finished = tensor.fill_constant_batch_size_like(
+ input=self.start_tokens,
+ shape=[-1],
+ dtype="bool",
+ value=False,
+ force_cpu=True)
+ init_inputs = self.embedding_fn(self.start_tokens)
+ return init_inputs, init_finished
+
+ def sample(self, time, outputs, states):
+ r"""
+ Perform sampling by using `argmax` according to the `outputs`.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the
+ caller, representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+
+ Returns:
+ Variable: An `int64` tensor with shape `[batch_size]`, representing \
+ the sampled ids.
+ """
+ sample_ids = tensor.argmax(outputs, axis=-1)
+ return sample_ids
+
+ def next_inputs(self, time, outputs, states, sample_ids):
+ r"""
+ Generate inputs for the next decoding step by applying `embedding_fn`
+ to `sample_ids`. Simultaneously, produce the states for next time step
+ by directly using the input `states` and emit status telling whether
+ each minibatch entry gets an `end_token` sample.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the
+ caller, representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+ sample_ids(Variable): An `int64` tensor variable shaped `[batch_size]`.
+ It is same as `sample_ids` returned by `sample()`.
+
+ Returns:
+ tuple: A tuple( :code:`(finished, next_inputs, next_states)` ). \
+ `next_inputs` and `next_states` both are a (possibly nested \
+ structure of) tensor variable[s], and the tensor's shape is \
+ `[batch_size, ...]`. `next_states` is identical to the input \
+ argument `states`. `finished` is a `bool` Tensor with \
+ shape `[batch_size]`.
+ """
+ finished = control_flow.equal(sample_ids, self.end_token)
+ next_inputs = self.embedding_fn(sample_ids)
+ return finished, next_inputs, states
+
+
+class SampleEmbeddingHelper(GreedyEmbeddingHelper):
+ """
+ SampleEmbeddingHelper is a subclass of GreedyEmbeddingHelper. It is a decoding
+ helper uses sampling (from a distribution) instead of argmax of the output
+ (treated as logits) and passes the results through an embedding layer to get
+ inputs for the next decoding step.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ trg_emb = fluid.data(name="trg_emb",
+ shape=[None, None, 128],
+ dtype="float32")
+
+ trg_embeder = lambda x: fluid.embedding(
+ x, size=[10000, 128], param_attr=fluid.ParamAttr(name="trg_embedding"))
+ output_layer = lambda x: layers.fc(x,
+ size=10000,
+ num_flatten_dims=len(x.shape) - 1,
+ param_attr=fluid.ParamAttr(name=
+ "output_w"),
+ bias_attr=False)
+ helper = layers.SampleEmbeddingHelper(trg_embeder, start_tokens=0, end_token=1)
+ decoder_cell = layers.GRUCell(hidden_size=128)
+ decoder = layers.BasicDecoder(decoder_cell, helper, output_fn=output_layer)
+ outputs = layers.dynamic_decode(
+ decoder=decoder, inits=decoder_cell.get_initial_states(encoder_output))
+ """
+
+ def __init__(self,
+ embedding_fn,
+ start_tokens,
+ end_token,
+ softmax_temperature=None,
+ seed=None):
+ r"""
+ Constructor of SampleEmbeddingHelper.
+
+ Parameters:
+ embedding_fn(callable): A functor to apply on the argmax results.
+ Mostly it is an embedding layer to transform ids to embeddings.
+ **Note that fluid.embedding should be used here rather than
+ fluid.layers.embedding, since shape of ids is [batch_size].
+ when using fluid.layers.embedding, must unsqueeze in embedding_fn.**
+ start_tokens(Variable): A `int64` tensor shaped `[batch_size]`,
+ representing the start tokens.
+ end_token(int): The end token id.
+ softmax_temperature(float, optional): the value to divide the logits
+ by before computing the softmax. Higher temperatures (above 1.0)
+ lead to more random, while lower temperatures push the sampling
+ distribution towards the argmax. It must be strictly greater than
+ 0. Defaults to None, meaning using a temperature valued 1.0.
+ seed: (int, optional) The sampling seed. Defaults to None, meaning not
+ to use fixed seed.
+
+ Returns:
+ tuple: A tuple( :code:`(initial_inputs, initial_states, finished)` ). \
+ `initial_inputs` and `initial_states` both are a (possibly nested \
+ structure of) tensor variable[s], and `finished` is a tensor with \
+ bool data type.
+ """
+ super(SampleEmbeddingHelper, self).__init__(embedding_fn, start_tokens,
+ end_token)
+ self.softmax_temperature = tensor.fill_constant(
+ shape=[1], dtype="float32", value=softmax_temperature
+ ) if softmax_temperature is not None else None
+ self.seed = seed
+
+ def sample(self, time, outputs, states):
+ r"""
+ Perform sampling from a categorical distribution, and the distribution
+ is computed by `softmax(outputs/softmax_temperature)`.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the
+ caller, representing the current time step number of decoding.
+ outputs(Variable): A tensor variable. Usually it's data type is float32
+ or float64, and it's shape is `[batch_size, vocabulary_size]`,
+ representing the predicted logits of current step. It is same as
+ `outputs` returned by `BasicDecoder.output_fn(BasicDecoder.cell.call())`.
+ states(Variable): A (possibly nested structure of) tensor variable[s].
+ It is same as `new_states` returned by `BasicDecoder.cell.call()`.
+
+ Returns:
+ Variable: An `int64` tensor with shape `[batch_size]`, representing \
+ the sampled ids.
+ """
+ logits = (outputs / self.softmax_temperature
+ ) if self.softmax_temperature is not None else outputs
+ probs = nn.softmax(logits)
+ # TODO: remove this stop_gradient. The stop_gradient of sample_ids can
+ # not pass to probs, since sampling_id op does not have corresponding
+ # grad op and thus can not pass.
+ probs.stop_gradient = True
+ sample_ids = nn.sampling_id(probs,
+ seed=self.seed,
+ dtype=self.start_tokens.dtype)
+ return sample_ids
+
+
+class BasicDecoder(Decoder):
+ """
+ BasicDecoder is a subclass of Decoder and assembles a RNNCell and DecodeHelper
+ instance as members, where the DecodeHelper helps to implement customed
+ decoding strategies.. It performs one decoding step as following steps:
+
+ 1. Perform `cell_outputs, cell_states = cell.call(inputs, states)`
+ to get outputs and new states from cell.
+
+ 2. Perform `sample_ids = helper.sample(time, cell_outputs, cell_states)`
+ to sample ids as decoded results of the current time step.
+
+ 3. Perform `finished, next_inputs, next_states = helper.next_inputs(time,
+ cell_outputs, cell_states, sample_ids)` to generate inputs, states and
+ finished status for the next decoding step.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ trg_emb = fluid.data(name="trg_emb",
+ shape=[None, None, 128],
+ dtype="float32")
+
+ trg_embeder = lambda x: fluid.embedding(
+ x, size=[10000, 128], param_attr=fluid.ParamAttr(name="trg_embedding"))
+ output_layer = lambda x: layers.fc(x,
+ size=10000,
+ num_flatten_dims=len(x.shape) - 1,
+ param_attr=fluid.ParamAttr(name=
+ "output_w"),
+ bias_attr=False)
+ helper = layers.SampleEmbeddingHelper(trg_embeder, start_tokens=0, end_token=1)
+ decoder_cell = layers.GRUCell(hidden_size=128)
+ decoder = layers.BasicDecoder(decoder_cell, helper, output_fn=output_layer)
+ outputs = layers.dynamic_decode(
+ decoder=decoder, inits=decoder_cell.get_initial_states(encoder_output))
+ """
+
+ def __init__(self, cell, helper, output_fn=None):
+ """
+ Constructor of BasicDecoder.
+
+ Parameters:
+ cell(RNNCell): An instance of `RNNCell` or object with the same interface.
+ helper(DecodeHelper): An instance of `DecodeHelper`.
+ output_fn(optional): A callable to apply to the cell's output prior to
+ sampling. Default None.
+ """
+ self.cell = cell
+ self.helper = helper
+ self.output_fn = output_fn
+
+ def initialize(self, initial_cell_states):
+ r"""
+ BasicDecoder initialization includes helper initialization and cell
+ initialization, and cell initialization uses `initial_cell_states` as
+ the result directly.
+
+ Parameters:
+ initial_cell_states(Variable): A (possibly nested structure of)
+ tensor variable[s]. An argument provided by the caller `dynamic_decode`.
+
+ Returns:
+ tuple: A tuple( :code:(initial_inputs, initial_cell_states, finished)` ). \
+ `initial_inputs` and `initial_states` both are a (possibly nested \
+ structure of) tensor variable[s], and `finished` is a tensor with \
+ bool data type. `initial_inputs` and `finished` are the results \
+ of `helper.initialize()`, and `initial_cell_states` is same as \
+ the input argument counterpart.
+ """
+ (initial_inputs, initial_finished) = self.helper.initialize()
+ return initial_inputs, initial_cell_states, initial_finished
+
+ class OutputWrapper(
+ collections.namedtuple("OutputWrapper",
+ ("cell_outputs", "sample_ids"))):
+ """
+ The structure for the returned value `outputs` of `decoder.step`.
+ A namedtuple includes cell_outputs, sample_ids as fields.
+ """
+ pass
+
+ def step(self, time, inputs, states, **kwargs):
+ r"""
+ Perform one decoding step as following steps:
+
+ 1. Perform `cell_outputs, cell_states = cell.call(inputs, states)`
+ to get outputs and new states from cell.
+
+ 2. Perform `sample_ids = helper.sample(time, cell_outputs, cell_states)`
+ to sample ids as decoded results of the current time step.
+
+ 3. Perform `finished, next_inputs, next_states = helper.next_inputs(time,
+ cell_outputs, cell_states, sample_ids)` to generate inputs, states and
+ finished status for the next decoding step.
+
+ Parameters:
+ time(Variable): An `int64` tensor with shape `[1]` provided by the caller,
+ representing the current time step number of decoding.
+ inputs(Variable): A tensor variable. It is same as `initial_inputs`
+ returned by `initialize()` for the first decoding step and
+ `next_inputs` returned by `step()` for the others.
+ states(Variable): A structure of tensor variables.
+ It is same as the `initial_cell_states` returned by `initialize()`
+ for the first decoding step and `next_states` returned by
+ `step()` for the others.
+ **kwargs: Additional keyword arguments, provided by the caller
+ `dynamic_decode`.
+
+ Returns:
+ tuple: A tuple( :code:`(outputs, next_states, next_inputs, finished)` ). \
+ `outputs` is a namedtuple(including cell_outputs, sample_ids, \
+ as fields) of tensor variables, where `cell_outputs` is the result \
+ fof `cell.call()` and `sample_ids` is the result of `helper.sample()`. \
+ `next_states` and `next_inputs` have the same structure, shape \
+ and data type as the input arguments `states` and `inputs` separately. \
+ `finished` is a `bool` tensor with shape `[batch_size]`.
+ """
+ cell_outputs, cell_states = self.cell(inputs, states, **kwargs)
+ if self.output_fn is not None:
+ cell_outputs = self.output_fn(cell_outputs)
+ sample_ids = self.helper.sample(time=time,
+ outputs=cell_outputs,
+ states=cell_states)
+ sample_ids.stop_gradient = True
+ (finished, next_inputs,
+ next_states) = self.helper.next_inputs(time=time,
+ outputs=cell_outputs,
+ states=cell_states,
+ sample_ids=sample_ids)
+ outputs = self.OutputWrapper(cell_outputs, sample_ids)
+ return (outputs, next_states, next_inputs, finished)
+
+
+def dynamic_lstm(input,
+ size,
+ h_0=None,
+ c_0=None,
+ param_attr=None,
+ bias_attr=None,
+ use_peepholes=True,
+ is_reverse=False,
+ gate_activation='sigmoid',
+ cell_activation='tanh',
+ candidate_activation='tanh',
+ dtype='float32',
+ name=None):
+ r"""
+ :api_attr: Static Graph
+
+ **Note**:
+ 1. This OP only supports LoDTensor as inputs. If you need to deal with Tensor, please use :ref:`api_fluid_layers_lstm` .
+ 2. In order to improve efficiency, users must first map the input of dimension [T, hidden_size] to input of [T, 4 * hidden_size], and then pass it to this OP.
+
+ The implementation of this OP include diagonal/peephole connections.
+ Please refer to `Gers, F. A., & Schmidhuber, J. (2000) `_ .
+ If you do not need peephole connections, please set use_peepholes to False .
+
+ This OP computes each timestep as follows:
+
+ .. math::
+ i_t = \sigma(W_{ix}x_{t} + W_{ih}h_{t-1} + b_{x_i} + b_{h_i})
+ .. math::
+ f_t = \sigma(W_{fx}x_{t} + W_{fh}h_{t-1} + b_{x_f} + b_{h_f})
+ .. math::
+ o_t = \sigma(W_{ox}x_{t} + W_{oh}h_{t-1} + b_{x_o} + b_{h_o})
+ .. math::
+ \widetilde{c_t} = tanh(W_{cx}x_t + W_{ch}h_{t-1} + b{x_c} + b_{h_c})
+ .. math::
+ c_t = f_t \odot c_{t-1} + i_t \odot \widetilde{c_t}
+ .. math::
+ h_t = o_t \odot tanh(c_t)
+
+ The symbolic meanings in the formula are as follows:
+
+ - :math:`x_{t}` represents the input at timestep :math:`t`
+ - :math:`h_{t}` represents the hidden state at timestep :math:`t`
+ - :math:`h_{t-1}, c_{t-1}` represent the hidden state and cell state at timestep :math:`t-1` , respectively
+ - :math:`\widetilde{c_t}` represents the candidate cell state
+ - :math:`i_t` , :math:`f_t` and :math:`o_t` represent input gate, forget gate, output gate, respectively
+ - :math:`W` represents weight (e.g., :math:`W_{ix}` is the weight of a linear transformation of input :math:`x_{t}` when calculating input gate :math:`i_t` )
+ - :math:`b` represents bias (e.g., :math:`b_{i}` is the bias of input gate)
+ - :math:`\sigma` represents nonlinear activation function for gate, default sigmoid
+ - :math:`\odot` represents the Hadamard product of a matrix, i.e. multiplying the elements of the same position for two matrices with the same dimension to get another matrix with the same dimension
+
+ Parameters:
+ input ( :ref:`api_guide_Variable_en` ): LSTM input tensor, multi-dimensional LODTensor of shape :math:`[T, 4*hidden\_size]` . Data type is float32 or float64.
+ size (int): must be 4 * hidden_size.
+ h_0( :ref:`api_guide_Variable_en` , optional): The initial hidden state of the LSTM, multi-dimensional Tensor of shape :math:`[batch\_size, hidden\_size]` .
+ Data type is float32 or float64. If set to None, it will be a vector of all 0. Default: None.
+ c_0( :ref:`api_guide_Variable_en` , optional): The initial hidden state of the LSTM, multi-dimensional Tensor of shape :math:`[batch\_size, hidden\_size]` .
+ Data type is float32 or float64. If set to None, it will be a vector of all 0. `h_0` and `c_0` can be None but only at the same time. Default: None.
+ param_attr(ParamAttr, optional): Parameter attribute of weight. If it is None, the default weight parameter attribute is used. Please refer to ref:`api_fluid_ParamAttr' .
+ If the user needs to set this parameter, the dimension must be :math:`[hidden\_size, 4*hidden\_size]` . Default: None.
+
+ - Weights = :math:`\{ W_{cr},W_{ir},W_{fr},W_{or} \}` , the shape is [hidden_size, 4*hidden_size].
+
+ bias_attr (ParamAttr, optional): The bias attribute for the learnable bias
+ weights, which contains two parts, input-hidden
+ bias weights and peephole connections weights if
+ setting `use_peepholes` to `True`.
+ Please refer to ref:`api_fluid_ParamAttr' . Default: None.
+
+ 1. `use_peepholes = False`
+ - Biases = {:math:`b_c, b_i, b_f, b_o`}.
+ - The shape is [1, 4*hidden_size].
+ 2. `use_peepholes = True`
+ - Biases = { :math:`b_c, b_i, b_f, b_o, W_{ic}, \
+ W_{fc}, W_{oc}`}.
+ - The shape is [1, 7*hidden_size].
+
+ use_peepholes (bool, optional): Whether to use peephole connection or not. Default: True.
+ is_reverse (bool, optional): Whether to calculate reverse LSTM. Default: False.
+ gate_activation (str, optional): The activation for input gate, forget gate and output gate. Default: "sigmoid".
+ cell_activation (str, optional): The activation for cell output. Default: "tanh".
+ candidate_activation (str, optional): The activation for candidate hidden state. Default: "tanh".
+ dtype (str, optional): Data type, can be "float32" or "float64". Default: "float32".
+ name (str, optional): A name for this layer. Please refer to :ref:`api_guide_Name` . Default: None.
+
+ Returns:
+ tuple ( :ref:`api_guide_Variable` , :ref:`api_guide_Variable` ) :
+
+ The hidden state and cell state of LSTM
+
+ - hidden: LoDTensor with shape of :math:`[T, hidden\_size]` , and its lod and dtype is the same as the input.
+ - cell: LoDTensor with shape of :math:`[T, hidden\_size]` , and its lod and dtype is the same as the input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ emb_dim = 256
+ vocab_size = 10000
+ hidden_dim = 512
+
+ data = fluid.data(name='x', shape=[None], dtype='int64', lod_level=1)
+ emb = fluid.embedding(input=data, size=[vocab_size, emb_dim], is_sparse=True)
+
+ forward_proj = fluid.layers.fc(input=emb, size=hidden_dim * 4,
+ bias_attr=False)
+
+ forward, cell = fluid.layers.dynamic_lstm(
+ input=forward_proj, size=hidden_dim * 4, use_peepholes=False)
+ forward.shape # (-1, 512)
+ cell.shape # (-1, 512)
+ """
+ assert _non_static_mode(
+ ) is not True, "please use lstm instead of dynamic_lstm in dygraph mode!"
+ assert bias_attr is not False, "bias_attr should not be False in dynamic_lstm."
+
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'dynamic_lstm')
+
+ check_type(h_0, 'h_0', (Variable, type(None)), 'dynamic_lstm')
+ if isinstance(h_0, Variable):
+ check_variable_and_dtype(h_0, 'h_0', ['float32', 'float64'],
+ 'dynamic_lstm')
+
+ check_type(c_0, 'c_0', (Variable, type(None)), 'dynamic_lstm')
+ if isinstance(c_0, Variable):
+ check_variable_and_dtype(c_0, 'c_0', ['float32', 'float64'],
+ 'dynamic_lstm')
+
+ helper = LayerHelper('lstm', **locals())
+ size = size // 4
+ weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[size, 4 * size],
+ dtype=dtype)
+ bias_size = [1, 7 * size]
+ if not use_peepholes:
+ bias_size[1] = 4 * size
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=bias_size,
+ dtype=dtype,
+ is_bias=True)
+
+ hidden = helper.create_variable_for_type_inference(dtype)
+ cell = helper.create_variable_for_type_inference(dtype)
+ batch_gate = helper.create_variable_for_type_inference(dtype)
+ batch_cell_pre_act = helper.create_variable_for_type_inference(dtype)
+ inputs = {'Input': input, 'Weight': weight, 'Bias': bias}
+ batch_size = input.shape[0]
+ if h_0:
+ assert h_0.shape == (batch_size, size), \
+ 'The shape of h0 should be (batch_size, %d)' % size
+ inputs['H0'] = h_0
+ if c_0:
+ assert c_0.shape == (batch_size, size), \
+ 'The shape of c0 should be (batch_size, %d)' % size
+ inputs['C0'] = c_0
+
+ helper.append_op(type='lstm',
+ inputs=inputs,
+ outputs={
+ 'Hidden': hidden,
+ 'Cell': cell,
+ 'BatchGate': batch_gate,
+ 'BatchCellPreAct': batch_cell_pre_act
+ },
+ attrs={
+ 'use_peepholes': use_peepholes,
+ 'is_reverse': is_reverse,
+ 'gate_activation': gate_activation,
+ 'cell_activation': cell_activation,
+ 'candidate_activation': candidate_activation
+ })
+ return hidden, cell
+
+
+@deprecated(since='2.0.0',
+ update_to='paddle.nn.LSTM',
+ reason="This API may occur CUDNN errors.")
+def lstm(input,
+ init_h,
+ init_c,
+ max_len,
+ hidden_size,
+ num_layers,
+ dropout_prob=0.0,
+ is_bidirec=False,
+ is_test=False,
+ name=None,
+ default_initializer=None,
+ seed=-1):
+ r"""
+ :api_attr: Static Graph
+
+ **Note**:
+ This OP only supports running on GPU devices.
+
+ This OP implements LSTM operation - `Hochreiter, S., & Schmidhuber, J. (1997) `_ .
+
+ The implementation of this OP does not include diagonal/peephole connections.
+ Please refer to `Gers, F. A., & Schmidhuber, J. (2000) `_ .
+ If you need peephole connections, please use :ref:`api_fluid_layers_dynamic_lstm` .
+
+ This OP computes each timestep as follows:
+
+ .. math::
+ i_t = \sigma(W_{ix}x_{t} + W_{ih}h_{t-1} + b_{x_i} + b_{h_i})
+ .. math::
+ f_t = \sigma(W_{fx}x_{t} + W_{fh}h_{t-1} + b_{x_f} + b_{h_f})
+ .. math::
+ o_t = \sigma(W_{ox}x_{t} + W_{oh}h_{t-1} + b_{x_o} + b_{h_o})
+ .. math::
+ \widetilde{c_t} = tanh(W_{cx}x_t + W_{ch}h_{t-1} + b{x_c} + b_{h_c})
+ .. math::
+ c_t = f_t \odot c_{t-1} + i_t \odot \widetilde{c_t}
+ .. math::
+ h_t = o_t \odot tanh(c_t)
+
+ The symbolic meanings in the formula are as follows:
+
+ - :math:`x_{t}` represents the input at timestep :math:`t`
+ - :math:`h_{t}` represents the hidden state at timestep :math:`t`
+ - :math:`h_{t-1}, c_{t-1}` represent the hidden state and cell state at timestep :math:`t-1` , respectively
+ - :math:`\widetilde{c_t}` represents the candidate cell state
+ - :math:`i_t` , :math:`f_t` and :math:`o_t` represent input gate, forget gate, output gate, respectively
+ - :math:`W` represents weight (e.g., :math:`W_{ix}` is the weight of a linear transformation of input :math:`x_{t}` when calculating input gate :math:`i_t` )
+ - :math:`b` represents bias (e.g., :math:`b_{i}` is the bias of input gate)
+ - :math:`\sigma` represents nonlinear activation function for gate, default sigmoid
+ - :math:`\odot` represents the Hadamard product of a matrix, i.e. multiplying the elements of the same position for two matrices with the same dimension to get another matrix with the same dimension
+
+ Parameters:
+ input ( :ref:`api_guide_Variable_en` ): LSTM input tensor, 3-D Tensor of shape :math:`[batch\_size, seq\_len, input\_dim]` . Data type is float32 or float64
+ init_h( :ref:`api_guide_Variable_en` ): The initial hidden state of the LSTM, 3-D Tensor of shape :math:`[num\_layers, batch\_size, hidden\_size]` .
+ If is_bidirec = True, shape should be :math:`[num\_layers*2, batch\_size, hidden\_size]` . Data type is float32 or float64.
+ max_len (int): This parameter has no effect and will be discarded.
+ init_c( :ref:`api_guide_Variable_en` ): The initial cell state of the LSTM, 3-D Tensor of shape :math:`[num\_layers, batch\_size, hidden\_size]` .
+ If is_bidirec = True, shape should be :math:`[num\_layers*2, batch\_size, hidden\_size]` . Data type is float32 or float64.
+ hidden_size (int): hidden size of the LSTM.
+ num_layers (int): total layers number of the LSTM.
+ dropout_prob(float, optional): dropout prob, dropout ONLY work between rnn layers, NOT between time steps
+ There is NO dropout work on rnn output of the last RNN layers.
+ Default: 0.0.
+ is_bidirec (bool, optional): If it is bidirectional. Default: False.
+ is_test (bool, optional): If it is in test phrase. Default: False.
+ name (str, optional): A name for this layer. If set None, the layer
+ will be named automatically. Default: None.
+ default_initializer(Initializer, optional): Where use initializer to initialize the Weight
+ If set None, default initializer will be used. Default: None.
+ seed(int, optional): Seed for dropout in LSTM, If it's -1, dropout will use random seed. Default: 1.
+
+
+ Returns:
+ tuple ( :ref:`api_guide_Variable_en` , :ref:`api_guide_Variable_en` , :ref:`api_guide_Variable_en` ) :
+
+ Three tensors, rnn_out, last_h, last_c:
+
+ - rnn_out is result of LSTM hidden, shape is :math:`[seq\_len, batch\_size, hidden\_size]` \
+ if is_bidirec set to True, shape will be :math:`[seq\_len, batch\_size, hidden\_size*2]`
+ - last_h is the hidden state of the last step of LSTM \
+ shape is :math:`[num\_layers, batch\_size, hidden\_size]` \
+ if is_bidirec set to True, shape will be :math:`[num\_layers*2, batch\_size, hidden\_size]`
+ - last_c(Tensor): the cell state of the last step of LSTM \
+ shape is :math:`[num\_layers, batch\_size, hidden\_size]` \
+ if is_bidirec set to True, shape will be :math:`[num\_layers*2, batch\_size, hidden\_size]`
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+ paddle.enable_static()
+
+ emb_dim = 256
+ vocab_size = 10000
+ data = fluid.data(name='x', shape=[None, 100], dtype='int64')
+ emb = fluid.embedding(input=data, size=[vocab_size, emb_dim], is_sparse=True)
+ batch_size = 100
+ dropout_prob = 0.2
+ input_size = 100
+ hidden_size = 150
+ num_layers = 1
+ max_len = 12
+ init_h = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0 )
+ init_c = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0 )
+ rnn_out, last_h, last_c = layers.lstm( emb, init_h, init_c, \
+ max_len, hidden_size, num_layers, \
+ dropout_prob=dropout_prob)
+ rnn_out.shape # (-1, 100, 150)
+ last_h.shape # (1, 20, 150)
+ last_c.shape # (1, 20, 150)
+ """
+
+ helper = LayerHelper('cudnn_lstm', **locals())
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'lstm')
+ check_variable_and_dtype(init_h, 'init_h', ['float32', 'float64'], 'lstm')
+ check_variable_and_dtype(init_c, 'init_c', ['float32', 'float64'], 'lstm')
+ check_type(max_len, 'max_len', (int), 'lstm')
+ check_type(hidden_size, 'hidden_size', (int), 'lstm')
+ check_type(num_layers, 'num_layers', (int), 'lstm')
+ dtype = input.dtype
+ input_shape = list(input.shape)
+ input_size = input_shape[-1]
+ weight_size = 0
+ num_dirrection = 2 if is_bidirec == True else 1
+
+ for i in range(num_layers):
+ if i == 0:
+ input_weight_size = (input_size * hidden_size) * 4 * num_dirrection
+ else:
+ input_weight_size = (hidden_size * hidden_size) * 4 * num_dirrection
+ hidden_weight_size = (hidden_size * hidden_size) * 4 * num_dirrection
+
+ weight_size += input_weight_size + hidden_weight_size
+ weight_size += hidden_size * 8 * num_dirrection
+
+ weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[weight_size],
+ dtype=dtype,
+ default_initializer=default_initializer)
+
+ out = helper.create_variable_for_type_inference(dtype)
+ last_h = helper.create_variable_for_type_inference(dtype)
+ last_c = helper.create_variable_for_type_inference(dtype)
+ reserve = helper.create_variable_for_type_inference(
+ dtype=core.VarDesc.VarType.UINT8, stop_gradient=True)
+ state_out = helper.create_variable_for_type_inference(
+ dtype=core.VarDesc.VarType.UINT8, stop_gradient=True)
+ state_out.persistable = True
+
+ helper.append_op(type='cudnn_lstm',
+ inputs={
+ 'Input': input,
+ 'InitH': init_h,
+ 'InitC': init_c,
+ 'W': weight,
+ },
+ outputs={
+ 'Out': out,
+ 'LastH': last_h,
+ 'LastC': last_c,
+ 'Reserve': reserve,
+ 'StateOut': state_out,
+ },
+ attrs={
+ 'is_bidirec': is_bidirec,
+ 'input_size': input_size,
+ 'hidden_size': hidden_size,
+ 'num_layers': num_layers,
+ 'is_test': is_test,
+ 'dropout_prob': dropout_prob,
+ 'seed': seed,
+ })
+ return out, last_h, last_c
+
+
+def dynamic_lstmp(input,
+ size,
+ proj_size,
+ param_attr=None,
+ bias_attr=None,
+ use_peepholes=True,
+ is_reverse=False,
+ gate_activation='sigmoid',
+ cell_activation='tanh',
+ candidate_activation='tanh',
+ proj_activation='tanh',
+ dtype='float32',
+ name=None,
+ h_0=None,
+ c_0=None,
+ cell_clip=None,
+ proj_clip=None):
+ r"""
+ :api_attr: Static Graph
+
+ **Note**:
+ 1. In order to improve efficiency, users must first map the input of dimension [T, hidden_size] to input of [T, 4 * hidden_size], and then pass it to this OP.
+
+ This OP implements the LSTMP (LSTM Projected) layer.
+ The LSTMP layer has a separate linear mapping layer behind the LSTM layer. -- `Sak, H., Senior, A., & Beaufays, F. (2014) `_ .
+
+ Compared with the standard LSTM layer, LSTMP has an additional linear mapping layer,
+ which is used to map from the original hidden state :math:`h_t` to the lower dimensional state :math:`r_t` .
+ This reduces the total number of parameters and computational complexity, especially when the output unit is relatively large.
+
+ The default implementation of the OP contains diagonal/peephole connections,
+ please refer to `Gers, F. A., & Schmidhuber, J. (2000) `_ .
+ If you need to disable the peephole connections, set use_peepholes to False.
+
+ This OP computes each timestep as follows:
+
+ .. math::
+ i_t = \sigma(W_{ix}x_{t} + W_{ir}r_{t-1} + W_{ic}c_{t-1} + b_i)
+ .. math::
+ f_t = \sigma(W_{fx}x_{t} + W_{fr}r_{t-1} + W_{fc}c_{t-1} + b_f)
+ .. math::
+ o_t = \sigma(W_{ox}x_{t} + W_{or}r_{t-1} + W_{oc}c_{t-1} + b_o)
+ .. math::
+ \widetilde{c_t} = act_g(W_{cx}x_t + W_{cr}r_{t-1} + b_c)
+ .. math::
+ c_t = f_t \odot c_{t-1} + i_t \odot \widetilde{c_t}
+ .. math::
+ h_t = o_t \odot act_h(c_t)
+ .. math::
+ r_t = \overline{act_h}(W_{rh}h_t)
+
+ The symbolic meanings in the formula are as follows:
+
+ - :math:`x_{t}` represents the input at timestep :math:`t`
+ - :math:`h_{t}` represents the hidden state at timestep :math:`t`
+ - :math:`r_{t}` : represents the state of the projected output of the hidden state :math:`h_{t}`
+ - :math:`h_{t-1}, c_{t-1}, r_{t-1}` represent the hidden state, cell state and projected output at timestep :math:`t-1` , respectively
+ - :math:`\widetilde{c_t}` represents the candidate cell state
+ - :math:`i_t` , :math:`f_t` and :math:`o_t` represent input gate, forget gate, output gate, respectively
+ - :math:`W` represents weight (e.g., :math:`W_{ix}` is the weight of a linear transformation of input :math:`x_{t}` when calculating input gate :math:`i_t` )
+ - :math:`b` represents bias (e.g., :math:`b_{i}` is the bias of input gate)
+ - :math:`\sigma` represents nonlinear activation function for gate, default sigmoid
+ - :math:`\odot` represents the Hadamard product of a matrix, i.e. multiplying the elements of the same position for two matrices with the same dimension to get another matrix with the same dimension
+
+ Parameters:
+ input( :ref:`api_guide_Variable_en` ): The input of dynamic_lstmp layer, which supports
+ variable-time length input sequence.
+ It is a multi-dimensional LODTensor of shape :math:`[T, 4*hidden\_size]` . Data type is float32 or float64.
+ size(int): must be 4 * hidden_size.
+ proj_size(int): The size of projection output.
+ param_attr(ParamAttr, optional): Parameter attribute of weight. If it is None, the default weight parameter attribute is used. Please refer to ref:`api_fluid_ParamAttr' .
+ If the user needs to set this parameter, the dimension must be :math:`[hidden\_size, 4*hidden\_size]` . Default: None.
+
+ - Weights = :math:`\{ W_{cr},W_{ir},W_{fr},W_{or} \}` , the shape is [P, 4*hidden_size] , where P is the projection size.
+ - Projection weight = :math:`\{ W_{rh} \}` , the shape is [hidden_size, P].
+
+ bias_attr (ParamAttr, optional): The bias attribute for the learnable bias
+ weights, which contains two parts, input-hidden
+ bias weights and peephole connections weights if
+ setting `use_peepholes` to `True`.
+ Please refer to ref:`api_fluid_ParamAttr' . Default: None.
+
+ 1. `use_peepholes = False`
+ - Biases = {:math:`b_c, b_i, b_f, b_o`}.
+ - The shape is [1, 4*hidden_size].
+ 2. `use_peepholes = True`
+ - Biases = { :math:`b_c, b_i, b_f, b_o, W_{ic}, \
+ W_{fc}, W_{oc}`}.
+ - The shape is [1, 7*hidden_size].
+
+ use_peepholes (bool, optional): Whether to use peephole connection or not. Default True.
+ is_reverse (bool, optional): Whether to calculate reverse LSTM. Default False.
+ gate_activation (str, optional): The activation for input gate, forget gate and output gate. Default "sigmoid".
+ cell_activation (str, optional): The activation for cell output. Default "tanh".
+ candidate_activation (str, optional): The activation for candidate hidden state. Default "tanh".
+ proj_activation(str, optional): The activation for projection output. Default "tanh".
+ dtype (str, optional): Data type, can be "float32" or "float64". Default "float32".
+ name (str, optional): A name for this layer. Please refer to :ref:`api_guide_Name` . Default: None.
+ h_0( :ref:`api_guide_Variable` , optional): The initial hidden state is an optional input, default is zero.
+ This is a tensor with shape :math:`[batch\_size, P]` , where P is the projection size. Default: None.
+ c_0( :ref:`api_guide_Variable` , optional): The initial cell state is an optional input, default is zero.
+ This is a tensor with shape :math:`[batch\_size, P]` , where P is the projection size.
+ `h_0` and `c_0` can be None but only at the same time. Default: None.
+ cell_clip(float, optional): If not None, the cell state is clipped
+ by this value prior to the cell output activation. Default: None.
+ proj_clip(float, optional): If `num_proj > 0` and `proj_clip` is
+ provided, then the projected values are clipped elementwise to within
+ `[-proj_clip, proj_clip]`. Default: None.
+
+ Returns:
+ tuple ( :ref:`api_guide_Variable` , :ref:`api_guide_Variable` ) :
+
+ The hidden state and cell state of LSTMP
+
+ - hidden: LoDTensor with shape of :math:`[T, P]` , and its lod and dtype is the same as the input.
+ - cell: LoDTensor with shape of :math:`[T, hidden\_size]` , and its lod and dtype is the same as the input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ dict_dim, emb_dim = 128, 64
+ data = fluid.data(name='sequence', shape=[None], dtype='int64', lod_level=1)
+ emb = fluid.embedding(input=data, size=[dict_dim, emb_dim])
+ hidden_dim, proj_dim = 512, 256
+ fc_out = fluid.layers.fc(input=emb, size=hidden_dim * 4,
+ act=None, bias_attr=None)
+ proj_out, last_c = fluid.layers.dynamic_lstmp(input=fc_out,
+ size=hidden_dim * 4,
+ proj_size=proj_dim,
+ use_peepholes=False,
+ is_reverse=True,
+ cell_activation="tanh",
+ proj_activation="tanh")
+ proj_out.shape # (-1, 256)
+ last_c.shape # (-1, 512)
+ """
+
+ assert _non_static_mode(
+ ) is not True, "please use lstm instead of dynamic_lstmp in dygraph mode!"
+
+ assert bias_attr is not False, "bias_attr should not be False in dynamic_lstmp."
+
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'dynamic_lstmp')
+
+ check_type(h_0, 'h_0', (Variable, type(None)), 'dynamic_lstmp')
+ if isinstance(h_0, Variable):
+ check_variable_and_dtype(h_0, 'h_0', ['float32', 'float64'],
+ 'dynamic_lstmp')
+
+ check_type(c_0, 'c_0', (Variable, type(None)), 'dynamic_lstmp')
+ if isinstance(c_0, Variable):
+ check_variable_and_dtype(c_0, 'c_0', ['float32', 'float64'],
+ 'dynamic_lstmp')
+
+ helper = LayerHelper('lstmp', **locals())
+ size = size // 4
+ weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[proj_size, 4 * size],
+ dtype=dtype)
+ proj_weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[size, proj_size],
+ dtype=dtype)
+ bias_size = [1, 7 * size]
+ if not use_peepholes:
+ bias_size[1] = 4 * size
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=bias_size,
+ dtype=dtype,
+ is_bias=True)
+
+ projection = helper.create_variable_for_type_inference(dtype)
+ cell = helper.create_variable_for_type_inference(dtype)
+ ordered_proj0 = helper.create_variable_for_type_inference(dtype)
+ batch_hidden = helper.create_variable_for_type_inference(dtype)
+ batch_gate = helper.create_variable_for_type_inference(dtype)
+ batch_cell_pre_act = helper.create_variable_for_type_inference(dtype)
+ inputs = {
+ 'Input': input,
+ 'Weight': weight,
+ 'ProjWeight': proj_weight,
+ 'Bias': bias
+ }
+ batch_size = input.shape[0]
+ if h_0:
+ assert h_0.shape == (batch_size, proj_size), \
+ 'The shape of h0 should be (batch_size, %d)' % proj_size
+ inputs['H0'] = h_0
+ if c_0:
+ assert c_0.shape == (batch_size, size), \
+ 'The shape of c0 should be (batch_size, %d)' % size
+ inputs['C0'] = c_0
+
+ if cell_clip:
+ assert cell_clip >= 0, "cell_clip should not be negative."
+ if proj_clip:
+ assert proj_clip >= 0, "proj_clip should not be negative."
+
+ helper.append_op(type='lstmp',
+ inputs=inputs,
+ outputs={
+ 'Projection': projection,
+ 'Cell': cell,
+ 'BatchHidden': batch_hidden,
+ 'BatchGate': batch_gate,
+ 'BatchCellPreAct': batch_cell_pre_act
+ },
+ attrs={
+ 'use_peepholes': use_peepholes,
+ 'cell_clip': cell_clip,
+ 'proj_clip': proj_clip,
+ 'is_reverse': is_reverse,
+ 'gate_activation': gate_activation,
+ 'cell_activation': cell_activation,
+ 'candidate_activation': candidate_activation,
+ 'proj_activation': proj_activation
+ })
+ return projection, cell
+
+
+def dynamic_gru(input,
+ size,
+ param_attr=None,
+ bias_attr=None,
+ is_reverse=False,
+ gate_activation='sigmoid',
+ candidate_activation='tanh',
+ h_0=None,
+ origin_mode=False):
+ r"""
+ :api_attr: Static Graph
+
+ **Note: The input type of this must be LoDTensor. If the input type to be
+ processed is Tensor, use** :ref:`api_fluid_layers_StaticRNN` .
+
+ This operator is used to perform the calculations for a single layer of
+ Gated Recurrent Unit (GRU) on full sequences step by step. The calculations
+ in one time step support these two modes:
+
+ If ``origin_mode`` is True, then the formula used is from paper
+ `Learning Phrase Representations using RNN Encoder Decoder for Statistical
+ Machine Translation `_ .
+
+ .. math::
+
+ u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)
+
+ r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)
+
+ \\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)
+
+ h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \\tilde{h_t}
+
+
+ if ``origin_mode`` is False, then the formula used is from paper
+ `Empirical Evaluation of Gated Recurrent Neural Networks on Sequence
+ Modeling `_
+
+ .. math::
+
+ u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)
+
+ r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)
+
+ \\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)
+
+ h_t & = (1-u_t) \odot h_{t-1} + u_t \odot \\tilde{h_t}
+
+ :math:`x_t` is the input of current time step, but it is not from ``input`` .
+ This operator does not include the calculations :math:`W_{ux}x_{t}, W_{rx}x_{t}, W_{cx}x_{t}` ,
+ **Note** thus a fully-connect layer whose size is 3 times of ``size`` should
+ be used before this operator, and the output should be used as ``input`` here.
+ :math:`h_{t-1}` is the hidden state from previous time step.
+ :math:`u_t` , :math:`r_t` , :math:`\\tilde{h_t}` and :math:`h_t` stand for
+ update gate, reset gate, candidate hidden and hidden output separately.
+ :math:`W_{uh}, b_u` , :math:`W_{rh}, b_r` and :math:`W_{ch}, b_c` stand for
+ the weight matrix and bias used in update gate, reset gate, candidate hidden
+ calculations. For implementation, the three weight matrix are merged into a
+ tensor shaped :math:`[D, D \\times 3]` , the three bias are concatenated as
+ a tensor shaped :math:`[1, D \\times 3]` , where :math:`D` stands for the
+ hidden size; The data layout of weight tensor is: :math:`W_{uh}` and :math:`W_{rh}`
+ are concatenated with shape :math:`[D, D \\times 2]` lying on the first part,
+ and :math:`W_{ch}` lying on the latter part with shape :math:`[D, D]` .
+
+
+ Args:
+ input(Variable): A LoDTensor whose lod level is 1, representing the input
+ after linear projection. Its shape should be :math:`[T, D \\times 3]` ,
+ where :math:`T` stands for the total sequence lengths in this mini-batch,
+ :math:`D` for the hidden size. The data type should be float32 or float64.
+ size(int): Indicate the hidden size.
+ param_attr(ParamAttr, optional): To specify the weight parameter property.
+ Default: None, which means the default weight parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr, optional): To specify the bias parameter property.
+ Default: None, which means the default bias parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ is_reverse(bool, optional): Whether to compute in the reversed order of
+ input sequences. Default False.
+ gate_activation(str, optional): The activation function corresponding to
+ :math:`act_g` in the formula. "sigmoid", "tanh", "relu" and "identity"
+ are supported. Default "sigmoid".
+ candidate_activation(str, optional): The activation function corresponding to
+ :math:`act_c` in the formula. "sigmoid", "tanh", "relu" and "identity"
+ are supported. Default "tanh".
+ h_0 (Variable, optional): A Tensor representing the initial hidden state.
+ It not provided, the default initial hidden state is 0. The shape is
+ :math:`[N, D]` , where :math:`N` is the number of sequences in the
+ mini-batch, :math:`D` for the hidden size. The data type should be
+ same as ``input`` . Default None.
+
+ Returns:
+ Variable: A LoDTensor whose lod level is 1 and shape is :math:`[T, D]` , \
+ where :math:`T` stands for the total sequence lengths in this mini-batch \
+ :math:`D` for the hidden size. It represents GRU transformed sequence output, \
+ and has the same lod and data type with ``input`` .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ dict_dim, emb_dim = 128, 64
+ data = fluid.data(name='sequence',
+ shape=[None],
+ dtype='int64',
+ lod_level=1)
+ emb = fluid.embedding(input=data, size=[dict_dim, emb_dim])
+ hidden_dim = 512
+ x = fluid.layers.fc(input=emb, size=hidden_dim * 3)
+ hidden = fluid.layers.dynamic_gru(input=x, size=hidden_dim)
+ """
+
+ assert _non_static_mode(
+ ) is not True, "please use gru instead of dynamic_gru in dygraph mode!"
+
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'dynamic_gru')
+
+ check_type(h_0, 'h_0', (Variable, type(None)), 'dynamic_gru')
+ if isinstance(h_0, Variable):
+ check_variable_and_dtype(h_0, 'h_0', ['float32', 'float64'],
+ 'dynamic_gru')
+
+ helper = LayerHelper('gru', **locals())
+ dtype = helper.input_dtype()
+
+ weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[size, 3 * size],
+ dtype=dtype)
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=[1, 3 * size],
+ dtype=dtype,
+ is_bias=True)
+ batch_size = input.shape[0]
+ inputs = {'Input': input, 'Weight': weight, 'Bias': bias}
+ if h_0:
+ assert h_0.shape == (
+ batch_size,
+ size), 'The shape of h0 should be(batch_size, %d)' % size
+ inputs['H0'] = h_0
+
+ hidden = helper.create_variable_for_type_inference(dtype)
+ batch_gate = helper.create_variable_for_type_inference(dtype)
+ batch_reset_hidden_prev = helper.create_variable_for_type_inference(dtype)
+ batch_hidden = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(type='gru',
+ inputs=inputs,
+ outputs={
+ 'Hidden': hidden,
+ 'BatchGate': batch_gate,
+ 'BatchResetHiddenPrev': batch_reset_hidden_prev,
+ 'BatchHidden': batch_hidden
+ },
+ attrs={
+ 'is_reverse': is_reverse,
+ 'gate_activation': gate_activation,
+ 'activation': candidate_activation,
+ 'origin_mode': origin_mode
+ })
+ return hidden
+
+
+def gru_unit(input,
+ hidden,
+ size,
+ param_attr=None,
+ bias_attr=None,
+ activation='tanh',
+ gate_activation='sigmoid',
+ origin_mode=False):
+ r"""
+ :api_attr: Static Graph
+
+ Gated Recurrent Unit (GRU) RNN cell. This operator performs GRU calculations for
+ one time step and it supports these two modes:
+
+ If ``origin_mode`` is True, then the formula used is from paper
+ `Learning Phrase Representations using RNN Encoder Decoder for Statistical
+ Machine Translation `_ .
+
+ .. math::
+
+ u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)
+
+ r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)
+
+ \\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)
+
+ h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \\tilde{h_t}
+
+
+ if ``origin_mode`` is False, then the formula used is from paper
+ `Empirical Evaluation of Gated Recurrent Neural Networks on Sequence
+ Modeling `_
+
+ .. math::
+
+ u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)
+
+ r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)
+
+ \\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)
+
+ h_t & = (1-u_t) \odot h_{t-1} + u_t \odot \\tilde{h_t}
+
+ :math:`x_t` is the input of current time step, but it is not ``input`` .
+ This operator does not include the calculations :math:`W_{ux}x_{t}, W_{rx}x_{t}, W_{cx}x_{t}` ,
+ **Note** thus a fully-connect layer whose size is 3 times of GRU hidden size should
+ be used before this operator, and the output should be used as ``input`` here.
+ :math:`h_{t-1}` is the hidden state from previous time step.
+ :math:`u_t` , :math:`r_t` , :math:`\\tilde{h_t}` and :math:`h_t` stand for
+ update gate, reset gate, candidate hidden and hidden output separately.
+ :math:`W_{uh}, b_u` , :math:`W_{rh}, b_r` and :math:`W_{ch}, b_c` stand for
+ the weight matrix and bias used in update gate, reset gate, candidate hidden
+ calculations. For implementation, the three weight matrix are merged into a
+ tensor shaped :math:`[D, D \\times 3]` , the three bias are concatenated as
+ a tensor shaped :math:`[1, D \\times 3]` , where :math:`D` stands for the
+ hidden size; The data layout of weight tensor is: :math:`W_{uh}` and :math:`W_{rh}`
+ are concatenated with shape :math:`[D, D \\times 2]` lying on the first part,
+ and :math:`W_{ch}` lying on the latter part with shape :math:`[D, D]` .
+
+
+ Args:
+ input(Variable): A 2D Tensor representing the input after linear projection
+ after linear projection. Its shape should be :math:`[N, D \\times 3]` ,
+ where :math:`N` stands for batch size, :math:`D` for the hidden size.
+ The data type should be float32 or float64.
+ hidden(Variable): A 2D Tensor representing the hidden state from previous step.
+ Its shape should be :math:`[N, D]` , where :math:`N` stands for batch size,
+ :math:`D` for the hidden size. The data type should be same as ``input`` .
+ size(int): Indicate the hidden size.
+ param_attr(ParamAttr, optional): To specify the weight parameter property.
+ Default: None, which means the default weight parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr, optional): To specify the bias parameter property.
+ Default: None, which means the default bias parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ activation(str, optional): The activation function corresponding to
+ :math:`act_c` in the formula. "sigmoid", "tanh", "relu" and "identity"
+ are supported. Default "tanh".
+ gate_activation(str, optional): The activation function corresponding to
+ :math:`act_g` in the formula. "sigmoid", "tanh", "relu" and "identity"
+ are supported. Default "sigmoid".
+
+ Returns:
+ tuple: The tuple contains three Tensor variables with the same data type \
+ as ``input`` . They represent the hidden state for next time step ( :math:`h_t` ), \
+ reset previous hidden state ( :math:`r_t \odot h_{t-1}` ), and the \
+ concatenation of :math:`h_t, r_t, \\tilde{h_t}` . And they have shape \
+ :math:`[N, D]` , :math:`[N, D]` , :math:`[N, D \times 3]` separately. \
+ Usually only the hidden state for next time step ( :math:`h_t` ) is used \
+ as output and state, the other two are intermediate results of calculations.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ dict_dim, emb_dim = 128, 64
+ data = fluid.data(name='step_data', shape=[None], dtype='int64')
+ emb = fluid.embedding(input=data, size=[dict_dim, emb_dim])
+ hidden_dim = 512
+ x = fluid.layers.fc(input=emb, size=hidden_dim * 3)
+ pre_hidden = fluid.data(
+ name='pre_hidden', shape=[None, hidden_dim], dtype='float32')
+ hidden = fluid.layers.gru_unit(
+ input=x, hidden=pre_hidden, size=hidden_dim * 3)
+
+ """
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'gru_unit')
+ check_variable_and_dtype(hidden, 'hidden', ['float32', 'float64'],
+ 'gru_unit')
+ check_type(size, 'size', (int), 'gru_unit')
+ activation_dict = dict(
+ identity=0,
+ sigmoid=1,
+ tanh=2,
+ relu=3,
+ )
+ activation = activation_dict[activation]
+ gate_activation = activation_dict[gate_activation]
+
+ helper = LayerHelper('gru_unit', **locals())
+ dtype = helper.input_dtype()
+ size = size // 3
+
+ # create weight
+ weight = helper.create_parameter(attr=helper.param_attr,
+ shape=[size, 3 * size],
+ dtype=dtype)
+
+ gate = helper.create_variable_for_type_inference(dtype)
+ reset_hidden_pre = helper.create_variable_for_type_inference(dtype)
+ updated_hidden = helper.create_variable_for_type_inference(dtype)
+ inputs = {'Input': input, 'HiddenPrev': hidden, 'Weight': weight}
+ # create bias
+ if helper.bias_attr:
+ bias_size = [1, 3 * size]
+ bias = helper.create_parameter(attr=helper.bias_attr,
+ shape=bias_size,
+ dtype=dtype,
+ is_bias=True)
+ inputs['Bias'] = bias
+
+ helper.append_op(
+ type='gru_unit',
+ inputs=inputs,
+ outputs={
+ 'Gate': gate,
+ 'ResetHiddenPrev': reset_hidden_pre,
+ 'Hidden': updated_hidden,
+ },
+ attrs={
+ 'activation': 2, # tanh
+ 'gate_activation': 1, # sigmoid
+ 'origin_mode': origin_mode
+ })
+
+ return updated_hidden, reset_hidden_pre, gate
+
+
+def beam_search(pre_ids,
+ pre_scores,
+ ids,
+ scores,
+ beam_size,
+ end_id,
+ level=0,
+ is_accumulated=True,
+ name=None,
+ return_parent_idx=False):
+ r"""
+
+ Beam search is a classical algorithm for selecting candidate words in a
+ machine translation task.
+
+ Refer to `Beam search `_
+ for more details.
+
+ **This operator only supports LoDTensor.** It is used after finishing
+ scores calculation to perform beam search for one time step. Specifically,
+ after ``ids`` and ``scores`` have been produced, it selects the top-K
+ ( `k` is ``beam_size`` ) candidate word ids of current step from ``ids``
+ according to the corresponding ``scores``. Additionally, ``pre_id`` and
+ ``pre_scores`` are the output of `beam_search` at previous step, they
+ are needed for special use to handle ended candidate translations.
+
+ Note that if ``is_accumulated`` is True, the ``scores`` passed in should
+ be accumulated scores. Otherwise, the ``scores`` are
+ considered as the probabilities of single step and would be transformed to
+ the log field and added up with ``pre_scores`` for final scores in this
+ operator. Length penalty should be done with extra operators before calculating
+ the accumulated scores if needed.
+
+ Please see the following demo for a fully beam search usage example:
+
+ fluid/tests/book/test_machine_translation.py
+
+ Args:
+ pre_ids(Variable): A LodTensor variable (lod level is 2), representing
+ the selected ids of previous step. It is the output of beam_search
+ at previous step. Its shape is `[batch_size, 1]` and its lod is
+ `[[0, 1, ... , batch_size], [0, 1, ..., batch_size]]` at the
+ first step. The data type should be int64.
+ pre_scores(Variable): A LodTensor variable has the same shape and lod
+ with ``pre_ids`` , representing the accumulated scores corresponding
+ to the selected ids of previous step. It is the output of
+ beam_search at previous step. The data type should be float32 or float64.
+ ids(Variable|None): A LodTensor variable containing the candidates ids.
+ It has the same lod with ``pre_ids`` and its shape should be
+ `[batch_size * beam_size, K]`, where `K` supposed to be greater than
+ ``beam_size`` and the first dimension size (decrease as samples reach
+ to the end) should be same as that of ``pre_ids`` . The data type
+ should be int64. It can be None, which use index in ``scores`` as
+ ids.
+ scores(Variable): A LodTensor variable containing the accumulated
+ scores corresponding to ``ids`` . Both its shape and lod are same as
+ those of ``ids`` . The data type should be float32 or float64.
+ beam_size(int): The beam width used in beam search.
+ end_id(int): The id of end token.
+ level(int): **It can be ignored and mustn't change currently.**
+ The 2 level lod used in this operator has the following
+ meaning: The first level describes how many beams each sample has,
+ which would change to 0 when beams of the sample all end (batch reduce);
+ The second level describes how many times each beam is selected.
+ Default 0, which shouldn't be changed currently.
+ is_accumulated(bool): Whether the input ``score`` is accumulated scores.
+ Default True.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+ return_parent_idx(bool, optional): Whether to return an extra Tensor variable
+ in output, which stores the selected ids' parent index in
+ ``pre_ids`` and can be used to update RNN's states by gather operator.
+ Default False.
+
+ Returns:
+ tuple: The tuple contains two or three LodTensor variables. The two LodTensor, \
+ representing the selected ids and the corresponding accumulated scores of \
+ current step, have the same shape `[batch_size, beam_size]` and lod with 2 levels, \
+ and have data types int64 and float32. If ``return_parent_idx`` is True, \
+ an extra Tensor variable preserving the selected ids' parent index \
+ is included, whose shape is `[batch_size * beam_size]` and data type \
+ is int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ # Suppose `probs` contains predicted results from the computation
+ # cell and `pre_ids` and `pre_scores` is the output of beam_search
+ # at previous step.
+ beam_size = 4
+ end_id = 1
+ pre_ids = fluid.data(
+ name='pre_id', shape=[None, 1], lod_level=2, dtype='int64')
+ pre_scores = fluid.data(
+ name='pre_scores', shape=[None, 1], lod_level=2, dtype='float32')
+ probs = fluid.data(
+ name='probs', shape=[None, 10000], dtype='float32')
+ topk_scores, topk_indices = fluid.layers.topk(probs, k=beam_size)
+ accu_scores = fluid.layers.elementwise_add(
+ x=fluid.layers.log(x=topk_scores),
+ y=fluid.layers.reshape(pre_scores, shape=[-1]),
+ axis=0)
+ selected_ids, selected_scores = fluid.layers.beam_search(
+ pre_ids=pre_ids,
+ pre_scores=pre_scores,
+ ids=topk_indices,
+ scores=accu_scores,
+ beam_size=beam_size,
+ end_id=end_id)
+ """
+ check_variable_and_dtype(pre_ids, 'pre_ids', ['int64'], 'beam_search')
+ check_variable_and_dtype(pre_scores, 'pre_scores', ['float32', 'float64'],
+ 'beam_search')
+ check_type(ids, 'ids', (Variable, type(None)), 'beam_search')
+ check_variable_and_dtype(scores, 'scores', ['float32', 'float64'],
+ 'beam_search')
+ helper = LayerHelper('beam_search', **locals())
+ score_type = pre_scores.dtype
+ id_type = pre_ids.dtype
+
+ inputs = {"pre_ids": pre_ids, "pre_scores": pre_scores, "scores": scores}
+ if ids is not None:
+ inputs["ids"] = ids
+
+ selected_scores = helper.create_variable_for_type_inference(
+ dtype=score_type)
+ selected_ids = helper.create_variable_for_type_inference(dtype=id_type)
+ # parent_idx is a tensor used to gather cell states at the next time
+ # step. Though lod in selected_ids can also be used to gather by
+ # sequence_expand, it is not efficient.
+ # gather_op's index input only supports int32 dtype currently
+ parent_idx = helper.create_variable_for_type_inference(dtype="int32")
+
+ helper.append_op(
+ type='beam_search',
+ inputs=inputs,
+ outputs={
+ 'selected_ids': selected_ids,
+ 'selected_scores': selected_scores,
+ 'parent_idx': parent_idx
+ },
+ attrs={
+ # TODO(ChunweiYan) to assure other value support
+ 'level': level,
+ 'beam_size': beam_size,
+ 'end_id': end_id,
+ 'is_accumulated': is_accumulated,
+ })
+ if return_parent_idx:
+ return selected_ids, selected_scores, parent_idx
+ else:
+ return selected_ids, selected_scores
+
+
+def beam_search_decode(ids, scores, beam_size, end_id, name=None):
+ r"""
+
+ This operator is used after beam search has completed. It constructs the
+ full predicted sequences for each sample by walking back along the search
+ paths stored in lod of ``ids`` . The result sequences are stored in a
+ LoDTensor, which uses the following way to parse:
+
+ .. code-block:: text
+
+ If lod = [[0, 3, 6], [0, 12, 24, 40, 54, 67, 82]]
+
+ The first level of lod stands for: There are 2 samples each having 3
+ (beam width) predicted sequence.
+
+ The second level of lod stands for: The lengths of the first sample's
+ 3 predicted sequences are 12, 12, 16; The lengths of the second sample's
+ 3 predicted sequences are 14, 13, 15.
+
+
+ Please see the following demo for a fully beam search usage example:
+ fluid/tests/book/test_machine_translation.py
+
+ Args:
+ ids(Variable): The LoDTensorArray variable containing the selected ids
+ of all steps. Each LoDTensor in it has int64 data type and 2 level
+ lod which can be used to get the search paths.
+ scores(Variable): The LodTensorArray variable containing the accumulated
+ scores corresponding to selected ids of all steps. It has the same size
+ as ``ids`` . Each LoDTensor in it has the same shape and lod as the
+ counterpart in ``ids`` , and has a float32 data type.
+ beam_size(int): The beam width used in beam search.
+ end_id(int): The id of end token.
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ tuple: The tuple contains two LodTensor variables. The two LodTensor, \
+ containing the full sequences of ids and the corresponding accumulated \
+ scores, have the same shape flattened to 1D and have the same 2 level \
+ lod. The lod can be used to get how many predicted sequences each sample \
+ has and how many ids each predicted sequence has.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ # Suppose `ids` and `scores` are LodTensorArray variables reserving
+ # the selected ids and scores of all steps
+ ids = fluid.layers.create_array(dtype='int64')
+ scores = fluid.layers.create_array(dtype='float32')
+ finished_ids, finished_scores = fluid.layers.beam_search_decode(
+ ids, scores, beam_size=5, end_id=0)
+ """
+ check_variable_and_dtype(ids, 'ids', ['int64'], 'beam_search_encode')
+ check_variable_and_dtype(scores, 'scores', ['float32'],
+ 'beam_search_encode')
+ helper = LayerHelper('beam_search_decode', **locals())
+ sentence_ids = helper.create_variable_for_type_inference(dtype=ids.dtype)
+ sentence_scores = helper.create_variable_for_type_inference(
+ dtype=scores.dtype)
+
+ helper.append_op(type="beam_search_decode",
+ inputs={
+ "Ids": ids,
+ "Scores": scores
+ },
+ outputs={
+ "SentenceIds": sentence_ids,
+ "SentenceScores": sentence_scores
+ },
+ attrs={
+ "beam_size": beam_size,
+ "end_id": end_id
+ })
+
+ return sentence_ids, sentence_scores
+
+
+def lstm_unit(x_t,
+ hidden_t_prev,
+ cell_t_prev,
+ forget_bias=0.0,
+ param_attr=None,
+ bias_attr=None,
+ name=None):
+ r"""
+ :api_attr: Static Graph
+
+ Long-Short Term Memory (LSTM) RNN cell. This operator performs LSTM calculations for
+ one time step, whose implementation is based on calculations described in `RECURRENT
+ NEURAL NETWORK REGULARIZATION `_ .
+
+ We add forget_bias to the biases of the forget gate in order to
+ reduce the scale of forgetting. The formula is as follows:
+
+ .. math::
+
+ i_{t} & = \sigma(W_{x_{i}}x_{t} + W_{h_{i}}h_{t-1} + b_{i})
+
+ f_{t} & = \sigma(W_{x_{f}}x_{t} + W_{h_{f}}h_{t-1} + b_{f} + forget\\_bias)
+
+ c_{t} & = f_{t}c_{t-1} + i_{t} tanh (W_{x_{c}}x_{t} + W_{h_{c}}h_{t-1} + b_{c})
+
+ o_{t} & = \sigma(W_{x_{o}}x_{t} + W_{h_{o}}h_{t-1} + b_{o})
+
+ h_{t} & = o_{t} tanh (c_{t})
+
+ :math:`x_{t}` stands for ``x_t`` , corresponding to the input of current time step;
+ :math:`h_{t-1}` and :math:`c_{t-1}` correspond to ``hidden_t_prev`` and ``cell_t_prev`` ,
+ representing the output of from previous time step.
+ :math:`i_{t}, f_{t}, c_{t}, o_{t}, h_{t}` are input gate, forget gate, cell, output gate
+ and hidden calculation.
+
+ Args:
+ x_t(Variable): A 2D Tensor representing the input of current time step.
+ Its shape should be :math:`[N, M]` , where :math:`N` stands for batch
+ size, :math:`M` for the feature size of input. The data type should
+ be float32 or float64.
+ hidden_t_prev(Variable): A 2D Tensor representing the hidden value from
+ previous step. Its shape should be :math:`[N, D]` , where :math:`N`
+ stands for batch size, :math:`D` for the hidden size. The data type
+ should be same as ``x_t`` .
+ cell_t_prev(Variable): A 2D Tensor representing the cell value from
+ previous step. It has the same shape and data type with ``hidden_t_prev`` .
+ forget_bias (float, optional): :math:`forget\\_bias` added to the biases
+ of the forget gate. Default 0.
+ param_attr(ParamAttr, optional): To specify the weight parameter property.
+ Default: None, which means the default weight parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ bias_attr (ParamAttr, optional): To specify the bias parameter property.
+ Default: None, which means the default bias parameter property is used.
+ See usage for details in :ref:`api_fluid_ParamAttr` .
+ name(str, optional): For detailed information, please refer
+ to :ref:`api_guide_Name`. Usually name is no need to set and
+ None by default.
+
+ Returns:
+ tuple: The tuple contains two Tensor variables with the same shape and \
+ data type with ``hidden_t_prev`` , representing the hidden value and \
+ cell value which correspond to :math:`h_{t}` and :math:`c_{t}` in \
+ the formula.
+
+ Raises:
+ ValueError: Rank of x_t must be 2.
+ ValueError: Rank of hidden_t_prev must be 2.
+ ValueError: Rank of cell_t_prev must be 2.
+ ValueError: The 1st dimensions of x_t, hidden_t_prev and cell_t_prev must be the same.
+ ValueError: The 2nd dimensions of hidden_t_prev and cell_t_prev must be the same.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ dict_dim, emb_dim, hidden_dim = 128, 64, 512
+ data = fluid.data(name='step_data', shape=[None], dtype='int64')
+ x = fluid.embedding(input=data, size=[dict_dim, emb_dim])
+ pre_hidden = fluid.data(
+ name='pre_hidden', shape=[None, hidden_dim], dtype='float32')
+ pre_cell = fluid.data(
+ name='pre_cell', shape=[None, hidden_dim], dtype='float32')
+ hidden = fluid.layers.lstm_unit(
+ x_t=x,
+ hidden_t_prev=pre_hidden,
+ cell_t_prev=pre_cell)
+ """
+ helper = LayerHelper('lstm_unit', **locals())
+ check_variable_and_dtype(x_t, 'x_t', ['float32', 'float64'], 'lstm_unit')
+ check_variable_and_dtype(hidden_t_prev, 'hidden_t_prev',
+ ['float32', 'float64'], 'lstm_unit')
+ check_variable_and_dtype(cell_t_prev, 'cell_t_prev', ['float32', 'float64'],
+ 'lstm_unit')
+ if len(x_t.shape) != 2:
+ raise ValueError("Rank of x_t must be 2.")
+
+ if len(hidden_t_prev.shape) != 2:
+ raise ValueError("Rank of hidden_t_prev must be 2.")
+
+ if len(cell_t_prev.shape) != 2:
+ raise ValueError("Rank of cell_t_prev must be 2.")
+
+ if x_t.shape[0] != hidden_t_prev.shape[0] or x_t.shape[
+ 0] != cell_t_prev.shape[0]:
+ raise ValueError("The 1st dimensions of x_t, hidden_t_prev and "
+ "cell_t_prev must be the same.")
+
+ if hidden_t_prev.shape[1] != cell_t_prev.shape[1]:
+ raise ValueError("The 2nd dimensions of hidden_t_prev and "
+ "cell_t_prev must be the same.")
+
+ if bias_attr is None:
+ bias_attr = ParamAttr()
+
+ size = cell_t_prev.shape[1]
+ concat_out = nn.concat(input=[x_t, hidden_t_prev], axis=1)
+ fc_out = nn.fc(input=concat_out,
+ size=4 * size,
+ param_attr=param_attr,
+ bias_attr=bias_attr)
+ dtype = x_t.dtype
+ c = helper.create_variable_for_type_inference(dtype)
+ h = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(type='lstm_unit',
+ inputs={
+ "X": fc_out,
+ "C_prev": cell_t_prev
+ },
+ outputs={
+ "C": c,
+ "H": h
+ },
+ attrs={"forget_bias": forget_bias})
+
+ return h, c
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/sequence_lod.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/sequence_lod.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0ebe1adb61b70d74523eee53a8769073c8a483e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/sequence_lod.py
@@ -0,0 +1,1444 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import paddle
+from .layer_function_generator import templatedoc
+from ..framework import core, Variable, _non_static_mode, in_dygraph_mode, _in_legacy_dygraph, convert_np_dtype_to_dtype_
+from ..layer_helper import LayerHelper
+from ..data_feeder import check_variable_and_dtype, check_type, check_dtype
+from ..core import VarDesc
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'sequence_conv',
+ 'sequence_softmax',
+ 'sequence_pool',
+ 'sequence_concat',
+ 'sequence_first_step',
+ 'sequence_last_step',
+ 'sequence_slice',
+ 'sequence_expand',
+ 'sequence_expand_as',
+ 'sequence_pad',
+ 'sequence_unpad',
+ 'sequence_reshape',
+ 'sequence_scatter',
+ 'sequence_enumerate',
+ 'sequence_mask',
+ 'sequence_reverse',
+]
+
+
+@templatedoc()
+def sequence_conv(input,
+ num_filters,
+ filter_size=3,
+ filter_stride=1,
+ padding=True,
+ padding_start=None,
+ bias_attr=None,
+ param_attr=None,
+ act=None,
+ name=None):
+ r"""
+
+ Note:
+ Only receives LoDTensor as input. If your input is Tensor, please use conv2d Op.(fluid.layers.** :ref:`api_fluid_layers_conv2d` ).
+
+ This operator receives input sequences with variable length and other convolutional
+ configuration parameters(num_filters, filter_size) to apply the convolution operation.
+ It fills all-zero padding data on both sides of the sequence by default to ensure that
+ the output is the same length as the input. You can customize the padding behavior by
+ configuring the parameter :attr:`padding\_start` .
+
+ **Warning:** the parameter :attr:`padding` take no effect and will be deprecated in the future.
+
+ .. code-block:: text
+
+ Here we will illustrate the details of the padding operation:
+ For a mini-batch of 2 variable lengths sentences, containing 3, and 1 time-steps:
+ Assumed input (X) is a [4, N] float LoDTensor, and for the sake of simplicity, we assume N=2.
+ input.data = [[1, 1],
+ [2, 2],
+ [3, 3],
+ [4, 4]]
+
+ This is to say that input (X) has 4 words and the dimension of each word
+ representation is 2.
+
+ * Case1:
+
+ If padding_start is -1 and filter_size is 3.
+ The length of padding data is calculated as follows:
+ up_pad_len = max(0, -padding_start) = 1
+ down_pad_len = max(0, filter_size + padding_start - 1) = 1
+
+ The output of the input sequence after padding is:
+ data_aftet_padding = [[0, 0, 1, 1, 2, 2],
+ [1, 1, 2, 2, 3, 3],
+ [2, 2, 3, 3, 0, 0],
+ [0, 0, 4, 4, 0, 0]]
+
+ It will be multiplied by the filter weight to get the final output.
+ Assume num_filters = 3
+ output.data = [[ 0.3234, -0.2334, 0.7433],
+ [ 0.5646, 0.9464, -0.1223],
+ [-0.1343, 0.5653, 0.4555],
+ [ 0.9954, -0.1234, -0.1234]]
+ output.shape = [4, 3] # 3 = num_filters
+ output.lod = [[0, 3, 4]] # Remain the same
+
+
+ Args:
+ input (Variable): LoDTensor with shape :math:`(M, K)`, where M is the total time-step of mini-batch
+ and K is hidden_size of input. Only lod_level of 1 is supported. The data type should be float32 or
+ float64.
+ num_filters (int): the number of filters.
+ filter_size (int): the height of filter. Specified filter width is not supported, the width is
+ hidden_size by default. Default: 3.
+ filter_stride (int): stride of the filter. Currently only supports :attr:`stride` = 1.
+ padding (bool): the parameter :attr:`padding` take no effect and will be discarded in the
+ future. Currently, it will always pad input to make sure the length of the output is
+ the same as input whether :attr:`padding` is set true or false. Because the length of
+ input sequence may be shorter than :attr:`filter\_size`, which will cause the convolution
+ result to not be computed correctly. These padding data will not be trainable or updated
+ while training. Default: True.
+ padding_start (int): It is used to indicate the start index for padding the input
+ sequence, which can be negative. The negative number means to pad
+ :attr:`|padding_start|` time-steps of all-zero data at the beginning of each instance.
+ The positive number means to skip :attr:`padding_start` time-steps of each instance,
+ and it will pad :math:`filter\_size + padding\_start - 1` time-steps of all-zero data
+ at the end of the sequence to ensure that the output is the same length as the input.
+ If set None, the same length :math:`\\frac{filter\_size}{2}` of data will be filled
+ on both sides of the sequence. If set 0, the length of :math:`filter\_size - 1` data
+ is padded at the end of each input sequence. Default: None.
+ bias_attr (ParamAttr): To specify the bias parameter property. Default: None, which means the
+ default bias parameter property is used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ param_attr (ParamAttr): To specify the weight parameter property. Default: None, which means the
+ default weight parameter property is used. See usage for details in :ref:`api_fluid_ParamAttr` .
+ act (str): Activation to be applied to the output of this layer, such as tanh, softmax,
+ sigmoid, relu. For more information, please refer to :ref:`api_guide_activations_en` . Default: None.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: LoDTensor with the same length as input. The data type is float32 or float64, which is same as input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[-1, 10], dtype='float32', lod_level=1)
+ x_conved = paddle.static.nn.sequence_conv(input=x, num_filters=2, filter_size=3, padding_start=-1)
+ """
+
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'sequence_conv')
+ helper = LayerHelper('sequence_conv', **locals())
+ dtype = helper.input_dtype()
+ filter_shape = [filter_size * input.shape[1], num_filters]
+ filter_param = helper.create_parameter(attr=helper.param_attr,
+ shape=filter_shape,
+ dtype=dtype)
+ pre_bias = helper.create_variable_for_type_inference(dtype)
+ if padding_start is None:
+ padding_start = -int(filter_size // 2)
+
+ helper.append_op(type='sequence_conv',
+ inputs={
+ 'X': [input],
+ 'Filter': [filter_param],
+ },
+ outputs={"Out": pre_bias},
+ attrs={
+ 'contextStride': filter_stride,
+ 'contextStart': padding_start,
+ 'contextLength': filter_size,
+ })
+ pre_act = helper.append_bias_op(pre_bias)
+ return helper.append_activation(pre_act)
+
+
+def sequence_softmax(input, use_cudnn=False, name=None):
+ r"""
+
+ Note:
+ The input type of the OP must be LoDTensor. For Tensor, use:** :ref:`api_fluid_layers_softmax`
+
+ A LoD-tensor can be regarded as several sequences, and this op apply softmax algo on each sequence.
+ The shape of input Tensor can be :math:`[N, 1]` or :math:`[N]`, where :math:`N`
+ is the sum of the length of all sequences. Recommended usage: :math:`[N]`.
+
+ For i-th sequence in a mini-batch:
+
+ .. math::
+
+ Out(X[lod[i]:lod[i+1]], :) = \\frac{\exp(X[lod[i]:lod[i+1], :])}{\sum(\exp(X[lod[i]:lod[i+1], :]))}
+
+ For example, for a LoD-Tensor with 6 sequences ([3, 2, 4, 1, 2, 3] - sequence length list in order),
+ the lod in the runtime is [[0, 3, 5, 9, 10, 12, 15]],
+ then softmax will be computed among :math:`X[0:3,:],X[3:5,:],X[5:9,:],X[9:10,:],X[10:12,:],X[12:15,:]`,
+ and :math:`N` turns out to be 15.
+
+ .. code-block:: text
+
+ *Case 1:
+
+ Given:
+ input.data = [0.7, 1, 0.6,
+ 1.5, 1.1,
+ 1.2, 0.2, 0.6, 1.9,
+ 3.1,
+ 2.5, 0.8,
+ 0.1, 2.4, 1.3]
+ input.lod = [[0, 3, 5, 9, 10, 12, 15]]
+ then:
+ output.data = [0.30724832, 0.41474187, 0.2780098,
+ 0.59868765, 0.40131235,
+ 0.2544242, 0.09359743, 0.13963096, 0.5123474,
+ 1.,
+ 0.84553474, 0.15446526,
+ 0.06995796, 0.69777346, 0.23226859]
+ output.lod = [[0, 3, 5, 9, 10, 12, 15]]
+
+
+ Args:
+ input (Variable):A LoDTensor with shape of :math:`[N, 1]` or :math:`[N]`, Recommended usage: :math:`[N]`.
+ Supported data types: float32, float64.
+ use_cudnn (bool, optional): Use cudnn kernel or not. Effective only when the cudnn version of the paddle
+ library is installed and GPU is used for training or reasoning. Default: False.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: A LoD-Tensor which has the same shape and data type with input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[7, 1],
+ dtype='float32', lod_level=1)
+ x_sequence_softmax_1 = paddle.static.nn.sequence_softmax(input=x)
+
+ y = paddle.static.data(name='y', shape=[7],
+ dtype='float32', lod_level=1)
+ x_sequence_softmax_2 = paddle.static.nn.sequence_softmax(input=y)
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_softmax', **locals())
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'sequence_softmax')
+ dtype = helper.input_dtype()
+ softmax_out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type="sequence_softmax",
+ inputs={"X": input},
+ outputs={"Out": softmax_out},
+ attrs={"use_cudnn": use_cudnn})
+ return softmax_out
+
+
+def sequence_pool(input, pool_type, is_test=False, pad_value=0.0):
+ r"""
+
+ Note:
+ Only receives LoDTensor as input. If your input is Tensor, please use pool2d Op.(fluid.layers.** :ref:`api_fluid_layers_pool2d` ).
+
+ This operator only supports LoDTensor as input. It will apply specified pooling
+ operation on the input LoDTensor. It pools features of all time-steps of each
+ sequence at the last lod_level using :attr:`pool_type` mentioned in the parameters,
+ such as sum, average, sqrt, etc.
+
+ It supports six pool_type:
+
+ - average: :math:`Out[i] = \\frac{\sum_i X_i}{N}`
+ - sum: :math:`Out[i] = \sum_jX_{ij}`
+ - sqrt: :math:`Out[i] = \\frac{\sum_jX_{ij}}{\sqrt{len(X_i)}}`
+ - max: :math:`Out[i] = max(X_i)`
+ - last: :math:`Out[i] = X_{N_i}`
+ - first: :math:`Out[i]` = X_0
+
+ where :math:`N_i` is the length of i-th input sequence.
+
+ .. code-block:: text
+
+ Case 1:
+ input is a 1-level LoDTensor and pad_value = 0.0:
+ input.lod = [[0, 2, 5, 7, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ output is LoDTensor:
+ out.shape = [4, 1]
+ with condition out.shape[0] == len(x.lod[-1]) == 4
+
+ for different pool_type:
+ average: out.data = [[2.], [4.], [3.], [0.0]], where 2.=(1. + 3.)/2, 4.=(2. + 4. + 6.)/3, 3.=(5. + 1.)/2
+ sum : out.data = [[4.], [12.], [6.], [0.0]], where 4.=1. + 3., 12.=2. + 4. + 6., 6.=5. + 1.
+ sqrt : out.data = [[2.82], [6.93], [4.24], [0.0]], where 2.82=(1. + 3.)/sqrt(2), 6.93=(2. + 4. + 6.)/sqrt(3), 4.24=(5. + 1.)/sqrt(2)
+ max : out.data = [[3.], [6.], [5.], [0.0]], where 3.=max(1., 3.), 6.=max(2., 4., 6.), 5.=max(5., 1.)
+ last : out.data = [[3.], [6.], [1.], [0.0]], where 3.=last(1., 3.), 6.=last(2., 4., 6.), 1.=last(5., 1.)
+ first : out.data = [[1.], [2.], [5.], [0.0]], where 1.=first(1., 3.), 2.=first(2., 4., 6.), 5.=first(5., 1.)
+
+ and all above [0.0] at last of out.data is padding data.
+
+ Case 2:
+ input is a 2-level LoDTensor containing 3 sequences with length info [2, 0, 3],
+ where 0 means empty sequence.
+ The first sequence contains 2 subsequence with length info [1, 2];
+ The last sequence contains 3 subsequence with length info [1, 0, 3].
+ input.lod = [[0, 2, 2, 5], [0, 1, 3, 4, 4, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ If pool_typ = sum, it will apply pooling on last lod_level [0, 1, 3, 4, 4, 7]. pad_value = 0.0
+ output is LoDTensor:
+ out.shape= [5, 1]
+ out.lod = [[0, 2, 2, 5]]
+ where out.shape[0] == len(x.lod[-1]) == 5
+ sum: out.data = [[1.], [5.], [4.], [0.0], [12.]]
+ where 1.=1., 5.=3. + 2., 4.=4., 0.0=pad_value, 12.=6. + 5. + 1.
+
+ Args:
+ input (variable): LoDTensor with lod_level no more than 2. The data type should be float32 or float64.
+ pool_type (str): The pooling type that supports average, sum, sqrt, max, last or first.
+ is_test (bool): Only works when :attr:`pool_type` is max. If set False, a temporary Tenosr maxIndex is
+ created to record the index information corresponding to the maximum value, which is used for backward
+ gradient calculation in the training phase. Default: False.
+ pad_value (float): Used to pad the pooling result for empty input sequence. Default: 0.0
+
+ Returns:
+ Variable: LoDTensor after pooling with data type float32 or float64.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[None, 10], dtype='float32', lod_level=1)
+ avg_x = paddle.static.nn.sequence_pool(input=x, pool_type='average')
+ sum_x = paddle.static.nn.sequence_pool(input=x, pool_type='sum')
+ sqrt_x = paddle.static.nn.sequence_pool(input=x, pool_type='sqrt')
+ max_x = paddle.static.nn.sequence_pool(input=x, pool_type='max')
+ last_x = paddle.static.nn.sequence_pool(input=x, pool_type='last')
+ first_x = paddle.static.nn.sequence_pool(input=x, pool_type='first')
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'sequence_pool')
+ helper = LayerHelper('sequence_pool', **locals())
+ dtype = helper.input_dtype()
+ pool_out = helper.create_variable_for_type_inference(dtype)
+ max_index = helper.create_variable_for_type_inference(dtype)
+
+ helper.append_op(type="sequence_pool",
+ inputs={"X": input},
+ outputs={
+ "Out": pool_out,
+ "MaxIndex": max_index
+ },
+ attrs={
+ "pooltype": pool_type.upper(),
+ "is_test": is_test,
+ "pad_value": pad_value
+ })
+
+ # when pool_type is max, variable max_index is initialized,
+ # so we stop the gradient explicitly here
+ if pool_type == 'max':
+ max_index.stop_gradient = True
+
+ return pool_out
+
+
+@templatedoc()
+def sequence_concat(input, name=None):
+ """
+
+ Note:
+ Only receives LoDTensor as input. If your input is Tensor, please use concat Op.(fluid.layers.** :ref:`api_fluid_layers_concat` ).
+
+ This operator only supports LoDTensor as input. It concatenates the multiple LoDTensor from input by the LoD information,
+ and outputs the concatenated LoDTensor.
+
+ .. code-block:: text
+
+ input is a list of LoDTensor:
+ input = [x1, x2]
+ where:
+ x1.lod = [[0, 3, 5]]
+ x1.data = [[1], [2], [3], [4], [5]]
+ x1.shape = [5, 1]
+
+ x2.lod = [[0, 2, 4]]
+ x2.data = [[6], [7], [8], [9]]
+ x2.shape = [4, 1]
+ and should satisfy: len(x1.lod[0]) == len(x2.lod[0])
+
+ output is LoDTensor:
+ out.lod = [[0, 3+2, 5+4]]
+ out.data = [[1], [2], [3], [6], [7], [4], [5], [8], [9]]
+ out.shape = [9, 1]
+
+ Args:
+ input(list of Variable): List of LoDTensor to be concatenated. The length of each LoDTensor should be same.
+ The data type can be float32, float64 or int64.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: Output the concatenated LoDTensor. The data type is same as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[-1, 10], dtype='float32', lod_level=1)
+ y = paddle.static.data(name='y', shape=[-1, 10], dtype='float32', lod_level=1)
+ out = paddle.static.nn.sequence_concat(input=[x, y])
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_concat', **locals())
+
+ check_type(input, 'input', list, 'fluid.layers.sequence_concat')
+ for i, input_x in enumerate(input):
+ check_variable_and_dtype(input_x, 'input[' + str(i) + ']',
+ ['int64', 'float32', 'float64'],
+ 'fluid.layers.sequence_concat')
+
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ helper.append_op(type='sequence_concat',
+ inputs={'X': input},
+ outputs={'Out': [out]})
+ return out
+
+
+def sequence_first_step(input):
+ """
+
+ Only supports LoDTensor as input. Given the input LoDTensor, it will
+ select first time-step feature of each sequence as output.
+
+ .. code-block:: text
+
+ Case 1:
+ input is 1-level LoDTensor:
+ input.lod = [[0, 2, 5, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ output is a LoDTensor:
+ out.shape = [3, 1]
+ out.shape[0] == len(x.lod[-1]) == 3
+ out.data = [[1.], [2.], [5.]], where 1.=first(1., 3.), 2.=first(2., 4., 6.), 5.=first(5., 1.)
+
+ Case 2:
+ input is a 2-level LoDTensor containing 3 sequences with length info [2, 0, 3],
+ where 0 means empty sequence.
+ The first sequence contains 2 subsequence with length info [1, 2];
+ The last sequence contains 3 subsequence with length info [1, 0, 3].
+ input.lod = [[0, 2, 2, 5], [0, 1, 3, 4, 4, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ It will apply pooling on last lod_level [0, 1, 3, 4, 4, 7]. pad_value = 0.0
+ output is a LoDTensor:
+ out.shape= [5, 1]
+ out.lod = [[0, 2, 2, 5]]
+ out.shape[0] == len(x.lod[-1]) == 5
+ out.data = [[1.], [3.], [4.], [0.0], [6.]]
+ where 1.=first(1.), 3.=first(3., 2.), 4.=first(4.), 0.0 = pad_value, 6.=first(6., 5., 1.)
+
+ Args:
+ input(Variable): LoDTensor with lod_level no more than 2. The data type should be float32 or float64.
+
+ Returns:
+ Variable: LoDTensor consist of the sequence's first step vector. The data type is float32 or float64.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[None, 10], dtype='float32', lod_level=1)
+ x_first_step = paddle.static.nn.sequence_first_step(input=x)
+ """
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'sequence_first_step')
+ return sequence_pool(input=input, pool_type="first")
+
+
+def sequence_last_step(input):
+ """
+
+ Only supports LoDTensor as input. Given the input LoDTensor, it will
+ select last time-step feature of each sequence as output.
+
+ .. code-block:: text
+
+ Case 1:
+ input is 1-level LoDTensor:
+ input.lod = [[0, 2, 5, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ output is a LoDTensor:
+ out.shape = [3, 1]
+ out.shape[0] == len(x.lod[-1]) == 3
+ out.data = [[3.], [6.], [1.]], where 3.=last(1., 3.), 6.=last(2., 4., 6.), 1.=last(5., 1.)
+
+ Case 2:
+ input is a 2-level LoDTensor containing 3 sequences with length info [2, 0, 3],
+ where 0 means empty sequence.
+ The first sequence contains 2 subsequence with length info [1, 2];
+ The last sequence contains 3 subsequence with length info [1, 0, 3].
+ input.lod = [[0, 2, 2, 5], [0, 1, 3, 4, 4, 7]]
+ input.data = [[1.], [3.], [2.], [4.], [6.], [5.], [1.]]
+ input.shape = [7, 1]
+
+ It will apply pooling on last lod_level [0, 1, 3, 4, 4, 7]. pad_value = 0.0
+ output is a LoDTensor:
+ out.shape= [5, 1]
+ out.lod = [[0, 2, 2, 5]]
+ out.shape[0] == len(x.lod[-1]) == 5
+ out.data = [[1.], [2.], [4.], [0.0], [1.]]
+ where 1.=last(1.), 2.=last(3., 2.), 4.=last(4.), 0.0 = pad_value, 1=last(6., 5., 1.)
+
+
+ Args:
+ input(Variable): LoDTensor with lod_level no more than 2. The data type should be float32.
+
+ Returns:
+ Variable: LoDTensor consist of the sequence's last step vector. The data type is float32.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[None, 10], dtype='float32', lod_level=1)
+ x_last_step = paddle.static.nn.sequence_last_step(input=x)
+ """
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'],
+ 'sequence_last_step')
+ return sequence_pool(input=input, pool_type="last")
+
+
+def sequence_slice(input, offset, length, name=None):
+ """
+
+ **Sequence Slice Layer**
+
+ The layer crops a subsequence from given sequence with given start
+ offset and subsequence length.
+
+ It only supports sequence data (LoDTensor with lod_level equal to 1).
+
+ .. code-block:: text
+
+ - Case:
+
+ Given the input Variable **input**:
+
+ input.data = [[a1, a2], [b1, b2], [c1, c2], [d1, d2], [e1, e2]],
+ input.lod = [[3, 2]],
+ input.dims = (5, 2),
+
+ with offset.data = [[0], [1]] and length.data = [[2], [1]],
+
+ the output Variable will be
+
+ out.data = [[a1, a2], [b1, b2], [e1, e2]],
+ out.lod = [[2, 1]],
+ out.dims = (3, 2).
+
+ Note:
+ The first dimension size of **input**, **offset** and **length**
+ should be equal. The **offset** should start from 0.
+
+ Args:
+ input(Variable): LoDTensor, The input Variable which consists of the complete
+ sequences.The data type can be float32, float64, int32 or int64
+ offset(Variable): LoDTensor, The offset to slice each sequence. The data
+ type is int32 or int64.
+ length(Variable): LoDTensor, The length of each subsequence. The data
+ type is int32 or int64.
+ name(str|None): The default value is None. Normally there is no need
+ for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: The output subsequences.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ import numpy as np
+ seqs = paddle.static.data(name='x', shape=[10, 5],
+ dtype='float32', lod_level=1)
+ offset = paddle.assign(np.array([[0, 1]]).astype("int32"))
+ length = paddle.assign(np.array([[2, 1]]).astype("int32"))
+ subseqs = paddle.static.nn.sequence_slice(input=seqs, offset=offset,
+ length=length)
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper("sequence_slice", **locals())
+
+ check_variable_and_dtype(input, 'input',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'sequence_slice')
+ check_variable_and_dtype(offset, 'offset', ['int32', 'int64'],
+ 'sequence_slice')
+ check_variable_and_dtype(length, 'length', ['int32', 'int64'],
+ 'sequence_slice')
+
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+
+ offset.stop_gradient = True
+ length.stop_gradient = True
+
+ helper.append_op(type="sequence_slice",
+ inputs={
+ "X": input,
+ "Offset": offset,
+ "Length": length
+ },
+ outputs={"Out": out})
+
+ return out
+
+
+def sequence_expand(x, y, ref_level=-1, name=None):
+ r"""
+
+ Sequence Expand Layer. This layer will expand the input variable ``x`` \
+ according to specified level ``ref_level`` lod of ``y``. Please note that \
+ the lod level of ``x`` is at most 1. If the lod level of ``x`` is 1, than \
+ the size of lod of ``x`` must be equal to the length of ``ref_level`` lod \
+ of ``y``. If the lod level of ``x`` is 0, then the first dim of ``x`` should \
+ be equal to the size of ``ref_level`` of ``y``. The rank of **x** is at least 2. \
+ When rank of ``x`` is greater than 2, then it would be viewed as a 2-D tensor.
+
+ Note:
+
+ Please note that the input ``x`` should be LodTensor or Tensor, \
+ and input ``y`` must be LodTensor.
+
+ **Following examples will explain how sequence_expand works:**
+
+ .. code-block:: text
+
+ Case 1
+
+ Consider 2 sequences [a][b] and [c][d], now we want to expand them to [a][b], [a][b], [c][d] and [c][d].
+ Sequence [a][b] expand twice and [c][d] expands twice, so the lod which according to is [2, 2].
+
+ Input x is a 1-level LoDTensor:
+ x.lod = [[2, 2]] #lod based on length may be easier to understand
+ x.data = [[a], [b], [c], [d]]
+ x.dims = [4, 1]
+
+ input y is a LoDTensor:
+ y.lod = [[2, 2], #the 0th level lod, according to this level
+ [3, 3, 1, 1]] #the 1st level lod, it has nothing to do with this level
+
+ ref_level: 0
+
+ then output is a 1-level LoDTensor out:
+ out.lod = [[2, 2, 2, 2]] #lod based on offset
+ out.data = [[a], [b], [a], [b], [c], [d], [c], [d]]
+ out.dims = [8, 1]
+
+
+ Case 2
+
+ Consider 3 sequences [a], [b], [c], now we want to expand them to [a][a], [c][c][c].
+ It's obvious that the lod info of expanded sequences is [2, 0, 3].
+
+ x is a Tensor:
+ x.data = [[a], [b], [c]]
+ x.dims = [3, 1]
+
+ y is a LoDTensor:
+ y.lod = [[2, 0, 3]]
+
+ ref_level: -1
+
+ then output is a 1-level LodTensor:
+ out.data = [[a], [a], [c], [c], [c]]
+ out.dims = [5, 1]
+
+ Args:
+ x (Variable): The input variable which is a Tensor or LoDTensor, with the \
+ dims ``[M, K]``. The lod level is at most 1. The data type should be \
+ float32, float64, int32 or int64.
+ y (Variable): The input variable which is a LoDTensor, the lod level is \
+ at least 1.
+ ref_level (int): Lod level of ``y`` to be referred by ``x``. If set to -1, \
+ refer the last level of lod.
+ name(str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ Tensor, The expanded variable which is a LoDTensor, with dims ``[N, K]``. \
+ ``N`` depends on the lod info of ``x`` and ``y``. \
+ The data type is same as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ from paddle import fluid
+ paddle.enable_static()
+ import numpy as np
+
+ x = paddle.static.data(name='x', shape=[4, 1], dtype='float32')
+ y = paddle.static.data(name='y', shape=[8, 1],
+ dtype='float32', lod_level=1)
+ out = paddle.static.nn.sequence_expand(x=x, y=y, ref_level=0)
+
+ exe = paddle.static.Executor(fluid.CPUPlace())
+ place = paddle.CPUPlace()
+
+ np_data = np.array([[1], [2], [3], [4]]).astype('float32')
+ x_lod_tensor = fluid.create_lod_tensor(np_data, [[2, 2]], place)
+ print(x_lod_tensor)
+ #lod: [[0, 2, 4]]
+ # dim: 4, 1
+ # layout: NCHW
+ # dtype: float
+ # data: [1 2 3 4]
+
+ np_data = np.array([[1], [2], [3], [4], [5], [6], [7], [8]]).astype('float32')
+ y_lod_tensor = fluid.create_lod_tensor(np_data, [[2, 2], [3,3,1,1]], place)
+ print(y_lod_tensor)
+ #lod: [[0, 2, 4][0, 3, 6, 7, 8]]
+ # dim: 8, 1
+ # layout: NCHW
+ # dtype: int64_t
+ # data: [0 0 1 1 1 1 1 0]
+
+ out_main = exe.run(fluid.default_main_program(),
+ feed={'x': x_lod_tensor, 'y': y_lod_tensor},
+ fetch_list=[out], return_numpy=False)
+ print(out_main[0])
+ #lod: [[0, 2, 4, 6, 8]]
+ # dim: 8, 1
+ # layout: NCHW
+ # dtype: float
+ # data: [1 2 1 2 3 4 3 4]
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
+ 'sequence_expand')
+ helper = LayerHelper('sequence_expand', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ tmp = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type='sequence_expand',
+ inputs={
+ 'X': x,
+ 'Y': y
+ },
+ outputs={'Out': tmp},
+ attrs={'ref_level': ref_level})
+ return tmp
+
+
+def sequence_expand_as(x, y, name=None):
+ r"""
+
+ Sequence Expand As Layer. This OP will expand the input variable ``x`` \
+ according to the zeroth level lod of ``y``. Current implementation requires \
+ the level number of ``y``'s lod must be 1, and the first dimension of \
+ ``x`` should be equal to the size of ``y``'s zeroth level lod, thus \
+ the expanded LodTensor has the same lod info as ``y``. The expanded result \
+ has nothing to do with ``x``'s lod, so the lod of Input(X) is not considered.
+
+ Note:
+ Please note that the input ``x`` should be LodTensor or Tensor, \
+ and input ``y`` must be LodTensor.
+
+ Following examples will explain how sequence_expand_as works:
+
+ .. code-block:: text
+
+ Case 1:
+
+ Consider 4 sequences [a], [b], [c], [d], now we want to expand them to [a][a][a], [b][b][b], [c] and [d].
+ It's obvious that the lod info of expanded sequences is [0, 3, 6, 7, 8].
+ Given a 1-level LodTensor ``x``:
+ x.data = [[a], [b], [c], [d]]
+ x.dims = [4, 1]
+ and input ``y``
+ y.lod = [[3, 3, 1, 1]] #lod based on length may be easier to understand
+
+ then we get 1-level LoDTensor out:
+ Out.lod = [[0, 3, 6, 7, 8]] #based on offset
+ Out.data = [[a], [a], [a], [b], [b], [b], [c], [d]]
+ Out.dims = [8, 1]
+
+
+ Case 2:
+
+ Given a common Tensor ``x``:
+ x.data = [[a, b], [c, d], [e, f]]
+ x.dims = [3, 2]
+ and input ``y``:
+ y.lod = [[0, 2, 3, 6]]
+
+ then we get a 1-level LoDTensor:
+ out.lod = [[0, 2, 3, 6]]
+ out.data = [[a, b], [a, b] [c, d], [e, f], [e, f], [e, f]]
+ out.dims = [6, 2]
+
+ Args:
+ x (Variable): The input variable which is a Tensor or LoDTensor, with the \
+ dims ``[M, K]``. The data type should be float32, float64, int32 \
+ or int64.
+ y (Variable): The input variable which is a LoDTensor with 1-level lod.
+ name (str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ Tensor, The expanded variable which is a LoDTensor with the dims ``[N, K]``. \
+ ``N`` depends on the lod of ``y``, and the lod level must be 1. \
+ The data type is same as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ paddle.enable_static()
+ import numpy as np
+
+ x = paddle.static.data(name='x', shape=[4, 1], dtype='float32')
+ y = paddle.static.data(name='y', shape=[8, 1], dtype='float32', lod_level=1)
+ out = paddle.static.nn.sequence_expand_as(x=x, y=y)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ place = fluid.CPUPlace()
+
+ np_data = np.array([[1], [2], [3], [4]]).astype('float32')
+ x_lod_tensor = fluid.create_lod_tensor(np_data, [[2, 2]], place)
+ print(x_lod_tensor)
+ #lod: [[0, 2, 4]]
+ # dim: 4, 1
+ # layout: NCHW
+ # dtype: float
+ # data: [1 2 3 4]
+
+ np_data = np.array([[1], [2], [3], [4], [5], [6], [7], [8]]).astype('float32')
+ y_lod_tensor = fluid.create_lod_tensor(np_data, [[3,3,1,1]], place)
+ print(y_lod_tensor)
+ #lod: [[0, 3, 6, 7, 8]]
+ # dim: 8, 1
+ # layout: NCHW
+ # dtype: int64_t
+ # data: [0 0 1 0 1 1 1 0]
+
+ out_main = exe.run(fluid.default_main_program(),
+ feed={'x': x_lod_tensor, 'y': y_lod_tensor},
+ fetch_list=[out], return_numpy=False)
+ print(out_main[0])
+ #lod: [[0, 3, 6, 7, 8]]
+ # dim: 8, 1
+ # layout: NCHW
+ # dtype: float
+ # data: [1 1 1 2 2 2 3 4]
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
+ 'sequence_expand_as')
+ check_type(y, 'y', Variable, 'sequence_expand_as')
+ helper = LayerHelper('sequence_expand_as', **locals())
+ dtype = helper.input_dtype(input_param_name='x')
+ tmp = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type='sequence_expand_as',
+ inputs={
+ 'X': x,
+ 'Y': y
+ },
+ outputs={'Out': tmp})
+ return tmp
+
+
+def sequence_pad(x, pad_value, maxlen=None, name=None):
+ r"""
+
+ This layer padding the sequences in a same batch to a common length (according
+ to ``maxlen``). The padding value is defined by ``pad_value``, and will be
+ appended to the tail of sequences. The result is a Python tuple ``(Out, Length)``:
+ the LodTensor ``Out`` is the padded sequences, and LodTensor ``Length`` is
+ the length information of input sequences. For removing padding data (unpadding operation), See :ref:`api_fluid_layers_sequence_unpad`.
+
+ Note:
+ Please note that the input ``x`` should be LodTensor.
+
+ .. code-block:: text
+
+ Case 1:
+ Given input 1-level LoDTensor x:
+ x.lod = [[0, 2, 5]]
+ x.data = [[a],[b],[c],[d],[e]]
+ pad_value:
+ pad_value.data = [0]
+ maxlen = 4
+
+ the output tuple (Out, Length):
+ Out.data = [[[a],[b],[0],[0]],[[c],[d],[e],[0]]]
+ Length.data = [2, 3] #Original sequences length
+
+ Case 2:
+ Given input 1-level LoDTensor x:
+ x.lod = [[0, 2, 5]]
+ x.data = [[a1,a2],[b1,b2],[c1,c2],[d1,d2],[e1,e2]]
+ pad_value:
+ pad_value.data = [0]
+ default maxlen = None, (the virtual value is 3, according to the shape of x)
+
+ the output tuple (Out, Length):
+ Out.data = [[[a1,a2],[b1,b2],[0,0]],[[c1,c2],[d1,d2],[e1,e2]]]
+ Length.data = [2, 3]
+
+ Case 3:
+ Given input 1-level LoDTensor x:
+ x.lod = [[0, 2, 5]]
+ x.data = [[a1,a2],[b1,b2],[c1,c2],[d1,d2],[e1,e2]]
+ pad_value:
+ pad_value.data = [p1,p2]
+ default maxlen = None, (the virtual value is 3)
+
+ get tuple (Out, Length):
+ Out.data = [[[a1,a2],[b1,b2],[p1,p2]],[[c1,c2],[d1,d2],[e1,e2]]]
+ Length.data = [2, 3]
+
+
+
+ Args:
+ x (Variable): Input 1-level LodTensor with dims ``[M, K]``. The batch \
+ size is described by lod infor (the number of sequences ). \
+ The data type should be float32, float64, int8, int32 or int64.
+ pad_value (Variable): Padding value. It can be a scalar or a 1D tensor \
+ with length ``K``. If it's a scalar, it will be automatically broadcasted \
+ to a Tensor. The data type should be as same as ``x``.
+ maxlen (int, optional): The length of padded sequences, None by default. \
+ When it is None, all sequences will be padded up to the length of the \
+ longest one among them; when it a certain positive value, it must be \
+ greater than the length of the longest original sequence.
+ name (str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ tuple, A Python tuple (Out, Length): the 1st is a 0 level LodTensor \
+ ``Out``, with the shape ``[batch_size, maxlen, K]``; the second is the original \
+ sequences length infor ``Length``, which should be a 0-level 1D LodTensor. \
+ The size of ``Length`` is equal to batch size, and the data type is int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ import paddle.fluid as fluid
+ import numpy
+
+ x = paddle.static.data(name='x', shape=[10, 5], dtype='float32', lod_level=1)
+ pad_value = paddle.assign(
+ numpy.array([0.0], dtype=numpy.float32))
+ out = paddle.static.nn.sequence_pad(x=x, pad_value=pad_value)
+ """
+
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_pad', **locals())
+ check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
+ 'fluid.layers.sequence_pad')
+ check_variable_and_dtype(pad_value, 'pad_value',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'fluid.layers.sequence_pad')
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+ length = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
+
+ pad_value.stop_gradient = True
+ length.stop_gradient = True
+
+ if maxlen is None:
+ maxlen = -1
+ helper.append_op(type='sequence_pad',
+ inputs={
+ 'X': x,
+ 'PadValue': pad_value
+ },
+ outputs={
+ 'Out': out,
+ 'Length': length
+ },
+ attrs={'padded_length': maxlen})
+ return out, length
+
+
+def sequence_unpad(x, length, name=None):
+ """
+
+ Note:
+ The input of the OP is Tensor and the output is LoDTensor. For padding operation, See:** :ref:`api_fluid_layers_sequence_pad`
+
+ Remove the padding data from the input based on the length information and returns a LoDTensor.
+
+ .. code-block:: text
+
+ Case 1:
+
+ Given input Variable **x**:
+ x.data = [[ 1.0, 2.0, 3.0, 4.0, 5.0],
+ [ 6.0, 7.0, 8.0, 9.0, 10.0],
+ [11.0, 12.0, 13.0, 14.0, 15.0]],
+
+ in which there are 3 sequences padded to length 5, and the actual length
+ specified by input Variable **length**:
+
+ length.data = [2, 3, 4],
+
+ after unpadding, the output Variable will be:
+
+ out.data = [[1.0, 2.0, 6.0, 7.0, 8.0, 11.0, 12.0, 13.0, 14.0]]
+ out.lod = [[0, 2, 5, 9]]
+
+ Args:
+ x(Variable): A Tensor which contains padding data, and its shape size can not be less than 2.
+ Supported data types: float32, float64, int32, int64.
+ length(Variable): A 1D Tensor that stores the actual length of each sample, and the Tensor
+ has the same shape with the 0th dimension of the X . Supported data types: int64.
+ name(str|None): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: A LoDTensor whose recursive sequence length is consistent with the information of the length parameter and it has the same data type with input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ import paddle.fluid as fluid
+ import numpy
+
+ # pad data
+ x = paddle.static.data(name='x', shape=[10, 5], dtype='float32', lod_level=1)
+ pad_value = paddle.assign(numpy.array([0.0], dtype=numpy.float32))
+ pad_data, len = paddle.static.nn.sequence_pad(x=x, pad_value=pad_value)
+
+ # unpad data
+ unpad_data = paddle.static.nn.sequence_unpad(x=pad_data, length=len)
+ """
+
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_unpad', **locals())
+ check_variable_and_dtype(x, 'x', ['float32', 'float64', 'int32', 'int64'],
+ 'fluid.layers.sequence_unpad')
+ check_variable_and_dtype(length, 'length', ['int64'],
+ 'fluid.layers.sequence_unpad')
+ dtype = helper.input_dtype(input_param_name='x')
+ out = helper.create_variable_for_type_inference(dtype)
+
+ length.stop_gradient = True
+
+ helper.append_op(type='sequence_unpad',
+ inputs={
+ 'X': x,
+ 'Length': length
+ },
+ outputs={'Out': out})
+ return out
+
+
+def sequence_reshape(input, new_dim):
+ """
+
+ Note:
+ Only receives LoDTensor as input. If your input is Tensor, please use reshape Op.(fluid.layers.** :ref:`api_fluid_layers_reshape` ).
+
+ Only supports LoDTensor as input. Given :attr:`new_dim` ,
+ it will compute new shape according to original length of each sequence,
+ original dimensions and :attr:`new_dim` . Then it will output a new LoDTensor
+ containing :attr:`new_dim` . Currently it only supports 1-level LoDTensor.
+ Please make sure that (original length * original dimensions) can be divided
+ by the :attr:`new_dim` with no remainder for each sequence.
+
+ .. code-block:: text
+
+ input is a LoDTensor:
+ input.lod = [[0, 2, 6]]
+ input.data = [[1, 2], [3, 4],
+ [5, 6], [7, 8],
+ [9, 10], [11, 12]]
+ input.shape = [6, 2]
+
+ set new_dim = 4
+ out is a LoDTensor:
+ out.lod = [[0, 1, 3]]
+ out.data = [[1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12]]
+ out.shape = [3, 4]
+
+
+ Args:
+
+ input (Variable): 1-level LoDTensor with shape :math:`[M, K]` . The data type should
+ be int32, int64, float32 or float64.
+ new_dim (int): New dimension that the input LoDTensor is reshaped to.
+
+ Returns:
+ Variable: Reshaped LoDTensor according to new dimension. The data type is same as input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[None, 16], dtype='float32', lod_level=1)
+ x_reshaped = paddle.static.nn.sequence_reshape(input=x, new_dim=4)
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_reshape', **locals())
+ check_variable_and_dtype(input, 'input',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'fluid.layers.sequence_reshape')
+ out = helper.create_variable_for_type_inference(helper.input_dtype())
+ helper.append_op(type='sequence_reshape',
+ inputs={'X': [input]},
+ outputs={'Out': [out]},
+ attrs={'new_dim': new_dim})
+ return out
+
+
+def sequence_scatter(input, index, updates, name=None):
+ """
+
+ Note:
+ The index and updates parameters of the OP must be LoDTensor.
+
+ Plus the updates data to the corresponding input according to the index.
+
+ The updated algorithm is as follows: output[instance_index][index [pos]] = input[instance_index][index [pos]] + updates[pos],
+ where instance_idx is the K sample corresponding to pos in batch.
+
+ The value of output[i][j] depends on whether j can be found in the i+1th interval of the index. If found,
+ out[i][j] = input[i][j] + update[m] [n], otherwise, out[i][j] = input[i][j].
+
+ For example, in the following example, the lod information for index is divided into three sequences. Among
+ them, because the element 0 can be found in the first interval of the index, it is updated with the value of
+ the corresponding position of the updates, out[0][0] = input[0][0]+updates[0][0] . Because element 1 cannot
+ be found in the third interval of index, out[2][1] = input[2][1].
+
+ .. code-block:: text
+
+ *Case 1:
+
+ Given:
+ input.data = [[1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+ [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+ [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]]
+ input.dims = [3, 6]
+
+ index.data = [[0], [1], [2], [5], [4], [3], [2], [1], [3], [2], [5], [4]]
+ index.lod = [[0, 3, 8, 12]]
+
+ updates.data = [[0.3], [0.3], [0.4], [0.1], [0.2], [0.3], [0.4], [0.0], [0.2], [0.3], [0.1], [0.4]]
+ updates.lod = [[ 0, 3, 8, 12]]
+
+ Then:
+ out.data = [[1.3, 1.3, 1.4, 1.0, 1.0, 1.0],
+ [1.0, 1.0, 1.4, 1.3, 1.2, 1.1],
+ [1.0, 1.0, 1.3, 1.2, 1.4, 1.1]]
+ out.dims = X.dims = [3, 6]
+
+ Args:
+ input (Variable): A Tensor with shape of :math:`[N, k_1... k_n]`. Supported data types: float32, float64, int32, int64.
+ index (Variable): A LoDTensor contains index information. Its LoD level must be 1 and its data type can be int32 or int64.
+ updates (Variable): A LodTensor contains updates information. It has the same LoD level with the index and has the
+ same data type with the input. Supported data types: float32, float64, int32, int64.
+ name (str, optional): The default value is None. Normally there is no need for user to set this property. For more information,
+ please refer to :ref:`api_guide_Name`
+
+ Returns:
+ Variable: A Tensor which has been updated. It has the same shape and data type with input.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ input = paddle.static.data(name="x", shape=[None, 3, 6], dtype='float32' )
+ index = paddle.static.data(name='index', shape=[12, 1], dtype='int64', lod_level=1)
+ updates = paddle.static.data(name='updates', shape=[12, 1], dtype='float32', lod_level=1)
+ output = paddle.static.nn.sequence_scatter(input, index, updates)
+
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper('sequence_scatter', **locals())
+
+ check_variable_and_dtype(input, 'input',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'sequence_scatter')
+ check_variable_and_dtype(index, 'index', ['int32', 'int64'],
+ 'sequence_scatter')
+ check_variable_and_dtype(updates, 'updates',
+ ['float32', 'float64', 'int32', 'int64'],
+ 'sequence_scatter')
+
+ dtype = helper.input_dtype()
+ out = helper.create_variable_for_type_inference(dtype)
+ helper.append_op(type="sequence_scatter",
+ inputs={
+ "X": input,
+ "Ids": index,
+ "Updates": updates
+ },
+ outputs={"Out": out})
+ return out
+
+
+def sequence_enumerate(input, win_size, pad_value=0, name=None):
+ r"""
+
+ Generate a new sequence for the input index sequence with \
+ shape ``[d_1, win_size]``, which enumerates all the \
+ sub-sequences with length ``win_size`` of the input with \
+ shape ``[d_1, 1]``, and padded by ``pad_value`` if necessary in generation.
+
+ Please note that the `input` must be LodTensor.
+
+ .. code-block:: text
+
+ Input x:
+ x.lod = [[0, 3, 5]]
+ x.data = [[1], [2], [3], [4], [5]]
+ x.dims = [5, 1]
+
+ Attrs:
+ win_size = 2
+ pad_value = 0
+
+ Output:
+ out.lod = [[0, 3, 5]]
+ out.data = [[1, 2], [2, 3], [3, 0], [4, 5], [5, 0]]
+ out.dims = [5, 2]
+
+
+ Args:
+ input (Variable): The input variable which is a index sequence, \
+ which should be a LodTensor with shape ``[d_1, 1]`` and 1-level lod info. \
+ The data type should be int32 or int64.
+ win_size (int): The window size for enumerating all sub-sequences.
+ pad_value (int, optional): The padding value, default 0.
+ name(str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ Tensor, The enumerate sequence variable which is a LoDTensor with \
+ shape ``[d_1, win_size]`` and 1-level lod info. \
+ The data type is same as ``input``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[-1, 1], dtype='int32', lod_level=1)
+ out = paddle.static.nn.sequence_enumerate(input=x, win_size=3, pad_value=0)
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ check_variable_and_dtype(input, 'input', ['int32', 'int64'],
+ 'sequence_enumerate')
+ helper = LayerHelper('sequence_enumerate', **locals())
+ out = helper.create_variable_for_type_inference(helper.input_dtype(),
+ stop_gradient=True)
+ helper.append_op(type='sequence_enumerate',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={
+ 'win_size': win_size,
+ 'pad_value': pad_value
+ })
+ return out
+
+
+def sequence_mask(x, maxlen=None, dtype='int64', name=None):
+ r"""
+ **SequenceMask Layer**
+
+ This layer outputs a mask according to the input :code:`x` and
+ :code:`maxlen` with data type of :code:`dtype`.
+
+ Supposing :code:`x` is a Tensor with shape [d_1, d_2, ..., d_n], the
+ :code:`y` is a mask with shape [d_1, d_2, ..., d_n, maxlen], where:
+
+ .. math::
+
+ y(i_1, i_2,..., i_n, j) = (j < x(i_1, i_2,..., i_n))
+
+ .. code-block:: text
+
+ Case:
+
+ Consider input:
+ x = [3, 1, 1, 0] max_len = 4
+
+ then we get out:
+ mask = [[1, 1, 1, 0],
+ [1, 0, 0, 0],
+ [1, 0, 0, 0],
+ [0, 0, 0, 0]]
+
+ Args:
+ x (Variable): Input tensor of sequence_mask layer, \
+ whose elements are integers less than :code:`maxlen`. \
+ Tensor or LodTensor with shape [d_1, d_2, ..., d_n].
+ maxlen (int, optional): Maximum length of the sequence. If :code:`maxlen` \
+ is None, it would be replace with :math:`max(x)`.
+ dtype (np.dtype|paddle.dtype|str, optional): Data type of the output, \
+ ``int64`` by default.
+ name(str, optional): For detailed information, please refer \
+ to :ref:`api_guide_Name`. Usually name is no need to set and \
+ None by default.
+
+ Returns:
+ Tensor, The output sequence mask. Tensor with shape [d_1, d_2, ..., d_n, maxlen]
+ and data type of :code:`dtype`. The data type should be bool, float32, float64, int8,
+ int32 or int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ lengths = paddle.to_tensor([10, 9, 8])
+ mask = paddle.nn.functional.sequence_mask(lengths)
+
+ print(mask.numpy())
+ # [[1 1 1 1 1 1 1 1 1 1]
+ # [1 1 1 1 1 1 1 1 1 0]
+ # [1 1 1 1 1 1 1 1 0 0]]
+
+ """
+
+ return paddle.nn.functional.sequence_mask(x, maxlen, dtype, name)
+
+
+@templatedoc()
+def sequence_reverse(x, name=None):
+ """
+ Note:
+ Only receives LoDTensor as input. If your input is Tensor, please use reverse Op.(fluid.layers.** :ref:`api_fluid_layers_reverse` ).
+
+ Only supports LoDTensor as input. It will reverse each sequence for input LoDTensor.
+ Currently it only supports 1-level LoDTensor. This operator is very useful when building a
+ reverse :ref:`api_fluid_layers_DynamicRNN` network.
+
+ .. code-block:: text
+
+ input(x) is a LoDTensor:
+ x.lod = [[0, 2, 5]]
+ x.data = [[1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12],
+ [13,14, 15, 16],
+ [17,18, 19, 20]]
+ x.shape = [5, 4]
+
+ output LoDTensor with same shape and LoD info:
+ out.lod = [[0, 2, 5]]
+ out.data = [[5, 6, 7, 8],
+ [1, 2, 3, 4],
+ [17,18, 19, 20],
+ [13,14, 15, 16],
+ [9, 10, 11, 12]]
+ out.shape = [5, 4]
+
+ Args:
+ x(Variable): LoDTensor with 1-level LoD info. Currently it only supports 1-level LoDTensor.
+ The data type should be float32, float64, int8, int32 or int64.
+ name(str, optional): The default value is None. Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name` .
+
+ Returns:
+ Variable: LoDTensor reversed from input. The data type is same with input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+
+ x = paddle.static.data(name='x', shape=[None, 10], dtype='float32', lod_level=1)
+ x_reversed = paddle.static.nn.sequence_reverse(x)
+ """
+ assert not _non_static_mode(), (
+ "sequence layer is not supported in dygraph mode yet.")
+ helper = LayerHelper("sequence_reverse", **locals())
+ check_variable_and_dtype(x, 'x',
+ ['float32', 'float64', 'int8', 'int32', 'int64'],
+ 'fluid.layers.sequence_reverse')
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ helper.append_op(type="sequence_reverse",
+ inputs={"X": x},
+ outputs={"Y": out},
+ attrs=dict())
+ return out
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/tensor.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/tensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..3973a7187908bfbbc405edbfdb696ae6e1e608da
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/tensor.py
@@ -0,0 +1,1897 @@
+# Copyright (c) 2022 PaddlePaddle 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
+#
+# Unlessf 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 __future__ import print_function
+
+import math
+import numpy
+import warnings
+
+from ..layer_helper import LayerHelper
+from ..param_attr import ParamAttr
+from ..initializer import Initializer
+from ..framework import _current_expected_place, convert_np_dtype_to_dtype_, _non_static_mode, _varbase_creator, device_guard, _in_legacy_dygraph, in_dygraph_mode, _get_paddle_place
+from ..framework import Variable
+from ..initializer import Constant
+from ..core import VarDesc
+from .. import core
+from .layer_function_generator import templatedoc
+from . import utils
+from ..data_feeder import check_variable_and_dtype, check_type, check_dtype, convert_dtype
+from paddle.utils import deprecated
+
+from .utils import check_shape
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = [
+ 'create_tensor',
+ 'create_parameter',
+ 'create_global_var',
+ 'cast',
+ 'tensor_array_to_tensor',
+ 'concat',
+ 'sums',
+ 'assign',
+ 'fill_constant_batch_size_like',
+ 'fill_constant',
+ 'argmin',
+ 'argmax',
+ 'argsort',
+ 'ones',
+ 'zeros',
+ 'reverse',
+ 'has_inf',
+ 'has_nan',
+ 'isfinite',
+ 'range',
+ 'linspace',
+ 'zeros_like',
+ 'ones_like',
+ 'diag',
+ 'eye',
+ 'triu',
+]
+
+
+def create_tensor(dtype, name=None, persistable=False):
+ """
+ Create a variable, which will hold a Tensor with data type dtype.
+
+ Args:
+ dtype(string|numpy.dtype): the data type of Tensor to be created, the
+ data type is bool, float16, float32, float64, int8, int16, int32 and int64.
+ name(string, optional): The default value is None. Normally there is no need for
+ user to set this property. For more information, please refer to :ref:`api_guide_Name`
+ persistable(bool): Set the persistable flag of the create tensor.
+ default value is False.
+
+ Returns:
+ Variable: The tensor to be created according to dtype.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ tensor = fluid.layers.create_tensor(dtype='float32')
+ """
+ check_dtype(dtype, 'dtype', [
+ 'bool', 'float16', 'float32', 'float64', 'int8', 'int32', 'int32',
+ 'int64'
+ ], 'create_tensor')
+ helper = LayerHelper("create_tensor", **locals())
+ return helper.create_variable(name=helper.name,
+ dtype=dtype,
+ persistable=persistable)
+
+
+def create_parameter(shape,
+ dtype,
+ name=None,
+ attr=None,
+ is_bias=False,
+ default_initializer=None):
+ """
+ :api_attr: Static Graph
+
+ This function creates a parameter. The parameter is a learnable variable, which can have
+ gradient, and can be optimized.
+
+ NOTE: this is a very low-level API. This API is useful when you create
+ operator by your self. instead of using layers.
+
+ Parameters:
+ shape (list of int): Shape of the parameter
+ dtype (str): Data type of the parameter
+ name (str, optional): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+ attr (ParamAttr, optional): Attributes of the parameter
+ is_bias (bool, optional): This can affect which default initializer is chosen
+ when default_initializer is None. If is_bias,
+ initializer.Constant(0.0) will be used. Otherwise,
+ Xavier() will be used.
+ default_initializer (Initializer, optional): Initializer for the parameter
+
+ Returns:
+ The created parameter.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ W = paddle.static.create_parameter(shape=[784, 200], dtype='float32')
+ """
+ check_type(shape, 'shape', (list, tuple, numpy.ndarray), 'create_parameter')
+ for item in shape:
+ check_type(item, 'item of shape',
+ (int, numpy.uint8, numpy.int8, numpy.int16, numpy.int32,
+ numpy.int64), 'create_parameter')
+
+ check_dtype(dtype, 'dtype', [
+ 'bool', 'float16', 'float32', 'float64', 'int8', 'int16', 'int32',
+ 'int64', 'uint8'
+ ], 'create_parameter')
+ check_type(attr, 'attr', (type(None), ParamAttr), 'create_parameter')
+ check_type(default_initializer, 'default_initializer',
+ (type(None), Initializer), 'create_parameter')
+
+ helper = LayerHelper("create_parameter", **locals())
+ if attr is None:
+ attr = ParamAttr(name=name)
+ return helper.create_parameter(attr, shape, convert_dtype(dtype), is_bias,
+ default_initializer)
+
+
+def create_global_var(shape,
+ value,
+ dtype,
+ persistable=False,
+ force_cpu=False,
+ name=None):
+ """
+ This function creates a new tensor variable with value in the global block(block 0).
+
+ Parameters:
+ shape (list[int]|tuple[int]): Shape of the variable
+ value (float): The value of the variable. The new created
+ variable will be filled with it.
+ dtype (str): Data type of the variable
+ persistable (bool, optional): If this variable is persistable.
+ Default: False
+ force_cpu (bool, optional): Force this variable to be on CPU.
+ Default: False
+ name (str, optional): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+
+ Returns:
+ Variable: The created Variable
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.enable_static()
+ var = paddle.static.create_global_var(shape=[2,3], value=1.0, dtype='float32',
+ persistable=True, force_cpu=True, name='new_var')
+ """
+ check_type(shape, 'shape', (list, tuple, numpy.ndarray),
+ 'create_global_var')
+ for item in shape:
+ check_type(item, 'item of shape',
+ (int, numpy.uint8, numpy.int8, numpy.int16, numpy.int32,
+ numpy.int64), 'create_global_var')
+
+ check_dtype(dtype, 'dtype', [
+ 'bool',
+ 'float16',
+ 'float32',
+ 'float64',
+ 'int8',
+ 'int16',
+ 'int32',
+ 'int64',
+ 'uint8',
+ 'uint16',
+ ], 'create_global_var')
+
+ helper = LayerHelper("global_var", **locals())
+ var = helper.create_global_variable(dtype=dtype,
+ shape=shape,
+ persistable=persistable,
+ name=name,
+ stop_gradient=True)
+ helper.set_variable_initializer(var,
+ initializer=Constant(value=float(value),
+ force_cpu=force_cpu))
+
+ return var
+
+
+def cast(x, dtype):
+ """
+
+ This OP takes in the Tensor :attr:`x` with :attr:`x.dtype` and casts it
+ to the output with :attr:`dtype`. It's meaningless if the output dtype
+ equals the input dtype, but it's fine if you do so.
+
+ Args:
+ x(Tensor): An input N-D Tensor with data type bool, float16,
+ float32, float64, int32, int64, uint8.
+ dtype(np.dtype|str): Data type of the output:
+ bool, float16, float32, float64, int8, int32, int64, uint8.
+
+ Returns:
+ Tensor: A Tensor with the same shape as input's.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([2, 3, 4], 'float64')
+ y = paddle.cast(x, 'uint8')
+ """
+ if in_dygraph_mode():
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+ return _C_ops.cast(x, dtype)
+
+ if _non_static_mode():
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+ out = _legacy_C_ops.cast(x, 'in_dtype', x.dtype, 'out_dtype', dtype)
+ return out
+
+ check_variable_and_dtype(x, 'x', [
+ 'bool', 'float16', 'float32', 'float64', 'int16', 'int32', 'int64',
+ 'uint8', 'uint16'
+ ], 'cast')
+ check_dtype(dtype, 'dtype', [
+ 'bool', 'float16', 'float32', 'float64', 'int8', 'int16', 'int32',
+ 'int64', 'uint8', 'uint16'
+ ], 'cast')
+
+ helper = LayerHelper('cast', **locals())
+ out = helper.create_variable_for_type_inference(
+ dtype=dtype, stop_gradient=x.stop_gradient)
+ helper.append_op(type='cast',
+ inputs={'X': [x]},
+ outputs={'Out': [out]},
+ attrs={
+ 'in_dtype': x.dtype,
+ 'out_dtype': out.dtype
+ })
+ return out
+
+
+def concat(input, axis=0, name=None):
+ """
+ This OP concatenates the input along the axis.
+
+ Args:
+ input(list|tuple|Tensor): ``input`` can be Tensor, Tensor list or Tensor tuple which is with data type
+ bool, float16, float32, float64, int32, int64. All the Tensors in ``input`` must have the same data type.
+ axis(int|Tensor, optional): Specify the axis to operate on the input Tensors.
+ It's a scalar with data type int or a Tensor with shape [1] and data type int32 or int64.
+ The effective range is [-R, R), where R is Rank(x). When ``axis < 0``, it works the same way
+ as ``axis+R``. Default is 0.
+ name (str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: A Tensor with the same data type as ``input``.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ in1 = np.array([[1, 2, 3],
+ [4, 5, 6]])
+ in2 = np.array([[11, 12, 13],
+ [14, 15, 16]])
+ in3 = np.array([[21, 22],
+ [23, 24]])
+ with fluid.dygraph.guard():
+ x1 = fluid.dygraph.to_variable(in1)
+ x2 = fluid.dygraph.to_variable(in2)
+ x3 = fluid.dygraph.to_variable(in3)
+ # When the axis is negative, the real axis is (axis + Rank(x)).
+ # As follows, axis is -1, Rank(x) is 2, the real axis is 1
+ out1 = fluid.layers.concat(input=[x1, x2, x3], axis=-1)
+ out2 = fluid.layers.concat(input=[x1, x2], axis=0)
+ print(out1.numpy())
+ # [[ 1 2 3 11 12 13 21 22]
+ # [ 4 5 6 14 15 16 23 24]]
+ print(out2.numpy())
+ # [[ 1 2 3]
+ # [ 4 5 6]
+ # [11 12 13]
+ # [14 15 16]]
+ """
+
+ if in_dygraph_mode():
+ if isinstance(axis, Variable):
+ axis = axis.numpy()
+ axis = axis.item(0)
+ if not isinstance(input, Variable):
+ input = [t for t in input if t.shape.count(0) == 0]
+ out = _C_ops.concat(input, axis)
+ return out
+
+ if _in_legacy_dygraph():
+ if isinstance(axis, Variable):
+ axis = axis.numpy()
+ axis = axis.item(0)
+ if not isinstance(input, Variable):
+ input = [t for t in input if t.shape.count(0) == 0]
+ out = _varbase_creator()
+ _legacy_C_ops.concat(input, out, 'axis', axis)
+ return out
+
+ check_type(input, 'input', (list, tuple, Variable), 'concat')
+ if not isinstance(input, Variable):
+ for id, x in enumerate(input):
+ check_variable_and_dtype(
+ x, 'input[' + str(id) + ']',
+ ['bool', 'float16', 'float32', 'float64', 'int32', 'int64'],
+ 'concat')
+ if x.dtype != input[0].dtype:
+ raise TypeError(
+ "All the Tensors in the input must have the same data type."
+ )
+ else:
+ input = [input]
+ check_type(axis, 'axis', (int, Variable), 'concat')
+
+ if isinstance(axis, Variable):
+ check_dtype(
+ axis.dtype, 'axis', ['int32', 'int64'], 'concat',
+ "The data type of axis must be int32 or int64 when axis is a Tensor"
+ )
+
+ helper = LayerHelper('concat', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+
+ if input[0].desc.type() == core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ # NOTE(liym27): Don't remove this if branch!
+ # This feature is supported for Dynamic-to-Static, because after transformed, the type of inputs[0]
+ # is LOD_TENSOR_ARRAY in some scenarios. And this feature can be used in static mode.
+
+ assert len(input) == 1, "If the elements of 'input' in concat are Variable(LoDTensorArray), " \
+ "number of the elements must be 1, but received %s." % len(input)
+ out_index = helper.create_variable_for_type_inference(dtype="int32")
+ helper.append_op(type='tensor_array_to_tensor',
+ inputs={'X': input[0]},
+ outputs={
+ 'Out': [out],
+ 'OutIndex': [out_index]
+ },
+ attrs={
+ 'axis': axis,
+ 'use_stack': False
+ })
+ else:
+ inputs = {'X': input}
+ attrs = {}
+ if isinstance(axis, Variable):
+ axis.stop_gradient = True
+ attrs['axis'] = axis
+
+ helper.append_op(type='concat',
+ inputs=inputs,
+ outputs={'Out': [out]},
+ attrs=attrs)
+ return out
+
+
+def tensor_array_to_tensor(input, axis=1, name=None, use_stack=False):
+ r"""
+ This function concatenates or stacks all tensors in the input LoDTensorArray
+ along the axis mentioned and returns that as the output.
+
+ For Example:
+
+ .. code-block:: text
+
+ Case 1:
+
+ Given:
+
+ input.data = {[[0.6, 0.1, 0.3],
+ [0.5, 0.3, 0.2]],
+ [[1.3],
+ [1.8]],
+ [[2.3, 2.1],
+ [2.5, 2.4]]}
+
+ axis = 1, use_stack = False
+
+ Then:
+
+ output.data = [[0.6, 0.1, 0.3, 1.3, 2.3, 2.1],
+ [0.5, 0.3, 0.2, 1.8, 2.5, 2.4]]
+
+ output_index.data = [3, 1, 2]
+
+ Case 2:
+
+ Given:
+
+ input.data = {[[0.6, 0.1],
+ [0.5, 0.3]],
+ [[0.3, 1.3],
+ [0.2, 1.8]],
+ [[2.3, 2.1],
+ [2.5, 2.4]]}
+
+ axis = 1, use_stack = True
+
+ Then:
+
+ output.data = [[[0.6, 0.1]
+ [0.3, 1.3]
+ [2.3, 2.1],
+ [[0.5, 0.3]
+ [0.2, 1.8]
+ [2.5, 2.4]]]
+
+ output_index.data = [2, 2, 2]
+
+ Args:
+ input(Variable): A LodTensorArray variable.
+ axis(int): The axis along which the tensors in attr::`input` will be
+ concatenated or stacked.
+ name(str|None): A name for this layer(optional). If set None, the layer
+ will be named automatically.
+ use_stack(bool): Act as concat_op or stack_op. For stack mode, all
+ tensors in the tensor array must have the same shape.
+
+ Returns:
+ Variable: The concatenated or stacked tensor variable.
+ Variable: A 1-D tensor variable with int32 data type. The data in this \
+ tensor contains all input including tensors' sizes along the axis.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ x0 = fluid.layers.assign(np.random.rand(2, 2).astype("float32"))
+ x1 = fluid.layers.assign(np.random.rand(2, 2).astype("float32"))
+ i = fluid.layers.fill_constant(shape=[1], dtype="int64", value=0)
+ array = fluid.layers.create_array(dtype='float32')
+ fluid.layers.array_write(x0, i, array)
+ fluid.layers.array_write(x1, i + 1, array)
+ output, output_index = fluid.layers.tensor_array_to_tensor(input=array)
+ """
+ if _non_static_mode():
+ assert isinstance(
+ input, list), "The 'input' in tensor_array_to_tensor must be list"
+ from .nn import stack, concat
+ from ..dygraph import to_variable
+ op = stack if use_stack else concat
+ res = op(input, axis=axis)
+ sizes = to_variable(
+ numpy.array(list(map(lambda x: int(x.shape[axis]), input))))
+ return res, sizes
+
+ check_type(input, 'input', (list, Variable), 'tensor_array_to_tensor')
+ if isinstance(input, list):
+ for i, input_x in enumerate(input):
+ check_type(input_x, 'input[' + str(i) + ']', Variable,
+ 'tensor_array_to_tensor')
+ helper = LayerHelper('tensor_array_to_tensor', **locals())
+ out = helper.create_variable_for_type_inference(dtype=helper.input_dtype())
+ out_index = helper.create_variable_for_type_inference(dtype="int32")
+ helper.append_op(type='tensor_array_to_tensor',
+ inputs={'X': input},
+ outputs={
+ 'Out': [out],
+ 'OutIndex': [out_index]
+ },
+ attrs={
+ 'axis': axis,
+ 'use_stack': use_stack
+ })
+ return out, out_index
+
+
+def sums(input, out=None):
+ r"""
+ This function computes the sum of multiple input Tensors elementwisely.
+
+ - Case 1, sum of 3 Tensors
+
+ .. code-block:: text
+
+ # Input Tensors
+ x0.shape = [2, 3]
+ x0.data = [[1., 2., 3.],
+ [4., 5., 6.]]
+ x1.shape = [2, 3]
+ x1.data = [[10., 20., 30.],
+ [40., 50., 60.]]
+ x2.shape = [2, 3]
+ x2.data = [[100., 200., 300.],
+ [400., 500., 600.]]
+
+ # Output Tensor
+ out.shape = [2, 3]
+ out.data = [[111., 222., 333.],
+ [444., 555., 666.]]
+
+ Args:
+ input (list): A list of Variables which hold input Tensors with the same
+ data type and shape. Optional data types are: float32, float64, int32, int64.
+ out (Variable, optional): Output Tensor. It can be any existing Variable.
+ The default value is None, then a new Variable will be created and returned.
+
+ Returns:
+ Variable: The sum of inputs. The shape and data type is the same with input. \
+ If :code:`out` is not None, the returned value is :code:`out` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ x0 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=1)
+ x1 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=2)
+ x2 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=3)
+ x3 = fluid.layers.fill_constant(shape=[16, 32], dtype='int64', value=0)
+
+ # Sum of multiple Tensors, the result is stored to a new Variable sum0 (sum0=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]])
+ sum0 = fluid.layers.sums(input=[x0, x1, x2])
+
+ # Sum of multiple Tensors, sum1 and x3 represents the same Variable (x3=x0+x1+x2, the value is [[6, ..., 6], ..., [6, ..., 6]])
+ sum1 = fluid.layers.sums(input=[x0, x1, x2], out=x3)
+ """
+ check_type(input, 'input', (Variable, tuple, list), 'sums')
+ if isinstance(input, list) or isinstance(input, tuple):
+ for input_section in input:
+ check_variable_and_dtype(input_section, "input", \
+ ['float16', 'float32', 'float64', 'int32', 'int64'], 'sums')
+ else:
+ check_variable_and_dtype(input, "input", \
+ ['float16', 'float32', 'float64', 'int32', 'int64'], 'sums')
+
+ helper = LayerHelper('sum', **locals())
+ if out is None:
+ out = helper.create_variable_for_type_inference(
+ dtype=helper.input_dtype())
+ else:
+ check_variable_and_dtype(out, "out",
+ ['float32', 'float64', 'int32', 'int64'],
+ 'sums')
+
+ helper.append_op(type='sum',
+ inputs={'X': input},
+ outputs={'Out': out},
+ attrs={'use_mkldnn': False})
+ return out
+
+
+def assign(input, output=None):
+ """
+
+ The OP copies the :attr:`input` to the :attr:`output`.
+
+ Parameters:
+ input (Tensor|numpy.ndarray|list|tuple|scalar): A tensor, numpy ndarray, tuple/list of scalar,
+ or scalar. Its data type supports float16, float32, float64, int32, int64, and bool.
+ Note: the float64 data will be converted to float32 because of current platform protobuf
+ data limitation.
+ output (Tensor, optional): A tensor. If :attr:`output` is None, a new tensor will
+ be created as :attr:`output`. Default: None.
+
+ Returns:
+ Tensor: A tensor with the same shape, data type and value as :attr:`input`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy as np
+ data = paddle.full(shape=[3, 2], fill_value=2.5, dtype='float64') # [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
+ array = np.array([[1, 1],
+ [3, 4],
+ [1, 3]]).astype(np.int64)
+ result1 = paddle.zeros(shape=[3, 3], dtype='float32')
+ paddle.assign(array, result1) # result1 = [[1, 1], [3 4], [1, 3]]
+ result2 = paddle.assign(data) # result2 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
+ result3 = paddle.assign(np.array([[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]], dtype='float32')) # result3 = [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
+ """
+ helper = LayerHelper('assign', **locals())
+ check_type(input, 'input',
+ (Variable, numpy.ndarray, list, tuple, float, int, bool),
+ 'assign')
+ is_inplace = True if output is not None else False
+
+ if numpy.isscalar(input) and not isinstance(input, str):
+ input = numpy.array([input])
+ elif isinstance(input, (list, tuple)):
+ input = numpy.array(input)
+ # NOTE(Aurelius84): Why we judge core.VarBase?
+ # In case of @to_static, a VarBase can be as input of `assign`,
+ # but _non_static_mode()==False under @to_static, which means
+ # isinstance(VarBase, Variable) == False. It will cause return None
+ # after this api.
+ if isinstance(input, (Variable, core.VarBase)):
+ if _non_static_mode():
+ if in_dygraph_mode() and output is None:
+ output = _C_ops.assign(input)
+ elif in_dygraph_mode() and output is not None:
+ _C_ops.assign_out_(input, output)
+ else:
+ if output is None:
+ if _in_legacy_dygraph():
+ output = core.VarBase()
+ else:
+ output = core.eager.Tensor()
+ _legacy_C_ops.assign(input, output)
+ else:
+ check_dtype(input.dtype, 'input', [
+ 'float16', 'uint16', 'float32', 'float64', 'int32', 'int64',
+ 'uint8', 'bool'
+ ], 'assign', '(When the type of input in assign is Variable.)')
+ if output is None:
+ output = helper.create_variable_for_type_inference(
+ dtype=input.dtype)
+ helper.append_op(type='assign',
+ inputs={'X': [input]},
+ outputs={'Out': [output]})
+ elif isinstance(input, numpy.ndarray):
+ # Not support [var, var, ...] currently.
+ if len(input.shape) > 0 and any(isinstance(x, Variable) for x in input):
+ raise TypeError(
+ "Required type(input) numpy.ndarray, but found `list(Variable)` in input."
+ )
+ dtype = convert_np_dtype_to_dtype_(input.dtype)
+ if dtype == VarDesc.VarType.FP64:
+ # Setting FP64 numpy data is not supported in Paddle, so we
+ # use FP32 here
+ warnings.warn(
+ "paddle.assign doesn't support float64 input now due "
+ "to current platform protobuf data limitation, we convert "
+ "it to float32")
+ dtype = VarDesc.VarType.FP32
+ if dtype == VarDesc.VarType.BOOL:
+ value_name = "bool_values"
+ values = [int(v) for v in input.flat]
+ elif dtype == VarDesc.VarType.FP32:
+ value_name = "fp32_values"
+ values = [float(v) for v in input.flat]
+ elif dtype == VarDesc.VarType.INT32:
+ value_name = "int32_values"
+ values = [int(v) for v in input.flat]
+ elif dtype == VarDesc.VarType.INT64:
+ value_name = "int64_values"
+ values = [int(v) for v in input.flat]
+ else:
+ raise TypeError(
+ "When the type of 'input' in assign is numpy.ndarray, "
+ "the data type of 'input' must be bool, float32, int32 or int64, but "
+ "received %s." % convert_dtype(dtype))
+ if input.size > 1024 * 1024:
+ raise ValueError("The size of input is too big. Please consider "
+ "saving it to file and 'load_op' to load it")
+ if in_dygraph_mode():
+ if output is None:
+ output = zeros(list(input.shape), dtype)
+ _C_ops.assign_value_(output, list(input.shape), dtype, values,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ if output is None:
+ output = core.VarBase()
+ _legacy_C_ops.assign_value(output, 'shape', list(input.shape),
+ 'dtype', dtype, value_name, values)
+ else:
+ if output is None:
+ output = helper.create_variable_for_type_inference(
+ dtype=input.dtype)
+ helper.append_op(type='assign_value',
+ outputs={'Out': [output]},
+ attrs={
+ 'dtype': dtype,
+ 'shape': list(input.shape),
+ value_name: values
+ })
+
+ if is_inplace and _non_static_mode():
+ output._bump_inplace_version()
+
+ return output
+
+
+def fill_constant(shape, dtype, value, force_cpu=False, out=None, name=None):
+ """
+
+ This OP creates a Tensor with specified `shape` and `dtype`, and
+ initializes it with a constant specified by `value`.
+
+ The attribute `stop_gradient` of the created Tensor is set to True.
+
+ Args:
+ shape(list|tuple|Tensor): Shape of the output Tensor, the data type of ``shape`` is int32 or int64.
+ If ``shape`` is a list or tuple, the elements of it should be integers or Tensors with shape [1].
+ If ``shape`` is an Tensor, it should be an 1-D Tensor with date type int32 or int64.
+ dtype(np.dtype|str): Data type of the output Tensor which can
+ be float16, float32, float64, uint8, int16, int32, int64.
+ value(bool|float|int|Tensor): The constant value used to initialize
+ the Tensor to be created. If ``value`` is an Tensor, it should be an 1-D Tensor.
+ force_cpu(bool, optional): data should be on CPU if it's true, default value is False.
+ out(Tensor, optional): Optional output which can be any created
+ Tensor that meets the requirements to store the result of operation.
+ if ``out`` is None, a new Tensor will be create to store the result.
+ name(str, optional): The default value is None. Normally there is no need for user to set this
+ property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: Tensor which is created according to shape and dtype.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ # attr shape is a list which doesn't contain Tensor.
+ data1 = fluid.layers.fill_constant(shape=[2,1], value=0, dtype='int64') # data1=[[0],[0]]
+ data2 = fluid.layers.fill_constant(shape=[2,1], value=5, dtype='int64', out=data1)
+ # data1=[[5], [5]] data2=[[5], [5]]
+
+ # attr shape is a list which contains Tensor.
+ positive_2 = fluid.layers.fill_constant([1], "int32", 2)
+ data3 = fluid.layers.fill_constant(shape=[1, positive_2], dtype='float32', value=1.5) # data3=[[1.5, 1.5]]
+
+ # attr shape is a Tensor.
+ shape = fluid.layers.fill_constant([2], "int32", 2) # shape=[2,2]
+ data4 = fluid.layers.fill_constant(shape=shape, dtype='bool', value=True) # data4=[[True,True],[True,True]]
+
+ # attr value is a Tensor.
+ val = fluid.layers.fill_constant([1], "float32", 2.0) # val=[2.0]
+ data5 = fluid.layers.fill_constant(shape=[2,1], value=val, dtype='float32') #data5=[[2.0],[2.0]]
+ """
+
+ attrs = {'force_cpu': force_cpu}
+ dtype = convert_dtype(dtype)
+ if not isinstance(value, Variable):
+ if dtype in ['uint8', 'int16', 'int32', 'int64']:
+ attrs['str_value'] = str(int(value))
+ attrs['value'] = int(value)
+ else:
+ attrs['str_value'] = str(float(value))
+ attrs['value'] = float(value)
+
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ if force_cpu:
+ place = core.CPUPlace()
+ if isinstance(shape, (list, tuple)):
+ for item in shape:
+ if not isinstance(item, Variable):
+ shape = list(
+ map(
+ lambda x: x.numpy().flat[0]
+ if isinstance(x, Variable) else x, shape))
+ break
+
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+
+ if out is None:
+ out = _C_ops.full(shape, float(value), dtype, place)
+ out.stop_gradient = True
+ return out
+
+ if out is not None:
+ # final state mode is support out is not None.
+ _C_ops.full_(out, shape, float(value), dtype, place)
+ out.stop_gradient = True
+ return out
+
+ if _in_legacy_dygraph():
+ shape = utils.convert_shape_to_list(shape)
+ if out is None:
+ out = _varbase_creator(dtype=dtype)
+
+ if isinstance(value, Variable):
+ if dtype in ['uint8', 'int16', 'int32', 'int64']:
+ attrs['str_value'] = str(int(value.numpy().item(0)))
+ else:
+ attrs['str_value'] = str(float(value.numpy().item(0)))
+
+ _legacy_C_ops.fill_constant(out, 'value', float(value), 'force_cpu',
+ force_cpu, 'dtype', out.dtype, 'str_value',
+ attrs['str_value'], 'shape', shape)
+ out.stop_gradient = True
+ return out
+
+ helper = LayerHelper("fill_constant", **locals())
+ inputs = {}
+ if isinstance(value, Variable):
+ if convert_dtype(value.dtype) != dtype:
+ value = cast(value, dtype)
+ inputs['ValueTensor'] = value
+
+ check_shape(shape)
+ check_dtype(dtype, 'dtype', [
+ 'bool', 'float16', 'float32', 'float64', 'uint8', 'int16', 'int32',
+ 'int64', 'complex64', 'complex128'
+ ], 'fill_constant')
+ check_type(shape, 'shape', (Variable, list, tuple), 'fill_constant')
+
+ if out is not None:
+ check_variable_and_dtype(out, 'out', [convert_dtype(dtype)],
+ 'fill_constant')
+
+ helper = LayerHelper("fill_constant", **locals())
+ utils.get_shape_tensor_inputs(inputs=inputs,
+ attrs=attrs,
+ shape=shape,
+ op_type='fill_constant')
+
+ if out is None:
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+ attrs['dtype'] = out.dtype
+ helper.append_op(type='fill_constant',
+ inputs=inputs,
+ outputs={'Out': [out]},
+ attrs=attrs,
+ stop_gradient=True)
+ out.stop_gradient = True
+ return out
+
+
+@deprecated(since='1.8.0', update_to="paddle.fluid.layers.fill_constant")
+@templatedoc()
+def fill_constant_batch_size_like(input,
+ shape,
+ dtype,
+ value,
+ input_dim_idx=0,
+ output_dim_idx=0,
+ force_cpu=False):
+ """
+ This OP creates a Tesnor according the shape and dtype, and initializes the
+ Tensor with the constants provided in ``value``. When the input is LoDTensor
+ and the input_dim_idx is 0, the output_dim_idx dimension is set to the value
+ of the batch_size input by the input, the Stop_gradient attribute of the created
+ Tensor is False by default.
+
+ Args:
+ input(Variable): Tensor which data type is float32, float64, int32 and int64.
+ shape(list): The shape of Tensor to be created, Tensor's shape may be changed
+ according the input.
+ dtype(np.dtype|core.VarDesc.VarType|str): The data type of created Tensor which
+ can be float32, float64, int32, int64.
+ value(float|int): The constant value used to initialize the Tensor to be created.
+ input_dim_idx(int): When the value is 0 and the input is LoDTensor, the output_dim_idx
+ dimension of the created Tensor is set to the batch_size value of input.
+ The default value is 0.
+ output_dim_idx(int): Used to specify which dimension of Tensor is created to be set
+ the value of batch_size of input Tensor. The default value is 0.
+ force_cpu(bool): data should be on CPU if it's true, default value is False.
+
+ Returns:
+ Variable: Tensor which will be created according to dtype.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ like = fluid.layers.fill_constant(shape=[1,2], value=10, dtype='int64') #like=[[10, 10]]
+ data = fluid.layers.fill_constant_batch_size_like(
+ input=like, shape=[1], value=0, dtype='int64') #like=[[10, 10]] data=[0]
+
+ """
+ if in_dygraph_mode():
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+
+ place = _current_expected_place()
+ if force_cpu:
+ place = core.CPUPlace()
+ out = _C_ops.full_batch_size_like(input, shape, dtype, value,
+ input_dim_idx, output_dim_idx, place)
+ out.stop_gradient = True
+ return out
+
+ helper = LayerHelper("fill_constant_batch_size_like", **locals())
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+ attrs = {
+ 'shape': shape,
+ 'dtype': out.dtype,
+ 'value': float(value),
+ 'input_dim_idx': input_dim_idx,
+ 'output_dim_idx': output_dim_idx,
+ 'force_cpu': force_cpu
+ }
+ if convert_dtype(dtype) in ['int64', 'int32']:
+ attrs['str_value'] = str(int(value))
+ else:
+ attrs['str_value'] = str(float(value))
+ helper.append_op(type='fill_constant_batch_size_like',
+ inputs={'Input': input},
+ outputs={'Out': [out]},
+ attrs=attrs)
+ out.stop_gradient = True
+ return out
+
+
+def argmin(x, axis=0):
+ """
+ :alias_main: paddle.argmin
+ :alias: paddle.argmin,paddle.tensor.argmin,paddle.tensor.search.argmin
+ :old_api: paddle.fluid.layers.argmin
+
+ **argmin**
+
+ This OP computes the indices of the min elements of the input tensor's
+ element along the provided axis.
+
+ Args:
+ x(Variable): An input N-D Tensor with type float32, float64, int16,
+ int32, int64, uint8.
+ axis(int, optional): Axis to compute indices along. The effective range
+ is [-R, R), where R is Rank(x). when axis<0, it works the same way
+ as axis+R. Default is 0.
+
+ Returns:
+ Variable: A Tensor with data type int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ in1 = np.array([[[5,8,9,5],
+ [0,0,1,7],
+ [6,9,2,4]],
+ [[5,2,4,2],
+ [4,7,7,9],
+ [1,7,0,6]]])
+ with fluid.dygraph.guard():
+ x = fluid.dygraph.to_variable(in1)
+ out1 = fluid.layers.argmin(x=x, axis=-1)
+ out2 = fluid.layers.argmin(x=x, axis=0)
+ out3 = fluid.layers.argmin(x=x, axis=1)
+ out4 = fluid.layers.argmin(x=x, axis=2)
+ print(out1.numpy())
+ # [[0 0 2]
+ # [1 0 2]]
+ print(out2.numpy())
+ # [[0 1 1 1]
+ # [0 0 0 0]
+ # [1 1 1 0]]
+ print(out3.numpy())
+ # [[1 1 1 2]
+ # [2 0 2 0]]
+ print(out4.numpy())
+ # [[0 0 2]
+ # [1 0 2]]
+ """
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
+ 'argmin')
+ helper = LayerHelper("arg_min", **locals())
+ out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
+ helper.append_op(type='arg_min',
+ inputs={'X': x},
+ outputs={'Out': [out]},
+ attrs={'axis': axis})
+ out.stop_gradient = True
+ return out
+
+
+def argmax(x, axis=0):
+ """
+ **argmax**
+
+ This OP computes the indices of the max elements of the input tensor's
+ element along the provided axis.
+
+ Args:
+ x(Variable): An input N-D Tensor with type float32, float64, int16,
+ int32, int64, uint8.
+ axis(int, optional): Axis to compute indices along. The effective range
+ is [-R, R), where R is Rank(x). when axis<0, it works the same way
+ as axis+R. Default is 0.
+
+ Returns:
+ Variable: A Tensor with data type int64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ in1 = np.array([[[5,8,9,5],
+ [0,0,1,7],
+ [6,9,2,4]],
+ [[5,2,4,2],
+ [4,7,7,9],
+ [1,7,0,6]]])
+ with fluid.dygraph.guard():
+ x = fluid.dygraph.to_variable(in1)
+ out1 = fluid.layers.argmax(x=x, axis=-1)
+ out2 = fluid.layers.argmax(x=x, axis=0)
+ out3 = fluid.layers.argmax(x=x, axis=1)
+ out4 = fluid.layers.argmax(x=x, axis=2)
+ print(out1.numpy())
+ # [[2 3 1]
+ # [0 3 1]]
+ print(out2.numpy())
+ # [[0 0 0 0]
+ # [1 1 1 1]
+ # [0 0 0 1]]
+ print(out3.numpy())
+ # [[2 2 0 1]
+ # [0 1 1 1]]
+ print(out4.numpy())
+ # [[2 3 1]
+ # [0 3 1]]
+ """
+ check_variable_and_dtype(
+ x, 'x', ['float32', 'float64', 'uint8', 'int16', 'int32', 'int64'],
+ 'argmax')
+ helper = LayerHelper("arg_max", **locals())
+ out = helper.create_variable_for_type_inference(VarDesc.VarType.INT64)
+ helper.append_op(type='arg_max',
+ inputs={'X': x},
+ outputs={'Out': [out]},
+ attrs={'axis': axis})
+ out.stop_gradient = True
+ return out
+
+
+def argsort(input, axis=-1, descending=False, name=None):
+ """
+ :alias_main: paddle.argsort
+ :alias: paddle.argsort,paddle.tensor.argsort,paddle.tensor.search.argsort
+ :old_api: paddle.fluid.layers.argsort
+
+ This OP sorts the input along the given axis, and returns sorted output
+ data Varibale and its corresponding index Variable with the same shape as
+ :attr:`input`.
+
+ Args:
+ input(Variable): An input N-D Tensor with type float32, float64, int16,
+ int32, int64, uint8.
+ axis(int, optional): Axis to compute indices along. The effective range
+ is [-R, R), where R is Rank(x). when axis<0, it works the same way
+ as axis+R. Default is 0.
+ descending(bool, optional) : Descending is a flag, if set to true,
+ algorithm will sort by descending order, else sort by
+ ascending order. Default is false.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ tuple: A tuple of sorted data Variable(with the same shape and data
+ type as input) and the sorted indices(with the same shape as input's
+ and with data type int64).
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ in1 = np.array([[[5,8,9,5],
+ [0,0,1,7],
+ [6,9,2,4]],
+ [[5,2,4,2],
+ [4,7,7,9],
+ [1,7,0,6]]]).astype(np.float32)
+ with fluid.dygraph.guard():
+ x = fluid.dygraph.to_variable(in1)
+ out1 = fluid.layers.argsort(input=x, axis=-1)
+ out2 = fluid.layers.argsort(input=x, axis=0)
+ out3 = fluid.layers.argsort(input=x, axis=1)
+ print(out1[0].numpy())
+ # [[[5. 5. 8. 9.]
+ # [0. 0. 1. 7.]
+ # [2. 4. 6. 9.]]
+ # [[2. 2. 4. 5.]
+ # [4. 7. 7. 9.]
+ # [0. 1. 6. 7.]]]
+ print(out1[1].numpy())
+ # [[[0 3 1 2]
+ # [0 1 2 3]
+ # [2 3 0 1]]
+ # [[1 3 2 0]
+ # [0 1 2 3]
+ # [2 0 3 1]]]
+ print(out2[0].numpy())
+ # [[[5. 2. 4. 2.]
+ # [0. 0. 1. 7.]
+ # [1. 7. 0. 4.]]
+ # [[5. 8. 9. 5.]
+ # [4. 7. 7. 9.]
+ # [6. 9. 2. 6.]]]
+ print(out3[0].numpy())
+ # [[[0. 0. 1. 4.]
+ # [5. 8. 2. 5.]
+ # [6. 9. 9. 7.]]
+ # [[1. 2. 0. 2.]
+ # [4. 7. 4. 6.]
+ # [5. 7. 7. 9.]]]
+ """
+ check_variable_and_dtype(
+ input, 'input',
+ ['float32', 'float64', 'int16', 'int32', 'int64', 'uint8'], 'argsort')
+ helper = LayerHelper("argsort", **locals())
+ out = helper.create_variable_for_type_inference(dtype=input.dtype,
+ stop_gradient=True)
+ ids = helper.create_variable_for_type_inference(VarDesc.VarType.INT64,
+ stop_gradient=True)
+ helper.append_op(type='argsort',
+ inputs={'X': input},
+ outputs={
+ 'Out': out,
+ 'Indices': ids
+ },
+ attrs={
+ 'axis': axis,
+ 'descending': descending
+ })
+ return out, ids
+
+
+def ones(shape, dtype, force_cpu=False):
+ """
+ The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 1.
+ Its :attr:`stop_gradient` will be set to True to stop gradient computation.
+
+ Parameters:
+ shape(tuple|list|Tensor): Shape of output Tensor, the data type of shape is int32 or int64.
+ dtype (np.dtype|str): Data type of output Tensor, it supports
+ bool, float16, float32, float64, int32 and int64.
+ force_cpu (bool, optional): Whether force to store the output Tensor in CPU memory.
+ If :attr:`force_cpu` is False, the output Tensor will be stored in running device memory.
+ Default: False.
+
+ Returns:
+ Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 1.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data0 = fluid.layers.ones(shape=[2, 4], dtype='float32') # [[1., 1., 1., 1.], [1., 1., 1., 1.]]
+
+ # shape is a Tensor
+ shape = fluid.layers.fill_constant(shape=[2], dtype='int32', value=2)
+ data1 = fluid.layers.ones(shape=shape, dtype='int32') #[[1, 1], [1, 1]]
+ """
+ return fill_constant(value=1.0, **locals())
+
+
+def zeros(shape, dtype, force_cpu=False, name=None):
+ """
+ The OP creates a tensor of specified :attr:`shape` and :attr:`dtype`, and fills it with 0.
+ Its :attr:`stop_gradient` will be set to True to stop gradient computation.
+
+ Parameters:
+ shape(tuple|list|Tensor): Shape of output Tensor, the data type of ``shape`` is int32 or int64.
+ dtype (np.dtype|str): Data type of output Tensor, it supports
+ bool, float16, float32, float64, int32 and int64.
+ force_cpu (bool, optional): Whether force to store the output Tensor in CPU memory.
+ If :attr:`force_cpu` is False, the output Tensor will be stored in running device memory.
+ Default: False.
+ name(str, optional): The default value is None. Normally there is no need for user to set this
+ property. For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: A tensor of data type :attr:`dtype` with shape :attr:`shape` and all elements set to 0.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.zeros(shape=[3, 2], dtype='float32') # [[0., 0.], [0., 0.], [0., 0.]]
+
+ # shape is a Tensor
+ shape = fluid.layers.fill_constant(shape=[2], dtype='int32', value=2)
+ data1 = fluid.layers.zeros(shape=shape, dtype='int32') #[[0, 0], [0, 0]]
+ """
+ return fill_constant(value=0.0, **locals())
+
+
+def reverse(x, axis):
+ """
+ :alias_main: paddle.reverse
+ :alias: paddle.reverse,paddle.tensor.reverse,paddle.tensor.manipulation.reverse
+ :old_api: paddle.fluid.layers.reverse
+
+ The OP reverses the tensor :attr:`x` along the given :attr:`axis`.
+
+ .. code-block:: text
+
+ Case 1:
+
+ Given a LoDTensor:
+ x = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
+ axis = [0, 1]
+
+ Then:
+ output = [[8, 7, 6], [5, 4, 3], [2, 1, 0]]
+
+ Case 2:
+
+ Given a LoDTensorArray:
+ x = {[[0, 1], [2, 3]],
+ [[4, 5, 6]],
+ [[7],[8], [9]]}
+ axis = 0
+
+ Then:
+ output = {[[7],[8], [9]],
+ [[4, 5, 6]],
+ [[0, 1], [2, 3]]}
+
+ Parameters:
+ x (Variable): A tensor or LoDTensorArray to be reversed, its data type supports bool, float32, float64, int32, int64 and uint8.
+ If input is a LoDTensorArray, returns a new reversed LoDTensorArray without changing the internal order of each inner tensor.
+ axis (int|tuple|list): A dimension or a set of dimensions of :attr:`x` to reverse. Must be
+ in the range [-rank( :attr:`x` ), rank( :attr:`x` )). If it is a tuple or a list, reversing
+ will be apply on each axis in the tuple or list. If input is a LoDTensorArray, the value of axis shall be 0, or a
+ list [0] or tuple (0, ) with shape [1].
+
+ Returns:
+ Variable: The reversed tensor with the same shape and data type as :attr:`x`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ data = fluid.layers.assign(np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype='float32')) # [[0., 1., 2.], [3., 4., 5.], [6., 7., 8.]]
+ result1 = fluid.layers.reverse(data, 0) # [[6., 7., 8.], [3., 4., 5.], [0., 1., 2.]]
+ result2 = fluid.layers.reverse(data, [0, 1]) # [[8., 7., 6.], [5., 4., 3.], [2., 1., 0.]]
+
+ # example of LoDTensorArray
+ data1 = fluid.layers.assign(np.array([[0, 1, 2]], dtype='float32'))
+ data2 = fluid.layers.assign(np.array([[3, 4, 5]], dtype='float32'))
+ tensor_array = fluid.layers.create_array(dtype='float32')
+ i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
+ fluid.layers.array_write(data1, i, tensor_array)
+ fluid.layers.array_write(data2, i+1, tensor_array)
+
+ reversed_tensor_array = fluid.layers.reverse(tensor_array, 0) # {[[3, 4, 5]], [[0, 1, 2]]}
+ """
+ check_variable_and_dtype(x, 'x',
+ ('float32', 'float64', 'int32', 'int64', 'uint8'),
+ 'reverse')
+ check_type(axis, 'axis', (int, tuple, list, Variable), 'reverse')
+ if isinstance(axis, int):
+ axis = [axis]
+ if in_dygraph_mode():
+ return _C_ops.reverse(x, axis)
+ helper = LayerHelper("reverse", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(type='reverse',
+ inputs={'X': x},
+ outputs={'Out': [out]},
+ attrs={'axis': axis})
+ return out
+
+
+def save(x, file_path, overwrite=True):
+ """
+ Saves a variable as a file.
+
+ Args:
+ x(variable): The Tensor/LoDTensor to be saved.
+ file_path(str): The file path where the variable will be saved.
+ overwrite(bool): Whether or not cover the given file when it has already
+ existed. If it's set 'False' and the file is existed, a runtime
+ error will be thrown.
+ """
+ helper = LayerHelper("save", **locals())
+ helper.append_op(type="save",
+ inputs={"input": x},
+ outputs={},
+ args={
+ "file_path": file_path,
+ "overwrite": overwrite
+ })
+
+
+def save_combine(x, file_path, overwrite=True):
+ """
+ Saves a list of variables into a single file.
+
+ Args:
+ x(list): A list of Tensor/LoDTensor variables to be saved together in
+ a single file.
+ file_path(str): The file path where variables will be saved.
+ overwrite(bool): Whether or not cover the given file when it has already
+ existed. If it's set 'False' and the file is existed, a runtime
+ error will be thrown.
+
+ Returns:
+ There is no return value.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ v1 = fluid.layers.data(name="data",
+ shape=(4, 6),
+ dtype="float32")
+ v2 = fluid.layers.data(name="data",
+ shape=(6, 8, 4),
+ dtype="float32")
+ normed = fluid.layers.save_combine([v1, v2], file_path="output")
+ """
+ helper = LayerHelper("save_combine", **locals())
+ helper.append_op(type="save_combine",
+ inputs={"input": x},
+ outputs={},
+ args={
+ "file_path": file_path,
+ "overwrite": overwrite
+ })
+
+
+def load_combine(out, file_path):
+ """
+ Loads a list of variable from a single file.
+
+ Args:
+ out(list): The list of variables to be read from the disk file.
+ file_path(str): The path of the disk file.
+ """
+ helper = LayerHelper("load_combine", **locals())
+ helper.append_op(type="load_combine",
+ inputs={},
+ output={"Out": out},
+ args={"file_path": file_path})
+
+
+def has_inf(x):
+ """
+ Test if any of x contains an infinity number
+
+ Args:
+ x (Tensor): The Tensor to be checked.
+
+ Returns:
+ Tensor: The tensor storing the output, only a bool value, indicating that whether there is infinity number in x or not.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.randn(shape=[4, 32, 32], dtype="float32")
+ res = paddle.fluid.layers.has_inf(data)
+ # [False]
+
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.isinf(x)
+
+ check_type(x, 'x', (Variable), 'has_inf')
+ helper = LayerHelper("isinf", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(type="isinf", inputs={"X": x}, outputs={"Out": out})
+ return out
+
+
+def has_nan(x):
+ """
+ Test if any of x contains a NAN
+
+ Args:
+ x (Tensor): The Tensor to be checked.
+
+ Returns:
+ Tensor: The tensor variable storing the output, only a bool value, indicating that whether there is NAN in x or not.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.randn(shape=[2,3], dtype="float32")
+ res = paddle.fluid.layers.has_nan(data)
+ # [False]
+
+ """
+ if _non_static_mode():
+ return _legacy_C_ops.isnan(x)
+
+ check_type(x, 'x', (Variable), 'has_nan')
+ helper = LayerHelper("isnan", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(type="isnan", inputs={"X": x}, outputs={"Out": out})
+ return out
+
+
+def isfinite(x):
+ """
+
+ Test if any of x contains an infinity/NAN number. If all the elements are finite,
+ returns true, else false.
+
+ Args:
+ x(Tensor): The Tensor to be checked.
+
+ Returns:
+ Tensor: The tensor storing the output, contains a bool value.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.rand(shape=[4, 6], dtype='float32')
+ y = paddle.fluid.layers.isfinite(x)
+ print(y)
+
+ """
+ check_variable_and_dtype(x, "x", ["float32", "float64", "int32", "int64"],
+ "isfinite")
+ helper = LayerHelper("isfinite", **locals())
+
+ out = helper.create_variable_for_type_inference(dtype='bool')
+ helper.append_op(type="isfinite", inputs={"X": x}, outputs={"Out": out})
+ return out
+
+
+def range(start, end, step, dtype, name=None):
+ """
+ This OP returns a 1-D Tensor with spaced values within a given interval.
+
+ Values are generated into the half-open interval [``start``, ``end``) with
+ the ``step``. (the interval including ``start`` but excluding ``end``).
+
+ If ``dtype`` is float32 or float64, we advise adding a small epsilon to
+ ``end`` to avoid floating point rounding errors when comparing against ``end``.
+
+ Parameters:
+ start(float|int|Tensor): Start of interval. The interval includes this
+ value. If ``start`` is a Tensor, it is a 1-D Tensor with shape [1],
+ with data type int32, int64, float32, float64.
+ end(float|int|Tensor): End of interval. The interval does not include
+ this value. If ``end`` is a Tensor, it is a 1-D Tensor with shape
+ [1], with data type int32, int64, float32, float64.
+ step(float|int|Tensor): Spacing between values. For any out, it is
+ the istance between two adjacent values, out[i+1] - out[i]. If
+ ``step`` is a Tensor, it is a 1-D Tensor with shape [1], with data
+ type int32, int64, float32, float64.
+ dtype(str|np.dtype|core.VarDesc.VarType, optional): The data type of the
+ output tensor. Supported data types: int32, int64, float32, float64.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: A 1-D Tensor with values from the interval [``start``, ``end``)
+ taken with common difference ``step`` beginning from ``start``. Its
+ data type is set by ``dtype``.
+
+ Raises:
+ TypeError: If ``dtype`` is not int32, int64, float32, float64.
+
+ examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ out1 = fluid.layers.range(0, 10, 2, 'int32')
+ # [0, 2, 4, 6, 8]
+
+ start_var = fluid.layers.fill_constant([1], 'int64', 3)
+ out2 = fluid.layers.range(start_var, 7, 1, 'int64')
+ # [3, 4, 5, 6]
+
+ """
+ out_shape = None
+ if not isinstance(start, Variable) and not isinstance(
+ end, Variable) and not isinstance(step, Variable):
+ out_shape = [int(math.ceil((end - start) / step))]
+
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+
+ if not isinstance(start, Variable):
+ with device_guard("cpu"):
+ start = fill_constant([1], dtype, start, force_cpu=True)
+ elif start.dtype != dtype:
+ start = cast(start, dtype)
+
+ if not isinstance(end, Variable):
+ with device_guard("cpu"):
+ end = fill_constant([1], dtype, end, force_cpu=True)
+ elif end.dtype != dtype:
+ end = cast(end, dtype)
+
+ if not isinstance(step, Variable):
+ with device_guard("cpu"):
+ step = fill_constant([1], dtype, step, force_cpu=True)
+ elif step.dtype != dtype:
+ step = cast(step, dtype)
+
+ if in_dygraph_mode():
+ return _C_ops.arange(start, end, step, dtype, _current_expected_place())
+
+ if _in_legacy_dygraph():
+ out = _legacy_C_ops.range(start, end, step)
+ out.stop_gradient = True
+ return out
+
+ check_dtype(dtype, 'dtype', ['float32', 'float64', 'int32', 'int64'],
+ 'range/arange')
+ helper = LayerHelper('range', **locals())
+ out = helper.create_variable_for_type_inference(dtype, shape=out_shape)
+ helper.append_op(type='range',
+ inputs={
+ 'Start': start,
+ 'End': end,
+ 'Step': step
+ },
+ outputs={'Out': out})
+ out.stop_gradient = True
+ if out_shape is not None:
+ out.desc.set_shape(out_shape)
+ return out
+
+
+def linspace(start, stop, num, dtype=None, name=None):
+ r"""
+ This OP return fixed number of evenly spaced values within a given interval.
+
+ Args:
+ start(int|float|Tensor): The input :attr:`start` is start variable of range. It is a scalar, \
+ or a Tensor of shape [1] with input data type int32, int64, float32 or float64.
+ stop(int|float|Tensor): The input :attr:`stop` is start variable of range. It is a scalar, \
+ or a Tensor of shape [1] with input data type int32, int64, float32 or float64.
+ num(int|Tensor): The input :attr:`num` is given num of the sequence. It is an int scalar, \
+ or a Tensor of shape [1] with data type int32.
+ dtype(np.dtype|str, optional): The data type of output tensor, it could be
+ int32, int64, float32 and float64. Default: if None, the data type is float32.
+ name(str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.Default: None.
+
+ Returns:
+ Tensor: the output data type will be float32, float64. The 1-D tensor with fixed number of evenly spaced values, \
+ the data shape of this tensor is :math:`[num]` . If the :attr:`num` is set 1, the output tensor just has \
+ the value with input :attr:`start`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.linspace(0, 10, 5, 'float32') # [0.0, 2.5, 5.0, 7.5, 10.0]
+ data = paddle.linspace(0, 10, 1, 'float32') # [0.0]
+
+ """
+ if dtype is None:
+ dtype = 'float32'
+ tensor_num = num
+ tensor_start = start
+ tensor_stop = stop
+ if not isinstance(num, Variable):
+ check_type(num, 'num', (int), 'linspace')
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+ if not isinstance(start, Variable):
+ with device_guard("cpu"):
+ tensor_start = fill_constant([1], dtype, start)
+ if not isinstance(stop, Variable):
+ with device_guard("cpu"):
+ tensor_stop = fill_constant([1], dtype, stop)
+ if not isinstance(num, Variable):
+ with device_guard("cpu"):
+ tensor_num = fill_constant([1], 'int32', num)
+ if in_dygraph_mode():
+ return _C_ops.linspace(tensor_start, tensor_stop, tensor_num, dtype,
+ _current_expected_place())
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.linspace(tensor_start, tensor_stop, tensor_num,
+ 'dtype', dtype)
+ helper = LayerHelper("linspace", **locals())
+
+ start_dtype = convert_dtype(tensor_start.dtype)
+ stop_dtype = convert_dtype(tensor_stop.dtype)
+ out_dtype = convert_dtype(dtype)
+ if isinstance(start, Variable):
+ check_dtype(start.dtype, 'start',
+ ['float32', 'float64', 'int32', 'int64'], 'linspace')
+ else:
+ check_type(start, 'start', (int, float), 'linspace')
+
+ if isinstance(stop, Variable):
+ check_dtype(stop.dtype, 'stop',
+ ['float32', 'float64', 'int32', 'int64'], 'linspace')
+ else:
+ check_type(stop, 'stop', (int, float), 'linspace')
+ if isinstance(num, Variable):
+ check_dtype(num.dtype, 'num', ['int32'], 'linspace')
+ check_dtype(dtype, 'dtype', ['int32', 'int64', 'float32', 'float64'],
+ 'linspace')
+ if ((stop_dtype == "float64" or start_dtype == "float64")
+ and out_dtype in ["float32", "int32"]) or (
+ (stop_dtype == "int64" or start_dtype == "int64")
+ and out_dtype == "int32"):
+ raise ValueError(
+ "The dtype of start/stop is {}/{} but the attr(dtype) of linspace is {}, "
+ "which may cause data type overflows. Please reset attr(dtype) of linspace."
+ .format(start_dtype, stop_dtype, dtype))
+
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+
+ helper.append_op(type='linspace',
+ inputs={
+ 'Start': tensor_start,
+ 'Stop': tensor_stop,
+ 'Num': tensor_num
+ },
+ attrs={'dtype': dtype},
+ outputs={'Out': [out]})
+ if isinstance(num, int):
+ out.desc.set_shape((num, ))
+ return out
+
+
+def zeros_like(x, out=None):
+ """
+ This OP creates a zeros tensor which has identical shape and dtype
+ with `x`.
+
+ Args:
+ x(Variable): The input tensor which specifies shape and dtype, the
+ input data dtype could be bool, float32, float64, int32, int64.
+ out(Variable, optional): If is :attr:`None` , the op will create the
+ variable as output, the data type and shape of this variable will
+ be same as input :attr:`x`. If is a tensor, the data type and shape
+ need to be same as input :attr:`x`. The default value is :attr:`None` .
+
+ Returns:
+ Variable: The N-D tensor, the element in tensor is related to input
+ data type, if the input data type is bool, the output value is
+ False, otherwise is zero. The output shape is the same as the input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ x = fluid.data(name='x', dtype='float32', shape=[3])
+ data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]
+
+ """
+ check_variable_and_dtype(x, "x",
+ ['bool', 'float32', 'float64', 'int32', 'int64'],
+ 'zeros_like')
+ helper = LayerHelper("zeros_like", **locals())
+ if out is None:
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ else:
+ check_variable_and_dtype(
+ out, "out", ['bool', 'float32', 'float64', 'int32', 'int64'],
+ 'zeros_like')
+ helper.append_op(type='fill_any_like',
+ inputs={'X': [x]},
+ attrs={
+ 'value': 0,
+ "dtype": x.dtype
+ },
+ outputs={'Out': [out]})
+ out.stop_gradient = True
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.diag")
+def diag(diagonal):
+ r"""
+ :alias_main: paddle.diag
+ :alias: paddle.diag,paddle.tensor.diag,paddle.tensor.creation.diag
+ :old_api: paddle.fluid.layers.diag
+
+ This OP creates a square matrix which has diagonal values specified by input :attr:`diagonal`.
+
+ Args:
+ diagonal(Variable|numpy.ndarray): The input tensor should be 1D tensor, the input shape is :math:`[ N]` , \
+ specifying diagonal values by this input tensor. The input data type should be float32, float64, int32, int64.
+
+ Returns:
+ Variable, the output data type is the same as input data type.: The tensor variable storing the square matrix, \
+ the diagonal values specified by input :attr:`diagonal`. the output shape is :math:`[N, N]` with two dims.
+
+ Examples:
+ .. code-block:: python
+
+ # [[3, 0, 0]
+ # [0, 4, 0]
+ # [0, 0, 5]
+
+ import paddle.fluid as fluid
+ import numpy as np
+ diagonal = np.arange(3, 6, dtype='int32')
+ data = fluid.layers.diag(diagonal)
+ # diagonal.shape=(3,) data.shape=(3, 3)
+
+ """
+ check_type(diagonal, 'diagonal', (Variable, numpy.ndarray), 'diag')
+ check_dtype(diagonal.dtype, 'diagonal',
+ ['float32', 'float64', 'int32', 'int64'], 'diag')
+ helper = LayerHelper("diag", **locals())
+
+ if not isinstance(diagonal, Variable):
+ diagonal = assign(diagonal)
+
+ out = helper.create_variable_for_type_inference(dtype=diagonal.dtype)
+
+ helper.append_op(type='diag',
+ inputs={'Diagonal': [diagonal]},
+ outputs={'Out': [out]})
+
+ out.stop_gradient = True
+ return out
+
+
+def eye(num_rows,
+ num_columns=None,
+ batch_shape=None,
+ dtype='float32',
+ name=None):
+ """
+ This function constructs a or a batch of 2-D tensor with ones on the diagonal and zeros elsewhere.
+
+ Args:
+ num_rows(int): the number of rows in each batch tensor.
+ num_columns(int, optional): the number of columns in each batch tensor.
+ If None, default: num_rows.
+ batch_shape(list, optional): If provided, the returned tensor will have a leading
+ batch size of this shape, the data type of ``batch_shape`` is int. Default is None.
+ dtype(np.dtype|str, optional): The data type of the returned tensor.
+ It should be int32, int64, float16, float32, float64, default is 'float32'.
+ name(str, optional): The default value is None. Normally there is no
+ need for user to set this property. For more information, please
+ refer to :ref:`api_guide_Name`.
+
+ Returns:
+ Tensor: An identity Tensor or LoDTensor of shape batch_shape + [num_rows, num_columns].
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ data = fluid.layers.eye(3, dtype='int32')
+ # [[1, 0, 0]
+ # [0, 1, 0]
+ # [0, 0, 1]]
+
+ data = fluid.layers.eye(2, 3, dtype='int32')
+ # [[1, 0, 0]
+ # [0, 1, 0]]
+
+ data = fluid.layers.eye(2, batch_shape=[3])
+ # Construct a batch of 3 identity tensors, each 2 x 2.
+ # data[i, :, :] is a 2 x 2 identity tensor, i = 0, 1, 2.
+
+ """
+
+ def _check_attr(attr, message):
+ if isinstance(attr, ((Variable, core.VarBase, core.eager.Tensor))):
+ assert len(attr.shape) == 1 and attr.shape[0] in [1, -1]
+ elif not isinstance(attr, int) or attr < 0:
+ raise TypeError("{} should be a non-negative int.".format(message))
+
+ _check_attr(num_rows, "num_rows")
+ if not isinstance(dtype, core.VarDesc.VarType):
+ dtype = convert_np_dtype_to_dtype_(dtype)
+ if num_columns is not None:
+ _check_attr(num_columns, "num_columns")
+ else:
+ num_columns = num_rows
+
+ if in_dygraph_mode():
+ out = _C_ops.eye(num_rows, num_columns, dtype,
+ _current_expected_place())
+ elif _in_legacy_dygraph():
+ out = _legacy_C_ops.eye('dtype', dtype, 'num_rows', num_rows,
+ 'num_columns', num_columns)
+ else:
+ helper = LayerHelper("eye", **locals())
+ check_dtype(dtype, 'dtype',
+ ['float16', 'float32', 'float64', 'int32', 'int64'], 'eye')
+ out = helper.create_variable_for_type_inference(dtype=dtype)
+ helper.append_op(type='eye',
+ inputs={},
+ outputs={'Out': [out]},
+ attrs={
+ 'num_rows': num_rows,
+ 'num_columns': num_columns,
+ 'dtype': dtype
+ },
+ stop_gradient=True)
+
+ if batch_shape is not None:
+ re_shape = [1] * len(batch_shape)
+ re_shape = re_shape + [num_rows, num_columns]
+ expand_times = batch_shape + [1, 1]
+ if _non_static_mode():
+ out, _ = _legacy_C_ops.reshape2(out, None, 'shape', re_shape)
+ return _legacy_C_ops.expand(out, None, 'expand_times', expand_times)
+
+ if not isinstance(batch_shape, list):
+ raise TypeError("batch_shape should be a list")
+ for batch_val in (batch_shape):
+ if batch_val <= 0:
+ raise TypeError("batch_shape should be a positive int list")
+
+ from .nn import reshape, expand
+ out = reshape(x=out, shape=re_shape)
+ out = expand(x=out, expand_times=expand_times)
+
+ out.stop_gradient = True
+ return out
+
+
+def ones_like(x, out=None):
+ """
+ **ones_like**
+
+ This function creates a ones tensor which has identical shape and dtype
+ with `x`.
+
+ Args:
+ x(Variable): The input tensor which specifies shape and dtype.
+ out(Variable): The output tensor.
+
+ Returns:
+ out(Variable): The tensor variable storing the output.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
+ data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0]
+
+ """
+ check_variable_and_dtype(x, "x",
+ ['bool', 'float32', 'float64', 'int32', 'int64'],
+ 'ones_like')
+
+ helper = LayerHelper("ones_like", **locals())
+ if out is None:
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ else:
+ check_variable_and_dtype(
+ out, "out", ['bool', 'float32', 'float64', 'int32', 'int64'],
+ 'ones_like')
+ helper.append_op(type='fill_any_like',
+ inputs={'X': [x]},
+ attrs={'value': 1.0},
+ outputs={'Out': [out]})
+ return out
+
+
+@deprecated(since="2.0.0", update_to="paddle.triu")
+def triu(input, diagonal=0, name=None):
+ import paddle
+ return paddle.tensor.triu(x=input, diagonal=diagonal, name=name)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/utils.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad68366e1ed2061b9a408a5cef141b383916ef63
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/layers/utils.py
@@ -0,0 +1,503 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import collections
+import copy
+import six
+import numpy as np
+from ..framework import Block, Variable, _non_static_mode
+from ..data_feeder import convert_dtype, check_variable_and_dtype, check_type, check_dtype
+from ..layer_helper import LayerHelper
+from sys import version_info
+try:
+ from collections.abc import Sequence
+except:
+ from collections import Sequence
+
+
+def convert_to_list(value, n, name, dtype=int):
+ """
+ Converts a single numerical type or iterable of numerical
+ types into an numerical type list.
+
+ Arguments:
+ value: The value to validate and convert. Could an int, or any iterable
+ of ints.
+ n: The size of the list to be returned.
+ name: The name of the argument being validated, e.g. "stride" or
+ "filter_size". This is only used to format error messages.
+ dtype: the numerical type of the element of the list to be returned.
+
+ Returns:
+ A list of n dtypes.
+
+ Raises:
+ ValueError: If something else than an int/long or iterable thereof was
+ passed.
+ """
+ if isinstance(value, dtype):
+ return [
+ value,
+ ] * n
+ else:
+ try:
+ value_list = list(value)
+ except TypeError:
+ raise ValueError("The " + name +
+ "'s type must be list or tuple. Received: " +
+ str(value))
+ if len(value_list) != n:
+ raise ValueError("The " + name + "'s length must be " + str(n) +
+ ". Received: " + str(value))
+ for single_value in value_list:
+ assert not isinstance(
+ single_value, Variable
+ ), "Required numerical type with '%s', but received Tensor." % dtype
+ try:
+ dtype(single_value)
+ except (ValueError, TypeError):
+ raise ValueError("The " + name +
+ "'s type must be a list or tuple of " +
+ str(n) + " " + str(dtype) + " . Received: " +
+ str(value) + " "
+ "including element " + str(single_value) +
+ " of type" + " " + str(type(single_value)))
+ return value_list
+
+
+def is_sequence(seq):
+ """
+ Whether `seq` is an entry or nested structure
+ """
+ if isinstance(seq, dict):
+ return True
+ return (isinstance(seq, Sequence) and not isinstance(seq, six.string_types))
+
+
+def _hash_with_id(*args):
+ """
+ Return int hash value calculated by id(arg) or tuple(id1,id2, ...).
+ """
+ assert len(args) > 0
+ info = tuple([id(v) for v in args])
+ return hash(info) & 0xfffffff
+
+
+def _sorted(dict_):
+ """
+ Returns a sorted list of the dict keys, with error if keys not sortable.
+ """
+ try:
+ return sorted(six.iterkeys(dict_))
+ except TypeError:
+ raise TypeError("nest only supports dicts with sortable keys.")
+
+
+def _yield_value(iterable):
+ if isinstance(iterable, dict):
+ # Iterate through dictionaries in a deterministic order by sorting the
+ # keys. Notice this means that we ignore the original order of `OrderedDict`
+ # instances. This is intentional, to avoid potential bugs caused by mixing
+ # ordered and plain dicts (e.g., flattening a dict but using a
+ # corresponding `OrderedDict` to pack it back).
+ for key in _sorted(iterable):
+ yield iterable[key]
+ else:
+ for value in iterable:
+ yield value
+
+
+def _yield_flat_nest(nest):
+ for n in _yield_value(nest):
+ if is_sequence(n):
+ for ni in _yield_flat_nest(n):
+ yield ni
+ else:
+ yield n
+
+
+def to_sequence(nest):
+ if is_sequence(nest):
+ return nest
+ else:
+ return [nest]
+
+
+def flatten(nest):
+ """
+ :alias_main: paddle.flatten
+ :alias: paddle.flatten,paddle.tensor.flatten,paddle.tensor.manipulation.flatten
+ :old_api: paddle.fluid.layers.flatten
+
+ Traverse all entries in the nested structure and put them into an list.
+ """
+ if is_sequence(nest):
+ return list(_yield_flat_nest(nest))
+ else:
+ return [nest]
+
+
+def _sequence_like(instance, args):
+ """
+ Convert the sequence `args` to the same type as `instance`.
+ """
+ if isinstance(instance, dict):
+ # Pack dictionaries in a deterministic order by sorting the keys.
+ # Notice this means that we ignore the original order of `OrderedDict`
+ # instances. This is intentional, to avoid potential bugs caused by mixing
+ # ordered and plain dicts (e.g., flattening a dict but using a
+ # corresponding `OrderedDict` to pack it back).
+ result = dict(zip(_sorted(instance), args))
+ return type(instance)(
+ (key, result[key]) for key in six.iterkeys(instance))
+ elif (isinstance(instance, tuple) and hasattr(instance, "_fields")
+ and isinstance(instance._fields, Sequence)
+ and all(isinstance(f, six.string_types) for f in instance._fields)):
+ # This is a namedtuple
+ return type(instance)(*args)
+ else:
+ # Not a namedtuple
+ return type(instance)(args)
+
+
+def _packed_nest_with_indices(structure, flat, index):
+ """
+ Helper function for pack_sequence_as.
+ """
+ packed = []
+ for s in _yield_value(structure):
+ if is_sequence(s):
+ new_index, child = _packed_nest_with_indices(s, flat, index)
+ packed.append(_sequence_like(s, child))
+ index = new_index
+ else:
+ packed.append(flat[index])
+ index += 1
+ return index, packed
+
+
+def pack_sequence_as(structure, flat_sequence):
+ """
+ Pack a given flattened sequence into a given structure.
+ """
+ if not is_sequence(flat_sequence):
+ raise TypeError("flat_sequence must be a sequence")
+ if not is_sequence(structure):
+ if len(flat_sequence) != 1:
+ raise ValueError(
+ "Structure is a scalar but len(flat_sequence) == %d > 1" %
+ len(flat_sequence))
+ return flat_sequence[0]
+ flat_structure = flatten(structure)
+ if len(flat_structure) != len(flat_sequence):
+ raise ValueError(
+ "Could not pack sequence. Structure had %d elements, but flat_sequence "
+ "had %d elements. Structure: %s, flat_sequence: %s." %
+ (len(flat_structure), len(flat_sequence), structure, flat_sequence))
+ _, packed = _packed_nest_with_indices(structure, flat_sequence, 0)
+ return _sequence_like(structure, packed)
+
+
+def map_structure(func, *structure):
+ """
+ Apply `func` to each entry in `structure` and return a new structure.
+ """
+ flat_structure = [flatten(s) for s in structure]
+ entries = zip(*flat_structure)
+ return pack_sequence_as(structure[0], [func(*x) for x in entries])
+
+
+def hold_mutable_vars(structure):
+ """
+ Returns whether structure holds sequence like `list/dict`.
+ """
+ for s in structure:
+ if is_sequence(s):
+ return True
+ return False
+
+
+def copy_mutable_vars(structure):
+ """
+ Returns vars copied from sequence without mutable property.
+ """
+ flat_structure = copy.copy(flatten(structure))
+ return pack_sequence_as(structure, flat_structure)
+
+
+def _recursive_assert_same_structure(nest1, nest2, check_types):
+ """
+ Helper function for `assert_same_structure`.
+ """
+ is_sequence_nest1 = is_sequence(nest1)
+ if is_sequence_nest1 != is_sequence(nest2):
+ raise ValueError(
+ "The two structures don't have the same nested structure.\n\n"
+ "First structure: %s\n\nSecond structure: %s." % (nest1, nest2))
+ if not is_sequence_nest1:
+ return # finished checking
+ if check_types:
+ type_nest1 = type(nest1)
+ type_nest2 = type(nest2)
+ if type_nest1 != type_nest2:
+ raise TypeError(
+ "The two structures don't have the same sequence type. First "
+ "structure has type %s, while second structure has type %s." %
+ (type_nest1, type_nest2))
+ if isinstance(nest1, dict):
+ keys1 = set(six.iterkeys(nest1))
+ keys2 = set(six.iterkeys(nest2))
+ if keys1 != keys2:
+ raise ValueError(
+ "The two dictionaries don't have the same set of keys. First "
+ "structure has keys {}, while second structure has keys {}."
+ .format(keys1, keys2))
+ nest1_as_sequence = [n for n in _yield_value(nest1)]
+ nest2_as_sequence = [n for n in _yield_value(nest2)]
+ for n1, n2 in zip(nest1_as_sequence, nest2_as_sequence):
+ _recursive_assert_same_structure(n1, n2, check_types)
+
+
+def padding_to_same_structure(nest1, nest2, obj=None):
+
+ def _padding_to_same_structure_single(value, obj):
+
+ def change_none_to_obj(x):
+ if x is None: return obj
+ return x
+
+ if is_sequence(value):
+ value = pack_sequence_as(
+ value, [change_none_to_obj(item) for item in flatten(value)])
+ else:
+ value = change_none_to_obj(value)
+ return value
+
+ nest1 = _padding_to_same_structure_single(nest1, obj)
+ nest2 = _padding_to_same_structure_single(nest2, obj)
+ return nest1, nest2
+
+
+def assert_same_structure(nest1, nest2, check_types=True):
+ """
+ Confirm two nested structures with the same structure.
+ """
+ len_nest1 = len(flatten(nest1)) if is_sequence(nest1) else 1
+ len_nest2 = len(flatten(nest2)) if is_sequence(nest2) else 1
+ if len_nest1 != len_nest2:
+ raise ValueError("The two structures don't have the same number of "
+ "elements.\n\nFirst structure (%i elements): %s\n\n"
+ "Second structure (%i elements): %s" %
+ (len_nest1, nest1, len_nest2, nest2))
+ _recursive_assert_same_structure(nest1, nest2, check_types)
+
+
+def _is_symmetric_padding(padding, data_dim):
+ """
+ Check whether padding is symmetrical.
+ """
+ assert len(padding) == data_dim * 2 or len(padding) == data_dim
+ is_sys = True
+ if len(padding) == data_dim * 2:
+ for i in range(data_dim):
+ if padding[i * 2] != padding[i * 2 + 1]:
+ is_sys = False
+ return is_sys
+
+
+def _contain_var(list_or_tuple):
+ """
+ Check whether list or tuple contains variable.
+ """
+ for item in list_or_tuple:
+ if isinstance(item, Variable):
+ return True
+ return False
+
+
+def get_shape_tensor_inputs(inputs, attrs, shape, op_type):
+ from .tensor import fill_constant, cast
+
+ def _get_attr_shape(list_shape):
+ attr_shape = []
+ for idx, dim in enumerate(list_shape):
+ if isinstance(dim, Variable):
+ attr_shape.append(-1)
+ else:
+ attr_shape.append(dim)
+ return attr_shape
+
+ def _get_shape_tensor(list_shape):
+ shape_tensor_list = []
+ for idx, dim in enumerate(list_shape):
+ if isinstance(dim, Variable):
+ dim.stop_gradient = True
+ check_dtype(
+ dim.dtype, 'shape[' + str(idx) + ']', ['int32', 'int64'],
+ op_type,
+ '(When type of shape in' + op_type + 'is list or tuple.)')
+ if convert_dtype(dim.dtype) == 'int64':
+ dim = cast(x=dim, dtype='int32')
+ shape_tensor_list.append(dim)
+ else:
+ temp_out = fill_constant([1], 'int32', dim, force_cpu=True)
+ shape_tensor_list.append(temp_out)
+ return shape_tensor_list
+
+ if isinstance(shape, Variable):
+ shape.stop_gradient = True
+ check_dtype(shape.dtype, 'shape', ['int32', 'int64'], 'fill_constant',
+ '(When type of shape in' + op_type + ' is Variable.)')
+ if (convert_dtype(shape.dtype) == 'int64'):
+ shape = cast(shape, 'int32')
+ inputs["ShapeTensor"] = shape
+ elif isinstance(shape, (list, tuple)):
+ assert len(shape) > 0, ("The size of 'shape' in" + op_type +
+ " can't be zero, "
+ "but received %s." % len(shape))
+ attrs["shape"] = _get_attr_shape(shape)
+ if _contain_var(shape):
+ inputs['ShapeTensorList'] = _get_shape_tensor(shape)
+ else:
+ raise TypeError("Shape only supports Variable, or list, or tuple.")
+
+
+def _convert_to_tensor_list(old_list, dtype="int32"):
+ """
+ Converts all elements of a list to Variable.
+ """
+ from .tensor import fill_constant
+ new_list_tensor = []
+ for ele in old_list:
+
+ if isinstance(ele, Variable):
+ ele.stop_gradient = True
+ new_list_tensor.append(ele)
+ else:
+ assert isinstance(ele, six.integer_types)
+ temp_out = fill_constant([1], dtype, ele, force_cpu=True)
+ new_list_tensor.append(temp_out)
+ return new_list_tensor
+
+
+def convert_shape_to_list(shape):
+ """
+ Convert shape(list, tuple, variable) to list in imperative mode
+ """
+ if isinstance(shape, (list, tuple)):
+ shape = list(
+ map(lambda x: x.numpy().flat[0]
+ if isinstance(x, Variable) else x, shape))
+ else:
+ shape = shape.numpy().astype(int).tolist()
+ return shape
+
+
+def check_shape(shape):
+ """
+ Check shape type and shape elements type before passing it to fill_constant
+ """
+ if isinstance(shape, Variable):
+ check_dtype(shape.dtype, 'shape', ['int32', 'int64'], 'fill_constant')
+ else:
+ for ele in shape:
+ if not isinstance(ele, Variable):
+ if ele < 0:
+ raise ValueError(
+ "All elements in ``shape`` must be positive when it's a list or tuple"
+ )
+ if not isinstance(ele, six.integer_types):
+ raise TypeError(
+ "All elements in ``shape`` must be integers when it's a list or tuple"
+ )
+
+
+def try_set_static_shape_tensor(tensor, shape):
+ """Try to set static shape of tensor from a shape tensor.
+
+ For example,
+
+ import paddle
+ paddle.enable_static()
+ data = paddle.static.data(name="x", shape=[-1, 2], dtype='float32')
+ shape = paddle.shape(data) # shape should be [-1, 2] instead of [-1, -1]
+ x = paddle.uniform(shape)
+ print(x.shape)
+ # (-1, 2)
+
+ """
+ if not _non_static_mode():
+ # static mode, and shape is not all inferred (contains -1)
+ if -1 in tensor.shape:
+ if isinstance(shape, Variable):
+ shape = try_get_constant_shape_from_tensor(shape)
+ if shape:
+ tensor.desc.set_shape(shape)
+
+
+def try_get_constant_shape_from_tensor(shape_tensor):
+ """Try to get shape from a tensor with constant value.
+
+ For example,
+
+ import paddle
+ paddle.enable_static()
+ data = paddle.static.data(name="x", shape=[-1, 2], dtype='float32')
+ shape = paddle.shape(data) # shape should be [-1, 2] instead of [-1, -1]
+ x = paddle.uniform(shape)
+ print(x.shape)
+ # (-1, 2)
+
+ """
+ if not _non_static_mode():
+ try:
+ if shape_tensor.op is not None:
+ generate_op = shape_tensor.op
+ if generate_op.type == 'shape':
+ var = shape_tensor.block.vars[
+ generate_op.input_arg_names[0]]
+ return var.shape
+ except:
+ return None
+
+ return None
+
+
+def get_inputs_outputs_in_block(block):
+ """
+ Returns the inputs and outputs variable used in this block but not
+ created in this block.
+ """
+ assert isinstance(
+ block,
+ Block), "input non-Block argument for get_inputs_outputs_in_block."
+ assert block.parent_idx != -1, "input block should be a sub-block, not main block."
+
+ # Find input/output var names of all ops in block
+ inner_inputs = set()
+ inner_outputs = set()
+ for op in block.ops:
+ for iname in op.input_names:
+ for in_var_name in op.input(iname):
+ if not block.has_var(in_var_name):
+ # variable not created in this block
+ inner_inputs.add(in_var_name)
+ for oname in op.output_names:
+ for out_var_name in op.output(oname):
+ if not block.has_var(out_var_name):
+ # variable not created in this block
+ inner_outputs.add(out_var_name)
+
+ return inner_inputs, inner_outputs
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lazy_init.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lazy_init.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e6a457ab32baa42c38c5a05dde4a6ba1ef79dee
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lazy_init.py
@@ -0,0 +1,115 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import framework
+
+__all__ = ["LazyGuard"]
+
+
+class LazyInitHelper(object):
+ """
+ A Helper Context to trigger switching mode between dygraph and static mode,
+ and holds the startup program resource.
+ """
+
+ def __init__(self):
+ self._state = False
+ self._tracer = None
+ self._in_guard = False
+
+ def enable(self):
+ """
+ Switch into lazy mode.
+
+ NOTE(dev): This is a very low level API and not exposed for user.
+ """
+ if self._state:
+ return
+ assert framework._non_static_mode(
+ ), "LazyInit.enable() is only available in dygraph mode."
+ self._state = True
+
+ def disable(self):
+ """
+ Exit from lazy mode.
+
+ NOTE(dev): This is a very low level API and not exposed for user.
+ """
+ if not self._state:
+ return
+ self._state = False
+
+ def __enter__(self):
+ """
+ Switch into lazy mode and set _dygraph_tracer_ with None to convert
+ dygraph mode into static mode.
+ """
+ self.enable()
+ if self._in_guard: return
+ self._tracer = framework._dygraph_tracer_
+ framework._dygraph_tracer_ = None
+ self._in_guard = True
+
+ def __exit__(self, *args, **kwargs):
+ """
+ Exit from lazy mode and recover _dygraph_tracer_.
+ """
+ self.disable()
+ if not self._in_guard: return
+ assert self._tracer is not None
+ framework._dygraph_tracer_ = self._tracer
+ self._tracer = None
+ self._in_guard = False
+
+ @property
+ def state(self):
+ return self._state
+
+
+_lazy_init_helper = LazyInitHelper()
+
+
+def lazy_init_helper():
+ global _lazy_init_helper
+ return _lazy_init_helper
+
+
+class LazyGuard(object):
+ """
+ LazyGuard is a wrapper interface for nn.Layer, it forwards the construct
+ process of user defined Layer. Meanwhile, it provides necessary API to
+ trigger EagerParamBase Lazy Initialization and get startup Program.
+ """
+
+ def __enter__(self):
+ """
+ Construct instance from class_obj by Lazy Initializing parameters.
+
+ Examples:
+
+ .. code-block:: python
+
+ from paddle import LazyGuard
+ from paddle.nn import Linear
+
+ with LazyGuard():
+ fc = LazyInit(Linear)(10, 10)
+
+ for param in fc.parameters():
+ param.initialize()
+ """
+ lazy_init_helper().enable()
+
+ def __exit__(self, *args, **kwargs):
+ lazy_init_helper().disable()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/libpaddle.so b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/libpaddle.so
new file mode 100755
index 0000000000000000000000000000000000000000..e34b2a42806ee3f01e95380dc4827891808e173e
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/libpaddle.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4c791d2a6152197428f8937bec84b141ccc5e775af26c3f51388d90d1b2f707
+size 174270784
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lod_tensor.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lod_tensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffc949412947301ec64fb85f21f3f400c557b591
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/lod_tensor.py
@@ -0,0 +1,167 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from . import core
+from .data_feeder import DataToLoDTensorConverter
+import numpy as np
+
+__all__ = ['create_lod_tensor', 'create_random_int_lodtensor']
+
+
+def create_lod_tensor(data, recursive_seq_lens, place):
+ """
+ Create a LoDTensor from a numpy array, list or existing LoDTensor.
+
+ The implementation is as follows:
+
+ 1. Check whether the length-based LoD, i.e., :code:`recursive_seq_lens`
+ is valid.
+
+ 2. Convert :code:`recursive_seq_lens` to a offset-based LoD.
+
+ 3. Based on :code:`place` , copy the :code:`data` from a numpy array, list
+ or existing LoDTensor to CPU or GPU device.
+
+ 4. Set offset-based LoD to the output LoDTensor.
+
+ Suppose we want to create a LoDTensor to hold data for word sequences,
+ where each word is represented by an integer. If we want to create
+ a LoDTensor to represent two sentences, one of 2 words, and one of 3 words.
+
+ Then :code:`data` would be a numpy array of integers with shape (5, 1).
+ :code:`recursive_seq_lens` would be [[2, 3]], indicating the word number
+ in each sentence. This length-based :code:`recursive_seq_lens` [[2, 3]]
+ would be converted to offset-based LoD [[0, 2, 5]] inside the function
+ call.
+
+ Please reference :ref:`user_guide_lod_tensor` for more details regarding LoD.
+
+ Args:
+ data (numpy.ndarray|list|LoDTensor): a numpy array, a list or ad LoDTensor
+ holding the data to be copied.
+ recursive_seq_lens (list[list[int]]): a list of lists indicating the
+ length-based LoD info.
+ place (CPUPlace|CUDAPlace): CPU or GPU place indicating where the data
+ in the created LoDTensor will be stored.
+
+ Returns:
+ A LoDTensor with tensor data and recursive_seq_lens info.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ t = fluid.create_lod_tensor(np.ndarray([5, 30]), [[2, 3]], fluid.CPUPlace())
+ """
+ if isinstance(data, core.LoDTensor):
+ return create_lod_tensor(np.array(data), recursive_seq_lens, place)
+ elif isinstance(data, list):
+ # dtype and shape are not important here,
+ # we only want to reuse code of DataToLoDTensorConverter
+ converter = DataToLoDTensorConverter(place=place,
+ lod_level=len(recursive_seq_lens),
+ shape=[],
+ dtype=core.VarDesc.VarType.FP32)
+
+ new_recursive_seq_lens = []
+ for seq in data:
+ new_recursive_seq_lens.append(len(seq))
+ converter.feed(seq)
+
+ assert [
+ new_recursive_seq_lens
+ ] == recursive_seq_lens, "data and recursive_seq_lens do not match"
+
+ arr = np.array(converter.data)
+
+ # FIXME(zjl): the original logic of create_lod_tensor would append
+ # 1 to the shape. Maybe it is not a right way? Currently, we only
+ # follow the previous logic
+ arr = arr.reshape(arr.shape + (1, ))
+ tensor = core.LoDTensor()
+ tensor.set(arr, place)
+ tensor.set_recursive_sequence_lengths(recursive_seq_lens)
+ return tensor
+ elif isinstance(data, np.ndarray):
+ tensor = core.LoDTensor()
+ tensor.set(data, place)
+ tensor.set_recursive_sequence_lengths(recursive_seq_lens)
+ assert tensor.has_valid_recursive_sequence_lengths(
+ ), "the provided lod info is invalid"
+ return tensor
+ else:
+ raise TypeError(
+ "data should be either a LoDTensor, a Numpy array or a list")
+
+
+def create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low,
+ high):
+ """
+ :api_attr: Static Graph
+
+ Create a LoDTensor containing random integers.
+
+ The implementation is as follows:
+
+ 1. Obtain the shape of output LoDTensor based on :code:`recursive_seq_lens`
+ and :code:`base_shape` . The first dimension of the shape is the total
+ length of sequences, while the other dimensions are the same as
+ :code:`base_shape` .
+
+ 2. Create a numpy array of random integers, and parse the created numpy
+ array as parameter :code:`data` of :ref:`api_fluid_create_lod_tensor` to
+ create the output LoDTensor.
+
+ Suppose we want to create a LoDTensor to hold data for 2 sequences, where
+ the dimension of the sequences are [2, 30] and [3, 30] respectively.
+ The :code:`recursive_seq_lens` would be [[2, 3]], and :code:`base_shape`
+ would be [30] (the other dimensions excluding the sequence length).
+ Therefore, the shape of the output LoDTensor would be [5, 30], where
+ the first dimension 5 is the total lengths of the sequences, and the
+ other dimensions are :code:`base_shape`.
+
+ Args:
+ recursive_seq_lens (list[list[int]]): a list of lists indicating the
+ length-based LoD info.
+ base_shape (list[int]): the shape of the output LoDTensor excluding
+ the first dimension.
+ place (CPUPlace|CUDAPlace): CPU or GPU place indicating where
+ the data in the created LoDTensor will be stored.
+ low (int): the lower bound of the random integers.
+ high (int): the upper bound of the random integers.
+
+ Returns:
+ A LoDTensor with tensor data and recursive_seq_lens info, whose data
+ is inside [low, high].
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ t = fluid.create_random_int_lodtensor(recursive_seq_lens=[[2, 3]],
+ base_shape=[30], place=fluid.CPUPlace(), low=0, high=10)
+ print(t.shape()) # [5, 30]
+ """
+ assert isinstance(base_shape, list), "base_shape should be a list"
+ # append the total number of basic elements to the front of its shape
+ overall_shape = [sum(recursive_seq_lens[-1])] + base_shape
+ # the range of integer data elements is [low, high]
+ data = np.random.random_integers(low, high, overall_shape).astype("int64")
+ return create_lod_tensor(data, recursive_seq_lens, place)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/log_helper.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/log_helper.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a13831e8478a504ab53c36301889b6249e17442
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/log_helper.py
@@ -0,0 +1,56 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import logging
+
+__all__ = ['get_logger']
+
+
+def get_logger(name, level, fmt=None):
+ """
+ Get logger from logging with given name, level and format without
+ setting logging basicConfig. For setting basicConfig in paddle
+ will disable basicConfig setting after import paddle.
+
+ Args:
+ name (str): The logger name.
+ level (logging.LEVEL): The base level of the logger
+ fmt (str): Format of logger output
+
+ Returns:
+ logging.Logger: logging logger with given settings
+
+ Examples:
+ .. code-block:: python
+
+ logger = log_helper.get_logger(__name__, logging.INFO,
+ fmt='%(asctime)s-%(levelname)s: %(message)s')
+ """
+
+ logger = logging.getLogger(name)
+ logger.setLevel(level)
+ handler = logging.StreamHandler()
+
+ if fmt:
+ formatter = logging.Formatter(fmt=fmt, datefmt='%a %b %d %H:%M:%S')
+ handler.setFormatter(formatter)
+
+ logger.addHandler(handler)
+
+ # stop propagate for propagating may print
+ # log multiple times
+ logger.propagate = False
+ return logger
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/memory_analysis.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/memory_analysis.py
new file mode 100644
index 0000000000000000000000000000000000000000..de9a260ada89e57a730759a79b8abbeece9b4d69
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/memory_analysis.py
@@ -0,0 +1,77 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import core
+import numpy as np
+
+
+def get_var_and_memory_size(block, var_name, batch_size=None):
+ var = block._find_var_recursive(var_name)
+ assert var is not None, "Variable {} cannot be found".format(var_name)
+ assert var.type == core.VarDesc.VarType.LOD_TENSOR, "Variable {} is not Tensor".format(
+ var_name)
+ shape = list(var.shape)
+ if not shape:
+ return var, 0
+
+ has_none = False
+ for i, s in enumerate(shape):
+ if s is None or s < 0:
+ assert not has_none
+ shape[i] = batch_size
+ has_none = True
+ assert all([s >= 0
+ for s in shape]), "shape {} is not deterministic".format(shape)
+ mem_size = int(np.prod(shape)) * core.size_of_dtype(var.dtype)
+ return var, mem_size
+
+
+def pre_allocate_memory(size, place):
+ t = core.LoDTensor()
+ t._set_dims([size])
+ t._mutable_data(place, core.VarDesc.VarType.INT8)
+ del t
+
+
+# NOTE: does not consider inplace yet.
+def get_max_memory_info(program, batch_size=None):
+ assert program.num_blocks == 1, "only support to analysis program with only one block"
+ cur_tmp_mem = 0
+ max_tmp_mem = 0
+ max_persistable_mem = 0
+ visited_vars = set()
+ alived_vars = []
+
+ block = program.global_block()
+ gc_vars = core._get_eager_deletion_vars(program.desc, [])[0]
+ for i, op in enumerate(block.ops):
+ var_names = op.input_arg_names + op.output_arg_names
+ for var_name in var_names:
+ if var_name in visited_vars:
+ continue
+ visited_vars.add(var_name)
+ var, mem_size = get_var_and_memory_size(block, var_name, batch_size)
+ if var.persistable:
+ max_persistable_mem += mem_size
+ else:
+ cur_tmp_mem += mem_size
+ max_tmp_mem = max(max_tmp_mem, cur_tmp_mem)
+
+ cur_gc_vars = gc_vars[i]
+ for var_name in var_names:
+ if var_name not in cur_gc_vars:
+ continue
+ _, mem_size = get_var_and_memory_size(block, var_name, batch_size)
+ cur_tmp_mem -= mem_size
+ return max_tmp_mem, max_persistable_mem
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/metrics.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/metrics.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bc6be7e093876855dda0b1aeef08edcbb3cac1f
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/metrics.py
@@ -0,0 +1,1005 @@
+# Copyright (c) 2018 PaddlePaddle 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.
+"""
+Fluid Metrics
+"""
+
+from __future__ import print_function
+
+import numpy as np
+import copy
+import warnings
+import six
+
+from .layer_helper import LayerHelper
+from .initializer import Constant
+from . import unique_name
+from .framework import Program, Variable, program_guard
+from . import layers
+from .layers import detection
+
+__all__ = [
+ 'MetricBase',
+ 'CompositeMetric',
+ 'Precision',
+ 'Recall',
+ 'Accuracy',
+ 'ChunkEvaluator',
+ 'EditDistance',
+ 'DetectionMAP',
+ 'Auc',
+]
+
+
+def _is_numpy_(var):
+ return isinstance(var, (np.ndarray, np.generic))
+
+
+def _is_number_(var):
+ return isinstance(var, int) or isinstance(var, np.int64) or isinstance(
+ var, float) or (isinstance(var, np.ndarray) and var.shape == (1, ))
+
+
+def _is_number_or_matrix_(var):
+ return _is_number_(var) or isinstance(var, np.ndarray)
+
+
+class MetricBase(object):
+ """
+ In many cases, we usually have to split the test data into mini-batches for evaluating
+ deep neural networks, therefore we need to collect the evaluation results of each
+ mini-batch and aggregate them into the final result. The paddle.fluid.metrics is
+ designed for a convenient way of deep neural network evaluation.
+
+ The paddle.fluid.metrics contains serval different evaluation metrics
+ like precision and recall, and most of them have the following functions:
+
+ 1. take the prediction result and the corresponding labels of a mini-batch as input,
+ then compute the evaluation result for the input mini-batch.
+
+ 2. aggregate the existing evaluation results as the overall performance.
+
+ The class Metric is the base class for all classes in paddle.fluid.metrics, it defines
+ the fundamental APIs for all metrics classes, including:
+
+ 1. update(preds, labels): given the prediction results (preds) and the labels (labels)
+ of some mini-batch, compute the evaluation result of that mini-batch, and memorize the
+ evaluation result.
+
+ 2. eval(): aggregate all existing evaluation result in the memory, and return the overall
+ performance across different mini-batches.
+
+ 3. reset(): empty the memory.
+
+ """
+
+ def __init__(self, name):
+ """
+ The constructor of the metric class.
+
+ Args:
+ name(str): The name of metric instance. such as, "accuracy".
+ It can be used to distinguish different metric instances in a model.
+
+ Returns:
+ The constructed class instance.
+
+ Return types:
+ The MetricBase or its succeed classes
+
+ """
+ self._name = str(name) if name != None else self.__class__.__name__
+
+ def __str__(self):
+ return self._name
+
+ def reset(self):
+ """
+ reset function empties the evaluation memory for previous mini-batches.
+
+ Args:
+ None
+
+ Returns:
+ None
+
+ Return types:
+ None
+
+ """
+ states = {
+ attr: value
+ for attr, value in six.iteritems(self.__dict__)
+ if not attr.startswith("_")
+ }
+ for attr, value in six.iteritems(states):
+ if isinstance(value, int):
+ setattr(self, attr, 0)
+ elif isinstance(value, float):
+ setattr(self, attr, .0)
+ elif isinstance(value, (np.ndarray, np.generic)):
+ setattr(self, attr, np.zeros_like(value))
+ else:
+ setattr(self, attr, None)
+
+ def get_config(self):
+ """
+ Get the metric and current states.
+ The states are the members who do not has "_" prefix.
+
+ Args:
+ None
+
+ Returns:
+ a python dict, which contains the inner states of the metric instance
+
+ Return types:
+ a python dict
+ """
+ states = {
+ attr: value
+ for attr, value in six.iteritems(self.__dict__)
+ if not attr.startswith("_")
+ }
+ config = {}
+ config.update({"name": self._name, "states": copy.deepcopy(states)})
+ return config
+
+ def update(self, preds, labels):
+ """
+ Given the prediction results (preds) and the labels (labels)
+ of some mini-batch, compute the evaluation result of that mini-batch,
+ and memorize the evaluation result. Please notice that the update function only
+ memorizes the evaluation result but would not return the score. If you want to
+ get the evaluation result, please call eval() function.
+
+ Args:
+ preds(numpy.array): the predictions of current minibatch
+ labels(numpy.array): the labels of current minibatch.
+
+ Returns:
+ None
+
+ Return types:
+ None
+
+ """
+ raise NotImplementedError(
+ "Should not use it directly, please extend it.")
+
+ def eval(self):
+ """
+ Aggregate all existing evaluation results in the memory, and return the overall
+ performance across different mini-batches.
+
+ Args:
+ None
+
+ Returns:
+ The overall performance across different mini-batches.
+
+ Return types:
+ float|list(float)|numpy.array: the metrics via Python.
+ """
+ raise NotImplementedError(
+ "Should not use it directly, please extend it.")
+
+
+class CompositeMetric(MetricBase):
+ """
+ This op creates a container that contains the union of all the added metrics.
+ After the metrics added in, calling eval() method will compute all the contained metrics automatically.
+ CAUTION: only metrics with the SAME argument list can be added in a CompositeMetric instance.
+
+ Inherit from: `MetricBase `_
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+ import paddle.fluid as fluid
+ import numpy as np
+ preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
+ [0.2], [0.3], [0.5], [0.8], [0.6]]
+ labels = [[0], [1], [1], [1], [1],
+ [0], [0], [0], [0], [0]]
+ preds = np.array(preds)
+ labels = np.array(labels)
+ comp = fluid.metrics.CompositeMetric()
+ precision = fluid.metrics.Precision()
+ recall = fluid.metrics.Recall()
+ comp.add_metric(precision)
+ comp.add_metric(recall)
+ comp.update(preds=preds, labels=labels)
+ numpy_precision, numpy_recall = comp.eval()
+ print("expect precision: %.2f, got %.2f" % ( 3. / 5, numpy_precision ) )
+ print("expect recall: %.2f, got %.2f" % (3. / 4, numpy_recall ) )
+ """
+
+ def __init__(self, name=None):
+ super(CompositeMetric, self).__init__(name)
+ self._metrics = []
+
+ def add_metric(self, metric):
+ """
+ Add a new metric to container. Noted that the argument list
+ of the added one should be consistent with existed ones.
+
+ Args:
+ metric(MetricBase): a instance of MetricBase
+ """
+ if not isinstance(metric, MetricBase):
+ raise ValueError("SubMetric should be inherit from MetricBase.")
+ self._metrics.append(metric)
+
+ def update(self, preds, labels):
+ """
+ Update the metrics of this container.
+
+ Args:
+ preds(numpy.array): predicted results of current mini-batch, the shape and dtype of which should meet the requirements of the corresponded metric.
+ labels(numpy.array): ground truth of current mini-batch, the shape and dtype of which should meet the requirements of the corresponded metric.
+ """
+ for m in self._metrics:
+ m.update(preds, labels)
+
+ def eval(self):
+ """
+ Calculate the results of all metrics sequentially.
+
+ Returns:
+ list: results of all added metrics.
+ The shape and dtype of each result depend on the definition of its metric.
+ """
+ ans = []
+ for m in self._metrics:
+ ans.append(m.eval())
+ return ans
+
+
+class Precision(MetricBase):
+ """
+ Precision (also called positive predictive value) is the fraction of
+ relevant instances among the retrieved instances. Refer to
+ https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
+
+ Noted that this class manages the precision score only for binary classification task.
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ metric = fluid.metrics.Precision()
+
+ # generate the preds and labels
+
+ preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
+ [0.2], [0.3], [0.5], [0.8], [0.6]]
+
+ labels = [[0], [1], [1], [1], [1],
+ [0], [0], [0], [0], [0]]
+
+ preds = np.array(preds)
+ labels = np.array(labels)
+
+ metric.update(preds=preds, labels=labels)
+ numpy_precision = metric.eval()
+
+ print("expect precision: %.2f and got %.2f" % ( 3.0 / 5.0, numpy_precision))
+ """
+
+ def __init__(self, name=None):
+ super(Precision, self).__init__(name)
+ self.tp = 0 # true positive
+ self.fp = 0 # false positive
+
+ def update(self, preds, labels):
+ """
+ Update the precision based on the current mini-batch prediction results .
+
+ Args:
+ preds(numpy.ndarray): prediction results of current mini-batch,
+ the output of two-class sigmoid function.
+ Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'.
+ labels(numpy.ndarray): ground truth (labels) of current mini-batch,
+ the shape should keep the same as preds.
+ Shape: [batch_size, 1], Dtype: 'int32' or 'int64'.
+ """
+ if not _is_numpy_(preds):
+ raise ValueError("The 'preds' must be a numpy ndarray.")
+ if not _is_numpy_(labels):
+ raise ValueError("The 'labels' must be a numpy ndarray.")
+ sample_num = labels.shape[0]
+ preds = np.rint(preds).astype("int32")
+
+ for i in range(sample_num):
+ pred = preds[i]
+ label = labels[i]
+ if pred == 1:
+ if pred == label:
+ self.tp += 1
+ else:
+ self.fp += 1
+
+ def eval(self):
+ """
+ Calculate the final precision.
+
+ Returns:
+ float: Results of the calculated Precision. Scalar output with float dtype.
+ """
+ ap = self.tp + self.fp
+ return float(self.tp) / ap if ap != 0 else .0
+
+
+class Recall(MetricBase):
+ """
+ Recall (also known as sensitivity) is the fraction of
+ relevant instances that have been retrieved over the
+ total amount of relevant instances
+
+ Refer to:
+ https://en.wikipedia.org/wiki/Precision_and_recall
+
+ Noted that this class manages the recall score only for binary classification task.
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ metric = fluid.metrics.Recall()
+
+ # generate the preds and labels
+
+ preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
+ [0.2], [0.3], [0.5], [0.8], [0.6]]
+
+ labels = [[0], [1], [1], [1], [1],
+ [0], [0], [0], [0], [0]]
+
+ preds = np.array(preds)
+ labels = np.array(labels)
+
+ metric.update(preds=preds, labels=labels)
+ numpy_recall = metric.eval()
+
+ print("expect recall: %.2f and got %.2f" % ( 3.0 / 4.0, numpy_recall))
+ """
+
+ def __init__(self, name=None):
+ super(Recall, self).__init__(name)
+ self.tp = 0 # true positive
+ self.fn = 0 # false negative
+
+ def update(self, preds, labels):
+ """
+ Update the recall based on the current mini-batch prediction results.
+
+ Args:
+ preds(numpy.array): prediction results of current mini-batch,
+ the output of two-class sigmoid function.
+ Shape: [batch_size, 1]. Dtype: 'float64' or 'float32'.
+ labels(numpy.array): ground truth (labels) of current mini-batch,
+ the shape should keep the same as preds.
+ Shape: [batch_size, 1], Dtype: 'int32' or 'int64'.
+ """
+ if not _is_numpy_(preds):
+ raise ValueError("The 'preds' must be a numpy ndarray.")
+ if not _is_numpy_(labels):
+ raise ValueError("The 'labels' must be a numpy ndarray.")
+ sample_num = labels.shape[0]
+ preds = np.rint(preds).astype("int32")
+
+ for i in range(sample_num):
+ pred = preds[i]
+ label = labels[i]
+ if label == 1:
+ if pred == label:
+ self.tp += 1
+ else:
+ self.fn += 1
+
+ def eval(self):
+ """
+ Calculate the final recall.
+
+ Returns:
+ float: results of the calculated Recall. Scalar output with float dtype.
+ """
+ recall = self.tp + self.fn
+ return float(self.tp) / recall if recall != 0 else .0
+
+
+class Accuracy(MetricBase):
+ """
+ This interface is used to calculate the mean accuracy over multiple batches.
+ Accuracy object has two state: value and weight. The definition of Accuracy is available at
+ https://en.wikipedia.org/wiki/Accuracy_and_precision
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ #suppose we have batch_size = 128
+ batch_size=128
+ accuracy_manager = fluid.metrics.Accuracy()
+
+ #suppose the accuracy is 0.9 for the 1st batch
+ batch1_acc = 0.9
+ accuracy_manager.update(value = batch1_acc, weight = batch_size)
+ print("expect accuracy: %.2f, get accuracy: %.2f" % (batch1_acc, accuracy_manager.eval()))
+
+ #suppose the accuracy is 0.8 for the 2nd batch
+ batch2_acc = 0.8
+
+ accuracy_manager.update(value = batch2_acc, weight = batch_size)
+ #the joint acc for batch1 and batch2 is (batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2
+ print("expect accuracy: %.2f, get accuracy: %.2f" % ((batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2, accuracy_manager.eval()))
+
+ #reset the accuracy_manager
+ accuracy_manager.reset()
+ #suppose the accuracy is 0.8 for the 3rd batch
+ batch3_acc = 0.8
+ accuracy_manager.update(value = batch3_acc, weight = batch_size)
+ print("expect accuracy: %.2f, get accuracy: %.2f" % (batch3_acc, accuracy_manager.eval()))
+ """
+
+ def __init__(self, name=None):
+ super(Accuracy, self).__init__(name)
+ self.value = .0
+ self.weight = .0
+
+ def update(self, value, weight):
+ r"""
+ This function takes the minibatch states (value, weight) as input,
+ to accumulate and update the corresponding status of the Accuracy object. The update method is as follows:
+
+ .. math::
+ \\\\ \\begin{array}{l}{\\text { self. value }+=\\text { value } * \\text { weight }} \\\\ {\\text { self. weight }+=\\text { weight }}\\end{array} \\\\
+
+ Args:
+ value(float|numpy.array): accuracy of one minibatch.
+ weight(int|float): minibatch size.
+ """
+ if not _is_number_or_matrix_(value):
+ raise ValueError(
+ "The 'value' must be a number(int, float) or a numpy ndarray.")
+ if not _is_number_(weight):
+ raise ValueError("The 'weight' must be a number(int, float).")
+ if _is_number_(weight) and weight < 0:
+ raise ValueError("The 'weight' can not be negative")
+ self.value += value * weight
+ self.weight += weight
+
+ def eval(self):
+ """
+ This function returns the mean accuracy (float or numpy.array) for all accumulated minibatches.
+
+ Returns:
+ float or numpy.array: mean accuracy for all accumulated minibatches.
+
+ """
+ if self.weight == 0:
+ raise ValueError("There is no data in Accuracy Metrics. \
+ Please check layers.accuracy output has added to Accuracy.")
+ return self.value / self.weight
+
+
+class ChunkEvaluator(MetricBase):
+ """
+ Accumulate counter numbers output by chunk_eval from mini-batches and
+ compute the precision recall and F1-score using the accumulated counter
+ numbers.
+ ChunkEvaluator has three states: num_infer_chunks, num_label_chunks and num_correct_chunks,
+ which correspond to the number of chunks, the number of labeled chunks, and the number of correctly identified chunks.
+ For some basics of chunking, please refer to
+ `Chunking with Support Vector Machines `_ .
+ ChunkEvalEvaluator computes the precision, recall, and F1-score of chunk detection,
+ and supports IOB, IOE, IOBES and IO (also known as plain) tagging schemes.
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ # init the chunk-level evaluation manager
+ metric = fluid.metrics.ChunkEvaluator()
+
+ # suppose the model predict 10 chucks, while 8 ones are correct and the ground truth has 9 chucks.
+ num_infer_chunks = 10
+ num_label_chunks = 9
+ num_correct_chunks = 8
+
+ metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
+ numpy_precision, numpy_recall, numpy_f1 = metric.eval()
+
+ print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1))
+
+ # the next batch, predicting 3 perfectly correct chucks.
+ num_infer_chunks = 3
+ num_label_chunks = 3
+ num_correct_chunks = 3
+
+ metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
+ numpy_precision, numpy_recall, numpy_f1 = metric.eval()
+
+ print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1))
+
+ """
+
+ def __init__(self, name=None):
+ super(ChunkEvaluator, self).__init__(name)
+ self.num_infer_chunks = 0
+ self.num_label_chunks = 0
+ self.num_correct_chunks = 0
+
+ def update(self, num_infer_chunks, num_label_chunks, num_correct_chunks):
+ r"""
+ This function takes (num_infer_chunks, num_label_chunks, num_correct_chunks) as input,
+ to accumulate and update the corresponding status of the ChunkEvaluator object. The update method is as follows:
+
+ .. math::
+ \\\\ \\begin{array}{l}{\\text { self. num_infer_chunks }+=\\text { num_infer_chunks }} \\\\ {\\text { self. num_Label_chunks }+=\\text { num_label_chunks }} \\\\ {\\text { self. num_correct_chunks }+=\\text { num_correct_chunks }}\\end{array} \\\\
+
+ Args:
+ num_infer_chunks(int|numpy.array): The number of chunks in Inference on the given minibatch.
+ num_label_chunks(int|numpy.array): The number of chunks in Label on the given mini-batch.
+ num_correct_chunks(int|float|numpy.array): The number of chunks both in Inference and Label on the
+ given mini-batch.
+ """
+ if not _is_number_or_matrix_(num_infer_chunks):
+ raise ValueError(
+ "The 'num_infer_chunks' must be a number(int) or a numpy ndarray."
+ )
+ if not _is_number_or_matrix_(num_label_chunks):
+ raise ValueError(
+ "The 'num_label_chunks' must be a number(int, float) or a numpy ndarray."
+ )
+ if not _is_number_or_matrix_(num_correct_chunks):
+ raise ValueError(
+ "The 'num_correct_chunks' must be a number(int, float) or a numpy ndarray."
+ )
+ self.num_infer_chunks += num_infer_chunks
+ self.num_label_chunks += num_label_chunks
+ self.num_correct_chunks += num_correct_chunks
+
+ def eval(self):
+ """
+ This function returns the mean precision, recall and f1 score for all accumulated minibatches.
+
+ Returns:
+ float: mean precision, recall and f1 score.
+
+ """
+ precision = float(
+ self.num_correct_chunks
+ ) / self.num_infer_chunks if self.num_infer_chunks else 0
+ recall = float(self.num_correct_chunks
+ ) / self.num_label_chunks if self.num_label_chunks else 0
+ f1_score = float(2 * precision * recall) / (
+ precision + recall) if self.num_correct_chunks else 0
+ return precision, recall, f1_score
+
+
+class EditDistance(MetricBase):
+ """
+ This API is for the management of edit distances.
+ Editing distance is a method to quantify the degree of dissimilarity
+ between two strings, such as words, by calculating the minimum editing
+ operand (add, delete or replace) required to convert one string into another.
+ Refer to https://en.wikipedia.org/wiki/Edit_distance.
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ # suppose that batch_size is 128
+ batch_size = 128
+
+ # init the edit distance manager
+ distance_evaluator = fluid.metrics.EditDistance("EditDistance")
+
+ # generate the edit distance across 128 sequence pairs, the max distance is 10 here
+ edit_distances_batch0 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
+ seq_num_batch0 = batch_size
+
+ distance_evaluator.update(edit_distances_batch0, seq_num_batch0)
+ avg_distance, wrong_instance_ratio = distance_evaluator.eval()
+ print("the average edit distance for batch0 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
+
+ edit_distances_batch1 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
+ seq_num_batch1 = batch_size
+
+ distance_evaluator.update(edit_distances_batch1, seq_num_batch1)
+ avg_distance, wrong_instance_ratio = distance_evaluator.eval()
+ print("the average edit distance for batch0 and batch1 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
+
+ distance_evaluator.reset()
+
+ edit_distances_batch2 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
+ seq_num_batch2 = batch_size
+
+ distance_evaluator.update(edit_distances_batch2, seq_num_batch2)
+ avg_distance, wrong_instance_ratio = distance_evaluator.eval()
+ print("the average edit distance for batch2 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
+
+ """
+
+ def __init__(self, name):
+ super(EditDistance, self).__init__(name)
+ self.total_distance = .0
+ self.seq_num = 0
+ self.instance_error = 0
+
+ def update(self, distances, seq_num):
+ """
+ Update the overall edit distance
+
+ Args:
+ distances(numpy.array): a (batch_size, 1) numpy.array, each element represents the edit distance between two sequences.
+ seq_num(int|float): standing for the number of sequence pairs.
+ """
+ if not _is_numpy_(distances):
+ raise ValueError("The 'distances' must be a numpy ndarray.")
+ if not _is_number_(seq_num):
+ raise ValueError("The 'seq_num' must be a number(int, float).")
+ seq_right_count = np.sum(distances == 0)
+ total_distance = np.sum(distances)
+ self.seq_num += seq_num
+ self.instance_error += seq_num - seq_right_count
+ self.total_distance += total_distance
+
+ def eval(self):
+ """
+ Return two floats:
+ avg_distance: the average distance for all sequence pairs updated using the update function.
+ avg_instance_error: the ratio of sequence pairs whose edit distance is not zero.
+ """
+ if self.seq_num == 0:
+ raise ValueError(
+ "There is no data in EditDistance Metric. Please check layers.edit_distance output has been added to EditDistance."
+ )
+ avg_distance = self.total_distance / self.seq_num
+ avg_instance_error = self.instance_error / float(self.seq_num)
+ return avg_distance, avg_instance_error
+
+
+class Auc(MetricBase):
+ """
+ The auc metric is for binary classification.
+ Refer to https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve.
+ Please notice that the auc metric is implemented with python, which may be a little bit slow.
+ If you concern the speed, please use the fluid.layers.auc instead.
+
+ The `auc` function creates four local variables, `true_positives`,
+ `true_negatives`, `false_positives` and `false_negatives` that are used to
+ compute the AUC. To discretize the AUC curve, a linearly spaced set of
+ thresholds is used to compute pairs of recall and precision values. The area
+ under the ROC-curve is therefore computed using the height of the recall
+ values by the false positive rate, while the area under the PR-curve is the
+ computed using the height of the precision values by the recall.
+
+ Args:
+ name (str, optional): Metric name. For details, please refer to :ref:`api_guide_Name`. Default is None.
+ curve (str): Specifies the name of the curve to be computed, 'ROC' [default] or 'PR' for the Precision-Recall-curve.
+
+ "NOTE: only implement the ROC curve type via Python now."
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ # init the auc metric
+ auc_metric = fluid.metrics.Auc("ROC")
+
+ # suppose that batch_size is 128
+ batch_num = 100
+ batch_size = 128
+
+ for batch_id in range(batch_num):
+
+ class0_preds = np.random.random(size = (batch_size, 1))
+ class1_preds = 1 - class0_preds
+
+ preds = np.concatenate((class0_preds, class1_preds), axis=1)
+
+ labels = np.random.randint(2, size = (batch_size, 1))
+ auc_metric.update(preds = preds, labels = labels)
+
+ # shall be some score closing to 0.5 as the preds are randomly assigned
+ print("auc for iteration %d is %.2f" % (batch_id, auc_metric.eval()))
+ """
+
+ def __init__(self, name, curve='ROC', num_thresholds=4095):
+ super(Auc, self).__init__(name=name)
+ self._curve = curve
+ self._num_thresholds = num_thresholds
+
+ _num_pred_buckets = num_thresholds + 1
+ self._stat_pos = [0] * _num_pred_buckets
+ self._stat_neg = [0] * _num_pred_buckets
+
+ def update(self, preds, labels):
+ """
+ Update the auc curve with the given predictions and labels.
+
+ Args:
+ preds (numpy.array): an numpy array in the shape of (batch_size, 2), preds[i][j] denotes the probability of classifying the instance i into the class j.
+ labels (numpy.array): an numpy array in the shape of (batch_size, 1), labels[i] is either o or 1, representing the label of the instance i.
+ """
+ if not _is_numpy_(labels):
+ raise ValueError("The 'labels' must be a numpy ndarray.")
+ if not _is_numpy_(preds):
+ raise ValueError("The 'predictions' must be a numpy ndarray.")
+
+ for i, lbl in enumerate(labels):
+ value = preds[i, 1]
+ bin_idx = int(value * self._num_thresholds)
+ assert bin_idx <= self._num_thresholds
+ if lbl:
+ self._stat_pos[bin_idx] += 1.0
+ else:
+ self._stat_neg[bin_idx] += 1.0
+
+ @staticmethod
+ def trapezoid_area(x1, x2, y1, y2):
+ return abs(x1 - x2) * (y1 + y2) / 2.0
+
+ def eval(self):
+ """
+ Return the area (a float score) under auc curve
+
+ Return:
+ float: the area under auc curve
+ """
+ tot_pos = 0.0
+ tot_neg = 0.0
+ auc = 0.0
+
+ idx = self._num_thresholds
+ while idx >= 0:
+ tot_pos_prev = tot_pos
+ tot_neg_prev = tot_neg
+ tot_pos += self._stat_pos[idx]
+ tot_neg += self._stat_neg[idx]
+ auc += self.trapezoid_area(tot_neg, tot_neg_prev, tot_pos,
+ tot_pos_prev)
+ idx -= 1
+
+ return auc / tot_pos / tot_neg if tot_pos > 0.0 and tot_neg > 0.0 else 0.0
+
+
+class DetectionMAP(object):
+ """
+ Calculate the detection mean average precision (mAP).
+
+ The general steps are as follows:
+
+ 1. calculate the true positive and false positive according to the input
+ of detection and labels.
+ 2. calculate mAP value, support two versions: '11 point' and 'integral'.
+ 11point: the 11-point interpolated average precision.
+ integral: the natural integral of the precision-recall curve.
+
+ Please get more information from the following articles:
+
+ https://sanchom.wordpress.com/tag/average-precision/
+
+ https://arxiv.org/abs/1512.02325
+
+ Args:
+ input (Variable): LoDTensor, The detection results, which is a LoDTensor with shape
+ [M, 6]. The layout is [label, confidence, xmin, ymin, xmax, ymax].
+ The data type is float32 or float64.
+ gt_label (Variable): LoDTensor, The ground truth label index, which is a LoDTensor
+ with shape [N, 1].The data type is float32 or float64.
+ gt_box (Variable): LoDTensor, The ground truth bounding box (bbox), which is a
+ LoDTensor with shape [N, 4]. The layout is [xmin, ymin, xmax, ymax].
+ The data type is float32 or float64.
+ gt_difficult (Variable|None): LoDTensor, Whether this ground truth is a difficult
+ bounding bbox, which can be a LoDTensor [N, 1] or not set. If None,
+ it means all the ground truth labels are not difficult bbox.The
+ data type is int.
+ class_num (int): The class number.
+ background_label (int): The index of background label, the background
+ label will be ignored. If set to -1, then all categories will be
+ considered, 0 by default.
+ overlap_threshold (float): The threshold for deciding true/false
+ positive, 0.5 by default.
+ evaluate_difficult (bool): Whether to consider difficult ground truth
+ for evaluation, True by default. This argument does not work when
+ gt_difficult is None.
+ ap_version (str): The average precision calculation ways, it must be
+ 'integral' or '11point'. Please check
+ https://sanchom.wordpress.com/tag/average-precision/ for details.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ import paddle
+ paddle.enable_static()
+
+ batch_size = None # can be any size
+ image_boxs_num = 10
+ bounding_bboxes_num = 21
+
+ pb = fluid.data(name='prior_box', shape=[image_boxs_num, 4],
+ dtype='float32')
+
+ pbv = fluid.data(name='prior_box_var', shape=[image_boxs_num, 4],
+ dtype='float32')
+
+ loc = fluid.data(name='target_box', shape=[batch_size, bounding_bboxes_num, 4],
+ dtype='float32')
+
+ scores = fluid.data(name='scores', shape=[batch_size, bounding_bboxes_num, image_boxs_num],
+ dtype='float32')
+
+ nmsed_outs = fluid.layers.detection_output(scores=scores,
+ loc=loc, prior_box=pb, prior_box_var=pbv)
+
+ gt_box = fluid.data(name="gt_box", shape=[batch_size, 4], dtype="float32")
+ gt_label = fluid.data(name="gt_label", shape=[batch_size, 1], dtype="float32")
+ difficult = fluid.data(name="difficult", shape=[batch_size, 1], dtype="float32")
+
+ exe = fluid.Executor(fluid.CUDAPlace(0))
+ map_evaluator = fluid.metrics.DetectionMAP(nmsed_outs, gt_label, gt_box, difficult, class_num = 3)
+
+ cur_map, accum_map = map_evaluator.get_map_var()
+
+
+ """
+
+ def __init__(self,
+ input,
+ gt_label,
+ gt_box,
+ gt_difficult=None,
+ class_num=None,
+ background_label=0,
+ overlap_threshold=0.5,
+ evaluate_difficult=True,
+ ap_version='integral'):
+
+ self.helper = LayerHelper('map_eval')
+ gt_label = layers.cast(x=gt_label, dtype=gt_box.dtype)
+ if gt_difficult:
+ gt_difficult = layers.cast(x=gt_difficult, dtype=gt_box.dtype)
+ label = layers.concat([gt_label, gt_difficult, gt_box], axis=1)
+ else:
+ label = layers.concat([gt_label, gt_box], axis=1)
+
+ # calculate mean average precision (mAP) of current mini-batch
+ map = detection.detection_map(input,
+ label,
+ class_num,
+ background_label,
+ overlap_threshold=overlap_threshold,
+ evaluate_difficult=evaluate_difficult,
+ ap_version=ap_version)
+
+ states = []
+ states.append(
+ self._create_state(dtype='int32',
+ shape=None,
+ suffix='accum_pos_count'))
+ states.append(
+ self._create_state(dtype='float32',
+ shape=None,
+ suffix='accum_true_pos'))
+ states.append(
+ self._create_state(dtype='float32',
+ shape=None,
+ suffix='accum_false_pos'))
+ var = self._create_state(dtype='int32', shape=[1], suffix='has_state')
+ self.helper.set_variable_initializer(var,
+ initializer=Constant(value=int(0)))
+ self.has_state = var
+
+ # calculate accumulative mAP
+ accum_map = detection.detection_map(
+ input,
+ label,
+ class_num,
+ background_label,
+ overlap_threshold=overlap_threshold,
+ evaluate_difficult=evaluate_difficult,
+ has_state=self.has_state,
+ input_states=states,
+ out_states=states,
+ ap_version=ap_version)
+
+ layers.fill_constant(shape=self.has_state.shape,
+ value=1,
+ dtype=self.has_state.dtype,
+ out=self.has_state)
+
+ self.cur_map = map
+ self.accum_map = accum_map
+
+ def _create_state(self, suffix, dtype, shape):
+ """
+ Create state variable.
+ Args:
+ suffix(str): the state suffix.
+ dtype(str|core.VarDesc.VarType): the state data type
+ shape(tuple|list): the shape of state
+ Returns: State variable
+ """
+ state = self.helper.create_variable(name="_".join(
+ [unique_name.generate(self.helper.name), suffix]),
+ persistable=True,
+ dtype=dtype,
+ shape=shape)
+ return state
+
+ def get_map_var(self):
+ """
+ Returns: mAP variable of current mini-batch and
+ accumulative mAP variable cross mini-batches.
+ """
+ return self.cur_map, self.accum_map
+
+ def reset(self, executor, reset_program=None):
+ """
+ Reset metric states at the begin of each pass/user specified batch.
+ Args:
+ executor(Executor): a executor for executing
+ the reset_program.
+ reset_program(Program|None): a single Program for reset process.
+ If None, will create a Program.
+ """
+
+ def _clone_var_(block, var):
+ assert isinstance(var, Variable)
+ return block.create_var(name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ lod_level=var.lod_level,
+ persistable=var.persistable)
+
+ if reset_program is None:
+ reset_program = Program()
+ with program_guard(main_program=reset_program):
+ var = _clone_var_(reset_program.current_block(), self.has_state)
+ layers.fill_constant(shape=var.shape,
+ value=0,
+ dtype=var.dtype,
+ out=var)
+ executor.run(reset_program)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/multiprocess_utils.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/multiprocess_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..73bba0069cdd21f1235a97313d613c1b87b1a51b
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/multiprocess_utils.py
@@ -0,0 +1,140 @@
+# Copyright (c) 2020 PaddlePaddle 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 sys
+import signal
+import atexit
+
+from . import core
+
+# NOTE: queue has a different name in python2 and python3
+import queue
+
+# multi-process worker check indices queue interval, avoid
+# hanging in subprocess data loading
+MP_STATUS_CHECK_INTERVAL = 5.
+
+# NOTE: [ mmap files clear ] If there is still data in the multiprocess queue when the main process finishes reading,
+# the data in the queue needs to be popped. Then the LoDTensor read by the main process
+# from the child process will automatically clear the memory-mapped file.
+multiprocess_queue_set = set()
+
+
+def _clear_multiprocess_queue_set():
+ global multiprocess_queue_set
+ for data_queue in multiprocess_queue_set:
+ while True:
+ try:
+ data_queue.get_nowait()
+ except queue.Empty:
+ break
+
+
+# NOTE: main process clear function at exit
+def _cleanup():
+ # NOTE: inter-process Queue shared memory objects clear function
+ _clear_multiprocess_queue_set()
+ # NOTE: main process memory map files clear funciton
+ core._cleanup_mmap_fds()
+
+
+# NOTE: for child process clear function at exit
+def _cleanup_mmap():
+ # clear memory map files in child process
+ core._cleanup_mmap_fds()
+
+
+# NOTE used for register a function to be executed at interpreter exit.
+class CleanupFuncRegistrar():
+ # Record the cleanup functions that have been executed
+ _executed_func_set = set()
+ # Record the cleanup functions that have been registered
+ _registered_func_set = set()
+
+ @classmethod
+ def register(cls, function, signals=[]):
+
+ def _func_exectuor():
+ if function not in cls._executed_func_set:
+ try:
+ function()
+ finally:
+ cls._executed_func_set.add(function)
+
+ def _func_register(function):
+ if not callable(function):
+ raise TypeError("%s is not callable object." % (function))
+ # check function object whether hash-able
+ set([function])
+ if function not in cls._registered_func_set:
+ atexit.register(_func_exectuor)
+ cls._registered_func_set.add(function)
+
+ def _signal_handler(signum=None, frame=None):
+ _func_exectuor()
+ if signum is not None:
+ if signum == signal.SIGINT:
+ raise KeyboardInterrupt
+ sys.exit(signum)
+
+ def _signal_register(signals):
+ signals = set(signals)
+ for sig in signals:
+ orig_handler = signal.signal(sig, _signal_handler)
+ if orig_handler not in (signal.SIG_DFL, signal.SIG_IGN):
+ if (sig == signal.SIGINT
+ and orig_handler is signal.default_int_handler):
+ continue
+ if orig_handler not in cls._registered_func_set:
+ atexit.register(orig_handler)
+ cls._registered_func_set.add(orig_handler)
+
+ # deal with signals
+ _signal_register(signals)
+ # deal with function
+ _func_register(function)
+
+
+# NOTE: [ mmap files clear ] When the main process exits unexpectedly, the remaining
+# shared memory objects in the inter-process Queue and the main process (mostly in the
+# BlockingQueue) may not be completely released, resulting in the corresponding
+# memory-mapped file remaining on the disk (/dev/shm), so register this function
+# to clean up shared memory objects in these two queues before the python interpreter exits.
+# NOTE: Currently multi-process DataLoader only supports Linux platform
+if not (sys.platform == 'darwin' or sys.platform == 'win32'):
+ CleanupFuncRegistrar.register(_cleanup)
+
+# ------------ SIGCHLD handler setting --------------
+_SIGCHLD_handler_set = False
+
+
+def _set_SIGCHLD_handler():
+ global _SIGCHLD_handler_set
+ if _SIGCHLD_handler_set:
+ return
+
+ current_handler = signal.getsignal(signal.SIGCHLD)
+ if not callable(current_handler):
+ current_handler = None
+
+ def __handler__(signum, frame):
+ # NOTE: Here the signum is SIGCHLD, when the child process exits,
+ # this handler will be called whenever the child process exits
+ # normally or abnormally.
+ core._throw_error_if_process_failed()
+ if current_handler is not None:
+ current_handler(signum, frame)
+
+ signal.signal(signal.SIGCHLD, __handler__)
+ _SIGCHLD_handler_set = True
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/net_drawer.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/net_drawer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7323d1ead2d9193eebd641c748707c8109080d6
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/net_drawer.py
@@ -0,0 +1,131 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import argparse
+import json
+import logging
+from collections import defaultdict
+
+import paddle.fluid.core as core
+import paddle.fluid.proto.framework_pb2 as framework_pb2
+from paddle.fluid.log_helper import get_logger
+
+logger = get_logger(__name__, logging.INFO)
+
+try:
+ from .graphviz import Graph
+except ImportError:
+ logger.info(
+ 'Cannot import graphviz, which is required for drawing a network. This '
+ 'can usually be installed in python with "pip install graphviz". Also, '
+ 'pydot requires graphviz to convert dot files to pdf: in ubuntu, this '
+ 'can usually be installed with "sudo apt-get install graphviz".')
+ print('net_drawer will not run correctly. Please install the correct '
+ 'dependencies.')
+ exit(0)
+
+OP_STYLE = {
+ 'shape': 'oval',
+ 'color': '#0F9D58',
+ 'style': 'filled',
+ 'fontcolor': '#FFFFFF'
+}
+
+VAR_STYLE = {}
+
+GRAPH_STYLE = {
+ "rankdir": "TB",
+}
+
+GRAPH_ID = 0
+
+
+def unique_id():
+
+ def generator():
+ GRAPH_ID += 1
+ return GRAPH_ID
+
+ return generator
+
+
+def draw_node(op):
+ node = OP_STYLE
+ node["name"] = op.type
+ node["label"] = op.type
+ return node
+
+
+def draw_edge(var_parent, op, var, arg):
+ edge = VAR_STYLE
+ edge["label"] = "%s(%s)" % (var.parameter, arg)
+ edge["head_name"] = op.type
+ edge["tail_name"] = var_parent[arg]
+ return edge
+
+
+def parse_graph(program, graph, var_dict, **kwargs):
+
+ # fill the known variables
+ for block in program.blocks:
+ for var in block.vars:
+ if var not in var_dict:
+ var_dict[var] = "Feed"
+
+ temp_id = 0
+ proto = framework_pb2.ProgramDesc.FromString(
+ program.desc.serialize_to_string())
+ for block in proto.blocks:
+ for op in block.ops:
+ op.type = op.type + "_" + str(temp_id)
+ temp_id += 1
+ graph.node(**draw_node(op))
+ for o in op.outputs:
+ for arg in o.arguments:
+ var_dict[arg] = op.type
+ for e in op.inputs:
+ for arg in e.arguments:
+ if arg in var_dict:
+ graph.edge(**draw_edge(var_dict, op, e, arg))
+ break # only plot the first block
+
+
+def draw_graph(startup_program, main_program, **kwargs):
+ if "graph_attr" in kwargs:
+ GRAPH_STYLE.update(kwargs["graph_attr"])
+ if "node_attr" in kwargs:
+ OP_STYLE.update(kwargs["node_attr"])
+ if "edge_attr" in kwargs:
+ VAR_STYLE.update(kwargs["edge_attr"])
+
+ graph_id = unique_id()
+ filename = kwargs.get("filename")
+ if filename == None:
+ filename = str(graph_id) + ".gv"
+ g = Graph(name=str(graph_id),
+ filename=filename,
+ graph_attr=GRAPH_STYLE,
+ node_attr=OP_STYLE,
+ edge_attr=VAR_STYLE,
+ **kwargs)
+
+ var_dict = {}
+ parse_graph(startup_program, g, var_dict)
+ parse_graph(main_program, g, var_dict)
+
+ if filename != None:
+ g.save()
+ return g
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/nets.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/nets.py
new file mode 100644
index 0000000000000000000000000000000000000000..abafb48d866bb9242c6e02b9f925dbf1860a3569
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/nets.py
@@ -0,0 +1,593 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import six
+from . import layers
+from .data_feeder import check_variable_and_dtype, convert_dtype
+from ..utils import deprecated
+
+__all__ = [
+ "simple_img_conv_pool",
+ "sequence_conv_pool",
+ "glu",
+ "scaled_dot_product_attention",
+ "img_conv_group",
+]
+
+
+def simple_img_conv_pool(input,
+ num_filters,
+ filter_size,
+ pool_size,
+ pool_stride,
+ pool_padding=0,
+ pool_type='max',
+ global_pooling=False,
+ conv_stride=1,
+ conv_padding=0,
+ conv_dilation=1,
+ conv_groups=1,
+ param_attr=None,
+ bias_attr=None,
+ act=None,
+ use_cudnn=True):
+ r"""
+ :api_attr: Static Graph
+
+ The simple_img_conv_pool api is composed of :ref:`api_fluid_layers_conv2d` and :ref:`api_fluid_layers_pool2d` .
+
+ Args:
+ input (Variable): 4-D Tensor, shape is [N, C, H, W], data type can be float32 or float64.
+ num_filters(int): The number of filters. It is the same as the output channels.
+ filter_size (int|list|tuple): The filter size. If filter_size is a list or
+ tuple, it must contain two integers, (filter_size_H, filter_size_W). Otherwise,
+ the filter_size_H = filter_size_W = filter_size.
+ pool_size (int|list|tuple): The pooling size of pool2d layer. If pool_size
+ is a list or tuple, it must contain two integers, (pool_size_H, pool_size_W).
+ Otherwise, the pool_size_H = pool_size_W = pool_size.
+ pool_stride (int|list|tuple): The pooling stride of pool2d layer. If pool_stride
+ is a list or tuple, it must contain two integers, (pooling_stride_H, pooling_stride_W).
+ Otherwise, the pooling_stride_H = pooling_stride_W = pool_stride.
+ pool_padding (int|list|tuple): The padding of pool2d layer. If pool_padding is a list or
+ tuple, it must contain two integers, (pool_padding_H, pool_padding_W).
+ Otherwise, the pool_padding_H = pool_padding_W = pool_padding. Default 0.
+ pool_type (str): Pooling type can be :math:`max` for max-pooling or :math:`avg` for
+ average-pooling. Default :math:`max`.
+ global_pooling (bool): Whether to use the global pooling. If global_pooling = true,
+ pool_size and pool_padding while be ignored. Default False
+ conv_stride (int|list|tuple): The stride size of the conv2d Layer. If stride is a
+ list or tuple, it must contain two integers, (conv_stride_H, conv_stride_W). Otherwise,
+ the conv_stride_H = conv_stride_W = conv_stride. Default: conv_stride = 1.
+ conv_padding (int|list|tuple): The padding size of the conv2d Layer. If padding is
+ a list or tuple, it must contain two integers, (conv_padding_H, conv_padding_W).
+ Otherwise, the conv_padding_H = conv_padding_W = conv_padding. Default: conv_padding = 0.
+ conv_dilation (int|list|tuple): The dilation size of the conv2d Layer. If dilation is
+ a list or tuple, it must contain two integers, (conv_dilation_H, conv_dilation_W).
+ Otherwise, the conv_dilation_H = conv_dilation_W = conv_dilation. Default: conv_dilation = 1.
+ conv_groups (int): The groups number of the conv2d Layer. According to grouped
+ convolution in Alex Krizhevsky's Deep CNN paper: when group=2,
+ the first half of the filters is only connected to the first half
+ of the input channels, while the second half of the filters is only
+ connected to the second half of the input channels. Default: groups=1.
+ param_attr (ParamAttr|None): The parameter attribute for learnable parameters/weights
+ of conv2d. If it is set to None or one attribute of ParamAttr, conv2d
+ will create ParamAttr as param_attr. If the Initializer of the param_attr
+ is not set, the parameter is initialized with :math:`Normal(0.0, std)`,
+ and the :math:`std` is :math:`(\\frac{2.0 }{filter\_elem\_num})^{0.5}`.
+ Default: None.
+ bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of conv2d.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, conv2d
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+ act (str): Activation type for conv2d, if it is set to None, activation is not
+ appended. Default: None.
+ use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True
+
+ Return:
+ 4-D Tensor, the result of input after conv2d and pool2d, with the same data type as :attr:`input`
+
+ Return Type:
+ Variable
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ img = fluid.data(name='img', shape=[100, 1, 28, 28], dtype='float32')
+ conv_pool = fluid.nets.simple_img_conv_pool(input=img,
+ filter_size=5,
+ num_filters=20,
+ pool_size=2,
+ pool_stride=2,
+ act="relu")
+ """
+ conv_out = layers.conv2d(input=input,
+ num_filters=num_filters,
+ filter_size=filter_size,
+ stride=conv_stride,
+ padding=conv_padding,
+ dilation=conv_dilation,
+ groups=conv_groups,
+ param_attr=param_attr,
+ bias_attr=bias_attr,
+ act=act,
+ use_cudnn=use_cudnn)
+
+ pool_out = layers.pool2d(input=conv_out,
+ pool_size=pool_size,
+ pool_type=pool_type,
+ pool_stride=pool_stride,
+ pool_padding=pool_padding,
+ global_pooling=global_pooling,
+ use_cudnn=use_cudnn)
+ return pool_out
+
+
+def img_conv_group(input,
+ conv_num_filter,
+ pool_size,
+ conv_padding=1,
+ conv_filter_size=3,
+ conv_act=None,
+ param_attr=None,
+ conv_with_batchnorm=False,
+ conv_batchnorm_drop_rate=0.0,
+ pool_stride=1,
+ pool_type="max",
+ use_cudnn=True):
+ """
+ :api_attr: Static Graph
+
+ The Image Convolution Group is composed of Convolution2d, BatchNorm, DropOut,
+ and Pool2D. According to the input arguments, img_conv_group will do serials of
+ computation for Input using Convolution2d, BatchNorm, DropOut, and pass the last
+ result to Pool2D.
+
+ Args:
+ input (Variable): The input is 4-D Tensor with shape [N, C, H, W], the data type of input is float32 or float64.
+ conv_num_filter(list|tuple): Indicates the numbers of filter of this group.
+ pool_size (int|list|tuple): The pooling size of Pool2D Layer. If pool_size
+ is a list or tuple, it must contain two integers, (pool_size_height, pool_size_width).
+ Otherwise, the pool_size_height = pool_size_width = pool_size.
+ conv_padding (int|list|tuple): The padding size of the Conv2D Layer. If padding is
+ a list or tuple, its length must be equal to the length of conv_num_filter.
+ Otherwise the conv_padding of all Conv2D Layers are the same. Default 1.
+ conv_filter_size (int|list|tuple): The filter size. If filter_size is a list or
+ tuple, its length must be equal to the length of conv_num_filter.
+ Otherwise the conv_filter_size of all Conv2D Layers are the same. Default 3.
+ conv_act (str): Activation type for Conv2D Layer that is not followed by BatchNorm.
+ Default: None.
+ param_attr (ParamAttr): The parameters to the Conv2D Layer. Default: None
+ conv_with_batchnorm (bool|list): Indicates whether to use BatchNorm after Conv2D Layer.
+ If conv_with_batchnorm is a list, its length must be equal to the length of
+ conv_num_filter. Otherwise, conv_with_batchnorm indicates whether all the
+ Conv2D Layer follows a BatchNorm. Default False.
+ conv_batchnorm_drop_rate (float|list): Indicates the drop_rate of Dropout Layer
+ after BatchNorm. If conv_batchnorm_drop_rate is a list, its length must be
+ equal to the length of conv_num_filter. Otherwise, drop_rate of all Dropout
+ Layers is conv_batchnorm_drop_rate. Default 0.0.
+ pool_stride (int|list|tuple): The pooling stride of Pool2D layer. If pool_stride
+ is a list or tuple, it must contain two integers, (pooling_stride_H,
+ pooling_stride_W). Otherwise, the pooling_stride_H = pooling_stride_W = pool_stride.
+ Default 1.
+ pool_type (str): Pooling type can be :math:`max` for max-pooling and :math:`avg` for
+ average-pooling. Default :math:`max`.
+ use_cudnn (bool): Use cudnn kernel or not, it is valid only when the cudnn
+ library is installed. Default: True
+
+ Return:
+ A Variable holding Tensor representing the final result after serial computation using Convolution2d,
+ BatchNorm, DropOut, and Pool2D, whose data type is the same with input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ img = fluid.data(name='img', shape=[None, 1, 28, 28], dtype='float32')
+ conv_pool = fluid.nets.img_conv_group(input=img,
+ conv_padding=1,
+ conv_num_filter=[3, 3],
+ conv_filter_size=3,
+ conv_act="relu",
+ pool_size=2,
+ pool_stride=2)
+ """
+ tmp = input
+ assert isinstance(conv_num_filter, list) or \
+ isinstance(conv_num_filter, tuple)
+
+ def __extend_list__(obj):
+ if not hasattr(obj, '__len__'):
+ return [obj] * len(conv_num_filter)
+ else:
+ assert len(obj) == len(conv_num_filter)
+ return obj
+
+ conv_padding = __extend_list__(conv_padding)
+ conv_filter_size = __extend_list__(conv_filter_size)
+ param_attr = __extend_list__(param_attr)
+ conv_with_batchnorm = __extend_list__(conv_with_batchnorm)
+ conv_batchnorm_drop_rate = __extend_list__(conv_batchnorm_drop_rate)
+
+ for i in six.moves.range(len(conv_num_filter)):
+ local_conv_act = conv_act
+ if conv_with_batchnorm[i]:
+ local_conv_act = None
+
+ tmp = layers.conv2d(input=tmp,
+ num_filters=conv_num_filter[i],
+ filter_size=conv_filter_size[i],
+ padding=conv_padding[i],
+ param_attr=param_attr[i],
+ act=local_conv_act,
+ use_cudnn=use_cudnn)
+
+ if conv_with_batchnorm[i]:
+ tmp = layers.batch_norm(input=tmp, act=conv_act)
+ drop_rate = conv_batchnorm_drop_rate[i]
+ if abs(drop_rate) > 1e-5:
+ tmp = layers.dropout(x=tmp, dropout_prob=drop_rate)
+
+ pool_out = layers.pool2d(input=tmp,
+ pool_size=pool_size,
+ pool_type=pool_type,
+ pool_stride=pool_stride,
+ use_cudnn=use_cudnn)
+ return pool_out
+
+
+def sequence_conv_pool(input,
+ num_filters,
+ filter_size,
+ param_attr=None,
+ act="sigmoid",
+ pool_type="max",
+ bias_attr=None):
+ """
+ :api_attr: Static Graph
+
+ **This api takes input as an LoDTensor. If input is a Tensor, please use**
+ :ref:`api_fluid_nets_simple_img_conv_pool` **instead**
+
+ The sequence_conv_pool is composed of :ref:`api_fluid_layers_sequence_conv`
+ and :ref:`api_fluid_layers_sequence_pool` .
+
+ Args:
+ input (Variable): 2-D LoDTensor, the input of sequence_conv,
+ which supports variable-time length input sequence.
+ The underlying of input is a matrix with shape
+ (T, N), where T is the total time steps in this mini-batch and N is
+ the input_hidden_size. The data type is float32 or float64.
+ num_filters(int): The number of filter.
+ filter_size (int): The filter size.
+ param_attr (ParamAttr): The parameters of the sequence_conv Layer. Default: None.
+ act (str|None): Activation type for Sequence_conv Layer.
+ If set to None, no activation will be applied. Default: "sigmoid".
+ pool_type (str): Pooling type can be :math:`max` for max-pooling, :math:`average` for
+ average-pooling, :math:`sum` for sum-pooling, :math:`sqrt` for sqrt-pooling.
+ Default :math:`max`.
+ bias_attr (ParamAttr|bool|None): The parameter attribute for the bias of sequence_conv.
+ If it is set to False, no bias will be added to the output units.
+ If it is set to None or one attribute of ParamAttr, sequence_conv
+ will create ParamAttr as bias_attr. If the Initializer of the bias_attr
+ is not set, the bias is initialized zero. Default: None.
+
+ Returns:
+ The final result after sequence_conv and sequence_pool.
+ It is a 2-D Tensor, with the same data type as :attr:`input`
+
+ Return Type:
+ Variable
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+ input_dim = 100 #len(word_dict)
+ emb_dim = 128
+ hid_dim = 512
+ data = fluid.data(name="words", shape=[None, 1], dtype="int64", lod_level=1)
+ emb = fluid.layers.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
+ seq_conv = fluid.nets.sequence_conv_pool(input=emb,
+ num_filters=hid_dim,
+ filter_size=3,
+ act="tanh",
+ pool_type="sqrt")
+ """
+
+ check_variable_and_dtype(input, 'input', ['float32', 'float64'], 'input')
+ conv_out = layers.sequence_conv(input=input,
+ num_filters=num_filters,
+ filter_size=filter_size,
+ param_attr=param_attr,
+ bias_attr=bias_attr,
+ act=act)
+
+ pool_out = layers.sequence_pool(input=conv_out, pool_type=pool_type)
+ return pool_out
+
+
+@deprecated(since="2.0.0", update_to="paddle.nn.functional.glu")
+def glu(input, dim=-1):
+ r"""
+ :api_attr: Static Graph
+
+ The Gated Linear Units(GLU) composed by :ref:`api_fluid_layers_split` ,
+ :ref:`api_fluid_layers_sigmoid` and :ref:`api_fluid_layers_elementwise_mul` .
+ Specifically, GLU will plit the input into two equal-sized parts,
+ :math:`a` and :math:`b`, along the given dimension and then compute as
+ following:
+
+ .. math::
+
+ {GLU}(a, b)= a \otimes \sigma(b)
+
+ Refer to `Language Modeling with Gated Convolutional Networks
+ `_.
+
+ Args:
+ input (Variable): The input variable which is a Tensor or LoDTensor.
+ The supported data types include float32, float64
+ and float16 (only for GPU).
+ dim (int, optional): The dimension along which to split. If :math:`dim < 0`, the
+ dimension to split along is :math:`rank(input) + dim`. Default -1.
+
+ Returns:
+ Variable: Variable with half the size and same data type of input.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ data = fluid.data(
+ name="words", shape=[-1, 6, 3, 9], dtype="float32")
+ # shape of output: [-1, 3, 3, 9]
+ output = fluid.nets.glu(input=data, dim=1)
+ """
+ check_variable_and_dtype(input, 'input', ['float16', 'float32', 'float64'],
+ "glu")
+ a, b = layers.split(input, num_or_sections=2, dim=dim)
+ act_b = layers.sigmoid(x=b)
+ out = layers.elementwise_mul(x=a, y=act_b)
+ return out
+
+
+def scaled_dot_product_attention(queries,
+ keys,
+ values,
+ num_heads=1,
+ dropout_rate=0.):
+ r"""
+ :api_attr: Static Graph
+
+ This interface Multi-Head Attention using scaled dot product.
+ Attention mechanism can be seen as mapping a query and a set of key-value
+ pairs to an output. Multi-Head Attention performs attention using multi-head
+ parallel, and the inputs of attention would be transformed by linear projection.
+ The formula is as follows:
+
+ .. math::
+
+ MultiHead(Q, K, V ) & = Concat(head_1, ..., head_h)
+
+ where \ head_i & = Attention(QW_i^Q , KW_i^K , VW_i^V )
+
+ Attention(Q, K, V) & = softmax (\\frac{QK^\mathrm{T}}{\sqrt{d_k}}) V
+
+ For more details, please refer to `Attention Is All You Need
+ `_ .
+
+ Note that the implementation is adapted to batch, and all matrix multiplication
+ in :math:`Attention(Q, K, V)` is batched matrix multiplication. Refer to
+ :ref:`api_fluid_layers_matmul` .
+
+ Args:
+ queries (Variable): A 3-D Tensor with shape :math:`[N, L_q, d_k \\times h]` ,
+ where :math:`N` stands for batch size, :math:`L_q` for the sequence length
+ of query, :math:`d_k \\times h` for the feature size of query, :math:`h` for
+ head number. The data type should be float32 or float64.
+ keys (Variable): A 3-D Tensor with shape :math:`[N, L_k, d_k \\times h]` ,
+ where :math:`N` stands for batch size, :math:`L_k` for the sequence length
+ of key, :math:`d_k \\times h` for the feature size of key, :math:`h` for head
+ number. The data type should be the same as ``queries`` .
+ values (Variable): A 3-D Tensor with shape :math:`[N, L_k, d_v \\times h]` ,
+ where :math:`N` stands for batch size, :math:`L_k` for the sequence length
+ of key, :math:`d_v \\times h` for the feature size of value, :math:`h` for head
+ number. The data type should be the same as ``queries`` .
+ num_heads (int, optional): Indicate the number of head. If the number
+ is 1, linear projection would not be performed on inputs. Default: 1.
+ dropout_rate (float, optional): The rate to drop the attention weight.
+ Default: 0.0, which means no dropout.
+
+ Returns:
+ Variable: A 3-D Tensor with shape :math:`[N, L_q, d_v \\times h]` , \
+ where :math:`N` stands for batch size, :math:`L_q` for the sequence \
+ length of query, :math:`d_v \\times h` for the feature size of value. \
+ It has the same data type with inputs, representing the output of \
+ Multi-Head Attention.
+
+ Raises:
+ TypeError: The dtype of inputs keys, values and queries should be the same.
+ ValueError: Inputs queries, keys and values should all be 3-D tensors.
+ ValueError: The hidden size of queries and keys should be the same.
+ ValueError: The max sequence length in value batch and in key batch should be the same.
+ ValueError: he hidden size of keys must be divisible by the number of attention heads.
+ ValueError: he hidden size of values must be divisible by the number of attention heads.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle
+ paddle.enable_static()
+
+ queries = fluid.data(name="queries", shape=[3, 5, 9], dtype="float32")
+ keys = fluid.data(name="keys", shape=[3, 6, 9], dtype="float32")
+ values = fluid.data(name="values", shape=[3, 6, 10], dtype="float32")
+ contexts = fluid.nets.scaled_dot_product_attention(queries, keys, values)
+ contexts.shape # [3, 5, 10]
+ """
+ check_variable_and_dtype(queries, 'queries', ['float32', 'float64'],
+ "scaled_dot_product_attention")
+ check_variable_and_dtype(keys, 'keys', ['float32', 'float64'],
+ "scaled_dot_product_attention")
+ check_variable_and_dtype(values, 'values', ['float32', 'float64'],
+ "scaled_dot_product_attention")
+
+ if not (queries.dtype == keys.dtype == values.dtype):
+ raise TypeError(
+ "The dtype of keys, values and queries should be the same."
+ "But received queries.dtype = %s, "
+ " keys.dtype = %s, values.dtype) = %s." %
+ (convert_dtype(queries.dtype), convert_dtype(
+ keys.dtype), convert_dtype(values.dtype)))
+
+ if not (len(queries.shape) == len(keys.shape) == len(values.shape) == 3):
+ raise ValueError(
+ "Inputs queries, keys and values should all be 3-D tensors."
+ "But received len(queries.shape) = %d, "
+ "len(keys.shape) = %d, len(values.shape) = %d." %
+ (len(queries.shape), len(keys.shape), len(values.shape)))
+
+ if queries.shape[-1] != keys.shape[-1]:
+ raise ValueError(
+ "The hidden size of queries and keys should be the same."
+ "But received queries' hidden size = %d and keys' hidden size = %d."
+ % (queries.shape[-1], keys.shape[-1]))
+ if keys.shape[-2] != values.shape[-2]:
+ raise ValueError(
+ "The max sequence length in value batch and in key batch "
+ "should be the same. But received max sequence length in value batch "
+ "= %d, in key batch = %d." % (values.shape[-2], keys.shape[-2]))
+ if keys.shape[-1] % num_heads != 0:
+ raise ValueError("The hidden size of keys (%d) must be divisible "
+ "by the number of attention heads (%d)." %
+ (keys.shape[-1], num_heads))
+ if values.shape[-1] % num_heads != 0:
+ raise ValueError("The hidden size of values (%d) must be divisible "
+ "by the number of attention heads (%d)." %
+ (values.shape[-1], num_heads))
+
+ def __compute_qkv(queries, keys, values, num_heads):
+ """
+ Add linear projection to queries, keys, and values.
+
+ Args:
+ queries(Tensor): a 3-D input Tensor.
+ keys(Tensor): a 3-D input Tensor.
+ values(Tensor): a 3-D input Tensor.
+ num_heads(int): The number of heads. Linearly project the inputs
+ ONLY when num_heads > 1.
+
+ Returns:
+ Tensor: linearly projected output Tensors: queries', keys' and
+ values'. They have the same shapes with queries, keys and
+ values.
+ """
+
+ if num_heads == 1:
+ return queries, keys, values
+
+ q = layers.fc(input=queries, size=queries.shape[-1], num_flatten_dims=2)
+ k = layers.fc(input=keys, size=keys.shape[-1], num_flatten_dims=2)
+ v = layers.fc(input=values, size=values.shape[-1], num_flatten_dims=2)
+ return q, k, v
+
+ def __split_heads(x, num_heads):
+ """
+ Reshape the last dimension of input tensor x so that it becomes two
+ dimensions.
+
+ Args:
+ x(Tensor): a 3-D input Tensor.
+ num_heads(int): The number of heads.
+
+ Returns:
+ Tensor: a Tensor with shape [..., n, m/num_heads], where m is size
+ of the last dimension of x.
+ """
+ if num_heads == 1:
+ return x
+
+ hidden_size = x.shape[-1]
+ # reshape the 3-D input: [batch_size, max_sequence_length, hidden_dim]
+ # into a 4-D output:
+ # [batch_size, max_sequence_length, num_heads, hidden_size_per_head].
+ reshaped = layers.reshape(x=x,
+ shape=list(x.shape[:-1]) +
+ [num_heads, hidden_size // num_heads])
+
+ # permute the dimensions into:
+ # [batch_size, num_heads, max_sequence_len, hidden_size_per_head]
+ return layers.transpose(x=reshaped, perm=[0, 2, 1, 3])
+
+ def __combine_heads(x):
+ """
+ Reshape the last two dimensions of input tensor x so that it becomes
+ one dimension.
+
+ Args:
+ x(Tensor): a 4-D input Tensor with shape
+ [bs, num_heads, max_sequence_length, hidden_dim].
+
+ Returns:
+ Tensor: a Tensor with shape
+ [bs, max_sequence_length, num_heads * hidden_dim].
+ """
+
+ if len(x.shape) == 3: return x
+ if len(x.shape) != 4:
+ raise ValueError("Input(x) should be a 4-D Tensor.")
+
+ trans_x = layers.transpose(x, perm=[0, 2, 1, 3])
+ return layers.reshape(x=trans_x,
+ shape=list(
+ map(int, [
+ trans_x.shape[0], trans_x.shape[1],
+ trans_x.shape[2] * trans_x.shape[3]
+ ])))
+
+ q, k, v = __compute_qkv(queries, keys, values, num_heads)
+
+ q = __split_heads(q, num_heads)
+ k = __split_heads(k, num_heads)
+ v = __split_heads(v, num_heads)
+
+ key_dim_per_head = keys.shape[-1] // num_heads
+ scaled_q = layers.scale(x=q, scale=key_dim_per_head**-0.5)
+ product = layers.matmul(x=scaled_q, y=k, transpose_y=True)
+
+ weights = layers.reshape(x=layers.reshape(x=product,
+ shape=[-1, product.shape[-1]],
+ act="softmax"),
+ shape=product.shape)
+ if dropout_rate:
+ weights = layers.dropout(weights,
+ dropout_prob=dropout_rate,
+ is_test=False)
+ ctx_multiheads = layers.matmul(weights, v)
+ return __combine_heads(ctx_multiheads)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/op.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/op.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca92ac44128953cf2839c2159c7df53a309ac252
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/op.py
@@ -0,0 +1,334 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import numpy as np
+import six
+
+import paddle.fluid.core as core
+import paddle.fluid.proto.framework_pb2 as framework_pb2
+
+
+def get_all_op_protos():
+ """
+ Get all registered op proto from PaddlePaddle C++ end.
+ :return: A list of registered OpProto.
+ """
+ protostrs = core.get_all_op_protos()
+ ret_values = []
+ for pbstr in protostrs:
+ op_proto = framework_pb2.OpProto.FromString(six.binary_type(pbstr))
+ ret_values.append(op_proto)
+ return ret_values
+
+
+def is_str(s):
+ return isinstance(s, six.string_types)
+
+
+class OpDescCreationMethod(object):
+ """
+ Convert the user's input(only keyword arguments are supported) to OpDesc
+ based on the OpProto.
+
+ :param op_proto: The OpProto object.
+ :type op_proto: op_proto_pb2.OpProto
+ """
+
+ def __init__(self, op_proto):
+ if not isinstance(op_proto, framework_pb2.OpProto):
+ raise TypeError(
+ "Type of op_proto should be OpProto in PaddlePaddle.")
+ self.__op_proto__ = op_proto
+ self.__extra_attrs__ = core.get_op_extra_attrs(op_proto.type)
+
+ def __call__(self, *args, **kwargs):
+ """
+ Convert user's input to OpDesc. Only keyword arguments are supported.
+ :return: The OpDesc based on user input.
+ :rtype: op_desc_pb2.OpDesc
+ """
+ if len(args) != 0:
+ raise ValueError("Only keyword arguments are supported.")
+ op_desc = framework_pb2.OpDesc()
+ for input_parameter in self.__op_proto__.inputs:
+ input_arguments = kwargs.get(input_parameter.name, [])
+ if is_str(input_arguments):
+ input_arguments = [input_arguments]
+
+ if not input_parameter.duplicable and len(input_arguments) > 1:
+ raise ValueError(
+ "Input %s expects only one input, but %d are given." %
+ (input_parameter.name, len(input_arguments)))
+
+ ipt = op_desc.inputs.add()
+ ipt.parameter = input_parameter.name
+ ipt.arguments.extend(input_arguments)
+
+ for output_parameter in self.__op_proto__.outputs:
+ output_arguments = kwargs.get(output_parameter.name, [])
+ if is_str(output_arguments):
+ output_arguments = [output_arguments]
+
+ if not output_parameter.duplicable and len(output_arguments) > 1:
+ raise ValueError(
+ "Output %s expects only one output, but %d are given." %
+ (output_parameter.name, len(output_arguments)))
+
+ out = op_desc.outputs.add()
+ out.parameter = output_parameter.name
+ out.arguments.extend(output_arguments)
+
+ # Types
+ op_desc.type = self.__op_proto__.type
+
+ # Attrs
+ for attr in self.__op_proto__.attrs:
+ if attr.generated:
+ continue
+ user_defined_attr = kwargs.get(attr.name, None)
+ if user_defined_attr is not None:
+ new_attr = op_desc.attrs.add()
+ new_attr.name = attr.name
+ new_attr.type = attr.type
+ if isinstance(user_defined_attr, np.ndarray):
+ user_defined_attr = user_defined_attr.tolist()
+ if attr.type == framework_pb2.INT:
+ new_attr.i = user_defined_attr
+ elif attr.type == framework_pb2.FLOAT:
+ new_attr.f = user_defined_attr
+ elif attr.type == framework_pb2.LONG:
+ new_attr.l = user_defined_attr
+ elif attr.type == framework_pb2.STRING:
+ new_attr.s = user_defined_attr
+ elif attr.type == framework_pb2.BOOLEAN:
+ new_attr.b = user_defined_attr
+ elif attr.type == framework_pb2.INTS:
+ new_attr.ints.extend(user_defined_attr)
+ elif attr.type == framework_pb2.FLOATS:
+ new_attr.floats.extend(user_defined_attr)
+ elif attr.type == framework_pb2.STRINGS:
+ new_attr.strings.extend(user_defined_attr)
+ elif attr.type == framework_pb2.BOOLEANS:
+ new_attr.bools.extend(user_defined_attr)
+ elif attr.type == framework_pb2.LONGS:
+ new_attr.longs.extend(user_defined_attr)
+ elif attr.type == framework_pb2.FLOAT64:
+ new_attr.float64 = user_defined_attr
+ else:
+ raise NotImplementedError(
+ "A not supported attribute type: %s." %
+ (str(attr.type)))
+ for attr_name, defalut_val in self.__extra_attrs__.items():
+ user_defined_attr = kwargs.get(attr_name, None)
+ if user_defined_attr is not None:
+ attr_type = int(
+ core.get_attrtibute_type(op_desc.type, attr_name))
+ new_attr = op_desc.attrs.add()
+ new_attr.name = attr_name
+ new_attr.type = attr_type
+ if isinstance(user_defined_attr, np.ndarray):
+ user_defined_attr = user_defined_attr.tolist()
+ if attr_type == framework_pb2.INT:
+ new_attr.i = user_defined_attr
+ elif attr_type == framework_pb2.FLOAT:
+ new_attr.f = user_defined_attr
+ elif attr_type == framework_pb2.LONG:
+ new_attr.l = user_defined_attr
+ elif attr_type == framework_pb2.STRING:
+ new_attr.s = user_defined_attr
+ elif attr_type == framework_pb2.BOOLEAN:
+ new_attr.b = user_defined_attr
+ elif attr_type == framework_pb2.INTS:
+ new_attr.ints.extend(user_defined_attr)
+ elif attr_type == framework_pb2.FLOATS:
+ new_attr.floats.extend(user_defined_attr)
+ elif attr_type == framework_pb2.STRINGS:
+ new_attr.strings.extend(user_defined_attr)
+ elif attr_type == framework_pb2.BOOLEANS:
+ new_attr.bools.extend(user_defined_attr)
+ elif attr_type == framework_pb2.LONGS:
+ new_attr.longs.extend(user_defined_attr)
+ else:
+ raise NotImplementedError(
+ "A not supported attribute type: %s." %
+ (str(attr_type)))
+
+ return op_desc
+
+ @staticmethod
+ def any_is_true(generator):
+ """
+ Reduce a boolean array to a single boolean parameter. If any element in
+ the array is True, this function will return True, otherwise False.
+ """
+ for flag in generator:
+ if flag:
+ return True
+ return False
+
+
+class OpInfo(object):
+
+ def __init__(self, name, method, inputs, outputs, attrs, extra_attrs):
+ self.name = name
+ self.method = method
+ self.inputs = inputs
+ self.outputs = outputs
+ self.attrs = attrs
+ self.extra_attrs = extra_attrs
+
+
+def create_op_creation_method(op_proto):
+ """
+ Generate op creation method for an OpProto.
+ """
+ method = OpDescCreationMethod(op_proto)
+
+ def __impl__(*args, **kwargs):
+ opdesc = method(*args, **kwargs)
+ return core.Operator.create(opdesc.SerializeToString())
+
+ extra_attrs_map = core.get_op_extra_attrs(op_proto.type)
+
+ return OpInfo(method=__impl__,
+ name=op_proto.type,
+ inputs=[(var.name, var.duplicable)
+ for var in op_proto.inputs],
+ outputs=[(var.name, var.duplicable)
+ for var in op_proto.outputs],
+ attrs=[attr.name for attr in op_proto.attrs],
+ extra_attrs=[item for item in extra_attrs_map.keys()])
+
+
+class OperatorFactory(object):
+
+ def __init__(self):
+ self.op_methods = dict()
+
+ for op_proto in get_all_op_protos():
+ method = create_op_creation_method(op_proto)
+ self.op_methods[method.name] = method
+
+ def __call__(self, *args, **kwargs):
+ if "type" in kwargs:
+ if len(args) != 0:
+ raise ValueError(
+ "Except the argument \"type\","
+ "all of the other arguments should be keyword arguments.")
+ t = kwargs.pop("type")
+ else:
+ if len(args) != 1:
+ raise ValueError(
+ "Except the argument \"type\","
+ "all of the other arguments should be keyword arguments.")
+ t = args[0]
+
+ return self.get_op_info(t).method(**kwargs)
+
+ def types(self):
+ return list(self.op_methods.keys())
+
+ def get_op_info(self, t):
+ if t not in self.op_methods:
+ raise ValueError("The operator: %s is not registered." % t)
+ return self.op_methods.get(t)
+
+ def get_op_input_names(self, type):
+ return [x[0] for x in self.get_op_info(type).inputs]
+
+ def get_op_inputs(self, type):
+ return self.get_op_info(type).inputs
+
+ def get_op_output_names(self, type):
+ return [x[0] for x in self.get_op_info(type).outputs]
+
+ def get_op_outputs(self, type):
+ return self.get_op_info(type).outputs
+
+ def get_op_attr_names(self, type):
+ return self.get_op_info(type).attrs
+
+ def get_op_extra_attr_names(self, type):
+ return self.get_op_info(type).extra_attrs
+
+
+class __RecurrentOp__(object):
+ __proto__ = None
+ type = "recurrent"
+
+ def __init__(self):
+ # cache recurrent_op's proto
+ if self.__proto__ is None:
+ for op_proto in get_all_op_protos():
+ if op_proto.type == self.type:
+ self.__proto__ = op_proto
+
+ def __call__(self, *args, **kwargs):
+ if self.type not in args and "type" not in kwargs:
+ kwargs["type"] = self.type
+ # create proto
+ create_method = OpDescCreationMethod(self.__proto__)
+ proto = create_method(*args, **kwargs)
+ # create rnnop
+ return core.RecurrentOp.create(proto.SerializeToString())
+
+
+class __DynamicRecurrentOp__(object):
+ __proto__ = None
+ type = "dynamic_recurrent"
+
+ def __init__(self):
+ # cache recurrent_op's proto
+ if self.__proto__ is None:
+ for op_proto in get_all_op_protos():
+ if op_proto.type == self.type:
+ self.__proto__ = op_proto
+
+ def __call__(self, *args, **kwargs):
+ if self.type not in args and "type" not in kwargs:
+ kwargs["type"] = self.type
+ # create proto
+ create_method = OpDescCreationMethod(self.__proto__)
+ proto = create_method(*args, **kwargs)
+ # create rnnop
+ return core.DynamicRecurrentOp.create(proto.SerializeToString())
+
+
+class __CondOp__(object):
+ __proto__ = None
+ type = "cond"
+
+ def __init__(self):
+ # cache recurrent_op's proto
+ if self.__proto__ is None:
+ for op_proto in get_all_op_protos():
+ if op_proto.type == self.type:
+ self.__proto__ = op_proto
+
+ def __call__(self, *args, **kwargs):
+ if self.type not in args and "type" not in kwargs:
+ kwargs["type"] = self.type
+ # create proto
+ create_method = OpDescCreationMethod(self.__proto__)
+ proto = create_method(*args, **kwargs)
+ # create condop
+ return core.CondOp.create(proto.SerializeToString())
+
+
+Operator = OperatorFactory() # The default global factory
+RecurrentOp = __RecurrentOp__()
+DynamicRecurrentOp = __DynamicRecurrentOp__()
+CondOp = __CondOp__()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/optimizer.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/optimizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..c53872c0e54da9c0c741879f1c33d6b083a40306
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/optimizer.py
@@ -0,0 +1,7331 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import numpy as np
+import six
+import os
+import logging
+from collections import defaultdict
+
+import paddle
+from paddle.fluid.distribute_lookup_table import find_distributed_lookup_table
+from paddle.fluid.framework import Program, Variable, Parameter, name_scope, default_main_program, default_startup_program, device_guard
+
+from . import framework
+from . import layers
+from . import unique_name
+from .backward import append_backward, _some_in_set_, _append_grad_suffix_, _get_no_grad_set_name
+from .clip import GradientClipBase, GradientClipByNorm, error_clip_callback, append_gradient_clip_ops, ClipGradByGlobalNorm
+from .framework import program_guard
+from .initializer import Constant
+from .layer_helper import LayerHelper
+from .layers import ops
+from .dygraph import base as imperative_base
+from .dygraph import no_grad
+from .dygraph.learning_rate_scheduler import LearningRateDecay, _LearningRateEpochDecay
+from paddle.fluid import core
+from paddle.fluid.layers import tensor
+from functools import reduce
+from functools import cmp_to_key
+from .wrapped_decorator import signature_safe_contextmanager
+from .. import compat as cpt
+import warnings
+from paddle import _C_ops, _legacy_C_ops
+from ..fluid.framework import _in_legacy_dygraph, in_dygraph_mode, _current_expected_place
+
+__all__ = [
+ 'SGD', 'Momentum', 'Adagrad', 'Adam', 'Adamax', 'Dpsgd', 'DecayedAdagrad',
+ 'Ftrl', 'SGDOptimizer', 'MomentumOptimizer', 'AdagradOptimizer',
+ 'AdamOptimizer', 'AdamaxOptimizer', 'DpsgdOptimizer',
+ 'DecayedAdagradOptimizer', 'RMSPropOptimizer', 'FtrlOptimizer', 'Adadelta',
+ 'AdadeltaOptimizer', 'ModelAverage', 'LarsMomentum',
+ 'LarsMomentumOptimizer', 'LambOptimizer', 'ExponentialMovingAverage',
+ 'PipelineOptimizer', 'LookaheadOptimizer', 'RecomputeOptimizer'
+]
+
+
+class Optimizer(object):
+ """Optimizer Base class.
+
+ Define the common interface of an optimizer.
+ User should not use this class directly,
+ but need to use one of it's implementation.
+ """
+
+ @imperative_base.no_grad
+ def __init__(self,
+ learning_rate,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ flatten_param_grads=False,
+ align_size=-1,
+ name=None):
+ """
+ Args:
+ flatten_param_grads (bool, optional): Whether to flatten all the parameters and grads.
+ If true, the parameters and gradients will be coalesce to contiguous mempry,
+ and the grad_clip ops / optimizer ops will be fuse to one operator.
+ """
+ # Because of the loop import, so place it in the function body
+ from paddle.optimizer.lr import LRScheduler
+ self._parameter_list = list(
+ parameter_list) if parameter_list is not None else None
+ self._name = name
+ if framework._non_static_mode():
+ if not isinstance(learning_rate,
+ (float, LearningRateDecay, LRScheduler)):
+ raise TypeError(
+ "learning rate should be float or LRScheduler, got %s here"
+ % type(learning_rate))
+ if self._parameter_list is None:
+ raise AttributeError(
+ "parameter_list argument given to the Optimizer should not be None in dygraph mode."
+ )
+ if regularization is not None:
+ for param in self._parameter_list:
+ if param.regularizer is not None:
+ logging.info(
+ "If regularizer of a Parameter has been set by 'fluid.ParamAttr' or 'fluid.WeightNormParamAttr' already. "
+ "The Regularization[%s] in Optimizer will not take effect, and it will only be applied to other Parameters!"
+ % regularization.__str__())
+ break
+ else:
+ if not isinstance(learning_rate,
+ (float, framework.Variable, LRScheduler)):
+ raise TypeError(
+ "learning rate should be float or LRScheduler, got %s here"
+ % type(learning_rate))
+
+ if grad_clip is not None:
+ if not isinstance(grad_clip, GradientClipBase):
+ raise TypeError(
+ "'grad_clip' should be an instance of GradientClipBase's derived class"
+ )
+ self.regularization = regularization
+ self._grad_clip = grad_clip
+ self._learning_rate = learning_rate
+ self._flatten_param_grads = flatten_param_grads
+ self._align_size = align_size
+
+ self._dtype = None
+ # Infer the dtype form parameter
+ if self._parameter_list:
+ self._dtype = self._parameter_list[0].dtype
+
+ # each program should have a independent learning rate
+ # program -> Variable(learning_rate)
+ self._learning_rate_map = dict()
+ if isinstance(self._learning_rate, framework.Variable):
+ self._learning_rate_map[
+ framework.default_main_program()] = self._learning_rate
+ # Dictionary of accumulators. Some optimizer subclasses need to
+ # allocate and manage extra variables associated with the parameters
+ # to train. These variables are called accumulators.
+ # {accum_name : { paramter_name : accumulator_for_parameter, ...}, ...}
+ self._accumulators = defaultdict(lambda: dict())
+ # global_accumulator dict, {accum_name : acc_variable, ...}
+ self._global_accumulators = {}
+ self.helper = LayerHelper(self.__class__.__name__)
+ self._opti_name_list = []
+ self._accumulators_holder = {}
+ self._param_device_map = dict()
+ # NOTE(zhiqiu): sometimes we want to add some variables(Tenosr) to the optimizer for a specific optimization,
+ # for example, we want to pass 'found_inf' to adam optimizer so it can skip update when found_inf is True.
+ # And these variables should not be the parameters of Optimizer's construnctor (because not commonly used).
+ # Use _auxiliary_vars together with _set_auxiliary_var/_get_auxiliary_var to achieve that.
+ self._auxiliary_vars = dict()
+
+ @framework.dygraph_only
+ def state_dict(self):
+ '''
+ Get state dict information from optimizer. It contain all the variable used by optimizer. For Adam optimizer, contains beta1, beta2, momentum etc. If LearningRateDecay have been used, global_step will be include in state dict.
+ If the optimizer never be called(minimize function), the state_dict is empty.
+
+ Args: None
+ Return:
+ state_dict(dict) : dict contains all the variable used by optimizer
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ with fluid.dygraph.guard():
+ emb = fluid.dygraph.Embedding([10, 10])
+
+ adam = fluid.optimizer.Adam(0.001, parameter_list=emb.parameters())
+ state_dict = adam.state_dict()
+
+ '''
+ from paddle.optimizer.lr import LRScheduler
+ state_dict = {}
+ for k, v in self._accumulators.items():
+ for para_name, var_tmp in v.items():
+ state_dict[var_tmp.name] = var_tmp
+ for k, v in self._global_accumulators.items():
+ state_dict[v.name] = v
+ # global step if use lr decay
+ if isinstance(self._learning_rate, LRScheduler):
+ state_dict["LR_Scheduler"] = self._learning_rate.state_dict()
+ return state_dict
+ if isinstance(self._learning_rate, LearningRateDecay):
+ state_dict["LR_Scheduler"] = self._learning_rate.state_dict()
+
+ if not isinstance(self._learning_rate, _LearningRateEpochDecay):
+ var_tmp = None
+ var_temp = framework._varbase_creator(None,
+ name='global_step',
+ dtype='int32')
+
+ tensor.fill_constant([1],
+ "int32",
+ self._learning_rate.step_num,
+ out=var_temp)
+
+ state_dict['global_step'] = var_temp
+ return state_dict
+
+ @framework.dygraph_only
+ def set_state_dict(self, state_dict):
+ '''
+ Load optimizer state dict. For Adam optimizer, contains beta1, beta2, momentum etc. If LearningRateDecay have been used, global_step will be changed.
+
+ Args:
+ state_dict(dict) : Dict contains all the Variable needed by optimizer
+ Return:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ paddle.disable_static()
+
+ emb = paddle.nn.Embedding(10, 10)
+
+ state_dict = emb.state_dict()
+ fluid.save_dygraph(state_dict, "paddle_dy")
+
+ scheduler = paddle.optimizer.lr.NoamDecay(
+ d_model=0.01, warmup_steps=100, verbose=True)
+ adam = paddle.optimizer.Adam(
+ learning_rate=scheduler,
+ parameters=emb.parameters())
+ state_dict = adam.state_dict()
+ fluid.save_dygraph(state_dict, "paddle_dy")
+
+ para_state_dict, opti_state_dict = fluid.load_dygraph("paddle_dy")
+ '''
+ from paddle.optimizer.lr import LRScheduler
+ if isinstance(self._learning_rate, LRScheduler):
+ self._learning_rate.set_dict(state_dict["LR_Scheduler"])
+
+ if isinstance(self._learning_rate, LearningRateDecay):
+ self._learning_rate.set_dict(state_dict["LR_Scheduler"])
+
+ if not isinstance(self._learning_rate, _LearningRateEpochDecay):
+ assert 'global_step' in state_dict, \
+ 'Global step not in state dict, Dygraph use LearningRateDecay, global_step must in state_dict'
+ global_step = state_dict['global_step']
+
+ if isinstance(global_step, Variable):
+ step_np = global_step
+ step_np = np.array(step_np.value().get_tensor())
+ assert step_np.shape == (1,), \
+ "global step shape is (1,), the shape is {}".format( step_np.shape )
+
+ self._learning_rate.step_num = int(step_np[0])
+ elif isinstance(global_step, np.ndarray):
+ assert global_step.shape == (1,), \
+ "global step shape is (1,), the shape is {}".format( global_step.shape )
+ self._learning_rate.step_num = global_step[0]
+ else:
+ raise RuntimeError(
+ "Type not supprt, value in state dict must be [VarBase, Variable, numpy], the type is ",
+ type(global_step))
+
+ def _load_state_para(state_dict, param):
+ var = param.value()
+ tensor = var.get_tensor()
+ model_np = np.array(tensor)
+ load_para = state_dict[param.name]
+ if isinstance(load_para, Variable):
+ load_para_np = load_para.numpy()
+ elif isinstance(load_para, core.VarBase):
+ load_para_np = load_para.numpy()
+ elif isinstance(load_para, np.ndarray):
+ load_para_np = load_para
+ else:
+ raise RuntimeError("State dict type {} not supprt".format(
+ str(type(load_para))))
+
+ assert model_np.shape == load_para_np.shape, \
+ "Parameter shape not match, Dygraph Parameter [ {} ] need tensor with shape {} but load tensor with shape {}".format(
+ param.name, model_np.shape, load_para_np.shape)
+
+ assert model_np.dtype == load_para_np.dtype, \
+ "Parameter dtype not match, Dygraph Parameter [ {} ] need tensor with dtype {} but load tensor with dtype {}".format(
+ param.name, model_np.dtype, load_para_np.dtype)
+
+ tensor.set(load_para_np, framework._current_expected_place())
+
+ self._accumulators_holder = state_dict
+ for k, v in self._accumulators.items():
+ for para_name, var_tmp in v.items():
+ assert var_tmp.name in state_dict, \
+ "optimizer variable {} not found".format( var_tmp.name )
+ _load_state_para(state_dict, var_tmp)
+
+ for k, v in self._global_accumulators.items():
+ assert v.name in state_dict, \
+ "optimizer variable {} not found".format( v.name )
+ _load_state_para(state_dict, v)
+
+ # [aliases] Compatible with old method names
+ set_dict = set_state_dict
+
+ def get_opti_var_name_list(self):
+ return self._opti_name_list
+
+ def _set_auxiliary_var(self, key, val):
+ self._auxiliary_vars[key] = val
+
+ def _get_auxiliary_var(self, key):
+ if key in self._auxiliary_vars:
+ return self._auxiliary_vars[key]
+ else:
+ return None
+
+ def _create_global_learning_rate(self):
+ from paddle.optimizer.lr import LRScheduler
+ if isinstance(self._learning_rate, LRScheduler):
+ lr_var = self._global_learning_rate()
+ # only create global lr_var once
+ if not isinstance(lr_var, framework.Variable):
+ lr_name = unique_name.generate('learning_rate')
+ self._learning_rate._var_name = lr_name
+ lr_var = self.helper.create_global_variable(
+ name=lr_name,
+ shape=[1],
+ persistable=True,
+ stop_gradient=True,
+ dtype='float32' if self._dtype is None else self._dtype)
+ main_prog = framework.default_main_program()
+ main_prog.lr_sheduler = self._learning_rate
+ main_prog.lr_var = lr_var
+ self._learning_rate_map[
+ framework.default_main_program()] = lr_var
+
+ lr_value = float(self._learning_rate())
+ self.helper.set_variable_initializer(
+ lr_var, initializer=Constant(value=lr_value))
+ return
+
+ if imperative_base.enabled():
+ # create learning rate Variable
+ if isinstance(self._learning_rate, float):
+ lr = self._global_learning_rate()
+
+ if isinstance(lr, framework.Variable):
+ return
+ else:
+ self._learning_rate_map[framework.default_main_program(
+ )] = layers.create_global_var(
+ name=unique_name.generate("learning_rate"),
+ shape=[1],
+ value=float(self._learning_rate),
+ dtype='float32' if self._dtype is None else self._dtype,
+ persistable=True)
+ # get learning rate Variable from LearningRateDecay
+ elif isinstance(self._learning_rate, LearningRateDecay):
+ self._learning_rate_map[
+ framework.default_main_program()] = self._learning_rate()
+ else:
+ raise TypeError(
+ "optimizer's learning rate must be float or LearningRateDecay"
+ )
+ else:
+ lr = self._global_learning_rate()
+
+ if isinstance(lr, framework.Variable):
+ return
+ else:
+ if not isinstance(self._learning_rate, float):
+ raise TypeError(
+ "learning rate variable is create outside optimizer,"
+ "can not create new learning rate variable for new program"
+ )
+
+ # create learning rate in the current main program
+ self._learning_rate_map[
+ framework.default_main_program()] = layers.create_global_var(
+ name=unique_name.generate("learning_rate"),
+ shape=[1],
+ value=float(self._learning_rate),
+ dtype='float32' if self._dtype is None else self._dtype,
+ persistable=True)
+
+ @framework.dygraph_only
+ def set_lr(self, value):
+ """
+ :api_attr: imperative
+
+ Set the value of the learning rate manually in the optimizer. If the optimizer use LearningRateDecay,
+ this API cannot be invoked, because it will lead to conflict.
+
+ Args:
+ value (float|Variable): the value of learning rate
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ with fluid.dygraph.guard():
+ linear = fluid.dygraph.nn.Linear(10, 10)
+
+ adam = fluid.optimizer.Adam(0.1, parameter_list=linear.parameters())
+
+ # set learning rate manually by python float value
+ lr_list = [0.2, 0.3, 0.4, 0.5, 0.6]
+ for i in range(5):
+ adam.set_lr(lr_list[i])
+ lr = adam.current_step_lr()
+ print("current lr is {}".format(lr))
+ # Print:
+ # current lr is 0.2
+ # current lr is 0.3
+ # current lr is 0.4
+ # current lr is 0.5
+ # current lr is 0.6
+
+
+ # set learning rate manually by framework Variable
+ lr_var = fluid.layers.create_global_var(
+ shape=[1], value=0.7, dtype='float32')
+ adam.set_lr(lr_var)
+ lr = adam.current_step_lr()
+ print("current lr is {}".format(lr))
+ # Print:
+ # current lr is 0.7
+
+
+
+ """
+ if not isinstance(value, (framework.Variable, float)):
+ raise TypeError(
+ "The type of 'value' in optimizer.set_lr must be (float, Variable), but received %s."
+ % (type(value)))
+ if isinstance(self._learning_rate, LearningRateDecay):
+ raise RuntimeError(
+ "optimizer's learning rate can't be LearningRateDecay when invoke this API, because this will lead to conflict."
+ )
+ if isinstance(value, float):
+ self._learning_rate = value
+ current_lr = self._global_learning_rate()
+ if current_lr is not None:
+ if in_dygraph_mode():
+ place = _current_expected_place()
+ _C_ops.full_(current_lr, list(current_lr.shape),
+ float(value), current_lr.dtype, place)
+
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.fill_constant(current_lr, 'value',
+ float(value), 'dtype',
+ current_lr.dtype, 'shape',
+ list(current_lr.shape))
+ else:
+ global_block = framework.default_main_program(
+ ).global_block()
+ global_block.append_op(type='fill_constant',
+ outputs={'Out': [current_lr]},
+ attrs={
+ 'dtype': current_lr.dtype,
+ 'shape': list(current_lr.shape),
+ 'value': float(value)
+ },
+ stop_gradient=True)
+ else:
+ assert len(value.shape) == 1 and value.shape[
+ 0] == 1, "optimizer's learning rate must be 1-D Tensor with shape[1]"
+ self._learning_rate_map[framework.default_main_program()] = value
+
+ @framework.dygraph_only
+ def current_step_lr(self):
+ """
+ :api_attr: imperative
+
+ Get current step learning rate. The return value is all the same When LearningRateDecay is not used,
+ otherwise return the step learning rate.
+
+ Returns:
+ float: The learning rate of the current step.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ # example1: LearningRateDecay is not used, return value is all the same
+ with fluid.dygraph.guard():
+ emb = fluid.dygraph.Embedding([10, 10])
+ adam = fluid.optimizer.Adam(0.001, parameter_list = emb.parameters())
+ lr = adam.current_step_lr()
+ print(lr) # 0.001
+
+ # example2: PiecewiseDecay is used, return the step learning rate
+ with fluid.dygraph.guard():
+ inp = np.random.uniform(-0.1, 0.1, [10, 10]).astype("float32")
+ linear = fluid.dygraph.nn.Linear(10, 10)
+ inp = fluid.dygraph.to_variable(inp)
+ out = linear(inp)
+ loss = fluid.layers.reduce_mean(out)
+
+ bd = [2, 4, 6, 8]
+ value = [0.2, 0.4, 0.6, 0.8, 1.0]
+ adam = fluid.optimizer.Adam(fluid.dygraph.PiecewiseDecay(bd, value, 0),
+ parameter_list=linear.parameters())
+
+ # first step: learning rate is 0.2
+ np.allclose(adam.current_step_lr(), 0.2, rtol=1e-06, atol=0.0) # True
+
+ # learning rate for different steps
+ ret = [0.2, 0.2, 0.4, 0.4, 0.6, 0.6, 0.8, 0.8, 1.0, 1.0, 1.0, 1.0]
+ for i in range(12):
+ adam.minimize(loss)
+ lr = adam.current_step_lr()
+ np.allclose(lr, ret[i], rtol=1e-06, atol=0.0) # True
+
+ """
+ current_lr = self._global_learning_rate()
+ if isinstance(current_lr, framework.Variable):
+ return self._global_learning_rate().numpy()[0]
+
+ if isinstance(self._learning_rate, float):
+ return self._learning_rate
+ elif isinstance(self._learning_rate, _LearningRateEpochDecay):
+ step_lr = self._learning_rate()
+ return step_lr.numpy()[0]
+ else:
+ step_lr = self._learning_rate.step()
+ if isinstance(step_lr, (float, int)):
+ return step_lr
+ else:
+ return step_lr.numpy()[0]
+
+ def _global_learning_rate(self, program=None):
+ """
+ get global decayed learning rate
+ :return:
+ """
+ if program is None:
+ program = framework.default_main_program()
+ return self._learning_rate_map.get(program, None)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ """ append optimize operator to block and return all the added optimize_op
+ """
+ raise NotImplementedError()
+
+ def _create_param_lr(self, param_and_grad):
+ # create learning rate variable for every parameter
+ param = param_and_grad[0]
+ param_lr = param.optimize_attr['learning_rate']
+ if type(param_lr) == Variable:
+ return param_lr
+ else:
+ if param_lr == 1.0:
+ return self._global_learning_rate()
+ else:
+ with default_main_program()._lr_schedule_guard(
+ is_with_opt=True), framework.name_scope(
+ 'scale_with_param_lr'):
+ return self._global_learning_rate() * param_lr
+
+ def _create_accumulators(self, block, parameters):
+ """Create all accumulators needed by the parameters
+
+ Args:
+ block: the block in which the loss variable is present
+ parameters: list of parameter variables for the optimizer
+ """
+ pass
+
+ def _finish_update(self, block, parameters_and_grads):
+ """Finish any custom updates needed
+ before completing an optimization step
+
+ Args:
+ block: the block in which the loss variable is present
+ parameters: list of parameter variables for the optimizer
+
+ Returns:
+ None
+ """
+ pass
+
+ def _add_accumulator(self,
+ name,
+ param,
+ dtype=None,
+ fill_value=0.0,
+ shape=None,
+ type=None,
+ device=None):
+ """Utility function to add an accumulator for a parameter
+
+ Args:
+ block: the block in which the loss variable is present
+ name: name of the accumulator
+ param: parameter variable for which accumulator is to be added
+ dtype: data type of the accumulator variable
+ fill_value: value to initialize the accumulator variable
+ """
+ if self._name is not None:
+ name = self._name + "_" + name
+ if (name in self._accumulators
+ and param.name in self._accumulators[name]):
+ if framework._non_static_mode():
+ return self._accumulators[name][param.name]
+ raise Exception(
+ "Accumulator {} already exists for parameter {}".format(
+ name, param.name))
+ if shape == None:
+ shape = param.shape
+ assert isinstance(self.helper, LayerHelper)
+
+ var_name = param.name + "_" + name
+ var_name = unique_name.generate(var_name)
+ self._opti_name_list.append(var_name)
+
+ var = self.helper.create_global_variable(
+ name=var_name,
+ persistable=True,
+ dtype=dtype or param.dtype,
+ type=core.VarDesc.VarType.LOD_TENSOR
+ if framework._non_static_mode() else
+ (param.type if type is None else type),
+ shape=shape,
+ belong_to_optimizer=True)
+ if device is None:
+ device = self._get_device_for_param(param.name)
+ with device_guard(device):
+ self.helper.set_variable_initializer(
+ var, initializer=Constant(value=float(fill_value)))
+
+ if framework._non_static_mode():
+ if len(self._accumulators_holder) > 0:
+ assert var_name in self._accumulators_holder, \
+ "Optimizer set error, {} should in state dict".format( var_name )
+ var.set_value(self._accumulators_holder[var_name])
+
+ self._accumulators[name][param.name] = var
+ return var
+
+ def _add_global_accumulator(self,
+ name,
+ dtype=None,
+ fill_value=0.0,
+ shape=None,
+ type=None,
+ device=None):
+ """Utility function to add a global accumulator for all parameters in the model
+
+ Args:
+ block: the block in which the loss variable is present
+ name: name of the accumulator
+ dtype: data type of the accumulator variable
+ fill_value: value to initialize the accumulator variable
+ shape: the shape of the accumulator
+ type: the variable type of the accumulator
+ device: the target place of the accumulator
+ """
+ if self._name is not None:
+ name = self._name + "_" + name
+ if (name in self._global_accumulators):
+ if framework._non_static_mode():
+ return self._global_accumulators[name]
+ raise Exception("Global accumulator {} already exists".format(name))
+ if shape == None:
+ shape = [1] # most case, global accumulator is of shape [1]
+ assert isinstance(self.helper, LayerHelper)
+
+ var_name = name
+ var_name = unique_name.generate(var_name)
+ self._opti_name_list.append(var_name)
+
+ var = self.helper.create_global_variable(
+ name=var_name,
+ persistable=True,
+ dtype=dtype if dtype else self._dtype,
+ type=type,
+ shape=shape,
+ belong_to_optimizer=True)
+ if device is None:
+ device = 'cpu'
+ with device_guard(device):
+ self.helper.set_variable_initializer(
+ var, initializer=Constant(value=float(fill_value)))
+
+ if framework._non_static_mode():
+ if len(self._accumulators_holder) > 0:
+ assert var_name in self._accumulators_holder, \
+ "Optimizer set error, {} should in state dict".format( var_name )
+ var.set_value(self._accumulators_holder[var_name])
+
+ self._global_accumulators[name] = var
+ return var
+
+ def _get_accumulator(self, name, param):
+ """Utility function to fetch an accumulator for a parameter
+
+ Args:
+ name: name of the accumulator
+ param: parameter variable for which accumulator is to be fetched
+
+ Returns:
+ accumulator variable
+ """
+ if self._name is not None:
+ name = self._name + "_" + name
+ if (name not in self._accumulators
+ or param.name not in self._accumulators[name]):
+ raise Exception(
+ "Accumulator {} does not exist for parameter {}".format(
+ name, param.name))
+ return self._accumulators[name][param.name]
+
+ def _get_global_accumulator(self, name):
+ """Utility function to fetch a global accumulator
+
+ Args:
+ name: name of the accumulator
+
+ Returns:
+ accumulator variable
+ """
+ if self._name is not None:
+ name = self._name + "_" + name
+ if (name not in self._global_accumulators):
+ raise Exception("Global accumulator {} does not exist".format(name))
+ return self._global_accumulators[name]
+
+ def _update_param_device_map(self, parameters_and_grads, target_block):
+ for param_and_grad in parameters_and_grads:
+ if param_and_grad[0].trainable is True:
+ param_name = param_and_grad[0].name
+ ops = target_block.ops
+ device_attr_name = core.op_proto_and_checker_maker.kOpDeviceAttrName(
+ )
+ for op in ops:
+ input_arg_names = op.input_arg_names
+ if param_name in input_arg_names:
+ self._param_device_map[param_name] = op.attr(
+ device_attr_name)
+ break
+
+ def _get_device_for_param(self, param_name):
+ device = None
+ if param_name in self._param_device_map:
+ device = self._param_device_map[param_name]
+ return device
+
+ def _create_optimization_pass(self, parameters_and_grads):
+ """Add optimization operators to update gradients to variables.
+
+ Args:
+ parameters_and_grads(list(tuple(Variable, Variable))):
+ a list of (variable, gradient) pair to update.
+
+ Returns:
+ return_op_list: a list of operators that will complete one step of
+ optimization. This will include parameter update ops, global step
+ update ops and any other custom ops required by subclasses to manage
+ their internal state.
+ """
+ # This is a default implementation of create_optimization_pass that
+ # can be shared by most optimizers. This implementation assumes that
+ # the subclass will implement the _append_optimize_op method and the
+ # _initialize_tensors method. The subclass can extend the
+ # _create_accumulators method if it needs to create accumulators
+ # for parameters and extend _finish_update method to add custom ops.
+
+ # Allways called under program_guard use global block as loss block
+ # But if current block is in control flow, append optimize op in the
+ # grad block of current block
+
+ global_block = framework.default_main_program().global_block()
+ target_block = global_block
+ current_block = framework.default_main_program().current_block()
+ if current_block.idx != global_block.idx:
+ assert current_block.backward_block_idx != -1, \
+ "current block is not global_block, but it doesn't have backward block."
+ target_block = framework.default_main_program().blocks[
+ current_block.backward_block_idx]
+
+ start = len(target_block.ops)
+
+ self._update_param_device_map(parameters_and_grads, target_block)
+ self._create_accumulators(
+ target_block,
+ [p[0] for p in parameters_and_grads if p[0].trainable])
+ self._create_global_learning_rate()
+
+ if framework._non_static_mode():
+ for param_and_grad in parameters_and_grads:
+ if param_and_grad[1] is None:
+ continue
+ if param_and_grad[0].trainable is True:
+ self._append_optimize_op(target_block, param_and_grad)
+ else:
+ for param_and_grad in parameters_and_grads:
+ if param_and_grad[1] is None:
+ continue
+ with param_and_grad[0].block.program._optimized_guard(
+ param_and_grad), name_scope("optimizer"):
+ if param_and_grad[0].trainable is True:
+ device = self._get_device_for_param(
+ param_and_grad[0].name)
+ with device_guard(device):
+ optimize_op = self._append_optimize_op(
+ target_block, param_and_grad)
+
+ # Get custom finish ops for subclasses
+ # FIXME: Need to fix this once we figure out how to handle dependencies
+ self._finish_update(target_block, parameters_and_grads)
+
+ end = len(target_block.ops)
+ return target_block._slice_ops(start, end)
+
+ def _process_distribute_lookuptable(self, param_grads):
+ """
+ Because distribute lookup table only support SGD optimizer for now, not support
+ other optimizer and regularization, so we should find the table parameter out,
+ and avoid to add regularization and other op for it, and add sgd optimize op
+ for it independently.
+ :param param_grads(list((Var, Var))): list of (param, grad) pair.
+ :param loss: the loss variable.
+ :param startup_program: the startup program
+ """
+ program = framework.default_main_program()
+ global_block = framework.default_main_program().global_block()
+ table_name = find_distributed_lookup_table(program)
+ table_param = None
+ table_grad = None
+ new_param_grads = []
+ for p, g in param_grads:
+ if p.name == table_name:
+ if table_param is not None:
+ raise RuntimeError(
+ "multi dist table var found, only support one now!")
+ table_param = p
+ table_grad = g
+ else:
+ new_param_grads.append((p, g))
+ sgd_op = None
+ if table_param is not None:
+ param_and_grad = [table_param, table_grad]
+ with table_param.block.program._optimized_guard(param_and_grad), \
+ framework.name_scope("optimizer"):
+ self._create_global_learning_rate()
+ # create the optimize op
+ sgd_op = global_block.append_op(
+ type='sgd',
+ inputs={
+ "Param": table_param,
+ "Grad": table_grad,
+ "LearningRate": self._create_param_lr(param_and_grad)
+ },
+ outputs={"ParamOut": param_and_grad[0]})
+ return new_param_grads, (table_param, table_grad), sgd_op
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ """
+ The first part of ``minimize``, do auto-diff to append backward operations for
+ the current program.
+
+ Args:
+ loss (Variable): ``loss`` variable to run optimizations.
+ startup_program (Program, optional): :ref:`api_fluid_Program` for
+ initializing parameters in ``parameter_list``. The default value
+ is None, at this time :ref:`api_fluid_default_startup_program` will be used.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` or ``Variable.name`` to update
+ to minimize ``loss``. The default value is None, at this time all parameters
+ will be updated.
+ no_grad_set (set, optional): Set of ``Variable`` or ``Variable.name`` that don't need
+ to be updated. The default value is None.
+ callbacks (list, optional): list of callable objects to run when appending backward
+ operator for one parameter. The default value is None.
+
+ Return:
+ list: list of (param, grad) variable pairs, param is ``Parameter``,
+ grad is the gradient value corresponding to the parameter.
+
+ Examples:
+ See examples in ``apply_gradients``.
+ """
+ act_no_grad_set = None
+ if framework._non_static_mode():
+ pass
+ else:
+ act_no_grad_set = self._get_no_grad_set(loss, no_grad_set)
+
+ # Infer dtype by loss if None
+ if self._dtype is None:
+ self._dtype = loss.dtype
+
+ if framework._non_static_mode():
+ parameter_list = parameter_list if parameter_list \
+ else self._parameter_list
+
+ params_grads = []
+ for param in parameter_list:
+ if not param.trainable:
+ continue
+ if param._grad_ivar() is not None:
+ # create gradient variable
+ grad_var = param._grad_ivar()
+ params_grads.append((param, grad_var))
+ else:
+ if callbacks is None:
+ callbacks = [error_clip_callback]
+ else:
+ assert (isinstance(callbacks, list))
+ program = loss.block.program
+ assert len(loss.shape) == 1 and loss.shape[0] == 1, \
+ "The loss.shape should be (1L,), but the current loss.shape is {}. " \
+ "Maybe that you should call paddle.mean to process the current loss.".format(
+ loss.shape)
+ parameter_list = parameter_list if parameter_list \
+ else self._parameter_list
+ with program_guard(program, startup_program):
+ params_grads = append_backward(loss, parameter_list,
+ act_no_grad_set, callbacks)
+ return params_grads
+
+ def _create_regularization_of_grad(self, param, grad, regularization=None):
+ """ Create and add backward regularization Operators
+
+ Function helper of append_regularization_ops.
+ """
+ # If no gradient or no regularization is specified, then we don't need to do anything
+ if grad is None or (
+ (not hasattr(param, 'regularizer') or
+ (hasattr(param, 'regularizer') and param.regularizer is None))
+ and regularization is None):
+ return grad
+ regularization_term = None
+ if hasattr(param, 'regularizer') and param.regularizer is not None:
+ # Add variable for regularization term in grad block
+ regularization_term = param.regularizer(param, grad, grad.block)
+ elif regularization is not None:
+ regularization_term = regularization(param, grad, grad.block)
+
+ assert regularization_term is not None
+
+ if framework._non_static_mode():
+ return _legacy_C_ops.sum([grad, regularization_term])
+
+ new_grad = grad
+ if grad.type == core.VarDesc.VarType.SELECTED_ROWS:
+ # FIXME(zcd): If the grad is SELECTED_ROWS, after regularization,
+ # the grad's type and name will be changed. But the gradient's name
+ # is used in ParallelExecutor Reduce mode, so I add a flag for
+ # the new_grad here.
+ new_grad = grad.block.create_var(
+ name=grad.name + core.kNewGradSuffix(),
+ dtype=param.dtype,
+ shape=param.shape,
+ lod_level=param.lod_level,
+ type=core.VarDesc.VarType.LOD_TENSOR)
+
+ inputs = {"X": [grad, regularization_term]}
+ outputs = {"Out": [new_grad]}
+ grad.block.append_op(type='sum', inputs=inputs, outputs=outputs)
+
+ return new_grad
+
+ def append_regularization_ops(self,
+ parameters_and_grads,
+ regularization=None):
+ r"""Create and add backward regularization Operators
+
+ Creates and adds backward regularization operators in the BlockDesc.
+ This will add gradients of the regularizer function to the gradients
+ of the parameters and return these modified gradients. This is the
+ same as implementing weight decay in optimizers for regularization.
+
+ Args:
+ parameters_and_grads: A list of (parameters, gradients) pairs
+ that need to be regularized.
+ regularization: A global regularizer. If the parameter is not
+ set. It will be applied with regularizer.
+
+ Returns:
+ list[(Variable, Variable)]: list of (parameters, gradients) \
+ pair with the regularized gradient
+
+ Raises:
+ Exception: Unknown regularization type
+ """
+ params_and_grads = []
+ if framework._non_static_mode():
+ for param, grad in parameters_and_grads:
+ new_grad = self._create_regularization_of_grad(
+ param, grad, regularization)
+ params_and_grads.append((param, new_grad))
+ else:
+ repeate_regularizer = False
+ with framework.name_scope('regularization'):
+ for param, grad in parameters_and_grads:
+ if not repeate_regularizer and getattr(
+ param, 'regularizer',
+ None) is not None and regularization is not None:
+ repeate_regularizer = True
+ logging.info(
+ "If regularizer of a Parameter has been set by 'fluid.ParamAttr' or 'fluid.WeightNormParamAttr' already. "
+ "The Regularization[%s] in Optimizer will not take effect, and it will only be applied to other Parameters!"
+ % regularization.__str__())
+ with param.block.program._optimized_guard([param, grad]):
+ new_grad = self._create_regularization_of_grad(
+ param, grad, regularization)
+ params_and_grads.append((param, new_grad))
+ return params_and_grads
+
+ def flatten_param_grads(self, params_grads):
+ need_flatten_params = []
+ need_flatten_grads = []
+ for p, g in params_grads:
+ if g is None:
+ continue
+ g.persistable = True
+ if getattr(p, 'need_clip', True) is False or getattr(
+ p, 'regularizer', None) is not None:
+ warnings.warn(
+ "flatten_param_grads=True will be discarded since paramter '{}''s need_clip is False or "
+ "the regularizer is set".format(p.name))
+ self._flatten_param_grads = False
+ return params_grads
+
+ need_flatten_params.append(p)
+ need_flatten_grads.append(g)
+
+ shape = [np.prod(p.shape) for p in need_flatten_params]
+ block = need_flatten_params[0].block
+
+ flatten_param = self.helper.create_global_variable(
+ name='flatten_param',
+ persistable=True,
+ dtype=need_flatten_params[0].dtype,
+ shape=[np.sum(shape)],
+ belong_to_optimizer=True)
+
+ flatten_param.trainable = True
+ flatten_param.optimize_attr = need_flatten_params[0].optimize_attr
+ flatten_param.regularizer = need_flatten_params[0].regularizer
+
+ flatten_grad = self.helper.create_global_variable(
+ name='flatten_grad',
+ persistable=True,
+ dtype=need_flatten_grads[0].dtype,
+ shape=[np.sum(shape)],
+ belong_to_optimizer=True)
+
+ with program_guard(default_main_program()):
+ block.append_op(type="coalesce_tensor",
+ inputs={"Input": need_flatten_params},
+ outputs={
+ "Output": need_flatten_params,
+ "FusedOutput": flatten_param
+ },
+ attrs={
+ "copy_data": True,
+ "use_align": True,
+ "align_size": self._align_size,
+ "dtype": need_flatten_params[0].dtype
+ })
+
+ block.append_op(type="coalesce_tensor",
+ inputs={"Input": need_flatten_grads},
+ outputs={
+ "Output": need_flatten_grads,
+ "FusedOutput": flatten_grad
+ },
+ attrs={
+ "copy_data": True,
+ "use_align": True,
+ "align_size": self._align_size,
+ "dtype": need_flatten_grads[0].dtype
+ })
+
+ #NOTE(zhiqiu): the initializer should be set after coalesce_tensor op,
+ # so the shape of flatten_param and flatten_grad will be inferred.
+ self.helper.set_variable_initializer(flatten_param,
+ initializer=Constant(0.0))
+ self.helper.set_variable_initializer(flatten_grad,
+ initializer=Constant(0.0))
+
+ return [(flatten_param, flatten_grad)]
+
+ def apply_gradients(self, params_grads):
+ """
+ Second part of `minimize`, appending optimization operators for
+ given `params_grads` pairs.
+
+ Args:
+ params_grads (list): list of (param, grad) pair to do optimization.
+
+ Returns:
+ list: A list of operators appended to the current program.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ loss = network()
+ optimizer = fluid.optimizer.SGD(learning_rate=0.1)
+ params_grads = optimizer.backward(loss)
+ # you may append operations for params_grads here
+ # ...
+ optimizer.apply_gradients(params_grads)
+ """
+ params_grads = sorted(params_grads, key=lambda x: x[0].name)
+
+ # NOTE(zhiqiu): currently, only support ClipGradByGlobalNorm and without regularization.
+ if self._flatten_param_grads and self.regularization is None:
+ if self._grad_clip == None or isinstance(self._grad_clip,
+ ClipGradByGlobalNorm):
+ params_grads = self.flatten_param_grads(params_grads)
+
+ # 'optimizer(grad_clip)' or 'set_gradient_clip'
+ if self._grad_clip is not None:
+ params_grads = self._grad_clip(params_grads)
+ else:
+ params_grads = append_gradient_clip_ops(params_grads)
+
+ # Add regularization if any
+ params_grads = self.append_regularization_ops(params_grads,
+ self.regularization)
+
+ optimize_ops = self._create_optimization_pass(params_grads)
+ return optimize_ops
+
+ def apply_optimize(self, loss, startup_program, params_grads):
+ """
+ Second part of `minimize`, appending optimization operators for
+ given `params_grads` pairs.
+ Args:
+ loss (Variable): loss variable to run optimizations.
+ startup_program (Program): startup_program for initializing parameters
+ in `parameter_list`.
+ params_grads (list): list of (param, grad) pair to do optimization.
+ Returns:
+ list: A list of operators appended to the current program.
+ """
+ if framework._non_static_mode():
+ with program_guard(framework.default_main_program(),
+ framework.default_startup_program()):
+ if self._grad_clip is not None:
+ params_grads = self._grad_clip(params_grads)
+ params_grads = self.append_regularization_ops(
+ params_grads, self.regularization)
+ optimize_ops = self._create_optimization_pass(params_grads)
+ else:
+ program = loss.block.program
+ with program_guard(program, startup_program):
+ optimize_ops = self.apply_gradients(params_grads)
+ return optimize_ops
+
+ def _get_no_grad_set(self, loss, no_grad_set=None):
+ no_grad_set = _get_no_grad_set_name(no_grad_set)
+ parameters = loss.block.program.global_block().all_parameters()
+ param_no_trainable = set(
+ [param.name for param in parameters if param.trainable is False])
+ # If the parameter is no trainable, it should not have a gradient.
+ no_grad_set.update(param_no_trainable)
+
+ return no_grad_set
+
+ @framework.dygraph_only
+ def clear_gradients(self):
+ """
+ Clear the gradients of all optimized parameters for model.
+
+ If not, new gradient will accumulat on previous gradient.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ with fluid.dygraph.guard():
+ value = np.arange(26).reshape(2, 13).astype("float32")
+ a = fluid.dygraph.to_variable(value)
+ linear = fluid.Linear(13, 5, dtype="float32")
+ # This can be any optimizer supported by dygraph.
+ adam = fluid.optimizer.Adam(learning_rate = 0.01,
+ parameter_list = linear.parameters())
+ out = linear(a)
+ out.backward()
+ adam.minimize(out)
+ adam.clear_gradients()
+
+ """
+ for p in self._parameter_list:
+ if p.trainable:
+ p.clear_gradient()
+
+ @imperative_base.no_grad
+ def minimize(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ """
+ Add operations to minimize ``loss`` by updating ``parameter_list``.
+
+ Args:
+ loss (Variable): A ``Variable`` containing the value to minimize.
+ startup_program (Program, optional): :ref:`api_fluid_Program` for
+ initializing parameters in ``parameter_list``. The default value
+ is None, at this time :ref:`api_fluid_default_startup_program` will be used.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` or ``Variable.name`` to update
+ to minimize ``loss``. The default value is None, at this time all parameters
+ will be updated.
+ no_grad_set (set, optional): Set of ``Variable`` or ``Variable.name`` that don't need
+ to be updated. The default value is None.
+
+ Returns:
+ tuple: tuple (optimize_ops, params_grads), A list of operators appended
+ by minimize and a list of (param, grad) variable pairs, param is
+ ``Parameter``, grad is the gradient value corresponding to the parameter.
+ The returned tuple can be passed to ``fetch_list`` in ``Executor.run()`` to
+ indicate program pruning. If so, the program will be pruned by ``feed`` and
+ ``fetch_list`` before run, see details in ``Executor``.
+
+ Examples:
+ Please refer to the example of current Optimizer.
+ """
+ assert isinstance(loss, Variable), "The loss should be an Variable."
+
+ parameter_list = parameter_list if parameter_list \
+ else self._parameter_list
+
+ params_grads = self.backward(loss,
+ startup_program=startup_program,
+ parameter_list=parameter_list,
+ no_grad_set=no_grad_set)
+
+ optimize_ops = self.apply_optimize(loss,
+ startup_program=startup_program,
+ params_grads=params_grads)
+
+ return optimize_ops, params_grads
+
+
+class SGDOptimizer(Optimizer):
+ r"""
+ Optimizer of the stochastic gradient descent algorithm.
+
+ .. math::
+
+ param\_out = param - learning\_rate * grad
+
+ Parameters:
+ learning_rate (float|Variable): The learning rate used to update parameters. \
+ Can be a float value or a Variable with one float value as data element.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.layers.data(name='x', shape=[13], dtype='float32')
+ y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
+ sgd_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+
+ """
+
+ def __init__(self,
+ learning_rate,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ multi_precision=False,
+ name=None):
+ assert learning_rate is not None
+ super(SGDOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "sgd"
+ self._use_mkldnn = False
+ self._multi_precision = multi_precision
+ self._master_weights = {}
+
+ def _create_master_weight(self, param):
+ if param.name in self._master_weights:
+ var = self._master_weights[param.name]
+ else:
+ assert isinstance(self.helper, LayerHelper)
+
+ var_name = param.name + "_fp32_master"
+ var_name = unique_name.generate(var_name)
+ var = layers.create_global_var(name=var_name,
+ shape=param.shape,
+ value=0,
+ dtype='float32',
+ persistable=True)
+ block = self.helper.startup_program.global_block()
+ block.append_op(type="cast",
+ inputs={"X": [param]},
+ outputs={"Out": [var]},
+ attrs={
+ "in_dtype": param.dtype,
+ "out_dtype": core.VarDesc.VarType.FP32
+ })
+ self._master_weights[param.name] = var
+ return var
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+ if isinstance(parameters, dict):
+ parameters = self._update_param_group(parameters)
+
+ # Create accumulator tensors for first and second moments
+ for p in parameters:
+ if self._multi_precision and p.dtype == core.VarDesc.VarType.FP16:
+ master_p = self._create_master_weight(p)
+ continue
+ if p.dtype == core.VarDesc.VarType.FP16 and not self._multi_precision:
+ warnings.warn(
+ "Accumulating with FP16 in optimizer can lead to poor accuracy or slow convergence."
+ "Consider using multi_precision=True option of the Adam optimizer."
+ )
+
+ @no_grad
+ def _append_optimize_op(self, block, param_and_grad):
+
+ find_master = self._multi_precision and param_and_grad[
+ 0].dtype == core.VarDesc.VarType.FP16
+ master_weight = (self._master_weights[param_and_grad[0].name]
+ if find_master else None)
+
+ lr = self._create_param_lr(param_and_grad)
+ if in_dygraph_mode():
+ _C_ops.sgd_(param_and_grad[0], lr, param_and_grad[1], master_weight,
+ find_master)
+ return None
+ if _in_legacy_dygraph():
+ _legacy_C_ops.sgd(param_and_grad[0], lr, param_and_grad[1],
+ master_weight, param_and_grad[0], master_weight)
+ return None
+
+ assert isinstance(block, framework.Block)
+ # create the optimize op
+ inputs = {
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "LearningRate": lr
+ }
+
+ outputs = {"ParamOut": param_and_grad[0]}
+
+ attrs = {"multi_precision": find_master}
+
+ if find_master:
+ inputs["MasterParam"] = master_weight
+ outputs["MasterParamOut"] = master_weight
+
+ sgd_op = block.append_op(type=self.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+ return sgd_op
+
+
+class MomentumOptimizer(Optimizer):
+ r"""
+
+ Simple Momentum optimizer with velocity state
+
+ This optimizer has a flag for Nestrov Momentum.
+
+ The update equations are as follows:
+
+ .. math::
+
+ & velocity = mu * velocity + gradient
+
+ & if (use\_nesterov):
+
+ &\quad param = param - (gradient + mu * velocity) * learning\_rate
+
+ & else:
+
+ &\quad param = param - learning\_rate * velocity
+
+ Parameters:
+ learning_rate (float|Variable): The learning rate used to update parameters. \
+ Can be a float value or a Variable with one float value as data element.
+ momentum (float): Momentum factor
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ use_nesterov (bool, optional): Enables Nesterov momentum, default is false.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.layers.data(name='x', shape=[13], dtype='float32')
+ y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ moment_optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.001, momentum=0.9)
+ moment_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+
+ """
+ _velocity_acc_str = "velocity"
+
+ def __init__(self,
+ learning_rate,
+ momentum,
+ parameter_list=None,
+ use_nesterov=False,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ assert learning_rate is not None
+ assert momentum is not None
+ super(MomentumOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "momentum"
+ self._momentum = momentum
+ self._use_nesterov = bool(use_nesterov)
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+
+ for p in parameters:
+ self._add_accumulator(self._velocity_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ velocity_acc = self._get_accumulator(self._velocity_acc_str,
+ param_and_grad[0])
+ lr = self._create_param_lr(param_and_grad)
+ master_weight = None
+ if framework._non_static_mode():
+ _, _, _ = _legacy_C_ops.momentum(
+ param_and_grad[0], param_and_grad[1], velocity_acc, lr,
+ master_weight, param_and_grad[0], velocity_acc, master_weight,
+ 'mu', self._momentum, 'use_nesterov', self._use_nesterov)
+ return None
+
+ attrs = {"mu": self._momentum, "use_nesterov": self._use_nesterov}
+ inputs = {
+ "Param": [param_and_grad[0]],
+ "Grad": [param_and_grad[1]],
+ "Velocity": [velocity_acc],
+ "LearningRate": [lr]
+ }
+
+ outputs = {
+ "ParamOut": [param_and_grad[0]],
+ "VelocityOut": [velocity_acc]
+ }
+ # create the momentum optimize op
+ momentum_op = block.append_op(type=self.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+ return momentum_op
+
+
+class DGCMomentumOptimizer(Optimizer):
+ r"""
+ :api_attr: Static Graph
+
+ DGC (Deep Gradient Compression) Momentum Optimizer. Original paper is https://arxiv.org/abs/1712.01887
+
+ DGC reduces the communication bandwidth by sending only the important gradients (sparse update):\
+ only gradients larger than a threshold are transmitted.
+
+ To avoid losing information, DGC accumulates the rest of the gradients locally.
+
+ Eventually, these gradients become large enough to be transmitted.
+
+ Thus, DGC sends the large gradients immediately but eventually sends all of the gradients over time.
+
+ To ensure no loss of accuracy, DGC employs momentum correction and local gradient clipping on top of the gradient sparsification to maintain model performance.
+
+ DGC also uses momentum factor masking and warmup training to overcome the staleness problem caused by reduced communication.
+
+ This optimizer will do two things:
+
+ 1. Compress the gradient by get TopK import value from tensor \
+ and use it for allreduce to reduce network bandwidth.
+
+ 2. Call momentum to optimize the cost.
+
+ Args:
+ learning_rate (float|Variable): The learning rate used to update parameters. \
+ It can be a float value or a Variable with one float value as a data element.
+ momentum (float): Momentum factor.
+ rampup_begin_step (int): The beginning step from which gradient compression is implemented.
+ rampup_step (int): Time steps used in sparsity warm-up periods. Default is 1.
+ For example, if the sparsity is [0.75, 0.9375, 0.984375, 0.996, 0.999], and the rampup_step is 100, \
+ it will use 0.75 at 0~19 steps, and 0.9375 at 20~39 steps, and so on. \
+ And when reach sparsity array ends, it will use 0.999 then and after.
+ sparsity (list[float]): Get top important element from gradient tensor, the ratio is (1 - current sparsity). \
+ Default is [0.999]. For example, if the sparsity is [0.99, 0.999], \
+ the top [1%, 0.1%] important element will be transmitted.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ use_nesterov (bool): Enables Nesterov momentum. True means use Nesterov. Default is False.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipByNorm, optional): Gradient cliping strategy. ``DGCMomentumOptimizer`` only support
+ :ref:`api_fluid_clip_GradientClipByNorm` , and if not, it will raise TypeError. Default None,
+ meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ optimizer = fluid.optimizer.DGCMomentumOptimizer(
+ learning_rate=0.0001,
+ momentum=0.9,
+ rampup_step=1000,
+ rampup_begin_step=1252,
+ sparsity=[0.999, 0.999])
+
+ """
+ _u_velocity_acc_str = "_dgc_u_"
+ _v_velocity_acc_str = "_dgc_v_"
+
+ def __init__(self,
+ learning_rate,
+ momentum,
+ rampup_begin_step,
+ rampup_step=1,
+ sparsity=[0.999],
+ parameter_list=None,
+ use_nesterov=False,
+ num_trainers=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ if framework._non_static_mode():
+ raise Exception("In dygraph, don't support DGCMomentumOptimizer.")
+
+ assert core.is_compiled_with_cuda(), \
+ "Paddle is not compiled with CUDA. DGC is only support GPU for now."
+
+ assert learning_rate is not None
+ assert momentum is not None
+ super(DGCMomentumOptimizer,
+ self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "dgc_momentum"
+ self._momentum = momentum
+ self._use_nesterov = bool(use_nesterov)
+
+ assert rampup_begin_step >= 0, "rampup_begin_step must >= 0"
+ self._rampup_begin_step = rampup_begin_step
+ self._rampup_step = rampup_step
+ self._sparsity = sparsity
+
+ self._rampup_begin_step_var = None
+ self._global_step_var = None
+
+ self._dgc_clip_norm = None
+ if grad_clip is not None:
+ if not isinstance(grad_clip, GradientClipByNorm):
+ raise TypeError(
+ "The type of grad_clip should be 'GradientClipByNorm', because DGCMomentumOptimizer only support GradientClipByNorm"
+ )
+ assert isinstance(
+ num_trainers, int
+ ), "The type of num_trainers should be 'int', but received %s" % type(
+ num_trainers)
+ assert num_trainers > 0, "The value of num_trainers should be greater than 0!"
+
+ self._num_trainers = num_trainers
+ self._dgc_clip_norm = grad_clip.clip_norm * (num_trainers**-0.5)
+
+ self.regular_type, self.regular_coeff = self._get_regularization_param(
+ self.regularization)
+
+ def _get_regularization_param(self, regularization):
+ regular_type = 0
+ regular_coeff = 0.0
+
+ if regularization is not None:
+ regular_coeff = regularization._regularization_coeff
+ from .regularizer import L1Decay, L2Decay
+ if isinstance(regularization, L1Decay):
+ regular_type = 1
+ elif isinstance(regularization, L2Decay):
+ regular_type = 2
+ else:
+ assert False, 'regularization must be None|L1Decay|L2Deacy'
+ return regular_type, regular_coeff
+
+ def _is_use_dgc(self, param_var, grad_var):
+ var_numel = abs(reduce(lambda x, y: x * y, param_var.shape))
+ if var_numel < 16384 or \
+ param_var.type == core.VarDesc.VarType.SELECTED_ROWS or \
+ grad_var.type == core.VarDesc.VarType.SELECTED_ROWS or \
+ param_var.dtype != core.VarDesc.VarType.FP32 :
+ return False
+ return True
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+ velocity_acc = self._get_accumulator(self._u_velocity_acc_str,
+ param_and_grad[0])
+ assert velocity_acc is not None
+
+ inputs = {
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "Velocity": velocity_acc,
+ "LearningRate": self._create_param_lr(param_and_grad),
+ }
+ outputs = {
+ "ParamOut": param_and_grad[0],
+ "VelocityOut": velocity_acc,
+ }
+ attrs = {"mu": self._momentum, "use_nesterov": self._use_nesterov}
+
+ if not self._is_use_dgc(param_and_grad[0], param_and_grad[1]):
+ type = "momentum"
+ else:
+ type = "dgc_momentum"
+ inputs.update({
+ "current_step": self._global_step_var,
+ "nranks": self._nranks_var
+ })
+ outputs.update({'Grad_out': param_and_grad[1]})
+ attrs.update({"rampup_begin_step": float(self._rampup_begin_step)})
+
+ # create the dgc momentum optimize op
+ dgc_momentum_op = block.append_op(type=type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+ return dgc_momentum_op
+
+ def _add_auto_increment_var(self, counter_name, begin, step=1):
+ helper = LayerHelper('global_step_counter')
+ counter, is_new_var = helper.create_or_get_global_variable(
+ name=counter_name, dtype='float32', shape=[1], persistable=True)
+ if is_new_var:
+ helper.set_variable_initializer(counter,
+ initializer=Constant(
+ value=float(begin - 1),
+ force_cpu=True))
+ helper.main_program.global_block()._prepend_op(
+ type='increment',
+ inputs={'X': [counter]},
+ outputs={'Out': [counter]},
+ attrs={'step': float(step)},
+ stop_gradient=True)
+ counter.stop_gradient = True
+
+ return counter
+
+ def _add_nranks_var(self, name, value=-1):
+ helper = LayerHelper('global_step_counter')
+ counter, is_new_var = helper.create_or_get_global_variable(
+ name=name, dtype='float32', shape=[1], persistable=True)
+ if is_new_var:
+ helper.set_variable_initializer(counter,
+ initializer=Constant(
+ value=float(value),
+ force_cpu=True))
+ counter.stop_gradient = True
+
+ return counter
+
+ def _append_dgc_ops(self, param_and_grads):
+ main_program = default_main_program()
+ main_program._enable_dgc = True
+
+ # step counter
+ self._global_step_var = self._add_auto_increment_var(
+ counter_name=core.dgc.kDGCCounterName(), begin=0)
+
+ self._nranks_var = self._add_nranks_var(name=core.dgc.kDGCNRanksName(),
+ value=-1)
+
+ # rampup begin step var for all_reduce_op_handle
+ self._rampup_begin_step_var = tensor.create_global_var(
+ shape=[1],
+ dtype=core.VarDesc.VarType.FP32,
+ persistable=True,
+ name=core.dgc.kDGCRampUpBeginStepName(),
+ value=self._rampup_begin_step * 1.0,
+ force_cpu=True)
+
+ self.helper = LayerHelper(self.__class__.__name__)
+
+ for param_var, grad_var in param_and_grads:
+ # reuse velocity in dgc_op and dgc_momentum_op
+ u_var = self._add_accumulator(self._u_velocity_acc_str, param_var)
+
+ if not self._is_use_dgc(param_var, grad_var):
+ continue
+
+ v_var = self._add_accumulator(self._v_velocity_acc_str, param_var)
+
+ k_var = tensor.create_global_var(shape=[1],
+ dtype=param_var.dtype,
+ persistable=True,
+ name=param_var.name +
+ core.dgc.kDGCKName(),
+ value=0.0,
+ force_cpu=True)
+
+ encoded_var = tensor.create_global_var(shape=[1],
+ dtype=param_var.dtype,
+ persistable=True,
+ name=param_var.name +
+ core.dgc.kDGCEncodedName(),
+ value=0.0,
+ force_cpu=False)
+
+ gather_var = tensor.create_global_var(shape=[1],
+ dtype=param_var.dtype,
+ persistable=True,
+ name=param_var.name +
+ core.dgc.kDGCGatherName(),
+ value=0.0,
+ force_cpu=False)
+
+ # del back oprolevarname
+ op_maker = core.op_proto_and_checker_maker
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ for op in main_program.global_block().ops:
+ if not self._is_the_backward_op(op):
+ continue
+
+ var_attr = op.all_attrs()[op_maker.kOpRoleVarAttrName()]
+ if param_var.name not in var_attr:
+ continue
+
+ var_attr.remove(param_var.name)
+ var_attr.remove(grad_var.name)
+ if len(var_attr) > 1:
+ op._set_attr(op_maker.kOpRoleVarAttrName(), var_attr)
+ else:
+ op._remove_attr(op_maker.kOpRoleVarAttrName())
+
+ clip_var = grad_var
+ if self._dgc_clip_norm is not None:
+ clip_var = self._append_clip_norm(grad_var, self._dgc_clip_norm)
+ self._dgc_op(param_var, clip_var, grad_var, u_var, v_var, k_var,
+ encoded_var, gather_var)
+
+ def _is_the_backward_op(self, op):
+ op_maker = core.op_proto_and_checker_maker
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ if op_maker.kOpRoleVarAttrName() in op.attr_names and \
+ int(op.all_attrs()[op_maker.kOpRoleAttrName()]) == int(backward):
+ return True
+ return False
+
+ def _clip_by_norm(self, x, max_norm, name=None):
+ args = {'x': x, 'max_norm': max_norm, 'name': name}
+
+ helper = LayerHelper("dgc_clip_by_norm_op", **args)
+
+ if name is None:
+ name = unique_name.generate_with_ignorable_key(".".join(
+ [helper.name, 'tmp']))
+
+ out = helper.create_variable(type=x.type,
+ name=name,
+ dtype=x.dtype,
+ persistable=False)
+
+ helper.append_op(type="dgc_clip_by_norm",
+ inputs={
+ "X": x,
+ "current_step": self._global_step_var
+ },
+ attrs={
+ "max_norm": max_norm,
+ "rampup_begin_step": float(self._rampup_begin_step)
+ },
+ outputs={"Out": out})
+ return out
+
+ def _append_clip_norm(self, grad_var, clip_norm):
+ with grad_var.block.program._backward_role_guard():
+ return self._clip_by_norm(x=grad_var,
+ max_norm=clip_norm,
+ name=grad_var.name)
+
+ def _dgc_op(self, param_var, clip_var, grad_var, u_var, v_var, k_var,
+ encoded_var, gather_var):
+ block = framework.default_main_program().global_block()
+ op_maker = core.op_proto_and_checker_maker
+
+ regular_type = self.regular_type
+ regular_coeff = self.regular_coeff
+ # The regularizer of the Parameters have higher priority
+ if param_var.regularizer is not None:
+ regular_type, regular_coeff = self._get_regularization_param(
+ param_var.regularizer)
+
+ dgc_op = block.append_op(type="dgc",
+ inputs={
+ "U": u_var,
+ "V": v_var,
+ "Grad": clip_var,
+ "Param": param_var,
+ "current_step": self._global_step_var,
+ "nranks": self._nranks_var,
+ },
+ outputs={
+ "U_out": u_var,
+ "V_out": v_var,
+ "EncodeGrad": encoded_var,
+ "k": k_var,
+ "Grad_out": grad_var,
+ "GatherBuff": gather_var,
+ },
+ attrs={
+ "m":
+ self._momentum,
+ "sparsity":
+ self._sparsity,
+ "use_nesterov":
+ self._use_nesterov,
+ "rampup_begin_step":
+ float(self._rampup_begin_step),
+ "rampup_step":
+ float(self._rampup_step),
+ "regular_coeff":
+ float(regular_coeff),
+ "regular_type":
+ int(regular_type),
+ },
+ stop_gradient=True)
+
+ backward = op_maker.OpRole.Backward
+ dgc_op._set_attr(op_maker.kOpRoleAttrName(), backward)
+ dgc_op._set_attr(op_maker.kOpRoleVarAttrName(),
+ [param_var.name, grad_var.name])
+
+ @imperative_base.no_grad
+ def apply_gradients(self, params_grads):
+ # Note: since we can't use all_reduce_op now,
+ # dgc_op should be the last op of one grad.
+ # Maybe need a grad allreduce pass.
+ self._append_dgc_ops(params_grads)
+
+ params_grads = sorted(params_grads, key=lambda x: x[0].name)
+ params_grads, table_param_and_grad, table_optimize_op = \
+ self._process_distribute_lookuptable(params_grads)
+
+ not_dgc_params_grads = []
+ dgc_params_grads = []
+ # DGC clip and regularization in optimizer.backward
+ for param, grad in params_grads:
+ if not self._is_use_dgc(param, grad):
+ not_dgc_params_grads.append((param, grad))
+ else:
+ dgc_params_grads.append((param, grad))
+
+ # 'optimizer(grad_clip)' or 'set_gradient_clip'
+ if self._grad_clip is not None:
+ not_dgc_params_grads = self._grad_clip(not_dgc_params_grads)
+ else:
+ not_dgc_params_grads = append_gradient_clip_ops(
+ not_dgc_params_grads)
+
+ not_dgc_params_grads = self.append_regularization_ops(
+ not_dgc_params_grads, self.regularization)
+
+ params_grads = not_dgc_params_grads + dgc_params_grads
+ params_grads = sorted(params_grads, key=lambda x: x[0].name)
+
+ optimize_ops = self._create_optimization_pass(params_grads)
+ if table_optimize_op is not None:
+ optimize_ops.append(table_optimize_op)
+ params_grads.append(table_param_and_grad)
+
+ return optimize_ops
+
+
+class LarsMomentumOptimizer(Optimizer):
+ r"""
+ Momentum optimizer with LARS support
+
+ The update equations are as follows:
+
+ .. math::
+
+ & local\_learning\_rate = learning\_rate * lars\_coeff * \\
+ \\frac{||param||}{||gradient|| + lars\_weight\_decay * ||param||}
+
+ & velocity = mu * velocity + local\_learning\_rate * (gradient + lars\_weight\_decay * param + epsilon)
+
+ & param = param - velocity
+
+ Parameters:
+ learning_rate (float|Variable): The learning rate used to update parameters. \
+ Can be a float value or a Variable with one float value as data element. \
+ momentum (float): momentum factor
+ lars_coeff (float): Defines how much we trust the layer to change its weights.
+ lars_weight_decay (float): Weight decay coefficient for decaying using LARS.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+ exclude_from_weight_decay (list[str], optional): Name string of layers which will be exclude from lars weight decay. Default is None.
+ epsilon (float, optional): Epsilon to avoid Division by Zero when calculate local lr. Default is 0.
+ multi_precision (bool, optional): Whether to use multi-precision during weight updating.
+ rescale_grad (float, optional): Multiply the gradient with `rescale_grad` \
+ before updating. Often choose to be `1.0/batch_size`.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+ inp = fluid.layers.data(
+ name="inp", shape=[2, 2], append_batch_size=False)
+ out = fluid.layers.fc(inp, size=3)
+ out = fluid.layers.reduce_sum(out)
+ optimizer = fluid.optimizer.LarsMomentumOptimizer(learning_rate=0.001, momentum=0.9)
+ optimizer.minimize(out)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+ exe.run(
+ feed={"inp": np_inp},
+ fetch_list=[out.name])
+ """
+ _velocity_acc_str = "velocity"
+
+ def __init__(self,
+ learning_rate,
+ momentum,
+ lars_coeff=0.001,
+ lars_weight_decay=0.0005,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None,
+ exclude_from_weight_decay=None,
+ epsilon=0,
+ multi_precision=False,
+ rescale_grad=1.0):
+ assert learning_rate is not None
+ assert momentum is not None
+ super(LarsMomentumOptimizer,
+ self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "lars_momentum"
+ self._momentum = momentum
+ self._lars_coeff = float(lars_coeff)
+ self._lars_weight_decay = float(lars_weight_decay)
+ self._epsilon = float(epsilon)
+ if exclude_from_weight_decay is None:
+ self._exclude_from_weight_decay = []
+ else:
+ self._exclude_from_weight_decay = exclude_from_weight_decay
+ self._multi_precision = multi_precision
+ self._rescale_grad = float(rescale_grad)
+ self._master_weights = {}
+
+ def _create_master_weight(self, param):
+ if param.name in self._master_weights:
+ var = self._master_weights[param.name]
+ else:
+ assert isinstance(self.helper, LayerHelper)
+
+ var_name = param.name + '_fp32_master'
+ var_name = unique_name.generate(var_name)
+ var = layers.create_global_var(name=var_name,
+ shape=param.shape,
+ value=0,
+ dtype='float32',
+ persistable=True)
+ block = self.helper.startup_program.global_block()
+ block.append_op(type="cast",
+ inputs={"X": [param]},
+ outputs={"Out": [var]},
+ attrs={
+ "in_dtype": param.dtype,
+ "out_dtype": core.VarDesc.VarType.FP32
+ })
+ self._master_weights[param.name] = var
+ return var
+
+ def _get_accumulator(self, name, param):
+ """Utility function to fetch an accumulator for a parameter
+ Args:
+ name: name of the accumulator
+ param: parameter variable for which accumulator is to be fetched
+ Returns:
+ accumulator variable for the parameter
+ """
+ if self._name is not None:
+ name = self._name + "_" + name
+ find_master = self._multi_precision and param.dtype == core.VarDesc.VarType.FP16
+ target_param = self._master_weights[
+ param.name] if find_master else param
+ target_name = target_param.name
+ if (name not in self._accumulators
+ or target_name not in self._accumulators[name]):
+ raise Exception(
+ "Accumulator {} does not exist for parameter {}".format(
+ name, target_name))
+ return self._accumulators[name][target_name]
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+
+ for p in parameters:
+ if self._multi_precision and p.dtype == core.VarDesc.VarType.FP16:
+ master_p = self._create_master_weight(p)
+ self._add_accumulator(self._velocity_acc_str, master_p)
+ continue
+ if p.dtype == core.VarDesc.VarType.FP16 and not self._multi_precision:
+ warnings.warn(
+ "Accumulating with FP16 in optimizer can lead to poor accuracy or slow convergence."
+ "Consider using multi_precision=True option of the Lars optimizer."
+ )
+ self._add_accumulator(self._velocity_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+ _lars_weight_decay = self._lars_weight_decay
+ param_name = param_and_grad[0].name
+ if len(self._exclude_from_weight_decay) > 0:
+ for name in self._exclude_from_weight_decay:
+ if name in param_name:
+ _lars_weight_decay = 0.0
+ break
+
+ velocity_acc = self._get_accumulator(self._velocity_acc_str,
+ param_and_grad[0])
+ lr = self._create_param_lr(param_and_grad)
+
+ find_master = self._multi_precision and param_and_grad[
+ 0].dtype == core.VarDesc.VarType.FP16
+ master_weight = (self._master_weights[param_and_grad[0].name]
+ if find_master else None)
+
+ attrs = {
+ "mu": self._momentum,
+ "lars_coeff": self._lars_coeff,
+ "lars_weight_decay": [_lars_weight_decay],
+ "multi_precision": find_master,
+ "epsilon": self._epsilon,
+ "rescale_grad": self._rescale_grad
+ }
+
+ inputs = {
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "Velocity": velocity_acc,
+ "LearningRate": lr
+ }
+
+ outputs = {"ParamOut": param_and_grad[0], "VelocityOut": velocity_acc}
+
+ if find_master:
+ inputs["MasterParam"] = master_weight
+ outputs["MasterParamOut"] = master_weight
+
+ if framework._non_static_mode():
+ tmp, tmp2 = _legacy_C_ops.lars_momentum(
+ [param_and_grad[0]], [param_and_grad[1]], [velocity_acc], [lr],
+ [param_and_grad[0]], [velocity_acc], "mu", self._momentum,
+ "lars_coeff", self._lars_coeff, "lars_weight_decay",
+ [_lars_weight_decay], "multi_precision", find_master, "epsilon",
+ self._epsilon, "rescale_grad", self._rescale_grad)
+ else:
+ # create the momentum optimize op
+ momentum_op = block.append_op(type=self.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+ return momentum_op
+
+
+class AdagradOptimizer(Optimizer):
+ r"""
+ The Adaptive Gradient optimizer (Adagrad for short) can adaptively assign
+ different learning rates to individual parameters.
+
+ The parameter ``param_out`` update rule with gradient ``grad``:
+
+ .. math::
+
+ moment\_out &= moment + grad * grad
+
+ param\_out &= param - \\frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}
+
+ Related paper: `Adaptive Subgradient Methods for Online Learning and
+ Stochastic Optimization `_.
+
+ The original paper does not have the ``epsilon`` attribute. It is added here
+ in our implementation as also proposed `Per-parameter adaptive learning rate
+ methods `_
+ for numerical stability to avoid the division by zero error.
+
+ Args:
+ learning_rate (float|Variable): The learning rate used to update ``Parameter``.
+ It can be a float value or a ``Variable`` with a float type.
+ epsilon (float, optional): A small float value for numerical stability.
+ The default value is 1e-06.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ The default value is None.
+ initial_accumulator_value (float, optional): Initial value for moment accumulator.
+ The default value is 0.0.
+
+ Examples:
+ .. code-block:: python
+
+ import numpy as np
+ import paddle.fluid as fluid
+
+ np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+ inp = fluid.data(name="inp", shape=[2, 2])
+ out = fluid.layers.fc(inp, size=3)
+ out = fluid.layers.reduce_sum(out)
+ optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.2)
+ optimizer.minimize(out)
+
+ exe = fluid.Executor(fluid.CPUPlace())
+ exe.run(fluid.default_startup_program())
+ exe.run(
+ feed={"inp": np_inp},
+ fetch_list=[out.name])
+ """
+ _moment_acc_str = "moment"
+
+ def __init__(self,
+ learning_rate,
+ epsilon=1.0e-6,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None,
+ initial_accumulator_value=0.0):
+ assert learning_rate is not None
+ assert epsilon is not None
+ super(AdagradOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "adagrad"
+ self._epsilon = epsilon
+ self.initial_accumulator_value = initial_accumulator_value
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+
+ for p in parameters:
+ self._add_accumulator(self._moment_acc_str,
+ p,
+ fill_value=self.initial_accumulator_value)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ moment_acc = self._get_accumulator(self._moment_acc_str,
+ param_and_grad[0])
+ if in_dygraph_mode():
+ _C_ops.adagrad_(param_and_grad[0], param_and_grad[1], moment_acc,
+ self._create_param_lr(param_and_grad),
+ self._epsilon)
+ return None
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.adagrad(param_and_grad[0], param_and_grad[1],
+ moment_acc,
+ self._create_param_lr(param_and_grad),
+ param_and_grad[0], moment_acc, "epsilon",
+ self._epsilon)
+ return None
+ else:
+ # Create the adagrad optimizer op
+ adagrad_op = block.append_op(
+ type=self.type,
+ inputs={
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "Moment": moment_acc,
+ "LearningRate": self._create_param_lr(param_and_grad)
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "MomentOut": moment_acc
+ },
+ attrs={"epsilon": self._epsilon},
+ stop_gradient=True)
+
+ return adagrad_op
+
+
+class AdamOptimizer(Optimizer):
+ r"""
+ The Adam optimizer uses an optimization described at the end
+ of section 2 of `Adam paper `_ ,
+ it can dynamically adjusts the learning rate of each parameter using
+ the 1st moment estimates and the 2nd moment estimates of the gradient.
+
+ The parameter ``param_out`` update rule with gradient ``grad``:
+
+ .. math::
+
+ t & = t + 1
+
+ moment\_1\_out & = {\\beta}_1 * moment\_1 + (1 - {\\beta}_1) * grad
+
+ moment\_2\_out & = {\\beta}_2 * moment\_2 + (1 - {\\beta}_2) * grad * grad
+
+ learning\_rate & = learning\_rate * \\
+ \\frac{\sqrt{1 - {\\beta}_2^t}}{1 - {\\beta}_1^t}
+
+ param\_out & = param - learning\_rate * \\frac{moment\_1}{\sqrt{moment\_2} + \epsilon}
+
+ Related paper: `Adam: A Method for Stochastic Optimization `_
+
+ Args:
+ learning_rate (float|Variable, optional): The learning rate used to update ``Parameter``.
+ It can be a float value or a ``Variable`` with a float type. The default value is 0.001.
+ beta1 (float|Variable, optional): The exponential decay rate for the 1st moment estimates.
+ It should be a float number or a Variable with shape [1] and data type as float32.
+ The default value is 0.9.
+ beta2 (float|Variable, optional): The exponential decay rate for the 2nd moment estimates.
+ It should be a float number or a Variable with shape [1] and data type as float32.
+ The default value is 0.999.
+ epsilon (float|Tensor, optional): A small float value for numerical stability.
+ It should be a float number or a Variable with shape [1] and data type as float32.
+ The default value is 1e-08.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ The default value is None.
+ lazy_mode (bool, optional): The official Adam algorithm has two moving-average accumulators.
+ The accumulators are updated at every step. Every element of the two moving-average
+ is updated in both dense mode and sparse mode. If the size of parameter is very large,
+ then the update may be very slow. The lazy mode only update the element that has
+ gradient in current mini-batch, so it will be much more faster. But this mode has
+ different semantics with the original Adam algorithm and may lead to different result.
+ The default value is False.
+ use_global_beta_pow (bool, optional): Whether to use global beta_pow. If true, Adam will use global beta_pow
+ for whole model instead of creating beta_pow for each parameter. Default is false.
+ flatten_param_grads (bool, optional): Whether to flatten all parameters and gradients. Default is false.
+ align_size (int, optional): The alignment size when flatten parameters and gradients. Default is -1, which means
+ use same align_size as allocator.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.data(name='x', shape=[None, 13], dtype='float32')
+ y = fluid.data(name='y', shape=[None, 1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ adam_optimizer = fluid.optimizer.AdamOptimizer(0.01)
+ adam_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+
+ .. code-block:: python
+
+ # Adam with beta1/beta2 as Variable
+ import paddle
+ import paddle.fluid as fluid
+ import paddle.fluid.layers.learning_rate_scheduler as lr_scheduler
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.data(name='x', shape=[None, 13], dtype='float32')
+ y = fluid.data(name='y', shape=[None, 1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ # define beta decay variable
+ def get_decayed_betas(beta1_init, beta2_init, decay_steps, decay_rate, epsilon_init):
+ global_step = lr_scheduler._decay_step_counter()
+
+ beta1 = fluid.layers.create_global_var(
+ shape=[1],
+ value=float(beta1_init),
+ dtype='float32',
+ # set persistable for save checkpoints and resume
+ persistable=True,
+ name="beta1")
+ beta2 = fluid.layers.create_global_var(
+ shape=[1],
+ value=float(beta2_init),
+ dtype='float32',
+ # set persistable for save checkpoints and resume
+ persistable=True,
+ name="beta2")
+ epsilon = fluid.layers.create_global_var(
+ shape=[1],
+ value=float(epsilon_init),
+ dtype='float32',
+ # set persistable for save checkpoints and resume
+ persistable=True,
+ name="epsilon")
+
+ div_res = global_step / decay_steps
+ decayed_beta1 = beta1_init * (decay_rate**div_res)
+ decayed_beta2 = beta2_init * (decay_rate**div_res)
+ fluid.layers.assign(decayed_beta1, beta1)
+ fluid.layers.assign(decayed_beta2, beta2)
+
+ return beta1, beta2, epsilon
+
+ beta1, beta2, epsilon = get_decayed_betas(0.9, 0.99, 1e5, 0.9, 1e-8)
+ adam_optimizer = fluid.optimizer.AdamOptimizer(
+ learning_rate=0.01,
+ beta1=beta1,
+ beta2=beta2,
+ epsilon=epsilon)
+ adam_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+ """
+ _moment1_acc_str = "moment1"
+ _moment2_acc_str = "moment2"
+ _beta1_pow_acc_str = "beta1_pow_acc"
+ _beta2_pow_acc_str = "beta2_pow_acc"
+
+ def __init__(self,
+ learning_rate=0.001,
+ beta1=0.9,
+ beta2=0.999,
+ epsilon=1e-8,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None,
+ lazy_mode=False,
+ use_global_beta_pow=False,
+ flatten_param_grads=False,
+ align_size=-1):
+ assert learning_rate is not None
+ assert beta1 is not None
+ assert beta2 is not None
+ assert epsilon is not None
+ super(AdamOptimizer,
+ self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ flatten_param_grads=flatten_param_grads,
+ align_size=align_size,
+ name=name)
+ self.type = "adam"
+ self._beta1 = beta1
+ self._beta2 = beta2
+ self._epsilon = epsilon
+ self._lazy_mode = lazy_mode
+ self._use_global_beta_pow = use_global_beta_pow
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+
+ # Create accumulator tensors for first and second moments
+ for p in parameters:
+ self._add_accumulator(self._moment1_acc_str, p)
+ self._add_accumulator(self._moment2_acc_str, p)
+ if not self._use_global_beta_pow:
+ self._add_accumulator(
+ name=self._beta1_pow_acc_str,
+ param=p,
+ fill_value=0.9 if isinstance(self._beta1, Variable) \
+ else self._beta1,
+ shape=[1],
+ type=core.VarDesc.VarType.LOD_TENSOR, device='cpu')
+ self._add_accumulator(
+ name=self._beta2_pow_acc_str,
+ param=p,
+ fill_value=0.999 if isinstance(self._beta2, Variable) \
+ else self._beta2,
+ shape=[1],
+ type=core.VarDesc.VarType.LOD_TENSOR, device='cpu')
+ if self._use_global_beta_pow:
+ self._add_global_accumulator(
+ name=self._beta1_pow_acc_str,
+ fill_value=0.9 if isinstance(self._beta1, Variable) \
+ else self._beta1,
+ shape=[1],
+ type=core.VarDesc.VarType.LOD_TENSOR, device='cpu')
+ self._add_global_accumulator(
+ name=self._beta2_pow_acc_str,
+ fill_value=0.999 if isinstance(self._beta2, Variable) \
+ else self._beta2,
+ shape=[1],
+ type=core.VarDesc.VarType.LOD_TENSOR, device='cpu')
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ moment1 = self._get_accumulator(self._moment1_acc_str,
+ param_and_grad[0])
+ moment2 = self._get_accumulator(self._moment2_acc_str,
+ param_and_grad[0])
+ if self._use_global_beta_pow:
+ beta1_pow_acc = self._get_global_accumulator(
+ self._beta1_pow_acc_str)
+ beta2_pow_acc = self._get_global_accumulator(
+ self._beta2_pow_acc_str)
+ else:
+ beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
+ param_and_grad[0])
+ beta2_pow_acc = self._get_accumulator(self._beta2_pow_acc_str,
+ param_and_grad[0])
+ lr = self._create_param_lr(param_and_grad)
+ # create the adam optimize op
+
+ if framework._non_static_mode():
+ _beta1 = self._beta1 if not isinstance(
+ self._beta1, Variable) else self._beta1.numpy().item(0)
+ _beta2 = self._beta2 if not isinstance(
+ self._beta2, Variable) else self._beta2.numpy().item(0)
+ master_weight = None
+ _, _, _, _, _, _ = _legacy_C_ops.adam(
+ param_and_grad[0], param_and_grad[1], lr, moment1, moment2,
+ beta1_pow_acc, beta2_pow_acc, master_weight, param_and_grad[0],
+ moment1, moment2, beta1_pow_acc, beta2_pow_acc, master_weight,
+ 'epsilon', self._epsilon, 'lazy_mode', self._lazy_mode,
+ 'min_row_size_to_use_multithread', 1000, 'beta1', _beta1,
+ 'beta2', _beta2, 'use_global_beta_pow',
+ self._use_global_beta_pow)
+
+ return None
+
+ inputs = {
+ "Param": [param_and_grad[0]],
+ "Grad": [param_and_grad[1]],
+ "LearningRate": [lr],
+ "Moment1": [moment1],
+ "Moment2": [moment2],
+ "Beta1Pow": [beta1_pow_acc],
+ "Beta2Pow": [beta2_pow_acc]
+ }
+
+ # Pass found_inf to adam, to skip update for not only param, but also momentum and beta_pow
+ found_inf = self._get_auxiliary_var('found_inf')
+
+ if found_inf:
+ inputs['SkipUpdate'] = found_inf
+
+ outputs = {
+ "ParamOut": [param_and_grad[0]],
+ "Moment1Out": [moment1],
+ "Moment2Out": [moment2],
+ "Beta1PowOut": [beta1_pow_acc],
+ "Beta2PowOut": [beta2_pow_acc],
+ }
+ attrs = {
+ "lazy_mode": self._lazy_mode,
+ "min_row_size_to_use_multithread": 1000,
+ 'use_global_beta_pow': self._use_global_beta_pow
+ }
+
+ if isinstance(self._beta1, Variable):
+ inputs['Beta1Tensor'] = self._beta1
+ else:
+ attrs['beta1'] = self._beta1
+ if isinstance(self._beta2, Variable):
+ inputs['Beta2Tensor'] = self._beta2
+ else:
+ attrs['beta2'] = self._beta2
+ if isinstance(self._epsilon, Variable):
+ inputs['EpsilonTensor'] = self._epsilon
+ else:
+ attrs['epsilon'] = self._epsilon
+
+ adam_op = block.append_op(type=self.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+ return adam_op
+
+ def _finish_update(self, block, parameters_and_grads):
+ r"""Update beta1_pow and beta2_pow accumulator
+ """
+ assert isinstance(block, framework.Block)
+ if self._use_global_beta_pow:
+ beta1_pow_acc = self._get_global_accumulator(
+ self._beta1_pow_acc_str)
+ beta2_pow_acc = self._get_global_accumulator(
+ self._beta2_pow_acc_str)
+
+ with block.program._optimized_guard([]):
+ inputs = {"X": beta1_pow_acc}
+ outputs = {"Out": beta1_pow_acc}
+ attrs = {}
+ if isinstance(self._beta1, Variable):
+ inputs["Y"] = self._beta1
+ # use elementwise_mul for better performance
+ block.append_op(type="elementwise_mul",
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+ else:
+ attrs['scale'] = self._beta1
+ block.append_op(type="scale",
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+ inputs = {"X": beta2_pow_acc}
+ outputs = {"Out": beta2_pow_acc}
+ attrs = {}
+ if isinstance(self._beta2, Variable):
+ inputs["Y"] = self._beta2
+ # use elementwise_mul for better performance
+ block.append_op(type="elementwise_mul",
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+ else:
+ attrs['scale'] = self._beta2
+ block.append_op(type="scale",
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs,
+ stop_gradient=True)
+
+
+class AdamaxOptimizer(Optimizer):
+ r"""
+ The Adamax optimizer is implemented based on the Adamax Optimization
+ in Section 7 of `Adam paper `_.
+ The Adamax algorithm is a variant of the Adam algorithm based on the infinite norm,
+ which makes the learning rate update algorithm more stable and simple.
+
+ The parameter ``param_out`` update rule with gradient ``grad``:
+
+ .. math::
+
+ t & = t + 1
+
+ moment\_out & = {\\beta}_1 * moment + (1 - {\\beta}_1) * grad
+
+ inf\_norm\_out & = max({\\beta}_2 * inf\_norm + \epsilon, |grad|)
+
+ learning\_rate & = \\frac{learning\_rate}{1 - {\\beta}_1^t}
+
+ param\_out & = param - learning\_rate * \\frac{moment\_out}{inf\_norm\_out}
+
+ Related paper: `Adam: A Method for Stochastic Optimization `_
+
+ The original paper does not have an ``epsilon`` attribute,
+ it is added here for numerical stability to prevent the division by 0 error.
+
+ Args:
+ learning_rate (float|Variable, optional): The learning rate used to update ``Parameter``.
+ It can be a float value or a ``Variable`` with a float type. The default value is 0.001.
+ beta1 (float, optional): The exponential decay rate for the 1st moment estimates.
+ The default value is 0.9.
+ beta2 (float, optional): The exponential decay rate for the 2nd moment estimates.
+ The default value is 0.999.
+ epsilon (float, optional): A small float value for numerical stability.
+ The default value is 1e-08.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ The default value is None.
+
+ **Notes**:
+ **Currently, AdamaxOptimizer doesn't support sparse parameter optimization.**
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+
+ # First create the Executor.
+ place = fluid.CPUPlace() # fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ data = fluid.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ loss = fluid.layers.mean(hidden)
+ adam = fluid.optimizer.AdamaxOptimizer(learning_rate=0.2)
+ adam.minimize(loss)
+
+ # Run the startup program once and only once.
+ exe.run(startup_program)
+
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ outs = exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+ """
+ _moment_acc_str = "moment"
+ _inf_norm_acc_str = "inf_norm"
+ _beta1_pow_acc_str = "beta1_pow_acc"
+
+ def __init__(self,
+ learning_rate=0.001,
+ beta1=0.9,
+ beta2=0.999,
+ epsilon=1e-8,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ assert learning_rate is not None
+ assert beta1 is not None
+ assert beta2 is not None
+ assert epsilon is not None
+ super(AdamaxOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "adamax"
+ self._beta1 = beta1
+ self._beta2 = beta2
+ self._epsilon = epsilon
+
+ def _create_accumulators(self, block, parameters):
+ # Create accumulator tensors for first moment and infinity norm
+ for p in parameters:
+ self._add_accumulator(self._moment_acc_str, p)
+ self._add_accumulator(self._inf_norm_acc_str, p)
+ self._add_accumulator(name=self._beta1_pow_acc_str,
+ param=p,
+ fill_value=self._beta1,
+ shape=[1])
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ moment = self._get_accumulator(self._moment_acc_str, param_and_grad[0])
+ inf_norm = self._get_accumulator(self._inf_norm_acc_str,
+ param_and_grad[0])
+ beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
+ param_and_grad[0])
+
+ if framework.in_dygraph_mode():
+ _C_ops.adamax_(param_and_grad[0], param_and_grad[1],
+ self._create_param_lr(param_and_grad), moment,
+ inf_norm, beta1_pow_acc, self._beta1, self._beta2,
+ self._epsilon)
+ elif framework._in_legacy_dygraph():
+ _legacy_C_ops.adamax(param_and_grad[0], param_and_grad[1],
+ self._create_param_lr(param_and_grad), moment,
+ inf_norm, beta1_pow_acc, param_and_grad[0],
+ moment, inf_norm, "beta1", self._beta1,
+ "beta2", self._beta2, "epsilon", self._epsilon)
+ else:
+ # create the adamax optimize op
+ adamax_op = block.append_op(
+ type=self.type,
+ inputs={
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "LearningRate": self._create_param_lr(param_and_grad),
+ "Moment": moment,
+ "InfNorm": inf_norm,
+ "Beta1Pow": beta1_pow_acc
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "MomentOut": moment,
+ "InfNormOut": inf_norm
+ },
+ attrs={
+ "beta1": self._beta1,
+ "beta2": self._beta2,
+ "epsilon": self._epsilon
+ },
+ stop_gradient=True)
+
+ return adamax_op
+
+ def _finish_update(self, block, parameters_and_grads):
+ """Update Beta1 Power accumulator
+ """
+ assert isinstance(block, framework.Block)
+ for param, grad in parameters_and_grads:
+ if grad is None or param.trainable is False:
+ continue
+ with param.block.program._optimized_guard([param, grad
+ ]), name_scope('adamx'):
+ beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
+ param)
+ if framework._non_static_mode():
+ if framework.in_dygraph_mode():
+ tmp = _C_ops.scale(beta1_pow_acc, self._beta1, 0.0,
+ True)
+ else:
+ tmp = _legacy_C_ops.scale(beta1_pow_acc, "scale",
+ self._beta1)
+ beta1_pow_acc.copy_(tmp, False)
+ else:
+ block.append_op(type="scale",
+ inputs={"X": beta1_pow_acc},
+ outputs={"Out": beta1_pow_acc},
+ attrs={"scale": self._beta1},
+ stop_gradient=True)
+
+
+class DpsgdOptimizer(Optimizer):
+ r"""
+ We implement the Dpsgd optimizer according to CCS16 paper -
+ Deep Learning with Differential Privacy.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+
+ # First create the Executor.
+ place = fluid.CPUPlace() # fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ data = fluid.layers.data(name='X', shape=[1], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ loss = fluid.layers.mean(hidden)
+ optimizer = fluid.optimizer.Dpsgd(learning_rate=0.01, clip=10.0, batch_size=16.0, sigma=1.0)
+ optimizer.minimize(loss)
+
+ # Run the startup program once and only once.
+ exe.run(startup_program)
+
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ outs = exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+
+ Args:
+ learning_rate (float|Variable): the learning rate used to update parameters. \
+ Can be a float value or a Variable with one float value as data element.
+ clip (float): clipping threshold
+ batch_size (float): batch size.
+ sigma (float): for gaussian noise.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ Notes:
+ Currently, DpsgdOptimizer doesn't support sparse parameter optimization.
+ """
+
+ def __init__(self,
+ learning_rate=0.001,
+ clip=0.9,
+ batch_size=0.999,
+ sigma=1e-8,
+ parameter_list=None):
+ assert learning_rate is not None
+ assert clip is not None
+ assert batch_size is not None
+ assert sigma is not None
+ super(DpsgdOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list)
+ self.type = "dpsgd"
+ self._clip = clip
+ self._batch_size = batch_size
+ self._sigma = sigma
+ '''
+ Note(wangzhongpu):
+ This property is only used for debugging, do not need to set it!
+ Dpsgd operator use time(NULL) as random seed to generate random number.
+ However, during debugging, we need determinated result, so we will set self._seed to a fixed number.
+ '''
+ self._seed = None
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ # create the dpsgd optimize op
+ if self._seed == None:
+ self._seed = 0
+
+ if framework._non_static_mode():
+ _legacy_C_ops.dpsgd(param_and_grad[0], param_and_grad[1],
+ self._create_param_lr(param_and_grad),
+ param_and_grad[0], "clip", self._clip,
+ "batch_size", self._batch_size, "sigma",
+ self._sigma, "seed", self._seed)
+ else:
+ dpsgd_op = block.append_op(type=self.type,
+ inputs={
+ "Param":
+ param_and_grad[0],
+ "Grad":
+ param_and_grad[1],
+ "LearningRate":
+ self._create_param_lr(param_and_grad)
+ },
+ outputs={"ParamOut": param_and_grad[0]},
+ attrs={
+ "clip": self._clip,
+ "batch_size": self._batch_size,
+ "sigma": self._sigma,
+ "seed": self._seed
+ },
+ stop_gradient=True)
+
+ return dpsgd_op
+
+
+class DecayedAdagradOptimizer(Optimizer):
+ r"""
+ The Decayed Adagrad optimizer can be seen as an Adagrad algorithm that introduces
+ the decay rate to solve the problem of a sharp drop in the learning rate
+ during model training when using the AdagradOptimizer.
+
+ The parameter ``param_out`` update rule with gradient ``grad``:
+
+ .. math::
+
+ moment\_out & = decay * moment + (1 - decay) * grad * grad
+
+ param\_out & = param - \\frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}
+
+ Related paper: `Adaptive Subgradient Methods for Online Learning and Stochastic
+ Optimization `_.
+
+ The original paper does not have an ``epsilon`` attribute. It is added here for numerical
+ stability to avoid the division by zero error.
+
+ Args:
+ learning_rate (float|Variable): The learning rate used to update ``Parameter``.
+ It can be a float value or a ``Variable`` with a float type.
+ decay (float, optional): The decay rate. The default value is 0.95.
+ epsilon (float, optional): A small float value for numerical stability.
+ The default value is 1e-06.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ The default value is None.
+
+ **Notes**:
+ **Currently, DecayedAdagradOptimizer doesn't support sparse parameter optimization.**
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ x = fluid.data( name='x', shape=[None, 10], dtype='float32' )
+ trans = fluid.layers.fc( x, 100 )
+ cost = fluid.layers.reduce_mean( trans )
+ optimizer = fluid.optimizer.DecayedAdagradOptimizer(learning_rate=0.2)
+ optimizer.minimize(cost)
+ """
+ _moment_acc_str = "moment"
+
+ def __init__(self,
+ learning_rate,
+ decay=0.95,
+ epsilon=1.0e-6,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ assert learning_rate is not None
+ assert decay is not None
+ assert epsilon is not None
+
+ super(DecayedAdagradOptimizer,
+ self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "decayed_adagrad"
+ self._decay = decay
+ self._epsilon = epsilon
+
+ def _create_accumulators(self, block, parameters):
+ assert isinstance(block, framework.Block)
+
+ for p in parameters:
+ self._add_accumulator(self._moment_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+
+ moment_acc = self._get_accumulator(self._moment_acc_str,
+ param_and_grad[0])
+
+ if framework._non_static_mode():
+ _legacy_C_ops.decayed_adagrad(param_and_grad[0], param_and_grad[1],
+ moment_acc,
+ self._create_param_lr(param_and_grad),
+ param_and_grad[0], moment_acc,
+ "epsilon", self._epsilon, "decay",
+ self._decay)
+ else:
+ # Create the decayed adagrad optimizer op
+ decayed_adagrad_op = block.append_op(
+ type=self.type,
+ inputs={
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "Moment": moment_acc,
+ "LearningRate": self._create_param_lr(param_and_grad)
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "MomentOut": moment_acc
+ },
+ attrs={
+ "epsilon": self._epsilon,
+ "decay": self._decay
+ },
+ stop_gradient=True)
+
+ return decayed_adagrad_op
+
+
+class AdadeltaOptimizer(Optimizer):
+ r"""
+ **Notes: This API does not support sparse parameter optimization.**
+
+ Adadelta Optimizer. Please refer to this for details:
+ `ADADELTA: AN ADAPTIVE LEARNING RATE METHOD `_.
+
+ The update is done as follows:
+
+ .. math::
+
+ E(g_t^2) &= \\rho * E(g_{t-1}^2) + (1-\\rho) * g^2
+
+ learning\_rate &= \sqrt{ ( E(dx_{t-1}^2) + \\epsilon ) / ( E(g_t^2) + \\epsilon ) }
+
+ E(dx_t^2) &= \\rho * E(dx_{t-1}^2) + (1-\\rho) * (-g*learning\_rate)^2
+
+ Args:
+ learning_rate (float|Variable): global learning rate.
+ epsilon (float): a small float number for numeric stability. Default 1.0e-6.
+ rho (float): a floating point value indicating the decay rate. Default 0.95.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): The default value is None. Normally there is no need for user
+ to set this property. For more information, please refer to
+ :ref:`api_guide_Name` .
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ image = fluid.data(name='image', shape=[None, 28], dtype='float32')
+ fc = fluid.layers.fc(image, size=10)
+ cost = fluid.layers.reduce_mean(fc)
+ optimizer = fluid.optimizer.Adadelta(
+ learning_rate=0.0003, epsilon=1.0e-6, rho=0.95)
+
+ # optimizer_ops is a list of optimizer operators to update parameters
+ # params_grads is a list of (param, param_grad), where param is each
+ # parameter and param_grad is the gradient variable of param.
+ optimizer_ops, params_grads = optimizer.minimize(cost)
+ """
+
+ _avg_squared_grad_acc_str = "_avg_squared_grad"
+ _avg_squared_update_acc_str = "_avg_squared_update"
+
+ def __init__(self,
+ learning_rate,
+ epsilon=1.0e-6,
+ rho=0.95,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ if learning_rate is None:
+ raise ValueError("learning_rate is not set.")
+ if epsilon is None:
+ raise ValueError("epsilon is not set.")
+ if rho is None:
+ raise ValueError("rho is not set.")
+ super(AdadeltaOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ self.type = "adadelta"
+ self._epsilon = epsilon
+ self._rho = rho
+
+ def _create_accumulators(self, block, parameters):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ for p in parameters:
+ self._add_accumulator(self._avg_squared_grad_acc_str, p)
+ self._add_accumulator(self._avg_squared_update_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ avg_squared_grad_acc = self._get_accumulator(
+ self._avg_squared_grad_acc_str, param_and_grad[0])
+ avg_squared_update_acc = self._get_accumulator(
+ self._avg_squared_update_acc_str, param_and_grad[0])
+
+ if framework.in_dygraph_mode():
+ _C_ops.adadelta_(param_and_grad[0], param_and_grad[1],
+ avg_squared_grad_acc, avg_squared_update_acc,
+ self._rho, self._epsilon)
+ elif framework._in_legacy_dygraph():
+ _legacy_C_ops.adadelta(param_and_grad[0], param_and_grad[1],
+ avg_squared_grad_acc, avg_squared_update_acc,
+ param_and_grad[0], avg_squared_grad_acc,
+ avg_squared_update_acc, "epsilon",
+ self._epsilon, "rho", self._rho)
+ else:
+ # Create the adadelta optimizer op
+ adadelta_op = block.append_op(type=self.type,
+ inputs={
+ "Param":
+ param_and_grad[0],
+ "Grad":
+ param_and_grad[1],
+ "AvgSquaredGrad":
+ avg_squared_grad_acc,
+ "AvgSquaredUpdate":
+ avg_squared_update_acc
+ },
+ outputs={
+ "ParamOut":
+ param_and_grad[0],
+ "AvgSquaredGradOut":
+ avg_squared_grad_acc,
+ "AvgSquaredUpdateOut":
+ avg_squared_update_acc
+ },
+ attrs={
+ "epsilon": self._epsilon,
+ "rho": self._rho
+ },
+ stop_gradient=True)
+
+ return adadelta_op
+
+
+class RMSPropOptimizer(Optimizer):
+ r"""
+ Root Mean Squared Propagation (RMSProp) is an unpublished, adaptive learning
+ rate method. The original slides proposed RMSProp: Slide 29 of
+ http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf .
+
+ The original equation is as follows:
+
+ .. math::
+
+ r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
+
+ w & = w - \\frac{\\eta} {\\sqrt{r(w,t) + \\epsilon}} \\nabla Q_{i}(w)
+
+ The first equation calculates moving average of the squared gradient for
+ each weight. Then dividing the gradient by :math:`sqrt{v(w,t)}`.
+
+ In some cases, adding a momentum term :math: `\\beta` is beneficial.
+ In our implementation, Nesterov momentum is used:
+
+ .. math::
+
+ r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
+
+ v(w, t) & = \\beta v(w, t-1) + \\frac{\\eta} {\\sqrt{r(w,t) +
+ \\epsilon}} \\nabla Q_{i}(w)
+
+ w & = w - v(w, t)
+
+ if centered is True:
+
+ .. math::
+
+ r(w, t) & = \\rho r(w, t-1) + (1 - \\rho)(\\nabla Q_{i}(w))^2
+
+ g(w, t) & = \\rho g(w, t-1) + (1 - \\rho)\\nabla Q_{i}(w)
+
+ v(w, t) & = \\beta v(w, t-1) + \\frac{\\eta} {\\sqrt{r(w,t) - (g(w, t))^2 +
+ \\epsilon}} \\nabla Q_{i}(w)
+
+ w & = w - v(w, t)
+
+ where, :math:`\\rho` is a hyperparameter and typical values are 0.9, 0.95
+ and so on. :math: `beta` is the momentum term. :math: `\\epsilon` is a
+ smoothing term to avoid division by zero, usually set somewhere in range
+ from 1e-4 to 1e-8.
+
+
+ Parameters:
+ learning_rate(float): Global learning rate.
+ rho(float): rho is :math: `\\rho` in equation, default is 0.95.
+ epsilon(float): :math: `\\epsilon` in equation is smoothing term to
+ avoid division by zero, default is 1e-6.
+ momentum(float): :math:`\\beta` in equation is the momentum term,
+ default is 0.0.
+ centered(bool): If True, gradients are normalized by the estimated variance of
+ the gradient; if False, by the uncentered second moment. Setting this to
+ True may help with training, but is slightly more expensive in terms of
+ computation and memory. Defaults to False.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Raises:
+ ValueError: If learning_rate, rho, epsilon, momentum are None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.layers.data(name='x', shape=[13], dtype='float32')
+ y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ rms_optimizer = fluid.optimizer.RMSProp(learning_rate=0.1)
+ rms_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+
+ """
+
+ _momentum_acc_str = "momentum"
+ _mean_square_acc_str = "mean_square"
+ _mean_grad_acc_str = "mean_grad"
+
+ def __init__(self,
+ learning_rate,
+ rho=0.95,
+ epsilon=1.0e-6,
+ momentum=0.0,
+ centered=False,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ super(RMSPropOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ if learning_rate is None:
+ raise ValueError("learning_rate is not set.")
+ if rho is None:
+ raise ValueError("rho is not set.")
+ if epsilon is None:
+ raise ValueError("epsilon is not set.")
+ if momentum is None:
+ raise ValueError("momentum is not set.")
+
+ self.type = "rmsprop"
+ self._rho = rho
+ self._epsilon = epsilon
+ self._momentum = momentum
+ self._centered = centered
+
+ def _create_accumulators(self, block, parameters):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ for p in parameters:
+ self._add_accumulator(self._momentum_acc_str, p)
+ self._add_accumulator(self._mean_square_acc_str, p)
+ self._add_accumulator(self._mean_grad_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ momentum_acc = self._get_accumulator(self._momentum_acc_str,
+ param_and_grad[0])
+ mean_square_acc = self._get_accumulator(self._mean_square_acc_str,
+ param_and_grad[0])
+ mean_grad_acc = self._get_accumulator(self._mean_grad_acc_str,
+ param_and_grad[0])
+ if in_dygraph_mode():
+ _C_ops.rmsprop_(param_and_grad[0], mean_square_acc,
+ param_and_grad[1], momentum_acc,
+ self._create_param_lr(param_and_grad),
+ mean_grad_acc, self._epsilon, self._rho,
+ self._momentum, self._centered)
+ return None
+ elif _in_legacy_dygraph():
+ _legacy_C_ops.rmsprop(param_and_grad[0], mean_square_acc,
+ self._create_param_lr(param_and_grad),
+ param_and_grad[1], momentum_acc,
+ param_and_grad[0], momentum_acc,
+ mean_square_acc, mean_grad_acc, "epsilon",
+ self._epsilon, "decay", self._rho, "momentum",
+ self._momentum, "centered", self._centered)
+ return None
+ else:
+ rmsprop_op = block.append_op(
+ type=self.type,
+ inputs={
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "Moment": momentum_acc,
+ "MeanSquare": mean_square_acc,
+ "MeanGrad": mean_grad_acc,
+ "LearningRate": self._create_param_lr(param_and_grad),
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "MomentOut": momentum_acc,
+ "MeanSquareOut": mean_square_acc,
+ "MeanGradOut": mean_grad_acc
+ },
+ attrs={
+ "epsilon": self._epsilon,
+ "decay": self._rho,
+ "momentum": self._momentum,
+ "centered": self._centered
+ },
+ stop_gradient=True)
+
+ return rmsprop_op
+
+
+class FtrlOptimizer(Optimizer):
+ r"""
+ FTRL (Follow The Regularized Leader) Optimizer.
+
+ The paper that proposed Follow The Regularized Leader (FTRL):
+ (https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf)
+
+ .. math::
+
+ &new\_accum = squared\_accum + grad^2
+
+ &if (lr\_power == -0.5):
+
+ &\quad linear\_accum += grad - \\frac{\\sqrt{new\_accum} - \\sqrt{squared\_accum}}{learning\_rate * param}
+
+ &else:
+
+ &\quad linear\_accum += grad - \\frac{new\_accum^{-lr\_power} - accum^{-lr\_power}}{learning\_rate * param}
+
+
+ &x = l1 * sign(linear\_accum) - linear\_accum
+
+ &if (lr\_power == -0.5):
+
+ &\quad y = \\frac{\\sqrt{new\_accum}}{learning\_rate} + (2 * l2)
+
+ &\quad pre\_shrink = \\frac{x}{y}
+
+ &\quad param = (abs(linear\_accum) > l1).select(pre\_shrink, 0.0)
+
+ &else:
+
+ &\quad y = \\frac{new\_accum^{-lr\_power}}{learning\_rate} + (2 * l2)
+
+ &\quad pre\_shrink = \\frac{x}{y}
+
+ &\quad param = (abs(linear\_accum) > l1).select(pre\_shrink, 0.0)
+
+ &squared\_accum += grad^2
+
+ Parameters:
+ learning_rate (float|Variable): Global learning rate.
+ l1 (float): L1 regularization strength, default is 0.0.
+ l2 (float): L2 regularization strength, default is 0.0.
+ lr_power (float): Learning Rate Power, default is -0.5.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_fluid_clip_GradientClipByGlobalNorm` , :ref:`api_fluid_clip_GradientClipByNorm` ,
+ :ref:`api_fluid_clip_GradientClipByValue` ). Default None, meaning there is no gradient clipping.
+ name (str, optional): This parameter is used by developers to print debugging information. \
+ For details, please refer to :ref:`api_guide_Name`. Default is None.
+
+ Raises:
+ ValueError: If learning_rate, rho, epsilon, momentum are None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ place = fluid.CPUPlace()
+ main = fluid.Program()
+ with fluid.program_guard(main):
+ x = fluid.layers.data(name='x', shape=[13], dtype='float32')
+ y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_cost = fluid.layers.mean(cost)
+
+ ftrl_optimizer = fluid.optimizer.Ftrl(learning_rate=0.1)
+ ftrl_optimizer.minimize(avg_cost)
+
+ fetch_list = [avg_cost]
+ train_reader = paddle.batch(
+ paddle.dataset.uci_housing.train(), batch_size=1)
+ feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ for data in train_reader():
+ exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
+
+ NOTE:
+ Currently, FtrlOptimizer doesn't support sparse parameter optimization.
+ """
+
+ _squared_acc_str = "squared"
+ _linear_acc_str = "linear"
+
+ def __init__(self,
+ learning_rate,
+ l1=0.0,
+ l2=0.0,
+ lr_power=-0.5,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ name=None):
+ super(FtrlOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ name=name)
+ if learning_rate is None:
+ raise ValueError("learning_rate is not set.")
+
+ self.type = "ftrl"
+ self._l1 = l1
+ self._l2 = l2
+ self._lr_power = lr_power
+
+ def _create_accumulators(self, block, parameters):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ for p in parameters:
+ self._add_accumulator(self._squared_acc_str, p)
+ self._add_accumulator(self._linear_acc_str, p)
+
+ def _append_optimize_op(self, block, param_and_grad):
+ if not isinstance(block, framework.Block):
+ raise TypeError("block is not instance of framework.Block.")
+
+ squared_acc = self._get_accumulator(self._squared_acc_str,
+ param_and_grad[0])
+ linear_acc = self._get_accumulator(self._linear_acc_str,
+ param_and_grad[0])
+ if framework._non_static_mode():
+ _legacy_C_ops.ftrl(param_and_grad[0], squared_acc, linear_acc,
+ param_and_grad[1],
+ self._create_param_lr(param_and_grad),
+ param_and_grad[0], squared_acc, linear_acc, "l1",
+ self._l1, "l2", self._l2, "lr_power",
+ self._lr_power)
+
+ else:
+ ftrl_op = block.append_op(type=self.type,
+ inputs={
+ "Param":
+ param_and_grad[0],
+ "Grad":
+ param_and_grad[1],
+ "SquaredAccumulator":
+ squared_acc,
+ "LinearAccumulator":
+ linear_acc,
+ "LearningRate":
+ self._create_param_lr(param_and_grad),
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "SquaredAccumOut": squared_acc,
+ "LinearAccumOut": linear_acc
+ },
+ attrs={
+ "l1": self._l1,
+ "l2": self._l2,
+ "lr_power": self._lr_power
+ },
+ stop_gradient=True)
+
+ return ftrl_op
+
+
+class LambOptimizer(AdamOptimizer):
+ r"""
+ LAMB (Layer-wise Adaptive Moments optimizer for Batching training) Optimizer.
+
+ LAMB Optimizer is designed to scale up the batch size of training without losing
+ accuracy, which supports adaptive element-wise updating and accurate layer-wise
+ correction. For more information, please refer to `Large Batch Optimization for
+ Deep Learning: Training BERT in 76 minutes `_ .
+
+ The updating of parameters follows:
+
+ .. math::
+
+ m_t &= \\beta_1 m_{t - 1}+ (1 - \\beta_1)g_t
+
+ v_t &= \\beta_2 v_{t - 1} + (1 - \\beta_2)g_t^2
+
+ m_t &= \\frac{m_t}{\\beta_1^t}
+
+ v_t &= \\frac{v_t}{\\beta_2^t}
+
+ r_t &= \\frac{m_t}{\\sqrt{v_t}+\\epsilon}
+
+ w_t &= w_{t-1} -\\eta_t \\frac{\\left \| w_{t-1}\\right \|}{\\left \| r_t + \\lambda w_{t-1}\\right \|} (r_t + \\lambda w_{t-1})
+
+
+ where :math:`m` is the 1st moment, and :math:`v` the 2nd moment, :math:`\\eta` the
+ learning rate, :math:`\\lambda` the LAMB weight decay rate.
+
+ Args:
+ learning_rate (float|Variable, optional): the learning rate used to update parameters. \
+ Can be a float value or a Variable with data type float32. Default 0.001.
+ lamb_weight_decay (float, optional): The LAMB weight decay rate. Default 0.01.
+ beta1 (float, optional): The exponential decay rate for the 1st moment estimates.
+ Default 0.9.
+ beta2 (float, optional): The exponential decay rate for the 2nd moment estimates.
+ Default 0.999.
+ epsilon (float, optional): A small float value for numerical stability. Default 1e-6.
+ parameter_list (Iterable, optional): Iterable of ``Variable`` names to update to minimize ``loss``. \
+ This parameter is required in dygraph mode. \
+ The default value is None in static mode, at this time all parameters will be updated.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ grad_clip (GradientClipBase, optional): Gradient cliping strategy, it's an instance of
+ some derived class of ``GradientClipBase`` . There are three cliping strategies
+ ( :ref:`api_paddle_fluid_clip_ClipGradByGlobalNorm` , :ref:`api_paddle_fluid_clip_ClipGradByNorm` ,
+ :ref:`api_paddle_fluid_clip_ClipGradByValue` ). If you want better convergence, it is recommended
+ to use :ref:`api_paddle_fluid_clip_ClipGradByGlobalNorm` . Default None, meaning there is no gradient clipping.
+ exclude_from_weight_decay_fn (function|None): Exclude a parameter from weight
+ decay when **exclude_from_weight_decay_fn(parameter)** returns true.
+ Default None.
+ name(str|None): For detailed information, please refer to
+ :ref:`api_guide_Name` . Usually name is no need to set and None by default.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ data = fluid.data(name='x', shape=[-1, 5], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ cost = fluid.layers.mean(hidden)
+
+ def exclude_fn(param):
+ return param.name.endswith('.b_0')
+
+ optimizer = fluid.optimizer.Lamb(learning_rate=0.002,
+ exclude_from_weight_decay_fn=exclude_fn)
+ optimizer.minimize(cost)
+ """
+ _moment1_acc_str = "moment1"
+ _moment2_acc_str = "moment2"
+ _beta1_pow_acc_str = "beta1_pow_acc"
+ _beta2_pow_acc_str = "beta2_pow_acc"
+
+ def __init__(self,
+ learning_rate=0.001,
+ lamb_weight_decay=0.01,
+ beta1=0.9,
+ beta2=0.999,
+ epsilon=1e-6,
+ parameter_list=None,
+ regularization=None,
+ grad_clip=None,
+ exclude_from_weight_decay_fn=None,
+ name=None):
+ assert learning_rate is not None
+ assert lamb_weight_decay is not None
+ assert beta1 is not None
+ assert beta2 is not None
+ assert epsilon is not None
+ super(LambOptimizer, self).__init__(learning_rate=learning_rate,
+ parameter_list=parameter_list,
+ regularization=regularization,
+ grad_clip=grad_clip,
+ beta1=beta1,
+ beta2=beta2,
+ epsilon=epsilon,
+ name=name)
+ self.type = "lamb"
+ self._weight_decay = lamb_weight_decay
+ self._exclude_from_weight_decay_fn = exclude_from_weight_decay_fn
+
+ def _append_optimize_op(self, block, param_and_grad):
+ assert isinstance(block, framework.Block)
+ block.program._use_lamb = True
+
+ moment1 = self._get_accumulator(self._moment1_acc_str,
+ param_and_grad[0])
+ moment2 = self._get_accumulator(self._moment2_acc_str,
+ param_and_grad[0])
+ beta1_pow_acc = self._get_accumulator(self._beta1_pow_acc_str,
+ param_and_grad[0])
+ beta2_pow_acc = self._get_accumulator(self._beta2_pow_acc_str,
+ param_and_grad[0])
+
+ if self._exclude_from_weight_decay_fn is not None \
+ and self._exclude_from_weight_decay_fn(param_and_grad[0]):
+ weight_decay = 0.0
+ else:
+ weight_decay = self._weight_decay
+ lr = self._create_param_lr(param_and_grad)
+ master_weight = None
+ if framework._non_static_mode():
+ _legacy_C_ops.lamb(param_and_grad[0], param_and_grad[1], lr,
+ moment1, moment2, beta1_pow_acc, beta2_pow_acc,
+ master_weight, param_and_grad[0], moment1,
+ moment2, beta1_pow_acc, beta2_pow_acc,
+ master_weight, 'beta1', self._beta1, 'beta2',
+ self._beta2, 'epsilon', self._epsilon,
+ 'weight_decay', weight_decay)
+ return None
+
+ # create the lamb optimize op
+ lamb_op = block.append_op(type=self.type,
+ inputs={
+ "Param": param_and_grad[0],
+ "Grad": param_and_grad[1],
+ "LearningRate": lr,
+ "Moment1": moment1,
+ "Moment2": moment2,
+ "Beta1Pow": beta1_pow_acc,
+ "Beta2Pow": beta2_pow_acc
+ },
+ outputs={
+ "ParamOut": param_and_grad[0],
+ "Moment1Out": moment1,
+ "Moment2Out": moment2,
+ "Beta1PowOut": beta1_pow_acc,
+ "Beta2PowOut": beta2_pow_acc
+ },
+ attrs={
+ "beta1": self._beta1,
+ "beta2": self._beta2,
+ "epsilon": self._epsilon,
+ "weight_decay": weight_decay
+ },
+ stop_gradient=True)
+
+ return lamb_op
+
+
+# We short the class name, since users will use the optimizer with the package
+# name. The sample code:
+#
+# import paddle.fluid as fluid
+#
+# sgd = fluid.optimizer.SGD(...)
+#
+# It is no need to add an `Optimizer` as the class suffix
+SGD = SGDOptimizer
+Momentum = MomentumOptimizer
+Adagrad = AdagradOptimizer
+Adam = AdamOptimizer
+Adamax = AdamaxOptimizer
+Dpsgd = DpsgdOptimizer
+DecayedAdagrad = DecayedAdagradOptimizer
+Adadelta = AdadeltaOptimizer
+RMSProp = RMSPropOptimizer
+Ftrl = FtrlOptimizer
+LarsMomentum = LarsMomentumOptimizer
+Lamb = LambOptimizer
+
+
+class ModelAverage(Optimizer):
+ r"""
+ :api_attr: Static Graph
+
+ The ModelAverage optimizer accumulates specific continuous historical parameters
+ during training. The accumulated historical range can be controlled by the passed
+ ``average_window_rate`` argument. The averaged ``Parameter`` are used in the prediction,
+ which usually can improve the accuracy of the prediction.
+
+ Accumulate the average of the ``Parameter`` in the sliding window, the result will be saved
+ in a temporary variable, can be applied to the current model's ``Parameter`` by calling
+ the ``apply()`` method, and the current model ``Parameter`` can be restored by calling
+ the ``restore()`` method.
+
+ The window size for calculating the average is determined by ``average_window_rate``,
+ ``min_average_window``, ``max_average_window`` and the current ``Parameter`` update times (num_updates).
+
+ When the cumulative times (num_accumulates) is greater than the specific window
+ threshold (average_window), the accumulated ``Parameter`` temporary variable is set to 0.0.
+ The following example will help to understand the role of these arguments:
+
+ ::
+
+ if num_accumulates >= min_average_window and num_accumulates >= min(max_average_window, num_updates * average_window_rate):
+ num_accumulates = 0
+
+ In the above conditional judgment statement, ``num_accumulates`` indicates the current
+ accumulated number, which can be abstractly understood as the length of the cumulative window.
+ The length of the window must be at least the length set by the ``min_average_window`` argument,
+ and cannot exceed the length specified by the ``max_average_window`` argument or
+ ``num_updates * average_window_rate``, where ``num_updates`` indicates the current ``Parameter``
+ update times, ``average_window_rate`` is a coefficient that calculates the length of the window.
+
+ Args:
+ average_window_rate (float): The calculate ratio of the window length relative to ``Parameter`` update times.
+ min_average_window (int, optional): the minimum size of average window length. The default value is 10000.
+ max_average_window (int, optional): The maximum size of average window length. The default value is 10000.
+ regularization (WeightDecayRegularizer, optional): The strategy of regularization. There are two method: \
+ :ref:`api_fluid_regularizer_L1Decay` , :ref:`api_fluid_regularizer_L2Decay` . If a parameter has set \
+ regularizer using :ref:`api_fluid_ParamAttr` already, the regularization setting here in optimizer will be \
+ ignored for this parameter. Otherwise, the regularization setting here in optimizer will take effect. \
+ Default None, meaning there is no regularization.
+ name (str, optional): Normally there is no need for user to set this property.
+ For more information, please refer to :ref:`api_guide_Name`.
+ The default value is None.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+
+ # First create the Executor.
+ place = fluid.CPUPlace() # fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ # build net
+ data = fluid.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ loss = fluid.layers.mean(hidden)
+ optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
+ optimizer.minimize(loss)
+
+ # build ModelAverage optimizer
+ model_average = fluid.optimizer.ModelAverage(0.15,
+ min_average_window=10000,
+ max_average_window=12500)
+
+ exe.run(startup_program)
+ for i in range(12500):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ outs = exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+
+ # apply ModelAverage
+ with model_average.apply(exe):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+ """
+
+ def __init__(self,
+ average_window_rate,
+ min_average_window=10000,
+ max_average_window=10000,
+ regularization=None,
+ name=None):
+ if framework._non_static_mode():
+ raise Exception("In dygraph, don't support ModelAverage.")
+ super(ModelAverage, self).__init__(0.0,
+ regularization=regularization,
+ name=name)
+ self.average_window = average_window_rate
+ self.min_average_window = min_average_window
+ self.max_average_window = max_average_window
+
+ self.params_grads = []
+ for param in framework.default_main_program().global_block(
+ ).all_parameters():
+ if param.do_model_average != False:
+ grad = param.block.create_var(
+ name=unique_name.generate_with_ignorable_key(".".join(
+ [param.name, 'tmp'])),
+ dtype=param.dtype,
+ persistable=False,
+ stop_gradient=True)
+ self.params_grads.append((param, grad))
+
+ for param, grad in self.params_grads:
+ if grad is None:
+ continue
+ with param.block.program._optimized_guard(
+ [param, grad]), name_scope('move_average'):
+ self._append_average_accumulate_op(param)
+
+ self.apply_program = Program()
+ block = self.apply_program.global_block()
+ with program_guard(main_program=self.apply_program):
+ for param_grad in self.params_grads:
+ self._add_average_apply_op(block, param_grad)
+
+ self.restore_program = Program()
+ block = self.restore_program.global_block()
+ with program_guard(main_program=self.restore_program):
+ for param_grad in self.params_grads:
+ self._add_average_restore_op(block, param_grad)
+
+ def _add_average_apply_op(self, block, param_grad):
+ param = block._clone_variable(param_grad[0])
+ grad = block._clone_variable(param_grad[1])
+ sum_1 = block._clone_variable(self._get_accumulator('sum_1', param))
+ sum_2 = block._clone_variable(self._get_accumulator('sum_2', param))
+ sum_3 = block._clone_variable(self._get_accumulator('sum_3', param))
+ num_accumulates = block._clone_variable(
+ self._get_accumulator('num_accumulates', param))
+ old_num_accumulates = block._clone_variable(
+ self._get_accumulator('old_num_accumulates', param))
+ num_updates = block._clone_variable(
+ self._get_accumulator('num_updates', param))
+ # backup param value to grad
+ layers.assign(input=param, output=grad)
+ # param = (sum_1 + sum_2 + sum_3) / (num_accumulates + old_num_accumulates)
+ tmp = layers.sum(x=[num_accumulates, old_num_accumulates])
+ sum = layers.sum(x=[sum_1, sum_2, sum_3])
+ tmp = layers.cast(
+ x=tmp, dtype='float32' if self._dtype == None else self._dtype)
+ sum = layers.cast(
+ x=sum, dtype='float32' if self._dtype == None else self._dtype)
+ ops._elementwise_div(x=sum, y=tmp, out=param)
+
+ def _add_average_restore_op(self, block, param_grad):
+ param = block._clone_variable(param_grad[0])
+ grad = block._clone_variable(param_grad[1])
+ layers.assign(input=grad, output=param)
+
+ def _append_average_accumulate_op(self, param):
+ self.helper = LayerHelper("average_accumulate")
+ sum_1 = self._add_accumulator('sum_1', param)
+ sum_2 = self._add_accumulator('sum_2', param)
+ sum_3 = self._add_accumulator('sum_3', param)
+ num_accumulates = self._add_accumulator('num_accumulates',
+ param,
+ dtype='int64',
+ shape=[1])
+ old_num_accumulates = self._add_accumulator('old_num_accumulates',
+ param,
+ dtype='int64',
+ shape=[1])
+ num_updates = self._add_accumulator('num_updates',
+ param,
+ dtype='int64',
+ shape=[1])
+
+ self.helper.append_op(type='average_accumulates',
+ inputs={
+ "param": param,
+ "in_sum_1": sum_1,
+ "in_sum_2": sum_2,
+ "in_sum_3": sum_3,
+ "in_num_accumulates": num_accumulates,
+ "in_old_num_accumulates": old_num_accumulates,
+ "in_num_updates": num_updates
+ },
+ outputs={
+ "out_sum_1": sum_1,
+ "out_sum_2": sum_2,
+ "out_sum_3": sum_3,
+ "out_num_accumulates": num_accumulates,
+ "out_old_num_accumulates":
+ old_num_accumulates,
+ "out_num_updates": num_updates,
+ },
+ attrs={
+ "average_window": self.average_window,
+ "min_average_window": self.min_average_window,
+ "max_average_window": self.max_average_window,
+ },
+ stop_gradient=True)
+
+ @signature_safe_contextmanager
+ def apply(self, executor, need_restore=True):
+ """
+ Apply the average of the cumulative ``Parameter`` to the parameters of the current model.
+
+ Args:
+ executor(fluid.Executor): The current network executor.
+ need_restore(bool): Restore flag variable, if set to True, the network will restore
+ the parameters of the network to the default value, if set to False,
+ it will not be restored. The default value is True.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+
+ # First create the Executor.
+ place = fluid.CPUPlace() # fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ # build net
+ data = fluid.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ loss = fluid.layers.mean(hidden)
+ optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
+ optimizer.minimize(loss)
+
+ # build ModelAverage optimizer
+ model_average = fluid.optimizer.ModelAverage(0.15,
+ min_average_window=10000,
+ max_average_window=12500)
+
+ exe.run(startup_program)
+ for i in range(12500):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ outs = exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+
+ # apply ModelAverage
+ with model_average.apply(exe):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+ """
+ executor.run(self.apply_program)
+ try:
+ yield
+ finally:
+ if need_restore:
+ self.restore(executor)
+
+ def restore(self, executor):
+ """
+ Restore ``Parameter`` values of current model.
+
+ Args:
+ executor(fluid.Executor): The current network executor.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy
+
+ # First create the Executor.
+ place = fluid.CPUPlace() # fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+
+ train_program = fluid.Program()
+ startup_program = fluid.Program()
+ with fluid.program_guard(train_program, startup_program):
+ # build net
+ data = fluid.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = fluid.layers.fc(input=data, size=10)
+ loss = fluid.layers.mean(hidden)
+ optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
+ optimizer.minimize(loss)
+
+ # build ModelAverage optimizer
+ model_average = fluid.optimizer.ModelAverage(0.15,
+ min_average_window=10000,
+ max_average_window=12500)
+
+ exe.run(startup_program)
+ for i in range(12500):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ outs = exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+
+ # apply ModelAverage
+ with model_average.apply(exe, False):
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ exe.run(program=train_program,
+ feed={'X': x},
+ fetch_list=[loss.name])
+
+ # restore Parameters
+ model_average.restore(exe)
+ """
+ executor.run(self.restore_program)
+
+
+class ExponentialMovingAverage(object):
+ r"""
+ :api_attr: Static Graph
+
+ Compute the moving average of parameters with exponential decay.
+ Given a parameter :math:`\\theta`, its exponential moving average (EMA)
+ will be
+
+ .. math::
+
+ \\text{EMA}_0 & = 0
+
+ \\text{EMA}_t & = \\text{decay} * \\text{EMA}_{t-1} + (1 - \\text{decay}) * \\theta_t
+
+ The average results calculated by **update()** method will be saved in
+ temporary variables which are created and maintained by the object, and can
+ be applied to parameters of current model by calling **apply()** method. And
+ the **restore()** method is used to restore the parameters.
+
+ **Bias correction**. All EMAs are initialized to :math:`0` and hence they will be
+ zero biased, which can be corrected by divided by a factor
+ :math:`(1 - \\text{decay}^t)` , i.e., the actual EMAs applied to parameters
+ when calling **apply()** method would be
+
+ .. math::
+
+ \\widehat{\\text{EMA}}_t = \\frac{\\text{EMA}_t}{1 - \\text{decay}^t}
+
+ **Decay rate scheduling**. A large decay rate very close to 1 would result
+ in that the averages move very slowly. And a better strategy is to set a
+ relative smaller decay rate in the very beginning. The argument **thres_steps**
+ allows users to pass a Variable to schedule the decay rate, in this case,
+ the actual decay rate becomes
+
+ .. math::
+
+ \\min(\\text{decay}, \\frac{1 + \\text{thres_steps}}{10 + \\text{thres_steps}})
+
+ Usually **thres_steps** can be the global training steps.
+
+
+ Args:
+ decay (float, optional): The exponential decay rate, usually close to 1, such as 0.999, 0.9999, ... . Default 0.999.
+ thres_steps (Variable|None, optional): If not `None`, schedule the decay rate. Default None.
+ name (str|None, optional): For detailed information, please refer to :ref:`api_guide_Name`. Usually name is no need to set and None by default.
+
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy
+ import paddle
+ import paddle.static as static
+ from paddle.static import ExponentialMovingAverage
+
+ paddle.enable_static()
+
+ data = static.data(name='x', shape=[-1, 5], dtype='float32')
+ hidden = static.nn.fc(x=data, size=10)
+ cost = paddle.mean(hidden)
+
+ test_program = static.default_main_program().clone(for_test=True)
+ optimizer = paddle.optimizer.Adam(learning_rate=0.001)
+ optimizer.minimize(cost)
+
+ ema = ExponentialMovingAverage(0.999)
+ ema.update()
+
+ place = paddle.CPUPlace()
+ exe = static.Executor(place)
+ exe.run(static.default_startup_program())
+
+ for pass_id in range(3):
+ for batch_id in range(6):
+ data = numpy.random.random(size=(10, 5)).astype('float32')
+ exe.run(program=static.default_main_program(),
+ feed={'x': data},
+ fetch_list=[cost.name])
+
+ # usage 1
+ with ema.apply(exe):
+ data = numpy.random.random(size=(10, 5)).astype('float32')
+ exe.run(program=test_program,
+ feed={'x': data},
+ fetch_list=[hidden.name])
+
+ # usage 2
+ with ema.apply(exe, need_restore=False):
+ data = numpy.random.random(size=(10, 5)).astype('float32')
+ exe.run(program=test_program,
+ feed={'x': data},
+ fetch_list=[hidden.name])
+ ema.restore(exe)
+
+ """
+
+ def __init__(self, decay=0.999, thres_steps=None, name=None):
+ if framework._non_static_mode():
+ raise Exception(
+ "In dygraph, don't support ExponentialMovingAverage.")
+ self._decay = decay
+ self._thres_steps = thres_steps
+ self._name = name if name is not None else ''
+ self._decay_var = self._get_ema_decay()
+
+ self._step_counter_name = "@EMA_STEP_COUNTER@"
+ self._params_tmps = []
+ for param in default_main_program().global_block().all_parameters():
+ if param.do_model_average != False:
+ tmp = param.block.create_var(name=unique_name.generate(".".join(
+ [self._name + param.name, 'ema_tmp'])),
+ dtype=param.dtype,
+ persistable=False,
+ stop_gradient=True)
+ self._params_tmps.append((param, tmp))
+
+ self._ema_vars = {}
+ for param, tmp in self._params_tmps:
+ with param.block.program._optimized_guard(
+ [param, tmp]), name_scope('moving_average'):
+ self._ema_vars[param.name] = self._create_ema_vars(param)
+
+ self.apply_program = Program()
+ block = self.apply_program.global_block()
+ with program_guard(main_program=self.apply_program):
+ decay_pow, global_step = self._get_decay_pow(block)
+ for param, tmp in self._params_tmps:
+ param = block._clone_variable(param)
+ tmp = block._clone_variable(tmp)
+ ema = block._clone_variable(self._ema_vars[param.name])
+ layers.assign(input=param, output=tmp)
+ # bias correction
+ with layers.control_flow.Switch() as switch:
+ with switch.case(global_step > 0):
+ layers.assign(output=param,
+ input=ema / (1.0 - decay_pow))
+ with switch.default():
+ layers.assign(output=param, input=ema)
+
+ self.restore_program = Program()
+ block = self.restore_program.global_block()
+ with program_guard(main_program=self.restore_program):
+ for param, tmp in self._params_tmps:
+ tmp = block._clone_variable(tmp)
+ param = block._clone_variable(param)
+ layers.assign(input=tmp, output=param)
+
+ def _get_ema_decay(self):
+ with default_main_program()._lr_schedule_guard():
+ decay_var = layers.tensor.create_global_var(
+ shape=[1],
+ value=self._decay,
+ dtype='float32',
+ persistable=True,
+ name="scheduled_ema_decay_rate")
+
+ if self._thres_steps is not None:
+ decay_t = (self._thres_steps + 1.0) / (self._thres_steps + 10.0)
+ with layers.control_flow.Switch() as switch:
+ with switch.case(decay_t < self._decay):
+ layers.tensor.assign(decay_t, decay_var)
+ with switch.default():
+ layers.tensor.assign(
+ np.array([self._decay], dtype=np.float32),
+ decay_var)
+ return decay_var
+
+ def _get_decay_pow(self, block):
+ global_step = layers.create_global_var(name=self._step_counter_name,
+ shape=[1],
+ value=0,
+ dtype='int64',
+ persistable=True)
+ global_step = layers.cast(global_step, "float32")
+ decay_var = block._clone_variable(self._decay_var)
+ decay_pow_acc = layers.elementwise_pow(decay_var, global_step)
+ return decay_pow_acc, global_step
+
+ def _create_ema_vars(self, param):
+ param_ema = layers.create_global_var(
+ name=unique_name.generate(self._name + param.name + '_ema'),
+ shape=param.shape,
+ value=0.0,
+ dtype=param.dtype,
+ persistable=True)
+
+ return param_ema
+
+ def update(self):
+ """
+ Update Exponential Moving Average. Should only call this method in
+ train program.
+ """
+ global_step = layers.autoincreased_step_counter(
+ counter_name=self._step_counter_name)
+ param_master_emas = []
+ for param, tmp in self._params_tmps:
+ with param.block.program._optimized_guard(
+ [param, tmp]), name_scope('moving_average'):
+ param_ema = self._ema_vars[param.name]
+ if param.name + '.master' in self._ema_vars:
+ master_ema = self._ema_vars[param.name + '.master']
+ param_master_emas.append([param_ema, master_ema])
+ else:
+ ema_t = param_ema * self._decay_var + param * (
+ 1 - self._decay_var)
+ layers.assign(input=ema_t, output=param_ema)
+
+ # for fp16 params
+ for param_ema, master_ema in param_master_emas:
+ default_main_program().global_block().append_op(
+ type="cast",
+ inputs={"X": master_ema},
+ outputs={"Out": param_ema},
+ attrs={
+ "in_dtype": master_ema.dtype,
+ "out_dtype": param_ema.dtype
+ })
+
+ @signature_safe_contextmanager
+ def apply(self, executor, need_restore=True):
+ """
+ Apply moving average to parameters for evaluation.
+
+ Args:
+ executor (Executor): The Executor to execute applying.
+ need_restore (bool, optional): Whether to restore parameters after
+ applying. Default True.
+ """
+ executor.run(self.apply_program)
+ try:
+ yield
+ finally:
+ if need_restore:
+ self.restore(executor)
+
+ def restore(self, executor):
+ """Restore parameters.
+
+ Args:
+ executor (Executor): The Executor to execute restoring.
+ """
+ executor.run(self.restore_program)
+
+
+class PipelineOptimizer(object):
+ """
+ :api_attr: Static Graph
+
+ Pipeline Optimizer: Make a program to run as pipeline, that is splitting a
+ program into multiple sections (sub-programs) and each section run on a
+ device to enable the training of large scale models and the use of
+ heterogeneous devices. Meanwhile, all sections run in the stype of pipeline.
+
+ Args:
+ optimizer (Optimizer): The optimizer to use, such as SGD.
+ num_microbatches (int): Number of microbatches. [Optional. Default:1].
+ start_cpu_core_id (int): The first cpu core id to use. [Optional. Default:0].
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.layers as layers
+
+ with fluid.device_guard("gpu:0"):
+ x = fluid.layers.data(name='x', shape=[1], dtype='int64', lod_level=0)
+ y = fluid.layers.data(name='y', shape=[1], dtype='int64', lod_level=0)
+ data_loader = fluid.io.DataLoader.from_generator(
+ feed_list=[x, y],
+ capacity=64,
+ use_double_buffer=True,
+ iterable=False)
+
+ emb_x = layers.embedding(input=x, param_attr=fluid.ParamAttr(name="embx"), size=[10,2], is_sparse=False)
+ emb_y = layers.embedding(input=y, param_attr=fluid.ParamAttr(name="emby",learning_rate=0.9), size=[10,2], is_sparse=False)
+
+ with fluid.device_guard("gpu:1"):
+ concat = layers.concat([emb_x, emb_y], axis=1)
+ fc = layers.fc(input=concat, name="fc", size=1, num_flatten_dims=1, bias_attr=False)
+ loss = layers.reduce_mean(fc)
+ optimizer = fluid.optimizer.SGD(learning_rate=0.5)
+ optimizer = fluid.optimizer.PipelineOptimizer(optimizer)
+ optimizer.minimize(loss)
+
+ def train_reader():
+ for _ in range(4):
+ x = np.random.random(size=[1]).astype('int64')
+ y = np.random.random(size=[1]).astype('int64')
+ yield x, y
+ data_loader.set_sample_generator(train_reader, batch_size=1)
+
+ place = fluid.CUDAPlace(0)
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ batch_size = 1
+ data_loader.start()
+ exe.train_from_dataset(
+ fluid.default_main_program())
+ data_loader.reset()
+ """
+
+ def __init__(self, optimizer, num_microbatches=1, start_cpu_core_id=0):
+ self._device = 'cpu'
+ if core.is_compiled_with_npu():
+ self._device = "npu"
+ elif core.is_compiled_with_cuda():
+ self._device = "gpu"
+ if framework._non_static_mode():
+ raise Exception("In dygraph, don't support PipelineOptimizer.")
+ valid_optimizers = (Optimizer, paddle.optimizer.Optimizer,
+ paddle.fluid.contrib.mixed_precision.decorator.
+ OptimizerWithMixedPrecision)
+ if not isinstance(optimizer, valid_optimizers):
+ raise ValueError("The 'optimizer' parameter for "
+ "PipelineOptimizer must be an instance of "
+ "{}, but the given type is {}.".format(
+ valid_optimizers, type(optimizer)))
+ self._optimizer = optimizer
+
+ # Get the original optimizer defined by users, such as SGD
+ self._origin_optimizer = self._optimizer
+ while hasattr(self._origin_optimizer, "inner_opt"):
+ self._origin_optimizer = self._origin_optimizer.inner_opt
+
+ assert num_microbatches >= 1, (
+ "num_microbatches must be a positive value.")
+ self._num_microbatches = num_microbatches
+ assert start_cpu_core_id >= 0, (
+ "start_cpu_core_id must be a non-negative integer.")
+ self._start_cpu_core_id = start_cpu_core_id
+ self._place_list = None
+ op_maker = core.op_proto_and_checker_maker
+ self._op_role = op_maker.OpRole
+ self._op_role_key = op_maker.kOpRoleAttrName()
+ self._op_role_var_key = op_maker.kOpRoleVarAttrName()
+ self._op_device_key = op_maker.kOpDeviceAttrName()
+ self._param_device_map = None
+ self._pipeline_pair = []
+ self._pp_ring_map = dict()
+ self.output_var_to_op = None
+ self.input_var_to_op = None
+
+ # insert allreduce op to sync global information for global
+ # gradient clip and amp
+ def _insert_allreduce_op(self, op_idx, block):
+ """
+ Insert allreduce op to sync global information for global
+ gradient clip and amp.
+ """
+ op = block.ops[op_idx]
+ out_name = op.desc.output_arg_names()[0]
+ out_var = block.var(out_name)
+ offset = 0
+ if op.type == "reduce_any":
+ # cast the bool var to int32 to use allreduce_max op
+ temp_var_name = unique_name.generate(out_name + "_cast_int32")
+ temp_var = block.create_var(name=temp_var_name,
+ shape=[1],
+ dtype="int32")
+ block._insert_op(op_idx + 1 + offset,
+ type='cast',
+ inputs={'X': out_var},
+ outputs={'Out': temp_var},
+ attrs={
+ 'in_dtype': out_var.dtype,
+ 'out_dtype': temp_var.dtype,
+ self._op_role_key: self._op_role.Optimize
+ })
+ offset += 1
+ block._insert_op(
+ op_idx + 1 + offset,
+ type='c_allreduce_max'
+ if op.type == "reduce_any" else 'c_allreduce_sum',
+ inputs={'X': temp_var if op.type == "reduce_any" else out_var},
+ outputs={'Out': temp_var if op.type == "reduce_any" else out_var},
+ attrs={
+ 'ring_id': self.global_ring_id,
+ self._op_role_key: self._op_role.Optimize,
+ 'use_calc_stream': True
+ })
+ offset += 1
+ if op.type == "reduce_any":
+ block._insert_op(op_idx + 1 + offset,
+ type='cast',
+ inputs={'X': temp_var},
+ outputs={'Out': out_var},
+ attrs={
+ 'in_dtype': temp_var.dtype,
+ 'out_dtype': out_var.dtype,
+ self._op_role_key: self._op_role.Optimize
+ })
+ offset += 1
+ return offset
+
+ def _create_vars(self, block, ori_block):
+ # Create vars for block, copied from ori_block
+ used_var_set = set()
+ added_op_num = 0
+ op_idx = 0
+ op_size = block.desc.op_size()
+ while op_idx < op_size + added_op_num:
+ # Whether to insert allreduce_sum or allreduce_max op.
+ # For amp and global gradient clip strategies, we should
+ # get the global information, so allreduce op is needed.
+ should_insert = False
+ op = block.ops[op_idx]
+ # For op process vars on all devices, remove its input
+ # vars not in this block
+ reserved_x = []
+ if op.type == 'reduce_any' and self._is_optimize_op(op):
+ should_insert = True
+ elif op.type == 'concat' and self._is_optimize_op(op):
+ for input_name in op.desc.input("X"):
+ if block._find_var_recursive(input_name):
+ reserved_x.append(input_name)
+ op.desc.set_input('X', reserved_x)
+ elif op.type == 'update_loss_scaling':
+ for input_name in op.desc.input("X"):
+ if block._find_var_recursive(input_name):
+ reserved_x.append(input_name)
+ op.desc.set_input('X', reserved_x)
+ op.desc.set_output('Out', reserved_x)
+ elif op.type == 'check_finite_and_unscale':
+ for input_name in op.desc.input("X"):
+ if block._find_var_recursive(input_name):
+ reserved_x.append(input_name)
+ op.desc.set_input('X', reserved_x)
+ op.desc.set_output('Out', reserved_x)
+ if len(reserved_x) == 0:
+ block._remove_op(op_idx)
+ op_size -= 1
+ continue
+ elif op.type == 'sum' and self._is_gradient_clip_op(op):
+ for input_name in op.desc.input("X"):
+ if block._find_var_recursive(input_name):
+ reserved_x.append(input_name)
+ op.desc.set_input('X', reserved_x)
+ should_insert = True
+
+ vars = op.desc.input_arg_names() + op.desc.output_arg_names()
+ for var in vars:
+ # a var whose name contains "blocking_queue"
+ # only exists in startup program
+ if var in used_var_set or "_blocking_queue" in var:
+ continue
+ used_var_set.add(var)
+ if block._find_var_recursive(str(var)): continue
+ source_var = ori_block._var_recursive(str(var))
+ if source_var.type == core.VarDesc.VarType.READER:
+ dest_var = block.create_var(
+ name=var,
+ type=core.VarDesc.VarType.READER,
+ persistable=source_var.persistable)
+ elif isinstance(source_var, Parameter):
+ dest_var = block.create_parameter(
+ name=source_var.name,
+ shape=source_var.shape,
+ dtype=source_var.dtype,
+ type=source_var.type,
+ lod_level=source_var.lod_level,
+ stop_gradient=source_var.stop_gradient,
+ trainable=source_var.trainable,
+ optimize_attr=source_var.optimize_attr,
+ regularizer=source_var.regularizer,
+ error_clip=source_var.error_clip)
+ else:
+ dest_var = block._clone_variable(source_var, False)
+ self._clone_var_attr(dest_var, source_var)
+ # When use with sharding, allreduce_sum and allreduce_max
+ # used for global gradient clip and amp will be added by sharding.
+ op_idx += 1
+ if self.use_sharding or not should_insert: continue
+ inserted_ops = self._insert_allreduce_op(op_idx - 1, block)
+ added_op_num += inserted_ops
+ op_idx += inserted_ops
+ block._sync_with_cpp()
+
+ def _is_loss_grad_op(self, op):
+ assert self._op_role_key in op.attr_names
+ op_role = int(op.attr(self._op_role_key))
+ return op_role & int(self._op_role.Backward) and op_role & int(
+ self._op_role.Loss)
+
+ def _is_forward_op(self, op):
+ return self._op_role_key in op.attr_names and (int(
+ op.attr(self._op_role_key)) == int(self._op_role.Forward))
+
+ def _is_backward_op(self, op):
+ return self._op_role_key in op.attr_names and (
+ int(op.attr(self._op_role_key)) & int(self._op_role.Backward))
+
+ def _is_loss_op(self, op):
+ assert self._op_role_key in op.attr_names
+ return int(op.attr(self._op_role_key)) == int(self._op_role.Loss)
+
+ def _is_optimize_op(self, op):
+ return self._op_role_key in op.attr_names and (
+ int(op.attr(self._op_role_key)) & int(self._op_role.Optimize))
+
+ def _is_update_op(self, op):
+ return 'Param' in op.input_names and 'Grad' in op.input_names and (
+ "LearningRate" in op.input_names)
+
+ def _split_program(self, main_program, devices):
+ """
+ Split a program into sections according to devices that ops run on.
+ The op whose op_device attr is "gpu:all" is copied to all sections.
+
+ Args:
+ main_program (Program): the main program
+ devices: all used devices
+ """
+ # Map from device to its corresponding section program info
+ device_program_map = defaultdict(Program)
+
+ block = main_program.block(0)
+ for op in block.ops:
+ device = op.attr(self._op_device_key)
+ # Copy ops whose op_device set to "gpu:all" to all sections.
+ if device == f"{self._device}:all":
+ for device in devices:
+ program = device_program_map[device]
+ op_desc = op.desc
+ ap_op = program.global_block().desc.append_op()
+ ap_op.copy_from(op_desc)
+ ap_op._set_attr(self._op_device_key, "")
+ else:
+ program = device_program_map[device]
+ op_desc = op.desc
+ ap_op = program.global_block().desc.append_op()
+ ap_op.copy_from(op_desc)
+ ap_op._set_attr(self._op_device_key, "")
+
+ program_list = []
+ for key in devices:
+ program = device_program_map[key]
+ program._sync_with_cpp()
+ program_list.append(program)
+
+ return program_list
+
+ def _get_op_device_for_startup_program(self, var_name):
+ """
+ For adam optimizer, it will add accumulators and initialize them
+ with fill_constant, and force the op device to cpu. Hence, we should
+ get the real op_device attribute of the fill_constant as the device
+ where the corresponding parameters on.
+ """
+ assert "beta1_pow_acc" in var_name or "beta2_pow_acc" in var_name, \
+ 'For accumulators for Adam, the name must contain beta1_pow_acc ' \
+ 'or beta2_pow_acc.'
+ param_name = var_name[0:var_name.index('_beta')]
+ device = self._param_device_map[param_name]
+ return device
+
+ def _split_startup_program(self, startup_program, device_id):
+ block = startup_program.global_block()
+ new_startup_program = Program()
+ for op in block.ops:
+ device = op.attr(self._op_device_key)
+ if device == "cpu":
+ assert op.type == "fill_constant", (
+ "For ops in startup program with the op_device attribute "
+ "of cpu, they must be of type fill_constant.")
+ output_var = op.output_arg_names[0]
+ device = self._get_op_device_for_startup_program(output_var)
+
+ if device:
+ device_index = int(device.split(':')[1])
+ else:
+ # LR related ops
+ device = None
+ if device and device_index != device_id: continue
+ op_desc = op.desc
+ ap_op = new_startup_program.global_block().desc.append_op()
+ ap_op.copy_from(op_desc)
+ ap_op._set_attr(self._op_device_key, "")
+ new_startup_program._sync_with_cpp()
+ self._create_vars(new_startup_program.global_block(), block)
+ return new_startup_program
+
+ def _find_post_op(self, index, var_name):
+ """
+ Find the post op that has variable named var_name as input.
+ """
+ # bugfix for uniform hybrid parallelism
+ if '.cast_fp32' in var_name:
+ var_name = var_name.replace('.cast_fp32', '')
+ if '.cast_fp16' in var_name:
+ var_name = var_name.replace('.cast_fp16', '')
+
+ post_ops = self.input_var_to_op[var_name]
+ if post_ops == None: return None
+ result_op = None
+ for post_op, post_idx in reversed(post_ops):
+ if post_idx > index:
+ result_op = post_op
+ break
+ return result_op
+
+ def _find_prev_op(self, index, var_name):
+ """
+ Find the previous op of op with index that outputs
+ variable named var_name.
+ """
+ prev_ops = self.output_var_to_op[var_name]
+ if prev_ops == None: return None
+ result_op = None
+ for prev_op, prev_idx in reversed(prev_ops):
+ if prev_idx < index:
+ result_op = prev_op
+ break
+ return result_op
+
+ def _rename_arg(self, op, old_name, new_name):
+ op._rename_input(old_name, new_name)
+ op._rename_output(old_name, new_name)
+
+ def _create_var(self, block, ref_var, name, dtype=None):
+ """
+ Create a new var for block, which has the same type,
+ shape and dtype as ref_var, then rename it with the
+ name `name`.
+ """
+ new_var = block.create_var(
+ name=name,
+ shape=ref_var.shape,
+ dtype=ref_var.dtype if dtype is None else dtype,
+ type=ref_var.type,
+ lod_level=ref_var.lod_level,
+ persistable=ref_var.persistable,
+ is_data=ref_var.is_data,
+ need_check_feed=ref_var.desc.need_check_feed())
+ self._clone_var_attr(new_var, ref_var)
+ return new_var
+
+ def _clone_var_attr(self, dest, src):
+ dest.stop_gradient = src.stop_gradient
+ if hasattr(src, 'is_distributed'):
+ dest.is_distributed = src.is_distributed
+
+ def _strip_grad_suffix(self, name):
+ """
+ Strip the grad suffix from the given variable name
+ """
+ pos = name.find(core.grad_var_suffix())
+ return name[:pos] if pos != -1 else name
+
+ def _append_grad_suffix(self, name):
+ """
+ Append grad suffix to the given variable name
+ """
+ return name + core.grad_var_suffix()
+
+ def _get_op_device_attr(self, op):
+ """
+ Get the op_device attribute of a op.
+ """
+ device = op.attr(self._op_device_key) \
+ if op.has_attr(self._op_device_key) else None
+ if device:
+ assert device[0:3] == 'gpu' or device[0:3] == 'npu', "Now, only gpu and npu devices are " \
+ "supported in pipeline parallemism."
+ return device
+
+ def _add_op_device_attr_for_op(self, op, idx, block):
+ """
+ Add op_device attrribute for ops that have not that attribute set.
+ We use "gpu:all" to represent the op should be put on all
+ sub-programs, such as lr-related ops. Note that: "gpu:all"
+ is only used by pipeline as an indicator.
+ """
+ lrsched_role = int(self._op_role.LRSched)
+ if op.attr(self._op_role_key) == lrsched_role:
+ # For LRSched ops, we should put them on all sub-programs to
+ # make sure each sub-program update the lr correctly
+ op._set_attr(self._op_device_key, f"{self._device}:all")
+ # bugfix in hybrid parallelism
+ elif op.type == "sum" and self._is_backward_op(op):
+ # For sum ops that compute the sum of @RENAMED@ vars
+ for name in op.desc.input_arg_names():
+ assert '@RENAME@' in name, \
+ "The op must be sum used to accumulate renamed vars."
+ assert len(op.desc.output_arg_names()) == 1
+ out_name = op.desc.output_arg_names()[0]
+ post_op = self._find_post_op(idx, out_name)
+ assert post_op.has_attr(
+ 'op_device'), "{} has no op_device attr for var {}".format(
+ post_op.type, out_name)
+ device = post_op.attr(self._op_device_key)
+ assert device, "The post op must have op_device set."
+ op._set_attr(self._op_device_key, device)
+ elif (op.type == "cast"
+ or op.type == "scale") and self._is_backward_op(op):
+ prev_op = self._find_prev_op(idx, op.desc.input("X")[0])
+ op._set_attr(self._op_device_key, prev_op.attr(self._op_device_key))
+ elif op.type == "memcpy" and not self._is_optimize_op(op):
+ # for checkpoint offloading
+ assert len(op.input_arg_names) == 1 and len(
+ op.output_arg_names) == 1
+ input_name = op.input_arg_names[0]
+ output_name = op.output_arg_names[0]
+ if '@Fetch' in output_name:
+ post_op = self._find_post_op(idx, output_name)
+ op._set_attr(self._op_device_key,
+ post_op.attr(self._op_device_key))
+ else:
+ prev_op = self._find_prev_op(idx, op.desc.input("X")[0])
+ op._set_attr(self._op_device_key,
+ prev_op.attr(self._op_device_key))
+ elif self._is_loss_op(op):
+ # For loss * loss_scaling op added by AMP
+ offset = 1
+ while (not block.ops[idx + offset].has_attr(self._op_device_key)
+ or not block.ops[idx + offset].attr(self._op_device_key)):
+ offset += 1
+ device = block.ops[idx + offset].attr(self._op_device_key)
+ assert device, "Please put you program within device_guard scope."
+ for i in range(offset):
+ block.ops[idx + i]._set_attr(self._op_device_key, device)
+ elif self._is_optimize_op(op) and op.type == "cast":
+ # For fp16-->fp32 cast added by AMP
+ grad_name = op.output('Out')
+ assert len(grad_name) == 1
+ param_name = self._strip_grad_suffix(grad_name[0])
+ device = self._param_device_map[param_name]
+ op._set_attr(self._op_device_key, device)
+ elif self._is_gradient_clip_op(op) or self._is_regularization_op(op):
+ # For gradient clip and regularization ops, we set their op_device
+ # attribute to the device where their corresponding parameters on.
+ assert self._op_role_var_key in op.attr_names, "gradient_clip " \
+ "and regularization ops must have op_role_var attribute."
+ op_role_var = op.attr(self._op_role_var_key)
+ assert len(op_role_var) == 2, "op_role_var for gradient_clip " \
+ "regularization ops must have two elements."
+ param_name = op_role_var[0]
+ device = self._param_device_map[param_name]
+ # For sum op added by global gradient clip, it must be
+ # put on all devices
+ if (op.type == 'sum' or op.type == 'sqrt'
+ or op.type == 'fill_constant'
+ or op.type == 'elementwise_max'
+ or op.type == 'elementwise_div'):
+ device = f"{self._device}:all"
+ op._set_attr(self._op_device_key, device)
+ elif op.type == "alloc_float_status" or op.type == "clear_float_status":
+ op._set_attr(self._op_device_key, f"{self._device}:all")
+ # NOTE(wangxi): NPU should only clear the float status
+ # once at each batch step
+ op._set_attr(self._op_role_key, self._op_role.LRSched)
+
+ float_status_name = op.output_arg_names[0]
+ float_status_var = block.var(float_status_name)
+ # FIXME(wangxi): pipeline lr schedule will exec on sub_scope(0)
+ # while update will exec on sub_scope(last_micro_step), should
+ # set persistable to use global scope
+ float_status_var.persistable = True
+ else:
+ other_known_ops = [
+ 'update_loss_scaling', 'reduce_any', 'concat', 'sum',
+ 'check_finite_and_unscale', 'memcpy'
+ ]
+ assert op.type in other_known_ops, "For other ops without " \
+ "op_device set, they must be one of {}, but it " \
+ "is {}".format(other_known_ops, op.type)
+ assert self._is_optimize_op(op)
+ op._set_attr(self._op_device_key, f"{self._device}:all")
+
+ def _add_op_device_attr(self, block):
+ """
+ Add op_device attrribute for ops in block that have
+ not that attribute set.
+ """
+ for idx, op in enumerate(list(block.ops)):
+ if (op.type == "create_py_reader" or op.type == "read"
+ or op.type == "create_double_buffer_reader"):
+ # Copy read related ops to all section to make them exit
+ # after each epoch.
+ # We use "gpu:all" to represent the op should be put on all
+ # sub-programs, such as lr-related ops. Note that: "gpu:all"
+ # is only used by pipeline as an indicator.
+ op._set_attr(self._op_device_key, f"{self._device}:all")
+ continue
+ # op_device attribute has been set
+ if self._get_op_device_attr(op): continue
+ self._add_op_device_attr_for_op(op, idx, block)
+
+ def _check_validation(self, block):
+ """
+ Check whether ops in a block have both the op_device and the
+ op_role attributes set.
+ Then, return all devices in order.
+ """
+ device_list = []
+ # Section worker only supports the following op_role
+ valid_op_role_value = [
+ int(self._op_role.LRSched),
+ int(self._op_role.Forward),
+ int(self._op_role.Backward),
+ int(self._op_role.Loss),
+ int(self._op_role.Optimize),
+ int(self._op_role.Backward) | int(self._op_role.Loss),
+ ]
+ for op in block.ops:
+ if not op._has_kernel(op.type):
+ assert op.type == "conditional_block" and (op.attr(
+ self._op_role_key) == int(self._op_role.LRSched)), (
+ "Now, the only supported op without kernel is "
+ "conditional_block, and its op role must be LRSched.")
+ assert op.has_attr(
+ self._op_role_key), ("op ({}) has no {} attribute.".format(
+ op.type, self._op_role_key))
+ op_role = op.attr(self._op_role_key)
+ assert int(op_role) in valid_op_role_value, \
+ "op_role {} for op {} must be one of {}".format(
+ op_role,
+ op.type,
+ valid_op_role_value)
+
+ assert op.has_attr(
+ self._op_device_key), ("op ({}) has no {} attribute.".format(
+ op.type, self._op_device_key))
+
+ device = op.attr(self._op_device_key)
+ assert device, ("op_device attribute for op "
+ "{} has not been set.".format(op.type))
+ if device == f"{self._device}:all": continue
+
+ dev_type = device.split(':')[0]
+ assert dev_type == "gpu" or dev_type == 'npu', (
+ "Now only gpu and npu devices are supported "
+ "for pipeline parallelism.")
+
+ if device not in device_list:
+ device_list.append(device)
+
+ return device_list
+
+ def _insert_sendrecv_ops_for_boundaries(self, block):
+ """
+ Insert a pair of send and recv ops for every two
+ consecutive ops on different devices.
+ """
+ # A map from var to device where op takes it as input,
+ # avoiding multiple send and recv ops.
+ input_var_to_device = dict()
+ # bugfix hybrid parallelism
+ first_optimize_index = None
+ for index, op in enumerate(list(block.ops)):
+ if self._is_optimize_op(op):
+ first_optimize_index = index
+ break
+ extra_index_info = {
+ 'index': 0,
+ 'first_optimize_index': first_optimize_index
+ }
+
+ for index, op in enumerate(list(block.ops)):
+ cur_device = op.attr(self._op_device_key)
+ if cur_device == f"{self._device}:all": continue
+ for var_name in op.input_arg_names:
+ var = block.var(var_name)
+ # skip data var
+ if var.is_data: continue
+ prev_device = None
+
+ prev_op = self._find_prev_op(index, var_name)
+ if prev_op is None:
+ if var_name not in self._param_device_map:
+ continue
+ prev_device = self._param_device_map[var_name]
+
+ if not prev_device:
+ prev_device = prev_op.attr(self._op_device_key) \
+ if prev_op else None
+
+ if prev_device is None or prev_device == f"{self._device}:all":
+ continue
+
+ if prev_device == cur_device: continue
+
+ if var_name not in input_var_to_device:
+ input_var_to_device[var_name] = []
+ if (cur_device, prev_device) in input_var_to_device[var_name]:
+ continue
+
+ device_type = cur_device.split(':')[0] + ':'
+
+ def _check_stage(cur_id, prev_id):
+ # check send/recv stage valid
+ is_forward = self._is_forward_op(op)
+ is_backward = self._is_backward_op(op)
+ assert is_forward or is_backward, \
+ 'send/recv in pipeline should only be inserted in forward or backward,' \
+ 'please check the op_role of op={}'.format(op)
+
+ if is_forward:
+ assert prev_id < cur_id, \
+ "In forward, send/recv can only be passed forward, but now " \
+ "prev_stage={} great than cur_stage={}, please check op_device of op={}".format(
+ prev_id, cur_id, op)
+ elif is_backward:
+ assert prev_id > cur_id, \
+ "In backward, send/recv can only be passed backward, but now " \
+ "prev_stage={} less than cur_stage={}, please check op_device of op={}".format(
+ prev_id, cur_id, op)
+
+ def _insert_send_recv(cur_id, prev_id):
+ cur_dev = device_type + str(cur_id)
+ prev_dev = device_type + str(prev_id)
+ if (cur_dev, prev_dev) in input_var_to_device[var_name]:
+ return
+
+ if cur_id - prev_id > 1:
+ _insert_send_recv(cur_id - 1, prev_id)
+ _insert_send_recv(cur_id, cur_id - 1)
+ input_var_to_device[var_name].append(
+ (cur_dev, prev_dev))
+ return
+ elif cur_id - prev_id < -1:
+ _insert_send_recv(cur_id + 1, prev_id)
+ _insert_send_recv(cur_id, cur_id + 1)
+ input_var_to_device[var_name].append(
+ (cur_dev, prev_dev))
+ return
+
+ assert abs(cur_id - prev_id) == 1
+ input_var_to_device[var_name].append((cur_dev, prev_dev))
+
+ op_role = op.attr(self._op_role_key)
+ var = block.vars[var_name]
+ pair = (prev_id, cur_id)
+ # 1000 is just a magic number
+ pair_key = prev_id * 1000 + cur_id
+ if pair not in self._pipeline_pair:
+ self._pipeline_pair.append(pair)
+ self._pp_ring_map[pair_key] = self.ring_id
+ ring_id = self.ring_id
+ self.ring_id += 1
+ else:
+ ring_id = self._pp_ring_map[pair_key]
+
+ if self.schedule_mode == 'F-then-B': # F-then-B
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='send_v2',
+ inputs={'X': var},
+ attrs={
+ self._op_device_key: prev_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': True,
+ 'peer': 1,
+ 'ring_id': ring_id
+ })
+ extra_index_info['index'] += 1
+ var_shape = list(var.shape)
+ var_shape[0] = self.micro_batch_size if var_shape[
+ 0] < 0 else var_shape[0]
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='recv_v2',
+ outputs={'Out': [var]},
+ attrs={
+ 'out_shape': var_shape,
+ 'dtype': var.dtype,
+ self._op_device_key: cur_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': True,
+ 'peer': 0,
+ 'ring_id': ring_id
+ })
+ extra_index_info['index'] += 1
+ elif self.schedule_mode == '1F1B': # 1F1B
+ var_shape = list(var.shape)
+ var_shape[0] = self.micro_batch_size if var_shape[
+ 0] < 0 else var_shape[0]
+
+ numel = np.prod(var_shape)
+ use_mp = (self.mp_degree > 1) and (numel %
+ self.mp_degree == 0)
+
+ if 'subprog' in var.name:
+ # For recompute, if the checkpoints var is layer_norm_6.tmp_2
+ # this var will be sent twice, layer_norm_6.tmp_2 for forward pass,
+ # layer_norm_6.tmp_2.subprog_* for recompute pass.
+ # We can store the first sent var and copy the value to the
+ # second one to reduce one send/recv op.
+ # The origin_ckpt_name is layer_norm_6.tmp_2, which will be used
+ # to find the stored var for the forward pass.
+ origin_name = var.name.split('subprog')[0][0:-1]
+ associate_var = block.var(origin_name)
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='assign',
+ inputs={'X': [associate_var]},
+ outputs={'Out': [var]},
+ attrs={
+ 'out_shape': var_shape,
+ 'dtype': var.dtype,
+ self._op_device_key: cur_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': True,
+ })
+ extra_index_info['index'] += 1
+ return
+
+ _check_stage(cur_id, prev_id)
+
+ block._insert_op_without_sync(index=index +
+ extra_index_info['index'],
+ type='c_sync_calc_stream',
+ inputs={'X': [var]},
+ outputs={'Out': [var]},
+ attrs={
+ self._op_device_key:
+ prev_dev,
+ self._op_role_key:
+ op_role,
+ })
+ extra_index_info['index'] += 1
+ prefix_name = var.name.split('@')[0]
+ prefix_var = block.var(prefix_name)
+ is_param = True if isinstance(prefix_var,
+ Parameter) else False
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='send_v2'
+ if not use_mp or is_param else 'partial_send',
+ inputs={'X': var},
+ attrs={
+ self._op_device_key: prev_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': False,
+ 'ring_id': ring_id,
+ 'peer': 1,
+ # if send_v2, num&id attr is not in op_attrs, will not insert
+ 'num': self.mp_degree,
+ 'id': self.mp_rank,
+ })
+ extra_index_info['index'] += 1
+ insert_index = None
+ if int(op_role) == int(self._op_role.Backward):
+ insert_index = extra_index_info[
+ 'first_optimize_index']
+ new_op_role = self._op_role.Optimize
+ else:
+ insert_index = index
+ new_op_role = self._op_role.Backward
+ sync_comm_op = block._insert_op_without_sync(
+ index=insert_index + extra_index_info['index'],
+ type='c_sync_comm_stream',
+ inputs={'X': [var]},
+ outputs={'Out': [var]},
+ attrs={
+ self._op_device_key: prev_dev,
+ self._op_role_key: new_op_role,
+ 'ring_id': ring_id,
+ })
+ if int(op_role) == int(self._op_role.Forward):
+ sync_comm_op._set_attr('pipeline_flag', '')
+ extra_index_info['index'] += 1
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='recv_v2'
+ if not use_mp or is_param else 'partial_recv',
+ outputs={'Out': [var]},
+ attrs={
+ 'out_shape': var_shape,
+ 'dtype': var.dtype,
+ self._op_device_key: cur_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': True,
+ 'peer': 0,
+ 'ring_id': ring_id,
+ # if recv_v2, num&id attr is not in op_attrs, will not insert
+ 'num': self.mp_degree,
+ 'id': self.mp_rank,
+ })
+ extra_index_info['index'] += 1
+ if use_mp and not is_param:
+ block._insert_op_without_sync(
+ index=index + extra_index_info['index'],
+ type='partial_allgather',
+ inputs={'X': [var]},
+ outputs={'Out': [var]},
+ attrs={
+ self._op_device_key: cur_dev,
+ self._op_role_key: op_role,
+ 'use_calc_stream': True,
+ 'ring_id': 0,
+ # if recv_v2, num&id attr is not in op_attrs, will not insert
+ 'nranks': self.mp_degree,
+ 'rank': self.mp_rank,
+ })
+ extra_index_info['index'] += 1
+ else:
+ raise ValueError(
+ "Now only 'F-then-B' and '1F1B' are supported."
+ "The given value is {}.".format(self.schedule_mode))
+
+ _insert_send_recv(int(cur_device.split(':')[1]),
+ int(prev_device.split(':')[1]))
+ block._sync_with_cpp()
+
+ def _insert_loss_scale(self, block):
+ """
+ Scale the loss corresponding to number of micro-batches.
+ """
+ if self._num_microbatches == 1: return
+ for index, op in reversed(tuple(enumerate(list(block.ops)))):
+ if self._is_loss_grad_op(op):
+ assert op.type == 'fill_constant', \
+ "loss_grad_op must be fill_constant op, " \
+ "but this op is {}".format(op.type)
+ assert op.has_attr('value')
+ loss_scale = float(op.attr('value'))
+ loss_scale = loss_scale / self._num_microbatches
+ op._set_attr('value', loss_scale)
+ break
+
+ def _rename_gradient_var_name(self, block):
+ for index, op in enumerate(block.ops):
+ if not self._is_optimize_op(op): continue
+ input_names = op.input_arg_names
+ output_names = op.output_arg_names
+ in_out_names = input_names + output_names
+ if op.type == 'cast' or op.type == "c_sync_comm_stream": continue
+ # append "MERGED" to the names of parameter gradients,
+ # and mofify the op_role_var attribute (by rename_arg func).
+ for name in in_out_names:
+ if not core.grad_var_suffix() in name: continue
+ param_name = name.strip(core.grad_var_suffix())
+ new_grad_name = name + "@MERGED"
+ self._rename_arg(op, name, new_grad_name)
+
+ def _accumulate_gradients(self,
+ block,
+ pp_allreduce_in_optimize=False,
+ strategy=None,
+ shard=None):
+ """
+ Create a new merged gradient for each parameter and accumulate the
+ corresponding gradient to it.
+ """
+ fp16_allreduce = strategy.fp16_allreduce if strategy else False
+ if strategy and strategy.fuse_grad_merge:
+ fused_gradient_names = self._accumulate_gradients_with_fuse(
+ block, fp16_allreduce, strategy.fuse_grad_size_in_MB, shard)
+ return fused_gradient_names
+
+ merged_gradient_names = []
+ first_opt_op_idx = None
+
+ merged_suffix = '@MERGED@FP16' if fp16_allreduce else '@MERGED'
+ dtype = paddle.float16 if fp16_allreduce else None
+
+ for index, op in reversed(tuple(enumerate(list(block.ops)))):
+ # remove the cast op of fp16 grad to fp32 grad
+ if self._is_optimize_op(op) and op.type == 'cast':
+ in_name = op.input_arg_names[0]
+ out_name = op.output_arg_names[0]
+ if out_name.strip('@GRAD') in self._param_device_map:
+ assert in_name.replace('.cast_fp16', '') == out_name
+ block._remove_op(index)
+ continue
+
+ if self._is_backward_op(op) and first_opt_op_idx is None:
+ first_opt_op_idx = index + 1
+ # maybe have no optimize
+ # if first_opt_op_idx == len(block.ops): return
+
+ if self._is_backward_op(op) and (self._op_role_var_key
+ in op.attr_names):
+ op_role_var = op.attr(self._op_role_var_key)
+ if len(op_role_var) == 0: continue
+ assert len(op_role_var) % 2 == 0
+ for i in range(0, len(op_role_var), 2):
+ offset = 0
+ param_name = op_role_var[i]
+ if not block.has_var(param_name): continue
+ if '@BroadCast' in param_name: continue
+
+ param_grad_name = param_name + core.grad_var_suffix()
+ merged_param_grad_name = param_grad_name + merged_suffix
+ if not block.has_var(merged_param_grad_name):
+ self._create_var(block, block.vars[param_name],
+ merged_param_grad_name, dtype)
+ assert block.has_var(merged_param_grad_name)
+
+ param_grad_var = block.var(param_grad_name)
+ merged_param_grad_var = block.var(merged_param_grad_name)
+ merged_param_grad_var.persistable = True
+ block._insert_op(
+ index=first_opt_op_idx + offset,
+ type='fill_constant',
+ inputs={},
+ outputs={'Out': [merged_param_grad_var]},
+ attrs={
+ 'shape':
+ merged_param_grad_var.shape,
+ 'dtype':
+ merged_param_grad_var.dtype,
+ 'value':
+ float(0),
+ # a trick to run this op once per mini-batch
+ self._op_role_key:
+ self._op_role.Optimize.LRSched,
+ })
+ offset += 1
+ grad_name = op_role_var[i + 1]
+ grad_var = block.vars[grad_name]
+
+ is_fp16_grad = 'cast_fp16' in grad_name
+ need_cast = (is_fp16_grad is not fp16_allreduce)
+
+ if need_cast:
+ # if fp16_allreduce:
+ # cast grad to fp16 to accumulate to merged gradient
+ # else:
+ # cast grad to fp32 to accumulate to merged gradient
+ cast_grad_var_name = param_grad_name + '@TMP'
+ cast_grad_var = self._create_var(
+ block, param_grad_var, cast_grad_var_name, dtype)
+ cast_grad_var.persistable = False
+ block._insert_op(index=first_opt_op_idx + offset,
+ type='cast',
+ inputs={'X': grad_var},
+ outputs={'Out': cast_grad_var},
+ attrs={
+ 'in_dtype':
+ grad_var.dtype,
+ 'out_dtype':
+ cast_grad_var.dtype,
+ self._op_role_key:
+ self._op_role.Backward,
+ })
+ offset += 1
+ grad_var = cast_grad_var
+
+ block._insert_op(
+ index=first_opt_op_idx + offset,
+ type='sum',
+ inputs={'X': [merged_param_grad_var, grad_var]},
+ outputs={'Out': merged_param_grad_var},
+ attrs={
+ self._op_role_key: self._op_role.Backward,
+ })
+ offset += 1
+ merged_gradient_names.append(merged_param_grad_name)
+
+ if not fp16_allreduce: return merged_gradient_names
+
+ first_opt_op_idx = None
+ for index, op in reversed(tuple(enumerate(list(block.ops)))):
+ if self._is_backward_op(op) and first_opt_op_idx is None:
+ first_opt_op_idx = index + 1
+ break
+ assert first_opt_op_idx is not None
+
+ # insert cast op from fp16->fp32
+ # FIXME(wangxi): maybe put in sharding is better, for some grad
+ # is not in sharding device.
+ for fp16_grad_name in merged_gradient_names:
+ grad_name = fp16_grad_name.replace('@FP16', '')
+ param_name = fp16_grad_name.replace('@GRAD@MERGED@FP16', '')
+
+ if not block.has_var(grad_name):
+ self._create_var(block, block.vars[param_name], grad_name)
+ assert block.has_var(grad_name)
+
+ fp16_grad_var = block.var(fp16_grad_name)
+ grad_var = block.var(grad_name)
+ grad_var.persistable = False
+
+ block._insert_op(index=first_opt_op_idx,
+ type='cast',
+ inputs={'X': fp16_grad_var},
+ outputs={'Out': grad_var},
+ attrs={
+ 'in_dtype': fp16_grad_var.dtype,
+ 'out_dtype': grad_var.dtype,
+ self._op_role_key: self._op_role.Optimize,
+ })
+
+ return merged_gradient_names
+
+ def _insert_accumulate_gradients_with_fuse(self, main_block, fp16,
+ fused_size, grad_param_pairs,
+ first_opt_op_idx):
+ grad_param_pairs = self._sort_grad_param_by_dtype(
+ main_block, grad_param_pairs)
+
+ grad_param_segments = []
+ merged_suffix = '@MERGED@FP16' if fp16 else '@MERGED'
+ dtype = paddle.float16 if fp16 else paddle.float32
+ cur_size = 0.
+ last_dtype = None
+ # split the grad based on dtype and fused size
+ for grad, param in grad_param_pairs:
+ real_grad = main_block.var(grad)
+ # create the gradient merged var for each grad
+ merged_grad_var = main_block.create_var(
+ name=param + core.grad_var_suffix() + merged_suffix,
+ dtype=dtype,
+ shape=real_grad.shape,
+ persistable=True,
+ stop_gradient=False)
+ real_param = main_block.var(param)
+ if hasattr(real_param, 'is_distributed'):
+ merged_grad_var.is_distributed = real_param.is_distributed
+ tmp_size = self._get_var_size(real_grad)
+ # two strategies for splitting the grad
+ # 1. the current segment's size reach the user defined grad_size_in_MB
+ # 2. the upcoming grad holds different dtype compared with grads in current segment
+ if len(grad_param_segments) == 0 \
+ or cur_size + tmp_size > fused_size \
+ or real_grad.dtype != last_dtype:
+ grad_param_segments.append(
+ ([real_grad], [real_param], [merged_grad_var]))
+ last_dtype = real_grad.dtype
+ cur_size = 0.
+ else:
+ grad_param_segments[-1][0].append(real_grad)
+ grad_param_segments[-1][1].append(real_param)
+ grad_param_segments[-1][2].append(merged_grad_var)
+ cur_size += tmp_size
+
+ fused_gradients = []
+ fused_merged_gradients = []
+ # create fused vars for grad and param
+ for grad_param_segment in grad_param_segments:
+ grad_segment = grad_param_segment[0]
+ merged_grad_segment = grad_param_segment[2]
+ fused_grad = main_block.create_var(name='FusedGrad_{}'.format(
+ grad_segment[0].name),
+ dtype=grad_segment[0].dtype,
+ persistable=False,
+ stop_gradient=False)
+ # keep the '.cast_fp16' info in the fuse var name
+ fused_merged_grad_name_prefix = 'FusedMergedGrad.cast_fp16.' if \
+ merged_grad_segment[0].dtype == paddle.float16 else 'FusedMergedGrad'
+ fused_merged_grad_name = fused_merged_grad_name_prefix + '_{}'.format(
+ merged_grad_segment[0].name)
+ fused_merged_grad = main_block.create_var(
+ name=fused_merged_grad_name,
+ dtype=merged_grad_segment[0].dtype,
+ persistable=True,
+ stop_gradient=False)
+ fused_gradients.append(fused_grad)
+ fused_merged_gradients.append(fused_merged_grad)
+
+ assert len(fused_gradients) == len(grad_param_segments)
+ assert len(fused_merged_gradients) == len(grad_param_segments)
+
+ # insert coalesce op at the start of the backward pass
+ # use param as the coalesce input to make sure the two Fused vars are in same shape
+ first_back_op_idx = None
+ for index, op in enumerate(main_block.ops):
+ if self._is_backward_op(op) and first_back_op_idx is None:
+ first_back_op_idx = index
+ break
+ assert first_back_op_idx is not None
+ offset = 0
+ for i in range(len(grad_param_segments)):
+ fused_grad = fused_gradients[i]
+ fused_merged_grad = fused_merged_gradients[i]
+ grads = grad_param_segments[i][0]
+ params = grad_param_segments[i][1]
+ merged_grads = grad_param_segments[i][2]
+ main_block._insert_op_without_sync(
+ first_back_op_idx + offset,
+ type="coalesce_tensor",
+ inputs={"Input": params},
+ outputs={
+ "Output": grads,
+ "FusedOutput": fused_grad
+ },
+ attrs={
+ # Explanation of user_defined_size_of_dtype:
+ # In coalesce op, the align size is 256 bytes
+ # the float takes 4 bytes while fp16 takes 2 bytes.
+ # To meet the requirement, 128 fp16 or 64 float will be aligned
+ # Think the total shape of the input tensors if [64],
+ # if the dtype is float, then the shape of the fuse var is [64]
+ # however if the dytpe if fp16, the shape of the fuse var is [128],
+ # which will cause the fused vars' shape vary between each other.
+ # To make sure the shape of the fused vars are identical,
+ # we set the dtype of float and fp16 both to 2.
+ # Under this way, the fused vars' shape for float and fp16 are all [128]
+ "user_defined_size_of_dtype": 2,
+ "copy_data": False,
+ "use_align": True,
+ "dtype": grads[0].dtype,
+ self._op_role_key: self._op_role.Backward,
+ # On npu, the nan/inf check login is different with gpu.
+ # If there are some not initialized sections in the fused var,
+ # and the value in those sections are nan/inf, it will trigger the nan/inf check.
+ # To avoid these problematic triggers, set constant is needed for npu
+ "set_constant": core.is_compiled_with_npu(),
+ "constant": float(0.0),
+ })
+ offset += 1
+ # For the gradient_merged_fused_var, given a init value during the coalesce op
+ # this will remove a problematic fill_constant op. This op role of this coalesce
+ # is set to be LRSched to make this coalesce (with init) only run once
+ main_block._insert_op_without_sync(
+ first_back_op_idx + offset,
+ type="coalesce_tensor",
+ inputs={"Input": params},
+ outputs={
+ "Output": merged_grads,
+ "FusedOutput": fused_merged_grad
+ },
+ attrs={
+ "user_defined_size_of_dtype": 2,
+ "set_constant": True,
+ "constant": float(0.0),
+ "copy_data": False,
+ "use_align": True,
+ "dtype": merged_grads[0].dtype,
+ self._op_role_key: self._op_role.Optimize.LRSched
+ })
+ offset += 1
+
+ # insert gradient merge relating ops
+ first_opt_op_idx += offset
+ offset = 0
+ for i in range(len(fused_gradients)):
+ fused_grad = fused_gradients[i]
+ fused_merged_grad = fused_merged_gradients[i]
+ is_fp16_grad = 'cast_fp16' in fused_grad.name
+ need_cast = (is_fp16_grad is not fp16)
+ if need_cast:
+ # for fp16 allreduce, cast fp32 grad to fp16
+ # for fp32 allreduce, cast fp16 grad to fp32
+ cast_grad_var_name = fused_grad.name + '@TMP'
+ cast_grad_var = main_block.create_var(name=cast_grad_var_name,
+ dtype=dtype,
+ persistable=False,
+ stop_gradient=False)
+ main_block._insert_op(index=first_opt_op_idx + offset,
+ type='cast',
+ inputs={'X': fused_grad},
+ outputs={'Out': cast_grad_var},
+ attrs={
+ 'in_dtype': fused_grad.dtype,
+ 'out_dtype': cast_grad_var.dtype,
+ self._op_role_key:
+ self._op_role.Backward,
+ })
+ offset += 1
+ fused_grad = cast_grad_var
+ main_block._insert_op(
+ index=first_opt_op_idx + offset,
+ type='sum',
+ inputs={'X': [fused_merged_grad, fused_grad]},
+ outputs={'Out': fused_merged_grad},
+ attrs={self._op_role_key: self._op_role.Backward})
+ offset += 1
+
+ if fp16:
+ # if using fp16 allreduce, the optimizer needs fp32 grads, cast them back to fp32
+ for grad, param in grad_param_pairs:
+ real_grad = main_block.var(grad)
+ fp16_grad_name = param + core.grad_var_suffix() + '@MERGED@FP16'
+ assert main_block.has_var(fp16_grad_name)
+ fp16_grad = main_block.var(fp16_grad_name)
+ fp32_grad_name = param + core.grad_var_suffix() + '@MERGED'
+ fp32_grad = main_block.create_var(name=fp32_grad_name,
+ dtype=paddle.float32,
+ shape=real_grad.shape,
+ persistable=False,
+ stop_gradient=False)
+ main_block._insert_op(index=first_opt_op_idx + offset,
+ type='cast',
+ inputs={'X': fp16_grad},
+ outputs={'Out': fp32_grad},
+ attrs={
+ 'in_dtype': paddle.float16,
+ 'out_dtype': paddle.float32,
+ self._op_role_key:
+ self._op_role.Optimize,
+ })
+ offset += 1
+
+ # replace the var with it's name, which will be used for inserting allreduce
+ for i in range(len(fused_merged_gradients)):
+ fused_merged_gradients[i] = fused_merged_gradients[i].name
+
+ return fused_merged_gradients, first_opt_op_idx
+
+ def _accumulate_gradients_with_fuse(self,
+ main_block,
+ fp16,
+ fused_size,
+ shard=None):
+ first_opt_op_idx = None
+ grad_param_pairs = []
+ # obtain all param/grad pairs that needed to be fused
+ for index, op in reversed(tuple(enumerate(list(main_block.ops)))):
+ # remove the cast op of fp16 grad to fp32 grad
+ if self._is_optimize_op(op) and op.type == 'cast':
+ in_name = op.input_arg_names[0]
+ out_name = op.output_arg_names[0]
+ if out_name.strip('@GRAD') in self._param_device_map:
+ assert in_name.replace('.cast_fp16', '') == out_name
+ main_block._remove_op(index)
+ continue
+
+ if self._is_backward_op(op) and first_opt_op_idx is None:
+ first_opt_op_idx = index + 1
+ # no optimize phase
+ if first_opt_op_idx == len(main_block.ops):
+ return
+
+ if self._is_backward_op(op) and (self._op_role_var_key
+ in op.attr_names):
+ op_role_var = op.attr(self._op_role_var_key)
+ if len(op_role_var) == 0:
+ continue
+ assert len(op_role_var) % 2 == 0
+ for i in range(0, len(op_role_var), 2):
+ param_name = op_role_var[i]
+ if not main_block.has_var(param_name):
+ continue
+ if '@BroadCast' in param_name:
+ continue
+ grad_param_pairs.append(
+ (op_role_var[i + 1], op_role_var[i]))
+
+ if len(grad_param_pairs) == 0:
+ return
+
+ nranks = shard.worker_num if shard else 1
+ device_to_pairs = [[] for _ in range(nranks)]
+ for pair in grad_param_pairs:
+ root_id = shard.device(pair[1]) if shard else 0
+ assert 0 <= root_id < nranks
+ device_to_pairs[root_id].append(pair)
+
+ all_fused_merged_gradients = []
+ for pairs in device_to_pairs:
+ fused_merged_gradients, first_opt_op_idx = \
+ self._insert_accumulate_gradients_with_fuse(
+ main_block, fp16, fused_size, pairs, first_opt_op_idx)
+ all_fused_merged_gradients += fused_merged_gradients
+
+ main_block._sync_with_cpp()
+ return all_fused_merged_gradients
+
+ def _sort_grad_param_by_dtype(self, main_block, grad_param_pairs):
+ # sort the grad param paris by the dtype
+ fp16_pairs = []
+ fp32_pairs = []
+ other_pairs = []
+ for pairs in grad_param_pairs:
+ dtype = main_block.var(pairs[0]).dtype
+ if dtype == paddle.float32:
+ fp32_pairs.append(pairs)
+ elif dtype == paddle.float16:
+ fp16_pairs.append(pairs)
+ else:
+ other_pairs.append(pairs)
+ sorted_pairs = fp16_pairs
+ sorted_pairs.extend(fp32_pairs)
+ sorted_pairs.extend(other_pairs)
+ return sorted_pairs
+
+ def _get_var_size(self, var):
+ dtype_to_size = {
+ core.VarDesc.VarType.FP16: 2,
+ core.VarDesc.VarType.FP32: 4,
+ core.VarDesc.VarType.FP64: 8,
+ core.VarDesc.VarType.INT16: 2,
+ core.VarDesc.VarType.INT32: 4,
+ core.VarDesc.VarType.INT64: 8,
+ core.VarDesc.VarType.BOOL: 1,
+ core.VarDesc.VarType.UINT8: 1,
+ }
+ assert -1 not in var.shape
+ return reduce(lambda x, y: x * y,
+ var.shape) * dtype_to_size[var.dtype] / 1024.0 / 1024.0
+
+ def _add_sub_blocks(self, main_block, program_list):
+ main_program = main_block.program
+ for prog in program_list:
+ for op in prog.block(0).ops:
+ if not op.has_attr('sub_block'):
+ continue
+ origin_sub_block_id = op.attr('sub_block').id
+ origin_sub_block = main_program.block(origin_sub_block_id)
+ new_sub_block = prog._create_block(parent_idx=0)
+ for sub_op in origin_sub_block.ops:
+ op_desc = sub_op.desc
+ ap_op = new_sub_block.desc.append_op()
+ ap_op.copy_from(op_desc)
+ new_sub_block._sync_with_cpp()
+ self._create_vars(new_sub_block, origin_sub_block)
+ op._set_attr('sub_block', new_sub_block)
+
+ def _get_device_info(self, block):
+ for op in block.ops:
+ if not op._has_kernel(op.type): continue
+ op_device = op.attr(self._op_device_key)
+ return op_device
+
+ def _process_persistable_vars_in_multi_sections(self, main_program,
+ startup_prog, program_list):
+ """
+ Special Case: process persistable vars that exist in
+ multiple sections, e.g., shared weight
+ """
+ # var_info = {var_name: [program1, program2...]},
+ # persistable var only
+ var_info = dict()
+ for prog in program_list:
+ block = prog.block(0)
+ for var_name in block.vars:
+ if var_name == "double_buffer_0": continue
+ var = block.var(var_name)
+ if not var.persistable: continue
+ if not var_name in var_info:
+ var_info[var_name] = []
+ if not prog in var_info[var_name]:
+ var_info[var_name].append(prog)
+ for var_name in list(var_info.keys()):
+ if len(var_info[var_name]) == 1:
+ var_info.pop(var_name)
+
+ # write_info = {var_name: program}, where program is the only program
+ # in which the var named var_name is written.
+ write_info = dict()
+ for var_name in var_info.keys():
+ for prog in var_info[var_name]:
+ block = prog.block(0)
+ for op in block.ops:
+ if op.type == "recv_v2" or op.type == "create_py_reader" or \
+ op.type == "read" or op.type == "update_loss_scaling":
+ continue
+ # We have processed lr related vars
+ if op.attr(self._op_role_key) == int(
+ self._op_role.Optimize.LRSched):
+ continue
+ if var_name in op.desc.output_arg_names():
+ assert var_name not in write_info, (
+ "two sections write the same var({}): second "
+ "op {}.".format(var_name, op))
+ write_info[var_name] = prog
+ break
+
+ for var_name in var_info.keys():
+ # Case 1: read only variables, no special process
+ if not var_name in write_info: continue
+
+ # Case 2: one write multiple reads
+ write_prog = write_info[var_name]
+ write_block = write_prog.block(0)
+ write_device = self._get_device_info(write_block)
+ write_dev_index = int(write_device.split(':')[1])
+ all_progs = var_info[var_name]
+ for prog in all_progs:
+ if prog == write_prog: continue
+ read_block = prog.block(0)
+ read_device = self._get_device_info(read_block)
+ read_dev_index = int(read_device.split(':')[1])
+ pair = (write_dev_index, read_dev_index)
+ pair_key = write_dev_index * 1000 + read_dev_index
+ if pair not in self._pipeline_pair:
+ self._pipeline_pair.append(pair)
+ self._pp_ring_map[pair_key] = self.ring_id
+ ring_id = self.ring_id
+ self.ring_id += 1
+ else:
+ ring_id = self._pp_ring_map[pair_key]
+
+ write_block._insert_op(
+ index=0,
+ type='send_v2',
+ inputs={
+ 'X': write_block.var(var_name),
+ },
+ attrs={
+ self._op_device_key:
+ write_device,
+ 'use_calc_stream':
+ False,
+ # A trick to make the role LRSched to avoid copy every
+ # microbatch
+ self._op_role_key:
+ self._op_role.LRSched,
+ 'peer':
+ read_dev_index,
+ 'ring_id':
+ ring_id
+ })
+ read_block._insert_op(
+ index=0,
+ type='recv_v2',
+ outputs={'Out': [read_block.var(var_name)]},
+ attrs={
+ 'out_shape':
+ read_block.var(var_name).shape,
+ 'dtype':
+ read_block.var(var_name).dtype,
+ self._op_device_key:
+ read_device,
+ 'use_calc_stream':
+ False,
+ # A trick to make the role LRSched to avoid copy every
+ # microbatch
+ self._op_role_key:
+ self._op_role.LRSched,
+ 'peer':
+ write_dev_index,
+ 'ring_id':
+ ring_id
+ })
+ read_block._insert_op(
+ index=1,
+ type='c_sync_comm_stream',
+ inputs={'X': [read_block.var(var_name)]},
+ outputs={'Out': [read_block.var(var_name)]},
+ attrs={
+ self._op_device_key:
+ read_device,
+ # A trick to make the role LRSched to avoid copy every
+ # microbatch
+ self._op_role_key:
+ self._op_role.LRSched,
+ 'ring_id':
+ ring_id
+ })
+
+ def _is_gradient_clip_op(self, op):
+ return op.desc.has_attr("op_namescope") \
+ and op.desc.attr("op_namescope").startswith("/gradient_clip")
+
+ def _is_regularization_op(self, op):
+ return op.desc.has_attr("op_namescope") \
+ and op.desc.attr("op_namescope").startswith("/regularization")
+
+ def _is_weight_decay_op(self, op):
+ # in AdamW namescope is /optimizer_*/weight decay/
+ return op.desc.has_attr("op_namescope") \
+ and 'weight decay' in op.desc.attr("op_namescope")
+
+ def _get_input_output_info(self, block):
+ '''
+ Get info of op input and output.
+ '''
+ # A map from output var to op which generate it.
+ output_var_to_op = defaultdict(list)
+ # A map from var to op which takes it as input.
+ input_var_to_op = defaultdict(list)
+
+ for index, op in enumerate(block.ops):
+ for var_name in op.input_arg_names:
+ input_var_to_op[var_name].append([op, index])
+ for var_name in op.output_arg_names:
+ output_var_to_op[var_name].append([op, index])
+
+ return output_var_to_op, input_var_to_op
+
+ def _optimize_forward_send_sync(self, program):
+ """
+ optimize forward send's sync_comm_stream schedule
+ """
+ if self.schedule_mode != '1F1B': return
+
+ block = program.block(0)
+
+ recv_type = 'recv_v2' if self.mp_degree == 1 else 'partial_recv'
+ backward_recv_index = None
+ for index, op in enumerate(block.ops):
+ if op.type == recv_type and self._is_backward_op(op):
+ backward_recv_index = index
+ break
+
+ # last pipeline stage
+ if backward_recv_index is None: return
+
+ offset = 0
+ for index, op in enumerate(list(block.ops)):
+ if index >= backward_recv_index: break
+ if op.type == 'c_sync_comm_stream' and op.has_attr('pipeline_flag'):
+ var_name = op.input_arg_names[0]
+ var = block.var(var_name)
+ block._remove_op(index + offset, sync=False)
+ offset -= 1
+ # NOTE:
+ # 1. When the backward recv is completed, it indicates
+ # that the forward send is completed too. So we only need
+ # to use the NOP op to prevent memory release.
+ # 2. Because we removed sync_comm_op,
+ # we will insert NOP after recv_op.
+ block._insert_op_without_sync(
+ index=backward_recv_index,
+ type='nop',
+ inputs={'X': [var]},
+ outputs={'Out': [var]},
+ attrs={self._op_role_key: self._op_role.Backward})
+ block._sync_with_cpp()
+
+ def _mv_head_recv(self, program):
+ """
+ A pass to move the recv op to the beginning of
+ the forward/backward phase
+ """
+ forward_insert_index = 0
+ backward_insert_index = None
+ block = program.global_block()
+ num_ops = len(program.global_block().ops)
+ for i in range(num_ops):
+ insert_index = None
+ op = program.global_block().ops[i]
+ op_role = int(op.attr(self._op_role_key))
+ if op_role == int(
+ self._op_role.Backward) and backward_insert_index is None:
+ backward_insert_index = i
+ if op.type != "partial_recv" and op.type != "partial_allgather" and op.type != "nop" and op.type != "recv_v2":
+ continue
+ if op_role == int(self._op_role.Forward):
+ if i == forward_insert_index:
+ forward_insert_index += 1
+ continue
+ insert_index = forward_insert_index
+ elif op_role == int(self._op_role.Backward):
+ if i == backward_insert_index:
+ backward_insert_index += 1
+ continue
+ insert_index = backward_insert_index
+ else:
+ raise ValueError("Unknown op_role: {}".format(op_role))
+ op_inputs = dict()
+ for name in op.input_names:
+ op_inputs[name] = op.input(name)
+ op_outputs = dict()
+ for name in op.output_names:
+ op_outputs[name] = op.output(name)
+ block._insert_op_without_sync(index=insert_index,
+ type=op.type,
+ inputs=op_inputs,
+ outputs=op_outputs,
+ attrs=op.all_attrs())
+ block._remove_op(i + 1)
+ if op_role == int(self._op_role.Forward):
+ forward_insert_index += 1
+ elif op_role == int(self._op_role.Backward):
+ backward_insert_index += 1
+ block._sync_with_cpp()
+
+ def _check_pipeline_persist_var(self, program):
+ """
+ Pipeline may need multiple forward before
+ """
+ block = program.global_block()
+
+ persist_output = set()
+ used_in_backward = set()
+ for op in block.ops:
+ if self._is_forward_op(op):
+ for var_name in op.output_arg_names:
+ var = block.vars[var_name]
+ if var.persistable:
+ persist_output.add(var_name)
+ elif self._is_backward_op(op):
+ for var_name in op.input_arg_names:
+ if var_name in persist_output:
+ used_in_backward.add(var_name)
+ if len(used_in_backward) == 0:
+ return
+ warnings.warn(
+ "The pipeline requires multiple forward calculations before backward, "
+ "so when the persistable var is changed in the forward, it may cause "
+ "errors in the backward calculation who using this persistable var. "
+ "However, some backward op don't need this var(NoNeedBufferVars), "
+ "there will be no error at this time.\n"
+ "So please check these persistable vars which changed in "
+ "forward and used in backward:\n{}".format(used_in_backward))
+
+ def minimize(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ main_block = loss.block
+ self.origin_main_block = main_block
+ main_program = main_block.program
+ if startup_program is None:
+ startup_program = default_startup_program()
+
+ pipeline_opt = main_program._pipeline_opt
+ assert pipeline_opt, 'Please use pipeline with fleet.'
+ required_keys = [
+ 'local_rank',
+ 'schedule_mode',
+ 'micro_batch_size',
+ 'ring_id',
+ 'global_ring_id',
+ 'use_sharding',
+ 'mp_degree',
+ 'mp_rank',
+ ]
+ for key in required_keys:
+ assert key in pipeline_opt, \
+ 'Please use pipeline with fleet to use {}.'.format(key)
+ self.local_rank = pipeline_opt['local_rank']
+ self.schedule_mode = pipeline_opt['schedule_mode']
+ self.micro_batch_size = pipeline_opt['micro_batch_size']
+ self.use_sharding = pipeline_opt['use_sharding']
+ self.ring_id = pipeline_opt['ring_id']
+ self.global_ring_id = pipeline_opt['global_ring_id']
+ self.mp_degree = pipeline_opt['mp_degree']
+ self.mp_rank = pipeline_opt['mp_rank']
+ self.scale_gradient = pipeline_opt.get('scale_gradient', False)
+ assert self.mp_degree >= 1
+ assert 0 <= self.mp_rank < self.mp_degree
+
+ optimize_ops, params_grads = self._optimizer.minimize(
+ loss, startup_program, parameter_list, no_grad_set)
+ self._param_device_map = self._origin_optimizer._param_device_map
+
+ self.output_var_to_op, self.input_var_to_op = \
+ self._get_input_output_info(main_block)
+ # Step1: add default op_device attribute for ops.
+ self._add_op_device_attr(main_block)
+ device_list = self._check_validation(main_block)
+
+ def device_cmp(device1, device2):
+ dev1_id = int(device1.split(':')[1])
+ dev2_id = int(device2.split(':')[1])
+ if dev1_id < dev2_id:
+ return -1
+ elif dev1_id > dev2_id:
+ return 1
+ else:
+ return 0
+
+ sorted_device_list = sorted(device_list, key=cmp_to_key(device_cmp))
+ assert sorted_device_list == device_list, (
+ "With pipeline parallelism, you must use gpu devices one after "
+ "another in the order of their ids.")
+ # Step2: add send and recv ops between section boundaries
+ self._insert_sendrecv_ops_for_boundaries(main_block)
+
+ # Step3: split program into sections and add pairs of
+ # send and recv ops for data var.
+ main_program = main_block.program
+ program_list = self._split_program(main_program, device_list)
+ for p in program_list:
+ self._create_vars(p.global_block(), main_block)
+
+ if os.getenv("PADDLE_MANUAL_PIPELINE_STAGE", None):
+ self.local_rank = int(os.getenv("PADDLE_MANUAL_PIPELINE_STAGE"))
+ assert self.local_rank < len(device_list), (
+ "Manually specified "
+ "pipeline stage must be less than total number of pipeline "
+ "stages.")
+ else:
+ self.local_rank %= len(device_list)
+ # Step3.5: optimize forward send sync_comm to overlap send and recv
+ self._optimize_forward_send_sync(program_list[self.local_rank])
+
+ # Step4: Special Case: process persistable vars that exist in
+ # multiple sections
+ # FIXME
+ # self._process_persistable_vars_in_multi_sections(
+ # main_program, startup_program, program_list)
+
+ # Step5: Add sub blocks for section programs
+ self._add_sub_blocks(main_block, program_list)
+
+ place_list = []
+ for dev in device_list:
+ dev_index = int(dev.split(":")[1])
+ if core.is_compiled_with_cuda():
+ place_list.append(core.CUDAPlace(dev_index % 1))
+ elif core.is_compiled_with_npu():
+ place_list.append(core.NPUPlace(dev_index % 1))
+
+ # Step6: Split startup program
+ new_startup_program = self._split_startup_program(
+ startup_program, self.local_rank)
+
+ startup_program._pipeline_opt = {
+ "startup_program": new_startup_program,
+ }
+ real_block = program_list[self.local_rank].global_block()
+ if not self.scale_gradient:
+ self._insert_loss_scale(real_block)
+ if not self.use_sharding:
+ # Step7: clear gradients before each mini-batch and
+ # accumulate gradients during backward
+ self._rename_gradient_var_name(real_block)
+ real_block._sync_with_cpp()
+ self._accumulate_gradients(real_block)
+ real_block._sync_with_cpp()
+
+ if core.is_compiled_with_cuda():
+ place_id = int(os.getenv("FLAGS_selected_gpus", "0"))
+ elif core.is_compiled_with_npu():
+ place_id = int(os.getenv("FLAGS_selected_npus", "0"))
+ # A pass to move the recv op to the beginning of
+ # the forward/backward phase
+ self._mv_head_recv(program_list[self.local_rank])
+
+ # A pass to check pipeline persist var which changed in
+ # forward and used in backward
+ self._check_pipeline_persist_var(program_list[self.local_rank])
+
+ main_program._pipeline_opt = {
+ "trainer": "PipelineTrainer",
+ "device_worker": "Section",
+ "pipeline_stage": self.local_rank,
+ "num_pipeline_stages": len(device_list),
+ "schedule_mode": self.schedule_mode,
+ "inner_parallelism": len(device_list),
+ "section_program": program_list[self.local_rank],
+ "place": place_list[self.local_rank],
+ "place_id": place_id,
+ "sync_steps": -1,
+ "num_microbatches": self._num_microbatches,
+ "start_cpu_core_id": self._start_cpu_core_id,
+ }
+ return optimize_ops, params_grads, program_list, self._pipeline_pair, self._pp_ring_map
+
+
+class RecomputeOptimizer(Optimizer):
+ """
+ :api_attr: Static Graph
+
+ Recompute Optimizer Wrapper
+
+ Normally, a training step contains three sub-steps: first, run forward
+ Operators to calculate the loss; second, run backward Operators to
+ calculate gradient of the parameters; third, apply optimization method
+ to update the value of the parameters.
+
+ In the forward computation process, all variables that are needed by
+ backward computation process will be kept in memory, which occupy a great
+ amount of memory when the network becomes very deep.
+
+ Recompute split the network to k segments. In each segment, It will
+ recompute the forward Operators, before running backward operators. It is
+ very helpful for saving memory.
+
+ The Variables that separate a network to segments are called as checkpoints,
+ and users should set it manually. The usage is very simple:
+
+ Args:
+ optimizer (Optimizer): The optimizer that is applied to parameters.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+ def gen_data():
+ return {"x": np.random.random(size=(32, 32)).astype('float32'),
+ "y": np.random.randint(2, size=(32, 1)).astype('int64')}
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ print(input_x)
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.RecomputeOptimizer(sgd)
+ sgd._set_checkpoints([fc_1, pred])
+ sgd.minimize(cost)
+
+ print("Finished optimize")
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+ step = 10
+
+ for i in range(step):
+ cost_val = exe.run(feed=gen_data(),
+ program=fluid.default_main_program(),
+ fetch_list=[cost.name])
+ print("step=%d cost=%f" % (i, cost_val[0]))
+
+ """
+
+ def __init__(self, optimizer):
+ if framework._non_static_mode():
+ raise Exception("In dygraph, don't support RecomputeOptimizer.")
+ self._optimizer = optimizer
+ self._checkpoints = None
+ self._learning_rate = self._optimizer._learning_rate
+ self._learning_rate_map = self._optimizer._learning_rate_map
+ self.enable_offload = False
+
+ def _set_checkpoints(self, checkpoints):
+ """
+ Args:
+ checkpoints (list): List of Variable or string
+ """
+ assert isinstance(
+ checkpoints, list
+ ), "_checkpoints should be a list of Variable or a list of String"
+ for ckpt in checkpoints:
+ assert (
+ isinstance(ckpt, six.string_types)
+ or isinstance(ckpt, Variable)
+ ), "_checkpoints should be a list of Variable or a list of String"
+ self._checkpoints = checkpoints
+
+ # should enable offload before calling backward
+ def _enable_offload(self):
+ self.enable_offload = True
+
+ @framework.deprecate_stat_dict
+ def load(self, state_dict):
+ """
+ :api_attr: Static Graph
+
+ load function is not supported by Recompute Optimizer for now.
+ :return: None
+
+ Args:
+ state_dict: the dict load by load_persistable method
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.compat as cpt
+
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+ print("Finished FF")
+
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.RecomputeOptimizer(sgd)
+ sgd._set_checkpoints([fc_1, pred])
+ try:
+ state_dict = {}
+ sgd.load(state_dict)
+ except NotImplementedError as e:
+ print(cpt.get_exception_message(e))
+ """
+ raise NotImplementedError(
+ "load function is not supported by Recompute Optimizer for now")
+
+ def apply_gradients(self, params_grads):
+ """
+ call apply_gradients function of self._optimizer.
+
+ Args:
+ params_grads (list): list of (param, grad) pair to do optimization.
+
+ Returns:
+ list: A list of operators appended to the current program.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.framework as framework
+
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+
+
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+ print("Finished FF")
+
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.RecomputeOptimizer(sgd)
+ sgd._set_checkpoints([fc_1, pred])
+ params_grads = sgd.backward(
+ cost,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None)
+
+ program = cost.block.program
+ with framework.program_guard(program, None):
+ optimize_ops = sgd.apply_gradients(params_grads)
+
+ print("Finished apply gradients")
+ """
+
+ return self._optimizer.apply_gradients(params_grads=params_grads)
+
+ def _creat_vars(self, varname):
+ pinned_var_name = unique_name.generate(varname + "@Pinned")
+ fetched_var_name = unique_name.generate(varname + "@Fetch")
+
+ pinned_var = self._main_program.global_block().create_var(
+ name=pinned_var_name,
+ shape=self.checkpoint_shape,
+ dtype=self._main_program.global_block().var(varname).dtype,
+ persistable=False,
+ stop_gradient=True)
+
+ fetch_var = self._main_program.global_block().create_var(
+ name=fetched_var_name,
+ shape=self.checkpoint_shape,
+ dtype=self._main_program.global_block().var(varname).dtype,
+ persistable=False,
+ stop_gradient=False)
+
+ return pinned_var_name, fetched_var_name
+
+ def _append_fill_constant_ops(self, startup_program):
+ """
+ add fill_constant_ops to the end of the prog
+
+ we should fill the pinned vars before runing the main_prog
+ to instantiate their tensor hold_, which could tell us whether
+ the host memory could hold all the checkpoints from all the
+ GPU devices in this node.
+ """
+ op_role = 0
+ block = startup_program.global_block()
+ fill_constant_vars = self.checkpoint_name2pinned_name.values()
+ OP_ROLE_KEY = core.op_proto_and_checker_maker.kOpRoleAttrName()
+ for varname in fill_constant_vars:
+ var = self._main_program.global_block().var(varname)
+ # NOTE (JZ-LIANG) to pre-allocate the CUDAPinned MEM
+ pinned_var = block.create_var(
+ name=varname,
+ shape=self.checkpoint_shape,
+ dtype=self._main_program.global_block().var(var.name).dtype,
+ persistable=False,
+ stop_gradient=True)
+ block.append_op(type='fill_constant',
+ outputs={'Out': varname},
+ attrs={
+ "shape": var.shape,
+ "dtype": var.dtype,
+ "value": 0.0,
+ "place_type": 2,
+ OP_ROLE_KEY: op_role,
+ })
+
+ return
+
+ def _insert_async_memcpy_op(self, insert_idx, src_varname, dst_varname,
+ op_role, dst_place_type):
+ OP_ROLE_KEY = core.op_proto_and_checker_maker.kOpRoleAttrName()
+ self.block._insert_op_without_sync(
+ insert_idx,
+ type='memcpy',
+ inputs={'X': [self._main_program.global_block().var(src_varname)]},
+ outputs={
+ 'Out': [self._main_program.global_block().var(dst_varname)]
+ },
+ attrs={
+ "dst_place_type": int(dst_place_type),
+ OP_ROLE_KEY: op_role
+ })
+
+ def _insert_fetch_op(self, idx, varname):
+ assert varname in self.checkpoint_name2pinned_name, "Try to fetch {} from Pinned Memory, but it is NOT a checkpoint".format(
+ varname)
+
+ pinned_varname = self.checkpoint_name2pinned_name[varname]
+ fetch_varname = self.checkpoint_name2fetch_name[varname]
+ self._insert_async_memcpy_op(idx, pinned_varname, fetch_varname, 1, 1)
+
+ def _insert_offload_op(self, idx, varname):
+ assert varname in self.checkpoint_name2pinned_name, "Try to offload {} to Pinned Memory, but it is NOT a checkpoint".format(
+ varname)
+ pinned_varname = self.checkpoint_name2pinned_name[varname]
+ self._insert_async_memcpy_op(idx, varname, pinned_varname, 0, 2)
+
+ def _insert_sync_op(self, op_idx, checkpoint_name):
+ # single stream offload no need sync
+ pass
+
+ def _record_fetch_op(self, idx):
+ assert len(self.un_fetch_checkpoint_names
+ ) > 0, "Could NOT found checkpoint to fetch"
+ checkpoint_name = self.un_fetch_checkpoint_names.pop(-1)
+ logging.debug("Record fetch [{}]".format(checkpoint_name))
+ self.idx2insertions[idx] = ("fetch", checkpoint_name)
+
+ return checkpoint_name
+
+ def _record_offload_op(self, idx, checkpoint_name):
+ expected_checkpoint_name = self.un_offload_checkpoint_names.pop(0)
+ assert checkpoint_name == expected_checkpoint_name, "expected to offload [{}] but got [{}]".format(
+ expected_checkpoint_name, checkpoint_name)
+ logging.debug("Record offload [{}]".format(checkpoint_name))
+ self.idx2insertions[idx] = ("offload", checkpoint_name)
+
+ def _record_sync_op(self, idx, checkpoint_name):
+ assert checkpoint_name not in self.synced_checkpoints, "Try to sync the checkpoint [{}] twice".format(
+ checkpoint_name)
+ self.synced_checkpoints.add(checkpoint_name)
+ logging.debug("Record offload sync [{}]".format(checkpoint_name))
+ self.idx2insertions[idx] = ("sync", checkpoint_name)
+
+ def _parse_backward(self):
+
+ self.idx2insertions = {}
+ # don't offload the last checkpoints, to favor throughput
+ self.un_fetch_checkpoint_names = self.sorted_checkpoint_names[:]
+ self.un_fetch_checkpoint_names.pop(-1)
+ need_fetch_checkpoint_names = self.un_fetch_checkpoint_names[:]
+ self.checkpoint_usage_count = {}
+ for checkpoint_name in self.un_fetch_checkpoint_names:
+ self.checkpoint_usage_count[checkpoint_name] = 0
+
+ self.bw_strart_op_idx = len(self.block.ops)
+ for idx, op in enumerate(self.block.ops):
+ if int(op.desc.attr("op_role")) == 1:
+ self.bw_strart_op_idx = idx
+ break
+
+ assert self.bw_strart_op_idx < len(
+ self.block.ops), "Could NOT found backword op in prog"
+
+ # fetch second to last checkpoint at the beginning of BW
+ fetched_checkpoint_varname = self._record_fetch_op(
+ self.bw_strart_op_idx)
+ last_last_fetch_checkpoint = None
+
+ for i, op in enumerate(self.block.ops[self.bw_strart_op_idx:]):
+ idx = self.bw_strart_op_idx + i
+ input_vars = op.desc.input_arg_names()
+
+ for input_var in input_vars:
+ if input_var in need_fetch_checkpoint_names:
+ if input_var not in self.un_fetch_checkpoint_names:
+ # fetch the offloade checkpoint when the first usage of its previous one
+ if self.checkpoint_usage_count[input_var] == 0:
+ # TODO (JZ-LIANG) sync memcpy_stream if extra stream for memcpy
+ second_to_last_fetch_checkpoint = fetched_checkpoint_varname
+ # there is NO fetch ahead the first checkpoint
+ if input_var != self.sorted_checkpoint_names[0]:
+ fetched_checkpoint_varname = self._record_fetch_op(
+ idx)
+
+ # should check the current used checkpoint is ths last fetch one
+ assert second_to_last_fetch_checkpoint == input_var, "Current recompute segment should use [{}] BUT got [{}]".format(
+ second_to_last_fetch_checkpoint, input_var)
+ # rename
+ self.block.ops[idx]._rename_input(
+ input_var,
+ self.checkpoint_name2fetch_name[input_var])
+ self.checkpoint_usage_count[input_var] += 1
+ else:
+ raise ValueError(
+ "use checkpoint [{}] before fetch in BW".format(
+ input_var))
+
+ assert len(self.un_fetch_checkpoint_names
+ ) == 0, "{} checkpoints have NOT been Recorded".format(
+ self.un_fetch_checkpoint_names)
+
+ def _update_backward(self):
+ if len(self.idx2insertions) == 0:
+ return
+ total_op = len(self.block.ops)
+ for op_idx in reversed(range(self.bw_strart_op_idx, total_op)):
+ if op_idx in self.idx2insertions:
+ operation, checkpoint_name = self.idx2insertions[op_idx]
+ if operation == "fetch":
+ self._insert_fetch_op(op_idx, checkpoint_name)
+ logging.debug(
+ "Insert [{}] fetch op.".format(checkpoint_name))
+ del self.idx2insertions[op_idx]
+ elif operation == "sync":
+ self._insert_sync_op(op_idx, checkpoint_name)
+ logging.debug("Sync [{}] fetch op.".format(checkpoint_name))
+ self.block._sync_with_cpp()
+ assert len(
+ self.idx2insertions) == 0, "{} checkpoints left un-Fecthed".format(
+ [ele[1] for ele in self.idx2insertions.values()])
+
+ def _parse_forward(self):
+
+ self.idx2insertions = {}
+ # don't offload the last checkpoints, faster, less memory saving
+ self.un_offload_checkpoint_names = self.sorted_checkpoint_names[:]
+ last_checkpoint = self.un_offload_checkpoint_names.pop(-1)
+ need_offload_checkpoint_names = self.un_offload_checkpoint_names[:]
+ self.checkpoint_usage_count_and_idx = {}
+ for checkpoint_name in self.un_offload_checkpoint_names:
+ self.checkpoint_usage_count_and_idx[checkpoint_name] = {
+ 'count': 0,
+ 'idx': -1
+ }
+ self.synced_checkpoints = set()
+ self.fw_strart_op_idx = len(self.block.ops)
+ for idx, op in enumerate(self.block.ops):
+ if int(op.desc.attr("op_role")) == 0:
+ self.fw_strart_op_idx = idx
+ break
+
+ assert self.fw_strart_op_idx < len(
+ self.block.ops), "Could NOT found Forward op in prog"
+ last_offload_checkpoint = None
+
+ for i, op in enumerate(
+ self.block.ops[self.fw_strart_op_idx:self.bw_strart_op_idx]):
+
+ idx = self.fw_strart_op_idx + i
+ output_vars = op.desc.output_arg_names()
+ input_vars = op.desc.input_arg_names()
+
+ for output_var in output_vars:
+ if output_var in need_offload_checkpoint_names:
+ assert len(
+ output_vars
+ ) == 1, "chekpoint should be the only Output of a certain op, but [{}] is from [{}]".format(
+ output_var, op)
+
+ if output_var in self.un_offload_checkpoint_names:
+ # insert sync op if last checkpoint has not been sync
+ if last_offload_checkpoint != None:
+ if self.checkpoint_usage_count_and_idx[
+ last_offload_checkpoint]['count'] == 0:
+ self._record_sync_op(idx,
+ last_offload_checkpoint)
+ else:
+ last_usage_idx = self.checkpoint_usage_count_and_idx[
+ last_offload_checkpoint]['idx']
+ assert last_usage_idx > 0, "last_usage_idx of checkpoint [{}] should large than 0".format(
+ last_offload_checkpoint)
+ self._record_sync_op(last_usage_idx + 1,
+ last_offload_checkpoint)
+ # insert offload op after the checkpoint's generation op
+ self._record_offload_op(idx + 1, output_var)
+ last_offload_checkpoint = output_var
+ else:
+ raise ValueError(
+ "There should be just ONE op that output checkpoint [{}]"
+ .format(output_var))
+ # need to sync the last need to offload checkpoint before the last checkpoint as output op
+ if output_var == last_checkpoint:
+ assert len(
+ output_vars
+ ) == 1, "chekpoint should be the only Output of a certain op, but [{}] is from [{}]".format(
+ output_var, op)
+ assert last_offload_checkpoint == self.sorted_checkpoint_names[
+ -2], "the last offload chekpoint before [{}] is suppose to be [{}], but got [{}]".format(
+ last_checkpoint, self.sorted_checkpoint_names[-2],
+ last_offload_checkpoint)
+ # sync if last checkpoint has not been sync
+ if self.checkpoint_usage_count_and_idx[
+ last_offload_checkpoint]['idx'] == 0:
+ self._record_sync_op(idx, last_offload_checkpoint)
+ else:
+ last_usage_idx = self.checkpoint_usage_count_and_idx[
+ last_offload_checkpoint]['idx']
+ assert last_usage_idx > 0, "last_usage_idx of checkpoint [{}] should large than 0".format(
+ last_offload_checkpoint)
+ self._record_sync_op(last_usage_idx + 1,
+ last_offload_checkpoint)
+ # record checkpoint usage
+ for input_var in input_vars:
+ if input_var in need_offload_checkpoint_names:
+ assert input_var not in self.synced_checkpoints, "checkpoint [{}] used after sync".format(
+ input_var)
+ self.checkpoint_usage_count_and_idx[input_var]['count'] += 1
+ self.checkpoint_usage_count_and_idx[input_var]['idx'] = idx
+
+ assert len(self.un_offload_checkpoint_names
+ ) == 0, "{} checkpoints have NOT been Recorded".format(
+ self.un_fetch_checkpoint_names)
+ assert len(self.synced_checkpoints) == len(
+ need_offload_checkpoint_names
+ ), "{} checkpoints have NOT been Recorded".format(
+ set(need_offload_checkpoint_names) - set(self.synced_checkpoints))
+
+ def _update_forward(self):
+ if len(self.idx2insertions) == 0:
+ return
+ for op_idx in reversed(
+ range(self.fw_strart_op_idx, self.bw_strart_op_idx)):
+ if op_idx in self.idx2insertions:
+ operation, checkpoint_name = self.idx2insertions[op_idx]
+ if operation == "offload":
+ self._insert_offload_op(op_idx, checkpoint_name)
+ logging.debug(
+ "Insert [{}] offload op.".format(checkpoint_name))
+ del self.idx2insertions[op_idx]
+ elif operation == "sync":
+ self._insert_sync_op(op_idx, checkpoint_name)
+ logging.debug(
+ "Insert [{}] offload_sync op.".format(checkpoint_name))
+ del self.idx2insertions[op_idx]
+
+ self.block._sync_with_cpp()
+ assert len(self.idx2insertions
+ ) == 0, "{} checkpoints left un-Offloaded".format(
+ [ele[1] for ele in self.idx2insertions.values()])
+
+ def _check_offload_fetch(self):
+ # TODO(JZ-LIANG) the single stream offload need no sync
+ pass
+
+ def _offload(self, loss, startup_program=None):
+ """
+ core steps for recompute offload
+ 1. create pinned vars and temp vars
+ 2. parse & update Forward pass: offload, sync
+ 3. parse & update Backward pass: rename, fetch, sync
+ 4. verify the correctness
+ """
+ self._main_program = loss.block.program
+ self.block = loss.block
+ if startup_program == None:
+ startup_program = paddle.static.default_startup_program()
+
+ with program_guard(self._main_program, startup_program):
+ assert len(self.checkpoint_shape) > 0, (
+ "checkpoints shape {} should be an non empty list like: [12, 512, 1024]"
+ .format(self.checkpoint_shape))
+ assert all([ele > 0 for ele in self.checkpoint_shape]), (
+ "all ele in checkpoints shape {} should be a determined integer larger than 0"
+ .format(self.checkpoint_shape))
+ self.checkpoint_name2pinned_name = dict()
+ self.checkpoint_name2fetch_name = dict()
+ for checkpoint_varname in self.sorted_checkpoint_names:
+ pinned_var_name, fetch_var_name = self._creat_vars(
+ checkpoint_varname)
+ self.checkpoint_name2pinned_name[
+ checkpoint_varname] = pinned_var_name
+ self.checkpoint_name2fetch_name[
+ checkpoint_varname] = fetch_var_name
+ self._append_fill_constant_ops(startup_program)
+ # TODO (JZ-LIANG) to provide two offload stragtegy in future
+ # step 2. parse & update FW: rename, offload, sync
+ self._parse_backward()
+ self._update_backward()
+ # step 3. parse & update BW: rename, offload, sync
+ self._parse_forward()
+ self._update_forward()
+ # step 4. verify the correctness
+ self._check_offload_fetch()
+
+ return
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ """
+ call append_backward with checkpoints.
+
+ Args:
+ loss (Variable): loss variable to run optimizations.
+ startup_program (Program): startup_program for initializing parameters
+ in `parameter_list`.
+ parameter_list (list): list of Variables or Variable.names to update.
+ no_grad_set (set|None): set of Variables or Variables.names should be ignored.
+ callbacks (list|None): list of callables to run when appending backward
+ operator for one parameter.
+ checkpoints (list): list of Variables as checkpoints
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+
+
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+ print("Finished FF")
+
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.RecomputeOptimizer(sgd)
+ sgd._set_checkpoints([fc_1, pred])
+ params_grads = sgd.backward(
+ cost,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None)
+ print("Finished backward")
+ """
+ assert (self._checkpoints
+ is not None), "You should call _set_checkpoints first"
+
+ if framework._non_static_mode():
+ raise NotImplementedError(
+ "DyGraph current does not support recompute")
+
+ self._dtype = loss.dtype
+ program = loss.block.program
+ with program_guard(program, startup_program):
+ checkpoint_vars = []
+ for ckpt in self._checkpoints:
+ if isinstance(ckpt, Variable):
+ checkpoint_vars.append(ckpt)
+ else:
+ checkpoint_vars.append(loss.block.var(ckpt))
+
+ # allow return to non-recompute when checkpoints is empty
+ if len(checkpoint_vars) > 0:
+ params_grads, sorted_checkpoint_names = append_backward(
+ loss,
+ parameter_list,
+ no_grad_set,
+ checkpoints=checkpoint_vars)
+ else:
+ params_grads = append_backward(loss,
+ parameter_list,
+ no_grad_set,
+ checkpoints=checkpoint_vars)
+
+ if self.enable_offload:
+ self.sorted_checkpoint_names = sorted_checkpoint_names
+ self._offload(loss, startup_program=startup_program)
+
+ return params_grads
+
+ def apply_optimize(self, loss, startup_program, params_grads):
+ """
+ call the apply_optimize function of self._optimizer
+ Args:
+ loss (Variable): loss variable to run optimizations.
+ startup_program (Program): startup_program for initializing parameters
+ in `parameter_list`.
+ params_grads (list): list of (param, grad) pair to do optimization.
+ Examples:
+ .. code-block:: python
+ import paddle.fluid as fluid
+
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+ print("Finished FF")
+
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.RecomputeOptimizer(sgd)
+ sgd._set_checkpoints([fc_1, pred])
+ params_grads = sgd.backward(
+ cost,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None)
+
+ optimize_ops = sgd.apply_optimize(
+ cost, startup_program=None, params_grads=params_grads)
+
+ print("Finished apply_optimize")
+ """
+
+ func = self._optimizer.apply_optimize if hasattr(
+ self._optimizer,
+ 'apply_optimize') else self._optimizer._apply_optimize
+ return func(loss,
+ startup_program=startup_program,
+ params_grads=params_grads)
+
+ def minimize(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ assert isinstance(loss, Variable), "The loss should be an Variable."
+ assert (self._checkpoints
+ is not None), "You should call _set_checkpoints first"
+ if framework._non_static_mode():
+ raise NotImplementedError(
+ "DyGraph current does not support recompute")
+ params_grads = self.backward(loss,
+ startup_program=startup_program,
+ parameter_list=parameter_list,
+ no_grad_set=no_grad_set)
+
+ optimize_ops = self.apply_optimize(loss,
+ startup_program=startup_program,
+ params_grads=params_grads)
+
+ return optimize_ops, params_grads
+
+
+class LookaheadOptimizer(object):
+ r"""
+ :api_attr: Static Graph
+
+ This implements the Lookahead optimizer of the
+ paper : https://arxiv.org/abs/1907.08610.
+
+ Lookahead keeps two sets of params: the fast_params and
+ the slow_params. inner_optimizer update fast_params every
+ training step. Lookahead updates the slow_params and fast_params
+ every k training steps as follows:
+
+ .. math::
+
+ slow\_param_t &= slow\_param_{t-1} + \\alpha * (fast\_param_{t-1} - slow\_param_{t-1})
+
+ fast\_param_t &= slow\_param_t
+
+ Args:
+ inner_optimizer (Optimizer): The optimizer that update fast params step by step.
+ alpha (float): The learning rate of Lookahead.
+ k (int): The slow params is updated every k steps.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+ import numpy.random as random
+
+ paddle.enable_static()
+
+ x = fluid.layers.data(name='x', shape=[2], dtype='float32')
+ label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+ y = fluid.layers.fc(input=[x], size=2, act="softmax")
+ loss = fluid.layers.cross_entropy(input=y, label=label)
+ loss = paddle.mean(x=loss)
+ sgd = fluid.optimizer.SGD(learning_rate=0.01)
+ optimizer = fluid.optimizer.LookaheadOptimizer(sgd,
+ alpha=0.5,
+ k=5)
+ optimizer.minimize(loss)
+ main_program = fluid.default_main_program()
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ def train_reader(limit=5):
+ for i in range(limit):
+ yield random.random([2]).astype('float32'), random.random([1]).astype('int64')
+
+ feeder = fluid.DataFeeder(feed_list=[x, label], place=place)
+ reader = paddle.batch(paddle.reader.shuffle(train_reader, buf_size=50000),batch_size=1)
+
+ for batch_data in reader():
+ exe.run(fluid.default_main_program(),
+ feed=feeder.feed(batch_data))
+
+ """
+
+ def __init__(self, inner_optimizer, alpha=0.5, k=5):
+
+ if framework._non_static_mode():
+ raise Exception("In dygraph, don't support LookaheadOptimizer.")
+ assert (inner_optimizer is not None), "inner optimizer can not be None"
+ assert (
+ 0.0 <= alpha <= 1.0
+ ), "alpha should be larger or equal to 0.0, and less or equal than 1.0"
+ assert (isinstance(k, int) and k > 0), "k should be a positive integer"
+
+ self.inner_optimizer = inner_optimizer
+ self.alpha = alpha
+ self.k = k
+ self.type = "lookahead"
+
+ def minimize(self, loss, startup_program=None):
+
+ # Apply inner optimizer to the main_program
+ mini_out = self.inner_optimizer.minimize(
+ loss, startup_program=startup_program)
+
+ # Get startup_program and main_program
+ if startup_program is None:
+ startup_program = default_startup_program()
+ main_block = loss.block
+
+ # add some vars to the main_program
+ params = [param.name for param in main_block.all_parameters()]
+ param_to_slow = {}
+ for param in params:
+ fast_var = main_block.var(param)
+ assert (fast_var is not None)
+ slow_var = main_block.create_var(name=param + "@SLOW",
+ shape=fast_var.shape,
+ dtype=fast_var.dtype,
+ persistable=True)
+ param_to_slow[param] = slow_var
+
+ # add some vars to the startup_program
+ startup_block = startup_program.global_block()
+ for param in params:
+ fast_var = startup_block.var(param)
+ assert (fast_var is not None)
+ slow_var = startup_block.create_var(name=param + "@SLOW",
+ shape=fast_var.shape,
+ dtype=fast_var.dtype,
+ persistable=True)
+
+ startup_block.append_op(type="assign",
+ inputs={"X": fast_var},
+ outputs={"Out": slow_var})
+
+ with framework.program_guard(main_block.program, startup_program):
+ # Add Var k to main prog and startup prog
+ k = layers.create_global_var(name="lookahead_k",
+ shape=[1],
+ value=int(self.k),
+ dtype='int32',
+ persistable=True)
+
+ # Add Var alpha to main prog and startup prog
+ alpha = layers.create_global_var(name="lookahead_alpha",
+ shape=[1],
+ value=float(self.alpha),
+ dtype='float32',
+ persistable=True)
+
+ # Add Var step
+ step = layers.create_global_var(name="lookahead_step",
+ shape=[1],
+ value=int(0),
+ dtype='int32',
+ persistable=True)
+ layers.increment(x=step, value=1.0, in_place=True)
+
+ # lookahead
+ zero_var = layers.fill_constant(shape=[1],
+ dtype='float32',
+ value=0.0)
+
+ one_var = layers.fill_constant(shape=[1],
+ dtype='float32',
+ value=1.0)
+
+ mod = layers.elementwise_mod(step, k)
+ with layers.control_flow.Switch() as switch:
+ with switch.case(step == one_var):
+ for param_name in params:
+ fast_var = main_block.var(param_name)
+ slow_var = param_to_slow[param_name]
+ layers.assign(input=fast_var, output=slow_var)
+ with switch.case(mod == zero_var):
+ for param_name in params:
+ fast_var = main_block.var(param_name)
+ slow_var = param_to_slow[param_name]
+ tmp_var = layers.elementwise_add(
+ layers.elementwise_mul(fast_var, alpha),
+ layers.elementwise_mul(
+ slow_var,
+ layers.elementwise_sub(one_var, alpha)))
+ layers.assign(input=tmp_var, output=slow_var)
+ layers.assign(input=tmp_var, output=fast_var)
+ with switch.default():
+ pass
+ return mini_out
+
+
+class GradientMergeOptimizer(object):
+ """
+ Gradient Merge, also called as Gradient Accumulation,
+ is a training strategy for larger batches. With this strategy,
+ the parameter will not be updated until specific steps.
+
+ For each step, the forward network and the backward network
+ will run to calculate the gradient of the parameters.
+
+ For every k step, the optimization network will run,
+ applying a specific optimization method (such as SGD, Adam)
+ to the parameters.
+
+ Args:
+ inner_optimizer (Optimizer): The specific optimization (such as SGD, Adam)
+ which update the parameters
+ k_steps (int): the update period of the parameters
+ avg (bool): whether to average the gradients of each mini-batch,
+ the default value is `True`
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ def gen_data(batch_size):
+ return {"x": np.random.random(size=(batch_size, 32)).astype('float32'),
+ "y": np.random.random(size=(batch_size, 1)).astype('int64')}
+
+ def mlp(input_x, input_y, hid_dim=128, label_dim=2):
+ fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
+ prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
+ cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
+ sum_cost = fluid.layers.reduce_mean(cost)
+ return sum_cost, fc_1, prediction
+
+ input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
+ input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
+ cost, fc_1, pred = mlp(input_x, input_y)
+ sgd = fluid.optimizer.Adam(learning_rate=0.01)
+ sgd = fluid.optimizer.GradientMergeOptimizer(sgd, k_steps=4, avg=True)
+ sgd.minimize(cost)
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ for i in range(10):
+ cost_val = exe.run(feed=gen_data(32),
+ program=fluid.default_main_program(),
+ fetch_list=[cost.name])
+ print("step=%d, cost=%f" % (i, cost_val[0]))
+ """
+
+ GRAD_MERGE_COND_NAME = "grad_merge_cond_name"
+
+ def __init__(self, inner_optimizer, k_steps=1, avg=True):
+ if framework._non_static_mode():
+ raise Exception(
+ "In dygraph, we don't support GradientMergeOptimizer."
+ "You can do Gradient merge by yourself with k-times forward + backward, "
+ "and one-time optimizer.minimize()")
+
+ assert (inner_optimizer is not None), "inner optimizer can not be None"
+ assert (isinstance(k_steps, int)
+ and k_steps > 0), "k_steps should be a positive integer"
+
+ self.inner_optimizer = inner_optimizer
+ self.k_steps = k_steps
+ self.type = "gradient_merge"
+ self.avg = avg
+ self._optimize_ops = None
+
+ def _set_k_steps(self, k_steps):
+ self.k_steps = k_steps
+
+ def _set_avg(self, avg):
+ self.avg = avg
+
+ def backward(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None,
+ callbacks=None):
+ assert isinstance(loss, Variable), "The loss should be an Variable."
+ assert (
+ parameter_list is None
+ ), "The parameter_list should be None when using GradientMergeOptimizer"
+ assert (
+ no_grad_set is None
+ ), "The no_grad_set should be None when using GradientMergeOptimizer"
+
+ params_grads = self.inner_optimizer.backward(
+ loss, startup_program=startup_program)
+ return params_grads
+
+ def apply_optimize(self, loss, startup_program, params_grads):
+ program = loss.block.program
+ with program_guard(program, startup_program):
+ optimize_ops = self.apply_gradients(params_grads)
+ return optimize_ops
+
+ def _is_the_backward_op(self, op):
+ op_maker = core.op_proto_and_checker_maker
+ backward = core.op_proto_and_checker_maker.OpRole.Backward
+ if op_maker.kOpRoleVarAttrName() in op.attr_names and \
+ int(op.all_attrs()[op_maker.kOpRoleAttrName()]) == int(backward):
+ return True
+ return False
+
+ def _remove_op_role_var(self, param, grad):
+ op_maker = core.op_proto_and_checker_maker
+ op = grad.op
+ assert self._is_the_backward_op(op), \
+ 'grad.op={} is not the backward op which produces the grad={}' \
+ .format(op, grad.name)
+
+ block = grad.block
+ var_attr = op.all_attrs()[op_maker.kOpRoleVarAttrName()]
+ assert param.name in var_attr, \
+ 'when using GradientMergeOptimizer, param={} must be in var_attr={}' \
+ .format(param.name, var_attr)
+ assert grad.name in var_attr, \
+ 'when using GradientMergeOptimizer, grad={} must be in var_attr={}' \
+ .format(param.name, var_attr)
+
+ # remove (param, grad) from op_role_var
+ var_attr.remove(param.name)
+ var_attr.remove(grad.name)
+ if len(var_attr) > 1:
+ op._set_attr(op_maker.kOpRoleVarAttrName(), var_attr)
+ else:
+ op._remove_attr(op_maker.kOpRoleVarAttrName())
+
+ def _add_gm_op_role_var(self, op, param, grad, cond):
+ grad.op = op
+ op_maker = core.op_proto_and_checker_maker
+ backward = op_maker.OpRole.Backward
+
+ # NOTE(wangxi). When distributed, we will insert grad_merge_all_reduce_op_handle
+ # in multi_devices_graph_pass, which will allreduce(grad) if cond is True, else
+ # do nothing.
+ # In this way, the gradient can be merged first, and then communicate when the
+ # condition is met, reducing the number of communications to increase the
+ # speed.
+ op._set_attr(self.GRAD_MERGE_COND_NAME, cond.name)
+ op._set_attr(op_maker.kOpRoleAttrName(), backward)
+ op._set_attr(op_maker.kOpRoleVarAttrName(), [param.name, grad.name])
+
+ def _get_gm_cond_var(self, main_block):
+ # Add const var
+ k_step_var = layers.create_global_var(name="gradient_merge_k",
+ shape=[1],
+ value=int(self.k_steps),
+ dtype='int32',
+ persistable=True,
+ force_cpu=True)
+
+ zero_var = layers.create_global_var(name="gradient_merge_zero",
+ shape=[1],
+ value=int(0),
+ dtype='int32',
+ persistable=True,
+ force_cpu=True)
+
+ # Add step var & cond var
+ step_var = layers.create_global_var(name="gradient_merge_step",
+ shape=[1],
+ value=int(0),
+ dtype='int32',
+ persistable=True,
+ force_cpu=True)
+
+ cond_var = main_block.create_var(name="gradient_merge_cond",
+ shape=[1],
+ dtype='bool')
+
+ with device_guard("cpu"):
+ # step_var = (step_var + 1) % k_step
+ layers.increment(x=step_var, value=1.0, in_place=True)
+ main_block.append_op(type='elementwise_mod',
+ inputs={
+ 'X': step_var,
+ 'Y': k_step_var
+ },
+ outputs={'Out': step_var},
+ attrs={
+ 'axis': -1,
+ 'use_mkldnn': False
+ })
+
+ # cond_var = (step_var == 0)
+ main_block.append_op(type='equal',
+ inputs={
+ 'X': step_var,
+ 'Y': zero_var
+ },
+ outputs={'Out': cond_var})
+
+ return cond_var
+
+ def apply_gradients(self, params_grads):
+ main_program = default_main_program()
+ startup_program = default_startup_program()
+ main_block = main_program.global_block()
+ startup_block = startup_program.global_block()
+
+ cond = self._get_gm_cond_var(main_block)
+
+ #TODO(mapingshuo) support sparse embedding
+ # step1: remove grad.op's op_role_var
+ for param, grad in params_grads:
+ assert (
+ param.type != core.VarDesc.VarType.SELECTED_ROWS
+ ), "SELECTED_ROWS is not supported in GradientMergeOptimizer for now"
+
+ self._remove_op_role_var(param, grad)
+
+ param_to_grad = {k.name: v for (k, v) in params_grads}
+ param_names = param_to_grad.keys()
+ param_to_gradient_merge = {}
+
+ new_params_grads = []
+ # step2: create gradient_merge var and init with 0
+ # and update op_role_var
+ for param, grad in params_grads:
+ param_name = param.name
+ param_var = main_block.var(param_name)
+ assert (param_var is not None)
+ gradient_merge_var = main_block.create_var(name=param_name +
+ "@GRAD@GradientMerge",
+ shape=param_var.shape,
+ dtype=param_var.dtype,
+ persistable=True)
+ param_to_gradient_merge[param_name] = gradient_merge_var
+
+ startup_gradient_merge_var = startup_block.create_var(
+ name=param_name + "@GRAD@GradientMerge",
+ shape=param_var.shape,
+ dtype=param_var.dtype,
+ persistable=True)
+ startup_block.append_op(type="fill_constant",
+ outputs={"Out": startup_gradient_merge_var},
+ attrs={
+ "shape": param_var.shape,
+ "dtype": param_var.dtype,
+ "value": float(0),
+ })
+
+ # grad_merge += grad
+ new_grad_op = main_block.append_op(
+ type="elementwise_add",
+ inputs={
+ 'X': grad,
+ 'Y': gradient_merge_var
+ },
+ outputs={'Out': gradient_merge_var},
+ attrs={
+ 'axis': -1,
+ 'use_mkldnn': False
+ })
+ self._add_gm_op_role_var(new_grad_op, param, gradient_merge_var,
+ cond)
+ new_params_grads.append([param, gradient_merge_var])
+
+ def true_apply_gradient():
+ cur_block_idx = main_program.current_block_idx
+ cur_block = main_program.current_block()
+
+ # cur_block's forward_block & backward_block is itself
+ cur_block._set_forward_block_idx(cur_block_idx)
+ op_maker = core.op_proto_and_checker_maker
+
+ if self.avg:
+ for param, new_grad in new_params_grads:
+ # grad /= k_steps
+ cur_block.append_op(type='scale',
+ inputs={'X': new_grad},
+ outputs={'Out': new_grad},
+ attrs={
+ 'scale': 1.0 / self.k_steps,
+ 'bias': 0.0,
+ 'bias_after_scale': False
+ })
+ new_grad.op._set_attr(op_maker.kOpRoleAttrName(),
+ op_maker.OpRole.Backward)
+
+ for param, new_grad in new_params_grads:
+ # NOTE. regularization will append ops to grad.block,
+ # while new_grad's real block is global_block,
+ # but we want append regularization ops to cur_block,
+ # so we set new_grad.block = cur_block
+ new_grad.block = cur_block
+
+ self._optimize_ops = self.inner_optimizer.apply_gradients(
+ new_params_grads)
+
+ # clear gradient_merge_vars
+ for param, new_grad in new_params_grads:
+ layers.fill_constant(shape=new_grad.shape,
+ dtype=new_grad.dtype,
+ value=0.0,
+ out=new_grad)
+ new_grad.op._set_attr(op_maker.kOpRoleAttrName(),
+ op_maker.OpRole.Optimize)
+
+ # step3. apply gradient
+ layers.cond(cond, true_fn=true_apply_gradient, false_fn=None)
+
+ return self._optimize_ops
+
+ def minimize(self,
+ loss,
+ startup_program=None,
+ parameter_list=None,
+ no_grad_set=None):
+ assert isinstance(loss, Variable), "The loss should be an Variable."
+
+ params_grads = self.backward(loss,
+ startup_program=startup_program,
+ parameter_list=parameter_list,
+ no_grad_set=no_grad_set)
+
+ optimize_ops = self.apply_optimize(loss,
+ startup_program=startup_program,
+ params_grads=params_grads)
+
+ return optimize_ops, params_grads
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/parallel_executor.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/parallel_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..e63270c1697f460dba70974ec84032ebae97e302
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/parallel_executor.py
@@ -0,0 +1,377 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+from . import core
+from . import framework
+from . import executor
+from . import compiler
+from .data_feeder import check_type
+import sys
+
+__all__ = ['ParallelExecutor']
+
+ExecutionStrategy = core.ParallelExecutor.ExecutionStrategy
+BuildStrategy = core.ParallelExecutor.BuildStrategy
+
+
+class ParallelExecutor(object):
+ """
+ :api_attr: Static Graph
+
+ The ParallelExecutor is an upgraded version of :code:`paddle.static.Executor` that supports multi-node model
+ training and testing based on the data-parallel mode. In data-parallel mode,
+ ParallelExecutor will broadcast the parameters from Node0 to other nodes during
+ construction and copy the input Program to other nodes from Node0 to make sure
+ that the initial state on each node is the same. Each node runs the model independently
+ and the parameters' gradient is aggregated between those nodes during backward
+ computation, and then each node independently updates its parameters. If you use
+ the GPU to run the model, i.e. use_cuda=True, the node refers to the GPU,
+ ParallelExecutor will automatically get the GPU resources available on the
+ current machine, users can also set the available GPU resources in the environment
+ variable, for example: want to use GPU0, GPU1, export CUDA_VISIBLEDEVICES=0,1;
+ If the operation is performed on the CPU, i.e. use_cuda=False, the node refers to the CPU.
+ **Note: At this time, the user needs to manually add CPU_NUM to the environment variable
+ and set the number of CPU devices. For example, export CPU_NUM=4, if the environment
+ variable is not set, the executor will add the variable to the environment variable
+ and set it to 1.**
+
+
+ Args:
+ use_cuda (bool): Whether to use CUDA or not.
+ loss_name (str): This parameter is the name of the loss Tensor of the
+ model. **Note: If it is data-parallel model training, you must set loss_name,
+ otherwise, the results may be wrong**. The default is None.
+ main_program (Program): This parameter represents the Program to be executed.
+ If this parameter is not provided, that parameter is None, the program will
+ be set to :code:`paddle.static.default_main_program()`. The default is None.
+ share_vars_from(ParallelExecutor): If share_vars_from is set, the current
+ ParallelExecutor will share the parameters with the ParallelExecutor
+ specified by share_vars_from. This parameter needs to be set when model testing
+ is required during model training, and the data parallel mode is used for
+ training and testing. Since ParallelExecutor will only distribute parameter
+ variables to other devices when it is first executed, the ParallelExecutor
+ specified by share_vars_from must be run before the current ParallelExecutor.
+ The default is None.
+ exec_strategy(ExecutionStrategy): exec_strategy specifies the options that can
+ be changed when running the current model, such as the thread pool size.
+ For more information about exec_strategy, please refer to :code:`paddle.static.ExecutionStrategy`.
+ The default is None.
+ build_strategy(BuildStrategy): By configuring build_strategy, we can
+ optimize the computational graph, such as operators' fusion in the
+ computational graph and memory optimization during the execution
+ of the computational graph. For more information about build_strategy,
+ please refer to :code:`paddle.static.BuildStrategy`. The default is None.
+ num_trainers(int): This parameter needs to be set in GPU distributed training.
+ If the parameter value is greater than 1, NCCL will be initialized by multi-level
+ nodes. Each node should have the same number of GPUs. The default is 1.
+ trainer_id(int): This parameter needs to be set when performing GPU distributed
+ training. This parameter must be used with the num_trainers parameter.
+ Trainer_id indicates the "rank" of the current node. The trainer_id starts
+ counting from 0. The default is 0.
+ scope(Scope): Specifies the scope in which the program is executed.
+ The default is paddle.static.global_scope().
+
+ Returns:
+ ParallelExecutor: The initialized ParallelExecutor object.
+
+ Raises:
+ TypeError: If share_vars_from is provided, but not ParallelExecutor object.
+
+ NOTES:
+
+ 1. If you only use ParallelExecutor to do multi-card test, you don't need to set loss_name
+ and share_vars_from.
+
+ 2. If you need to train and test the model with ParallelExecutor, the share_vars_from
+ must be set when building the ParallelExecutor corresponding to the model test.
+ Otherwise, the parameters used in the model test and the model training are inconsistent.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy
+ import os
+
+ use_cuda = True
+ paddle.enable_static()
+ place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace()
+
+ # NOTE: If you use CPU to run the program, you need
+ # to specify the CPU_NUM, otherwise, PaddlePaddle will use
+ # all the number of the logic core as the CPU_NUM,
+ # in that case, the batch size of the input should be
+ # greater than CPU_NUM, if not, the process will be
+ # failed by an exception.
+ if not use_cuda:
+ os.environ['CPU_NUM'] = str(2)
+
+ exe = paddle.static.Executor(place)
+
+ train_program = paddle.static.Program()
+ startup_program = paddle.static.Program()
+ with paddle.static.program_guard(train_program, startup_program):
+ data = paddle.static.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = paddle.static.nn.fc(data, 10)
+ loss = paddle.mean(hidden)
+ test_program = paddle.static.default_main_program().clone(for_test=True)
+ paddle.optimizer.SGD(learning_rate=0.01).minimize(loss)
+
+ exe.run(startup_program)
+
+ train_exe = paddle.static.ParallelExecutor(use_cuda=use_cuda,
+ main_program=train_program,
+ loss_name=loss.name)
+ # Note: if share_vars_from is not set here, the test parameter is different to the train one
+ test_exe = paddle.static.ParallelExecutor(use_cuda=use_cuda,
+ main_program=test_program,
+ share_vars_from=train_exe)
+
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ loss_data, = train_exe.run(feed={"X": x},
+ fetch_list=[loss.name])
+
+ loss_data, = test_exe.run(feed={"X": x},
+ fetch_list=[loss.name])
+
+ """
+
+ def __init__(self,
+ use_cuda,
+ loss_name=None,
+ main_program=None,
+ share_vars_from=None,
+ exec_strategy=None,
+ build_strategy=None,
+ num_trainers=1,
+ trainer_id=0,
+ scope=None):
+ if build_strategy is None:
+ build_strategy = BuildStrategy()
+
+ # TODO(paddle-dev): trainer_id and num_trainers should be removed from parameter list.
+ if num_trainers != 1 and build_strategy.num_trainers != num_trainers:
+ sys.stderr.write(
+ 'The value of build_strategy.num_trainers[%d] is overwritten '
+ 'by the passed num_trainers[%d].\n' %
+ (build_strategy.num_trainers, num_trainers))
+ build_strategy.num_trainers = num_trainers
+ if trainer_id != 0 and build_strategy.trainer_id != trainer_id:
+ sys.stderr.write(
+ 'The value of build_strategy.trainer_id[%d] is overwritten '
+ 'by the passed trainer_id[%d].\n' %
+ (build_strategy.trainer_id, trainer_id))
+ build_strategy.trainer_id = trainer_id
+
+ self._places = framework.cuda_places(
+ ) if use_cuda else framework.cpu_places()
+ self._scope = scope if scope is not None else executor.global_scope()
+
+ main_program = main_program if main_program is not None \
+ else framework.default_main_program()
+
+ self._compiled_program = compiler.CompiledProgram(main_program)
+ if share_vars_from:
+ assert isinstance(
+ share_vars_from, ParallelExecutor
+ ), "The share_vars_from should be ParallelExecutor."
+
+ self._compiled_program.with_data_parallel(
+ loss_name=loss_name,
+ build_strategy=build_strategy,
+ exec_strategy=exec_strategy,
+ share_vars_from=share_vars_from._compiled_program
+ if share_vars_from else None)
+
+ self._place = core.CUDAPlace(0) if use_cuda else core.CPUPlace()
+ self._exe = executor.Executor(self._place)
+
+ def run(self, fetch_list, feed=None, feed_dict=None, return_numpy=True):
+ """
+ This interface is used to run the current model. It should be noted
+ that the executor will execute all the operators in the Program,
+ and will not prune some operators in the Program according to the
+ fetch_list.
+
+ Args:
+ fetch_list(list): This parameter represents the Tensors that need to be returned
+ after the model runs. The default is None.
+ feed(list|dict): This parameter represents the input Tensors of the model.
+ If it is single card training, the feed is dict type, and if it is multi-card
+ training, the parameter feed can be dict or list of Tensor. If the
+ parameter type is dict, the data in the feed will be split and sent to
+ multiple devices (CPU/GPU), that is to say, the input data will be evenly
+ sent to different devices, so you should make sure the number of samples of
+ the current mini-batch must be greater than the number of places;
+ if the parameter type is list, those data are copied directly to each device,
+ so the length of this list should be equal to the number of places.
+ The default is None.
+ feed_dict: Alias for feed parameter, for backward compatibility.
+ This parameter has been deprecated. Default None.
+ return_numpy(bool): This parameter indicates whether convert the fetched Tensors
+ (the Tensor specified in the fetch list) to numpy.ndarray. if it is False,
+ the type of the return value is a list of :code:`LoDTensor`. The default is True.
+
+ Returns:
+ List: The fetched result list.
+
+ Raises:
+ ValueError: If the feed is a list, but its length is not equal the
+ length of active places, or its element's is not dict.
+
+ NOTES:
+ 1. If the feed parameter is dict type, the input data will be evenly distributed
+ to different cards. For example, using two GPUs to run the model, the input
+ sample number is 3, that is, [0, 1, 2], the sample number on GPU0 is 1,
+ that is, [0], and the sample number on GPU1 is 2, that is, [1, 2].
+ If the number of samples is less than the number of devices, the program will
+ throw an exception, so when running the model, you should make sure that the
+ number of samples of the last batch of the data set should be greater than the
+ number of CPU cores or GPU cards, if it is less than, it is recommended that
+ the batch be discarded.
+ 2. If the number of CPU cores or GPU cards available is greater than 1, the fetch
+ results are spliced together in dimension 0 for the same Tensor values
+ (Tensors in fetch_list) on different devices.
+
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy
+ import os
+
+ use_cuda = True
+ paddle.enable_static()
+ place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace()
+
+ # NOTE: If you use CPU to run the program, you need
+ # to specify the CPU_NUM, otherwise, PaddlePaddle will use
+ # all the number of the logic core as the CPU_NUM,
+ # in that case, the batch size of the input should be
+ # greater than CPU_NUM, if not, the process will be
+ # failed by an exception.
+ if not use_cuda:
+ os.environ['CPU_NUM'] = str(2)
+
+ exe = paddle.static.Executor(place)
+
+ train_program = paddle.static.Program()
+ startup_program = paddle.static.Program()
+ with paddle.static.program_guard(train_program, startup_program):
+ data = paddle.static.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = paddle.static.nn.fc(data, 10)
+ loss = paddle.mean(hidden)
+ paddle.optimizer.SGD(learning_rate=0.01).minimize(loss)
+
+ exe.run(startup_program)
+
+ train_exe = paddle.static.ParallelExecutor(use_cuda=use_cuda,
+ main_program=train_program,
+ loss_name=loss.name)
+
+ # If the feed is a dict:
+ # the image will be split into devices. If there is two devices
+ # each device will process an image with shape (5, 1)
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ loss_data, = train_exe.run(feed={"X": x},
+ fetch_list=[loss.name])
+
+ # If the feed is a list:
+ # each device will process each element in the list.
+ # the 1st device will process an image with shape (10, 1)
+ # the 2nd device will process an image with shape (9, 1)
+ #
+ # you can use exe.device_count to get the device number.
+ x2 = numpy.random.random(size=(9, 1)).astype('float32')
+ loss_data, = train_exe.run(feed=[{"X": x}, {"X": x2}],
+ fetch_list=[loss.name])
+
+ """
+ return self._exe.run(program=self._compiled_program,
+ scope=self._scope,
+ feed=feed,
+ fetch_list=fetch_list,
+ return_numpy=return_numpy)
+
+ @property
+ def device_count(self):
+ return len(self._places)
+
+ def drop_local_exe_scopes(self):
+ """
+ Drop the local execution scopes immediately. In order to avoid frequently
+ application and release of temporary variables, the strategy adopted by
+ ParallelExecutor is to drop the local execution scopes after several iterations.
+ ParallelExecutor provides the num_iteration_per_drop_scope option in
+ :code:`paddle.static.ExecutionStrategy`, which indicates how many iterations are intervened to
+ drop the local execution scopes. If the num_iteration_per_drop_scope value
+ is 100, but you want to drop the local execution scopes after 50 iterations,
+ you can call the interface manually.
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import numpy
+ import os
+
+ use_cuda = True
+ # NOTE: If you use CPU to run the program, you need
+ # to specify the CPU_NUM, otherwise, PaddlePaddle will use
+ # all the number of the logic core as the CPU_NUM,
+ # in that case, the batch size of the input should be
+ # greater than CPU_NUM, if not, the process will be
+ # failed by an exception.
+ if not use_cuda:
+ os.environ['CPU_NUM'] = str(2)
+
+ paddle.enable_static()
+ train_program = paddle.static.Program()
+ startup_program = paddle.static.Program()
+ with paddle.static.program_guard(train_program, startup_program):
+ data = paddle.static.data(name='X', shape=[None, 1], dtype='float32')
+ hidden = paddle.static.nn.fc(data, 10)
+ loss = paddle.mean(hidden)
+
+ place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(startup_program)
+
+ parallel_exe = paddle.static.ParallelExecutor(use_cuda=use_cuda,
+ main_program=train_program,
+ loss_name=loss.name)
+
+ x = numpy.random.random(size=(10, 1)).astype('float32')
+ loss_data, = parallel_exe.run(feed={"X": x},
+ fetch_list=[loss.name])
+
+ parallel_exe.drop_local_exe_scopes()
+
+ """
+ check_type(self._compiled_program._executor,
+ "the Executor of compiled program", core.ParallelExecutor,
+ "ParallelExecutor.drop_local_exe_scopes")
+ self._compiled_program._executor.drop_local_exe_scopes()
+
+ # This API is used to check whether DropLocalExeScopes can work.
+ def _need_create_local_exe_scopes(self):
+ check_type(self._compiled_program._executor,
+ "the Executor of compiled program", core.ParallelExecutor,
+ "ParallelExecutor._need_create_local_exe_scopes")
+ return self._compiled_program._executor._need_create_local_exe_scopes()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/param_attr.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/param_attr.py
new file mode 100644
index 0000000000000000000000000000000000000000..6580c82536a61702975cd227d59994a5153db2dd
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/param_attr.py
@@ -0,0 +1,306 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import six
+import warnings
+import sys
+
+from .initializer import Initializer, Xavier, Constant
+from .regularizer import WeightDecayRegularizer
+from paddle.fluid.data_feeder import check_type
+
+__all__ = [
+ 'ParamAttr',
+ 'WeightNormParamAttr',
+]
+
+
+class ParamAttr(object):
+ """
+
+ Note:
+ ``gradient_clip`` of ``ParamAttr`` HAS BEEN DEPRECATED since 2.0.
+ Please use ``need_clip`` in ``ParamAttr`` to speficiy the clip scope.
+ There are three clipping strategies: :ref:`api_paddle_nn_ClipGradByGlobalNorm` ,
+ :ref:`api_paddle_nn_ClipGradByNorm` , :ref:`api_paddle_nn_ClipGradByValue` .
+
+ Create a object to represent the attribute of parameter. The attributes are:
+ name, initializer, learning rate, regularizer, trainable, gradient clip,
+ and model average.
+
+ Parameters:
+ name (str, optional): The parameter's name. Default None, meaning that the name
+ would be created automatically.
+ initializer (Initializer, optional): The method to initial this parameter. Default
+ None, meaning that the weight parameter is initialized by Xavier initializer,
+ and the bias parameter is initialized by 0.
+ learning_rate (float, optional): The parameter's learning rate. The learning rate when
+ optimize is the global learning rates times the parameter's learning rate times
+ the factor of learning rate scheduler. Default 1.0.
+ regularizer (WeightDecayRegularizer, optional): Regularization strategy. There are two method:
+ :ref:`api_paddle_regularizer_L1Decay` , :ref:`api_paddle_regularizer_L2Decay` . If
+ regularizer is also set in ``optimizer`` (such as :ref:`api_paddle_optimizer_SGD` ),
+ that regularizer setting in optimizer will be ignored. Default None, meaning there is
+ no regularization.
+ trainable (bool, optional): Whether this parameter is trainable. Default True.
+ do_model_average (bool, optional): Whether this parameter should do model average
+ when model average is enabled. Only used in ExponentialMovingAverage. Default True.
+ need_clip (bool, optional): Whether the parameter gradient need to be cliped in optimizer. Default is True.
+
+ Returns:
+ ParamAttr Object.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ weight_attr = paddle.ParamAttr(name="weight",
+ learning_rate=0.5,
+ regularizer=paddle.regularizer.L2Decay(1.0),
+ trainable=True)
+ print(weight_attr.name) # "weight"
+ paddle.nn.Linear(3, 4, weight_attr=weight_attr)
+ """
+
+ def __init__(self,
+ name=None,
+ initializer=None,
+ learning_rate=1.0,
+ regularizer=None,
+ trainable=True,
+ do_model_average=True,
+ need_clip=True):
+
+ if sys.version_info.major == 2:
+ check_type(name, "name", (str, type(None), unicode), "ParamAttr")
+ else:
+ check_type(name, "name", (str, type(None)), "ParamAttr")
+ check_type(learning_rate, "learning_rate", (float, int), "ParamAttr")
+ check_type(trainable, "trainable", (bool), "ParamAttr")
+ check_type(do_model_average, "do_model_average", (bool), "ParamAttr")
+ check_type(need_clip, "need_clip", (bool), "ParamAttr")
+ check_type(initializer, "initializer", (Initializer, type(None)),
+ "ParamAttr")
+ check_type(regularizer, "regularizer",
+ (WeightDecayRegularizer, type(None)), "ParamAttr")
+
+ self.name = name
+ if self.name == "":
+ raise ValueError("name of ParamAttr can not be empty str")
+
+ self.initializer = initializer
+ self.learning_rate = learning_rate
+ self.regularizer = regularizer
+ self.trainable = trainable
+ self.do_model_average = do_model_average
+ self.need_clip = need_clip
+
+ def _set_default_initializer(self, initializer):
+ """
+ Set the default initializer, the initializer should be Constant,
+ Uniform, Normal, Xavier, MSRA.
+
+ Args:
+ initializer(Initializer): the initializer to set.
+
+ Returns:
+ None
+ """
+ if initializer is None:
+ if self.initializer is None:
+ raise ValueError("ParamAttr.initializer is not set")
+ return
+
+ if self.initializer is not None:
+ return
+
+ self.initializer = initializer
+
+ def _set_default_param_initializer(self):
+ """
+ Set the default initializer for the parameter with Xavier.
+
+ Args:
+ None.
+
+ Returns:
+ None.
+ """
+ self._set_default_initializer(Xavier())
+
+ def _set_default_bias_initializer(self):
+ """
+ Set the default initializer for the bias with Constant(0.0).
+
+ Args:
+ None.
+
+ Returns:
+ None.
+ """
+ self._set_default_initializer(Constant(0.0))
+
+ @staticmethod
+ def _to_attr(arg):
+ """
+ Create ParamAttr[s].
+
+ Args:
+ arg: Arguments to initialize ParamAttr[s]. arg's type can be
+ str, Initializer, float, WeightDecayRegularizer, BaseGradientClipAttr,
+ bool, ParamAttr, or a list of above type.
+
+ Returns:
+ ParamAttr[s]: ParamAttr[s] initialized with arg.
+
+ Raises:
+ arg can not initialize a ParamAttr.
+ """
+ if arg is None:
+ return ParamAttr()
+ elif isinstance(arg, list) or isinstance(arg, tuple):
+ return [ParamAttr._to_attr(a) for a in arg]
+ elif isinstance(arg, ParamAttr):
+ return arg
+ elif isinstance(arg, six.string_types):
+ return ParamAttr(name=arg)
+ elif isinstance(arg, Initializer):
+ return ParamAttr(initializer=arg)
+ elif isinstance(arg, WeightDecayRegularizer):
+ return ParamAttr(regularizer=arg)
+ elif isinstance(arg, bool):
+ return ParamAttr._to_attr(None) if arg else False
+ else:
+ raise TypeError("{0} cast to ParamAttr".format(type(arg)))
+
+ def _to_kwargs(self, with_initializer=False):
+ """
+ Returns the attributes of this parameter.
+
+ Args:
+ with_initializer(bool): Whether to add initializer attr.
+
+ Returns:
+ Parameter attributes(map): The attributes of this parameter.
+ """
+ kwargs = {
+ 'name': self.name,
+ 'optimize_attr': {
+ 'learning_rate': self.learning_rate
+ },
+ 'regularizer': self.regularizer,
+ 'trainable': self.trainable,
+ 'do_model_average': self.do_model_average,
+ 'need_clip': self.need_clip
+ }
+ if with_initializer:
+ kwargs['initializer'] = self.initializer
+ return kwargs
+
+
+class WeightNormParamAttr(ParamAttr):
+ r"""
+
+ Note:
+ Please use 'paddle.nn.utils.weight_norm' in dygraph mode.
+
+ Note:
+ ``gradient_clip`` of ``ParamAttr`` HAS BEEN DEPRECATED since 2.0.
+ Please use ``need_clip`` in ``ParamAttr`` to speficiy the clip scope.
+ There are three clipping strategies: :ref:`api_paddle_nn_ClipGradByGlobalNorm` ,
+ :ref:`api_paddle_nn_ClipGradByNorm` , :ref:`api_paddle_nn_ClipGradByValue` .
+
+ Parameter of weight Norm. Weight Norm is a reparameterization of the weight vectors
+ in a neural network that decouples the magnitude of those weight vectors from
+ their direction. Weight Norm has been implemented as discussed in this
+ paper: `Weight Normalization: A Simple Reparameterization to Accelerate
+ Training of Deep Neural Networks
+ `_.
+
+ Args:
+ dim(int, optional): Dimension over which to compute the norm. Dim is a non-negative
+ number which is less than the rank of weight Tensor. For Example, dim can
+ be chosen from 0, 1, 2, 3 for convolution whose weight shape is [cout, cin, kh, kw]
+ and rank is 4. Default None, meaning that all elements will be normalized.
+ name(str, optional): The parameter's name. Default None, meaning that the name would
+ be created automatically. Please refer to :ref:`api_guide_Name` for more details.
+ initializer(Initializer, optional): The method to initialize this parameter, such as
+ ``initializer = paddle.nn.initializer.Constant(1.0)``. Default None,
+ meaning that the weight parameter is initialized by Xavier initializer, and
+ the bias parameter is initialized by 0.
+ learning_rate(float32, optional): The parameter's learning rate when
+ optimizer is :math:`global\_lr * parameter\_lr * scheduler\_factor`.
+ Default 1.0.
+ regularizer (WeightDecayRegularizer, optional): Regularization strategy. There are
+ two method: :ref:`api_paddle_regularizer_L1Decay` ,
+ :ref:`api_paddle_regularizer_L2Decay`.
+ If regularizer isralso set in ``optimizer``
+ (such as :ref:`api_paddle_optimizer_SGD` ), that regularizer setting in
+ optimizer will be ignored. Default None, meaning there is no regularization.
+ trainable(bool, optional): Whether this parameter is trainable. Default True.
+ do_model_average(bool, optional): Whether this parameter should do model average.
+ Default False.
+ need_clip (bool, optional): Whether the parameter gradient need to be cliped in optimizer. Default is True.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ paddle.enable_static()
+
+ data = paddle.static.data(name="data", shape=[3, 32, 32], dtype="float32")
+
+ fc = paddle.static.nn.fc(x=data,
+ size=1000,
+ weight_attr=paddle.static.WeightNormParamAttr(
+ dim=None,
+ name='weight_norm_param',
+ initializer=paddle.nn.initializer.Constant(1.0),
+ learning_rate=1.0,
+ regularizer=paddle.regularizer.L2Decay(0.1),
+ trainable=True,
+ do_model_average=False,
+ need_clip=True))
+
+ """
+ # List to record the parameters reparameterized by weight normalization.
+ # If these parameters are treated as Variable rather than Parameter,
+ # it can be used to discriminate these parameters and help to serialize
+ # these paramters for inference.
+ params_with_weight_norm = []
+
+ def __init__(self,
+ dim=None,
+ name=None,
+ initializer=None,
+ learning_rate=1.0,
+ regularizer=None,
+ trainable=True,
+ do_model_average=False,
+ need_clip=True):
+ super(WeightNormParamAttr,
+ self).__init__(name=name,
+ initializer=initializer,
+ learning_rate=learning_rate,
+ regularizer=regularizer,
+ trainable=trainable,
+ do_model_average=do_model_average,
+ need_clip=need_clip)
+ self.dim = dim
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/profiler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/profiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..5739cdb2f593c0c52fa4b2a25898f22e8ddfa294
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/profiler.py
@@ -0,0 +1,422 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from . import core
+from .wrapped_decorator import signature_safe_contextmanager
+import os
+import six
+import sys
+
+from paddle.utils.deprecated import deprecated
+
+__all__ = [
+ 'cuda_profiler', 'reset_profiler', 'profiler', 'start_profiler',
+ 'stop_profiler'
+]
+
+NVPROF_CONFIG = [
+ "gpustarttimestamp",
+ "gpuendtimestamp",
+ "gridsize3d",
+ "threadblocksize",
+ "streamid",
+ "enableonstart 0",
+ "conckerneltrace",
+]
+
+
+@deprecated(
+ since="2.3.0",
+ update_to="paddle.profiler.Profiler",
+ level=1,
+ reason=
+ "Please use new profiler tool, this profiler tool is no longer maintained.")
+@signature_safe_contextmanager
+def cuda_profiler(output_file, output_mode=None, config=None):
+ """
+ API cuda_profiler has been abandoned. If you have relevant requirements, you can use `paddle.utils.profiler.start_profiler` and `paddle.utils.profiler.stop_profiler`.
+ The relevant reference documents are as follows:
+
+
+
+ """
+ raise RuntimeError(
+ "API cuda_profiler has been abandoned. If you have relevant requirements, you can use `paddle.utils.profiler.start_profiler` and `paddle.utils.profiler.stop_profiler`.\nThe relevant reference documents are as follows:\n\n\n"
+ )
+
+
+@signature_safe_contextmanager
+def npu_profiler(output_file, config=None):
+ """
+ The NPU profiler.
+
+ This fuctions is used to profile NPU program by NPU runtime application
+ programming interface. The profiling result will be written into
+ `output_file`. The users can set set the NPU profiling config by `config` argument.
+
+ After getting the profiling result file, users can use
+ `tools provided by Ascend `_
+ to load this output file to visualize results.
+
+ Args:
+ output_file (str) : The output file name, the result will be
+ written into this file. It should be absolute path.
+ config (list, optional) : NPU profile config. For more details, please
+ refer to `User Guide `_ .
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import paddle.fluid.profiler as profiler
+ import numpy as np
+
+ epoc = 8
+ dshape = [4, 3, 28, 28]
+ data = fluid.data(name='data', shape=[None, 3, 28, 28], dtype='float32')
+ conv = fluid.layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1])
+
+ place = fluid.NPUPlace(0)
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ output_file = 'npu.txt'
+ with profiler.npu_profiler(output_file) as npu_prof:
+ for i in range(epoc):
+ input = np.random.random(dshape).astype('float32')
+ exe.run(fluid.default_main_program(), feed={'data': input})
+ # then use NPU profiler tools to load this output file
+ # to visualize results.
+ """
+ # TODO: support config in python.
+ if not config:
+ config = core.npu_prof_create_config()
+
+ core.npu_prof_init(output_file)
+ # Enables profiler collection by the active NPU profiling tool.
+ core.npu_prof_start(config)
+ try:
+ yield
+ # Disables profiler collection.
+ finally:
+ core.npu_prof_stop(config)
+ core.npu_prof_finalize()
+
+
+@deprecated(
+ since="2.3.0",
+ update_to="paddle.profiler.Profiler",
+ level=1,
+ reason=
+ "Please use new profiler tool, this profiler tool is no longer maintained.")
+def reset_profiler():
+ """
+ Clear the previous time record. It works for
+ `fluid.profiler.start_profiler`, `fluid.profiler.stop_profiler`,
+ and `fluid.profiler.profiler`.
+
+ Examples:
+
+ .. code-block:: python
+
+ # required: gpu
+ import paddle.fluid as fluid
+ import paddle.fluid.profiler as profiler
+ with profiler.profiler('CPU', 'total', '/tmp/profile'):
+ for iter in range(10):
+ if iter == 2:
+ profiler.reset_profiler()
+ # ...
+ """
+ core.reset_profiler()
+
+
+@deprecated(
+ since="2.3.0",
+ update_to="paddle.profiler.Profiler",
+ level=1,
+ reason=
+ "Please use new profiler tool, this profiler tool is no longer maintained.")
+def start_profiler(state, tracer_option='Default'):
+ """
+ Enable the profiler. Uers can use `fluid.profiler.start_profiler` and
+ `fluid.profiler.stop_profiler` to profile, which is equal to the usage
+ of `fluid.profiler.profiler` interface.
+
+ Args:
+ state (str) : The profiling state, which should be one of 'CPU', 'GPU'
+ or 'All'. 'CPU' means only profiling CPU; 'GPU' means profiling
+ both CPU and GPU; 'All' means profiling both CPU and GPU, and
+ generates timeline as well.
+ tracer_option (str, optional) : tracer_option can be one of ['Default', 'OpDetail', 'AllOpDetail'], it
+ can control the profile level and print the different level profile result. `Default` option print
+ the different Op type profiling result and the `OpDetail` option print the detail profiling
+ result of different op types such as compute and data transform, `AllOpDetail` option
+ print the detail profiling result of different op name same as `OpDetail`.
+
+ Raises:
+ ValueError: If `state` is not in ['CPU', 'GPU', 'All'] or `tracer_option`
+ is not in ['Default', 'OpDetail', 'AllOpDetail'].
+
+ Examples:
+
+ .. code-block:: python
+
+ # required: gpu
+ import paddle.fluid as fluid
+ import paddle.fluid.profiler as profiler
+
+ profiler.start_profiler('GPU')
+ for iter in range(10):
+ if iter == 2:
+ profiler.reset_profiler()
+ # except each iteration
+ profiler.stop_profiler('total', '/tmp/profile')
+
+ profiler.start_profiler('GPU', "OpDetail")
+ for iter in range(10):
+ if iter == 2:
+ profiler.reset_profiler()
+ # except each iteration
+ profiler.stop_profiler('total', '/tmp/profile')
+ """
+ if core.is_profiler_enabled():
+ return
+ if state not in ['CPU', 'GPU', "All"]:
+ raise ValueError("The state must be 'CPU' or 'GPU' or 'All'.")
+ if state == "GPU":
+ prof_state = core.ProfilerState.kCUDA
+ elif state == "CPU":
+ prof_state = core.ProfilerState.kCPU
+ else:
+ prof_state = core.ProfilerState.kAll
+
+ if tracer_option not in ['Default', 'OpDetail', 'AllOpDetail']:
+ raise ValueError(
+ "tracer option must be 'Default', 'OpDetail', 'AllOpDetail'.")
+ if tracer_option == "Default":
+ prof_tracer_option = core.TracerOption.kDefault
+ elif tracer_option == "OpDetail":
+ prof_tracer_option = core.TracerOption.kOpDetail
+ else:
+ prof_tracer_option = core.TracerOption.kAllOpDetail
+
+ core.set_tracer_option(prof_tracer_option)
+ core.enable_profiler(prof_state)
+
+
+@deprecated(
+ since="2.3.0",
+ update_to="paddle.profiler.Profiler",
+ level=1,
+ reason=
+ "Please use new profiler tool, this profiler tool is no longer maintained.")
+def stop_profiler(sorted_key=None, profile_path='/tmp/profile'):
+ """
+ Stop the profiler. Uers can use `fluid.profiler.start_profiler` and
+ `fluid.profiler.stop_profiler` to profile, which is equal to the usage
+ of `fluid.profiler.profiler` interface.
+
+ Args:
+ sorted_key (str, optional) : The order of profiling results, which
+ should be one of None, 'calls', 'total', 'max', 'min' or 'ave'.
+ Default is None, means the profiling results will be printed
+ in the order of first end time of events.
+ The `calls` means sorting by the number of calls.
+ The `total` means sorting by the total execution time.
+ The `max` means sorting by the maximum execution time.
+ The `min` means sorting by the minimum execution time.
+ The `ave` means sorting by the average execution time.
+ and write it into `profile_path`. The default profile_path is `/tmp/profile`.
+ profile_path (str, optional) : If state == 'All', it will generate timeline,
+
+ Raises:
+ ValueError: If `sorted_key` is not in
+ ['calls', 'total', 'max', 'min', 'ave'].
+
+ Examples:
+
+ .. code-block:: python
+
+ # required: gpu
+ import paddle.fluid as fluid
+ import paddle.fluid.profiler as profiler
+
+ profiler.start_profiler('GPU')
+ for iter in range(10):
+ if iter == 2:
+ profiler.reset_profiler()
+ # except each iteration
+ profiler.stop_profiler('total', '/tmp/profile')
+ """
+ if not core.is_profiler_enabled():
+ return
+ sorted_key = 'default' if sorted_key is None else sorted_key
+ if sorted_key not in ['default', 'calls', 'total', 'max', 'min', 'ave']:
+ raise ValueError("The sorted_key must be None or in 'calls', 'total', "
+ "'max', 'min' and 'ave'")
+ key_map = {
+ 'default': core.EventSortingKey.kDefault,
+ 'calls': core.EventSortingKey.kCalls,
+ 'total': core.EventSortingKey.kTotal,
+ 'max': core.EventSortingKey.kMax,
+ 'min': core.EventSortingKey.kMin,
+ 'ave': core.EventSortingKey.kAve,
+ }
+ # TODO(qingqing) : redirect C++ ostream to Python stream.
+ # with core.ostream_redirect(stdout=True, stderr=True):
+ core.disable_profiler(key_map[sorted_key], profile_path)
+
+
+@deprecated(
+ since="2.3.0",
+ update_to="paddle.profiler.Profiler",
+ level=1,
+ reason=
+ "Please use new profiler tool, this profiler tool is no longer maintained.")
+@signature_safe_contextmanager
+def profiler(state,
+ sorted_key=None,
+ profile_path='/tmp/profile',
+ tracer_option='Default'):
+ """
+ The profiler interface. This profiler can be used to profile both CPU and GPU program.
+
+ Args:
+ state (str) : The profiling state, which should be one of 'CPU', 'GPU'
+ or 'All'. 'CPU' means only profiling CPU; 'GPU' means profiling
+ both CPU and GPU; 'All' means profiling both CPU and GPU, and
+ generates timeline as well.
+ sorted_key (str, optional) : The order of profiling results, which
+ should be one of None, 'calls', 'total', 'max', 'min' or 'ave'.
+ Default is None, means the profiling results will be printed
+ in the order of first end time of events.
+ The `calls` means sorting by the number of calls.
+ The `total` means sorting by the total execution time.
+ The `max` means sorting by the maximum execution time.
+ The `min` means sorting by the minimum execution time.
+ The `ave` means sorting by the average execution time.
+ profile_path (str, optional) : If state == 'All', it will generate timeline,
+ and write it into `profile_path`. The default profile_path is `/tmp/profile`.
+ tracer_option (str, optional) : tracer_option can be one of ['Default', 'OpDetail', 'AllOpDetail'], it
+ can control the profile level and print the different level profile result. `Default` option print
+ the different Op type profiling result and the `OpDetail` option print the detail profiling
+ result of different op types such as compute and data transform, `AllOpDetail` option
+ print the detail profiling result of different op name same as `OpDetail`.
+
+ Raises:
+ ValueError: If `state` is not in ['CPU', 'GPU', 'All']. If `sorted_key` is
+ not in ['calls', 'total', 'max', 'min', 'ave'].
+
+ Examples:
+
+ .. code-block:: python
+
+ # required: gpu
+ import paddle.fluid as fluid
+ import paddle.fluid.profiler as profiler
+ import numpy as np
+ import paddle
+ paddle.enable_static()
+
+ epoc = 8
+ dshape = [4, 3, 28, 28]
+ data = fluid.data(name='data', shape=[None, 3, 28, 28], dtype='float32')
+ conv = fluid.layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1])
+
+ place = fluid.CPUPlace()
+ exe = fluid.Executor(place)
+ exe.run(fluid.default_startup_program())
+
+ with profiler.profiler('CPU', 'total', '/tmp/profile', 'Default') as prof:
+ for i in range(epoc):
+ input = np.random.random(dshape).astype('float32')
+ exe.run(fluid.default_main_program(), feed={'data': input})
+
+ Examples Results:
+
+ .. code-block:: text
+
+ #### Examples Results ####
+ #### 1) sorted_key = 'total', 'calls', 'max', 'min', 'ave' ####
+ # The only difference in 5 sorted_key results is the following sentence:
+ # "Sorted by number of xxx in descending order in the same thread."
+ # The reason is that in this example, above 5 columns are already sorted.
+ -------------------------> Profiling Report <-------------------------
+
+ Place: CPU
+ Time unit: ms
+ Sorted by total time in descending order in the same thread
+ #Sorted by number of calls in descending order in the same thread
+ #Sorted by number of max in descending order in the same thread
+ #Sorted by number of min in descending order in the same thread
+ #Sorted by number of avg in descending order in the same thread
+
+ Event Calls Total Min. Max. Ave. Ratio.
+ thread0::conv2d 8 129.406 0.304303 127.076 16.1758 0.983319
+ thread0::elementwise_add 8 2.11865 0.193486 0.525592 0.264832 0.016099
+ thread0::feed 8 0.076649 0.006834 0.024616 0.00958112 0.000582432
+
+ #### 2) sorted_key = None ####
+ # Since the profiling results are printed in the order of first end time of Ops,
+ # the printed order is feed->conv2d->elementwise_add
+ -------------------------> Profiling Report <-------------------------
+
+ Place: CPU
+ Time unit: ms
+ Sorted by event first end time in descending order in the same thread
+
+ Event Calls Total Min. Max. Ave. Ratio.
+ thread0::feed 8 0.077419 0.006608 0.023349 0.00967738 0.00775934
+ thread0::conv2d 8 7.93456 0.291385 5.63342 0.99182 0.795243
+ thread0::elementwise_add 8 1.96555 0.191884 0.518004 0.245693 0.196998
+ """
+ start_profiler(state, tracer_option)
+ try:
+ yield
+ finally:
+ stop_profiler(sorted_key, profile_path)
+
+
+@signature_safe_contextmanager
+def _nvprof_range(iter_id, start, end, exit_after_prof=True):
+ '''
+ A range profiler interface (not public yet).
+
+ Examples:
+
+ .. code-block:: python
+
+ model = Model()
+ for i in range(max_iter):
+ paddle.fluid.profiler._nvprof_range(i, 10, 20):
+ out = model(in)
+ '''
+ try:
+ if iter_id == start:
+ core.nvprof_start()
+ core.nvprof_enable_record_event()
+ if iter_id >= start:
+ core.nvprof_nvtx_push(str(iter_id))
+ yield
+ finally:
+ if iter_id < end:
+ core.nvprof_nvtx_pop()
+ if iter_id == end:
+ core.nvprof_stop()
+ if exit_after_prof:
+ sys.exit()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/data_feed_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/data_feed_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..daa5fc54b3b2f3de7e64a34381907f61331196a3
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/data_feed_pb2.py
@@ -0,0 +1,350 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: data_feed.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='data_feed.proto',
+ package='paddle.framework',
+ syntax='proto2',
+ serialized_pb=_b('\n\x0f\x64\x61ta_feed.proto\x12\x10paddle.framework\"b\n\x04Slot\x12\x0c\n\x04name\x18\x01 \x02(\t\x12\x0c\n\x04type\x18\x02 \x02(\t\x12\x17\n\x08is_dense\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x16\n\x07is_used\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\r\n\x05shape\x18\x05 \x03(\x05\"H\n\rMultiSlotDesc\x12%\n\x05slots\x18\x01 \x03(\x0b\x32\x16.paddle.framework.Slot\x12\x10\n\x08uid_slot\x18\x02 \x01(\t\"\x95\x02\n\x0bGraphConfig\x12\x16\n\x0bwalk_degree\x18\x01 \x01(\x05:\x01\x31\x12\x14\n\x08walk_len\x18\x02 \x01(\x05:\x02\x32\x30\x12\x11\n\x06window\x18\x03 \x01(\x05:\x01\x35\x12%\n\x17once_sample_startid_len\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\"\n\x16sample_times_one_chunk\x18\x05 \x01(\x05:\x02\x31\x30\x12\x15\n\nbatch_size\x18\x06 \x01(\x05:\x01\x31\x12\x15\n\ndebug_mode\x18\x07 \x01(\x05:\x01\x30\x12\x17\n\x0f\x66irst_node_type\x18\x08 \x01(\t\x12\x11\n\tmeta_path\x18\t \x01(\t\x12 \n\x12gpu_graph_training\x18\n \x01(\x08:\x04true\"\xac\x02\n\x0c\x44\x61taFeedDesc\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x16\n\nbatch_size\x18\x02 \x01(\x05:\x02\x33\x32\x12\x38\n\x0fmulti_slot_desc\x18\x03 \x01(\x0b\x32\x1f.paddle.framework.MultiSlotDesc\x12\x14\n\x0cpipe_command\x18\x04 \x01(\t\x12\x12\n\nthread_num\x18\x05 \x01(\x05\x12\x13\n\x0brank_offset\x18\x06 \x01(\t\x12\x19\n\rpv_batch_size\x18\x07 \x01(\x05:\x02\x33\x32\x12\x15\n\ninput_type\x18\x08 \x01(\x05:\x01\x30\x12\x16\n\x0eso_parser_name\x18\t \x01(\t\x12\x33\n\x0cgraph_config\x18\n \x01(\x0b\x32\x1d.paddle.framework.GraphConfig')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+
+_SLOT = _descriptor.Descriptor(
+ name='Slot',
+ full_name='paddle.framework.Slot',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.Slot.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.Slot.type', index=1,
+ number=2, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_dense', full_name='paddle.framework.Slot.is_dense', index=2,
+ number=3, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_used', full_name='paddle.framework.Slot.is_used', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='shape', full_name='paddle.framework.Slot.shape', index=4,
+ number=5, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=37,
+ serialized_end=135,
+)
+
+
+_MULTISLOTDESC = _descriptor.Descriptor(
+ name='MultiSlotDesc',
+ full_name='paddle.framework.MultiSlotDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='slots', full_name='paddle.framework.MultiSlotDesc.slots', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='uid_slot', full_name='paddle.framework.MultiSlotDesc.uid_slot', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=137,
+ serialized_end=209,
+)
+
+
+_GRAPHCONFIG = _descriptor.Descriptor(
+ name='GraphConfig',
+ full_name='paddle.framework.GraphConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='walk_degree', full_name='paddle.framework.GraphConfig.walk_degree', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='walk_len', full_name='paddle.framework.GraphConfig.walk_len', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=20,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='window', full_name='paddle.framework.GraphConfig.window', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=5,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='once_sample_startid_len', full_name='paddle.framework.GraphConfig.once_sample_startid_len', index=3,
+ number=4, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=8000,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sample_times_one_chunk', full_name='paddle.framework.GraphConfig.sample_times_one_chunk', index=4,
+ number=5, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=10,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='batch_size', full_name='paddle.framework.GraphConfig.batch_size', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='debug_mode', full_name='paddle.framework.GraphConfig.debug_mode', index=6,
+ number=7, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='first_node_type', full_name='paddle.framework.GraphConfig.first_node_type', index=7,
+ number=8, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='meta_path', full_name='paddle.framework.GraphConfig.meta_path', index=8,
+ number=9, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='gpu_graph_training', full_name='paddle.framework.GraphConfig.gpu_graph_training', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=212,
+ serialized_end=489,
+)
+
+
+_DATAFEEDDESC = _descriptor.Descriptor(
+ name='DataFeedDesc',
+ full_name='paddle.framework.DataFeedDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.DataFeedDesc.name', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='batch_size', full_name='paddle.framework.DataFeedDesc.batch_size', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=32,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='multi_slot_desc', full_name='paddle.framework.DataFeedDesc.multi_slot_desc', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pipe_command', full_name='paddle.framework.DataFeedDesc.pipe_command', index=3,
+ number=4, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='thread_num', full_name='paddle.framework.DataFeedDesc.thread_num', index=4,
+ number=5, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='rank_offset', full_name='paddle.framework.DataFeedDesc.rank_offset', index=5,
+ number=6, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pv_batch_size', full_name='paddle.framework.DataFeedDesc.pv_batch_size', index=6,
+ number=7, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=32,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='input_type', full_name='paddle.framework.DataFeedDesc.input_type', index=7,
+ number=8, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='so_parser_name', full_name='paddle.framework.DataFeedDesc.so_parser_name', index=8,
+ number=9, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='graph_config', full_name='paddle.framework.DataFeedDesc.graph_config', index=9,
+ number=10, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=492,
+ serialized_end=792,
+)
+
+_MULTISLOTDESC.fields_by_name['slots'].message_type = _SLOT
+_DATAFEEDDESC.fields_by_name['multi_slot_desc'].message_type = _MULTISLOTDESC
+_DATAFEEDDESC.fields_by_name['graph_config'].message_type = _GRAPHCONFIG
+DESCRIPTOR.message_types_by_name['Slot'] = _SLOT
+DESCRIPTOR.message_types_by_name['MultiSlotDesc'] = _MULTISLOTDESC
+DESCRIPTOR.message_types_by_name['GraphConfig'] = _GRAPHCONFIG
+DESCRIPTOR.message_types_by_name['DataFeedDesc'] = _DATAFEEDDESC
+
+Slot = _reflection.GeneratedProtocolMessageType('Slot', (_message.Message,), dict(
+ DESCRIPTOR = _SLOT,
+ __module__ = 'data_feed_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.Slot)
+ ))
+_sym_db.RegisterMessage(Slot)
+
+MultiSlotDesc = _reflection.GeneratedProtocolMessageType('MultiSlotDesc', (_message.Message,), dict(
+ DESCRIPTOR = _MULTISLOTDESC,
+ __module__ = 'data_feed_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.MultiSlotDesc)
+ ))
+_sym_db.RegisterMessage(MultiSlotDesc)
+
+GraphConfig = _reflection.GeneratedProtocolMessageType('GraphConfig', (_message.Message,), dict(
+ DESCRIPTOR = _GRAPHCONFIG,
+ __module__ = 'data_feed_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.GraphConfig)
+ ))
+_sym_db.RegisterMessage(GraphConfig)
+
+DataFeedDesc = _reflection.GeneratedProtocolMessageType('DataFeedDesc', (_message.Message,), dict(
+ DESCRIPTOR = _DATAFEEDDESC,
+ __module__ = 'data_feed_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.DataFeedDesc)
+ ))
+_sym_db.RegisterMessage(DataFeedDesc)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/distributed_strategy_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/distributed_strategy_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ba70f2c82f3ec10ab6786b89887f3fb2bed2bd7
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/distributed_strategy_pb2.py
@@ -0,0 +1,2716 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: distributed_strategy.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='distributed_strategy.proto',
+ package='paddle.fleet',
+ syntax='proto2',
+ serialized_pb=_b('\n\x1a\x64istributed_strategy.proto\x12\x0cpaddle.fleet\"}\n\x0fRecomputeConfig\x12\x13\n\x0b\x63heckpoints\x18\x01 \x03(\t\x12\x1d\n\x0e\x65nable_offload\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x18\n\x10\x63heckpoint_shape\x18\x03 \x03(\x05\x12\x1c\n\renable_tuning\x18\x04 \x01(\x08:\x05\x66\x61lse\"\xe2\x03\n\x0eShardingConfig\x12\x37\n\x19sharding_segment_strategy\x18\x01 \x01(\t:\x14segment_broadcast_MB\x12 \n\x14segment_broadcast_MB\x18\x02 \x01(\x02:\x02\x33\x32\x12\x17\n\x0fsegment_anchors\x18\x03 \x03(\t\x12\x1a\n\x0fsharding_degree\x18\x04 \x01(\x05:\x01\x38\x12\x14\n\tmp_degree\x18\x05 \x01(\x05:\x01\x31\x12\x14\n\tdp_degree\x18\x06 \x01(\x05:\x01\x31\x12\x18\n\thybrid_dp\x18\x07 \x01(\x08:\x05\x66\x61lse\x12\"\n\x17gradient_merge_acc_step\x18\x08 \x01(\x05:\x01\x31\x12\x1f\n\x10optimize_offload\x18\t \x01(\x08:\x05\x66\x61lse\x12\'\n\x18pp_allreduce_in_optimize\x18\n \x01(\x08:\x05\x66\x61lse\x12\x14\n\tpp_degree\x18\x0b \x01(\x05:\x01\x31\x12\x1c\n\roptimize_cast\x18\x0c \x01(\x08:\x05\x66\x61lse\x12(\n\x19_dp_as_optimizer_sharding\x18\r \x01(\x08:\x05\x66\x61lse\x12\x10\n\x05stage\x18\x0e \x01(\x05:\x01\x31\x12\x1c\n\renable_tuning\x18\x0f \x01(\x08:\x05\x66\x61lse\"m\n\x0cHybridConfig\x12\x15\n\tdp_degree\x18\x01 \x01(\x05:\x02-1\x12\x14\n\tmp_degree\x18\x02 \x01(\x05:\x01\x31\x12\x14\n\tpp_degree\x18\x03 \x01(\x05:\x01\x31\x12\x1a\n\x0fsharding_degree\x18\x04 \x01(\x05:\x01\x31\"\xff\x02\n\tAMPConfig\x12 \n\x11init_loss_scaling\x18\x01 \x01(\x02:\x05\x33\x32\x37\x36\x38\x12 \n\x12incr_every_n_steps\x18\x02 \x01(\x05:\x04\x31\x30\x30\x30\x12\"\n\x17\x64\x65\x63r_every_n_nan_or_inf\x18\x03 \x01(\x05:\x01\x32\x12\x15\n\nincr_ratio\x18\x04 \x01(\x02:\x01\x32\x12\x17\n\ndecr_ratio\x18\x05 \x01(\x02:\x03\x30.8\x12&\n\x18use_dynamic_loss_scaling\x18\x06 \x01(\x08:\x04true\x12\x19\n\x11\x63ustom_white_list\x18\x07 \x03(\t\x12\x19\n\x11\x63ustom_black_list\x18\x08 \x03(\t\x12\x1d\n\x15\x63ustom_black_varnames\x18\t \x03(\t\x12\x1c\n\ruse_pure_fp16\x18\n \x01(\x08:\x05\x66\x61lse\x12\x1c\n\x0euse_fp16_guard\x18\x0b \x01(\x08:\x04true\x12!\n\x12use_optimizer_fp16\x18\x0c \x01(\x08:\x05\x66\x61lse\";\n\x0eLocalSGDConfig\x12\x12\n\x07k_steps\x18\x01 \x01(\x05:\x01\x31\x12\x15\n\nbegin_step\x18\x02 \x01(\x05:\x01\x31\"H\n\x16\x41\x64\x61ptiveLocalSGDConfig\x12\x17\n\x0cinit_k_steps\x18\x01 \x01(\x05:\x01\x31\x12\x15\n\nbegin_step\x18\x02 \x01(\x05:\x01\x31\"<\n\x13GradientMergeConfig\x12\x12\n\x07k_steps\x18\x01 \x01(\x05:\x01\x31\x12\x11\n\x03\x61vg\x18\x02 \x01(\x08:\x04true\"S\n\tDGCConfig\x12\x1c\n\x11rampup_begin_step\x18\x01 \x01(\x05:\x01\x30\x12\x16\n\x0brampup_step\x18\x02 \x01(\x05:\x01\x31\x12\x10\n\x08sparsity\x18\x03 \x03(\x02\"\x81\x01\n\nLarsConfig\x12\x19\n\nlars_coeff\x18\x01 \x01(\x02:\x05\x30.001\x12!\n\x11lars_weight_decay\x18\x02 \x01(\x02:\x06\x30.0005\x12\x12\n\x07\x65psilon\x18\x03 \x01(\x02:\x01\x30\x12!\n\x19\x65xclude_from_weight_decay\x18\x04 \x03(\t\"P\n\nLambConfig\x12\x1f\n\x11lamb_weight_decay\x18\x01 \x01(\x02:\x04\x30.01\x12!\n\x19\x65xclude_from_weight_decay\x18\x02 \x03(\t\"\xf6\x04\n\rBuildStrategy\x12*\n\x1b\x65nable_sequential_execution\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\'\n\x18\x66use_elewise_add_act_ops\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0f\x66use_bn_act_ops\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\'\n\x18\x66use_relu_depthwise_conv\x18\x04 \x01(\x08:\x05\x66\x61lse\x12!\n\x12\x66use_broadcast_ops\x18\x05 \x01(\x08:\x05\x66\x61lse\x12%\n\x16\x66use_all_optimizer_ops\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x1d\n\x0e\x65nable_inplace\x18\x07 \x01(\x08:\x05\x66\x61lse\x12/\n!enable_backward_optimizer_op_deps\x18\x08 \x01(\x08:\x04true\x12$\n\x15\x63\x61\x63he_runtime_context\x18\t \x01(\x08:\x05\x66\x61lse\x12!\n\x13\x66use_bn_add_act_ops\x18\n \x01(\x08:\x04true\x12!\n\x12\x65nable_auto_fusion\x18\x0b \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0c\x65nable_addto\x18\x0c \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x10\x66ix_op_run_order\x18\r \x01(\x08:\x05\x66\x61lse\x12\'\n\x18\x61llow_cuda_graph_capture\x18\x0e \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x0freduce_strategy\x18\x0f \x01(\x05:\x01\x30\x12!\n\x12\x66use_gemm_epilogue\x18\x10 \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x13\x64\x65\x62ug_graphviz_path\x18\x11 \x01(\t\"\x9a\x01\n\x11\x45xecutionStrategy\x12\x16\n\x0bnum_threads\x18\x01 \x01(\x05:\x01\x31\x12(\n\x1cnum_iteration_per_drop_scope\x18\x02 \x01(\x05:\x02\x31\x30\x12 \n\x15num_iteration_per_run\x18\x03 \x01(\x05:\x01\x31\x12!\n\x12use_thread_barrier\x18\x04 \x01(\x08:\x05\x66\x61lse\"Q\n\x13GradientScaleConfig\x12\x1b\n\x0escale_strategy\x18\x01 \x01(\t:\x03\x61vg\x12\x1d\n\x0escale_gradient\x18\x02 \x01(\x08:\x05\x66\x61lse\"\x89\x03\n\x0b\x41syncConfig\x12\x13\n\x07k_steps\x18\x01 \x01(\x05:\x02-1\x12\x1c\n\x11max_merge_var_num\x18\x02 \x01(\x05:\x01\x31\x12\x1b\n\x0fsend_queue_size\x18\x03 \x01(\x05:\x02\x31\x36\x12&\n\x17independent_recv_thread\x18\x04 \x01(\x08:\x05\x66\x61lse\x12(\n\x1dmin_send_grad_num_before_recv\x18\x05 \x01(\x05:\x01\x31\x12\x1b\n\x10thread_pool_size\x18\x06 \x01(\x05:\x01\x31\x12\x1a\n\x0fsend_wait_times\x18\x07 \x01(\x05:\x01\x31\x12&\n\x17runtime_split_send_recv\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x1c\n\x0elaunch_barrier\x18\t \x01(\x08:\x04true\x12&\n\x19heter_worker_device_guard\x18\n \x01(\t:\x03\x63pu\x12\x1a\n\x0elr_decay_steps\x18\x0b \x01(\x05:\x02\x31\x30\x12\x15\n\nuse_ps_gpu\x18\x0c \x01(\x05:\x01\x30\"\xc3\x01\n\x11TrainerDescConfig\x12\x18\n\x10\x64ump_fields_path\x18\x01 \x01(\t\x12\x13\n\x0b\x64ump_fields\x18\x02 \x03(\t\x12\x12\n\ndump_param\x18\x03 \x03(\t\x12\x16\n\x0estat_var_names\x18\x04 \x03(\t\x12\x0f\n\x07trainer\x18\x05 \x01(\t\x12\x15\n\rdevice_worker\x18\x06 \x01(\t\x12\x14\n\x0clocal_sparse\x18\x07 \x03(\t\x12\x15\n\rremote_sparse\x18\x08 \x03(\t\"\xae\x01\n\x0ePipelineConfig\x12\x1b\n\x10micro_batch_size\x18\x01 \x01(\x05:\x01\x31\x12\x1b\n\x10\x61\x63\x63umulate_steps\x18\x02 \x01(\x05:\x01\x31\x12\x1b\n\rschedule_mode\x18\x03 \x01(\t:\x04\x31\x46\x31\x42\x12\x1d\n\x0fp2p_cache_shape\x18\x04 \x01(\x08:\x04true\x12&\n\x18\x65nable_partial_send_recv\x18\x05 \x01(\x08:\x04true\"W\n\x14TensorParallelConfig\x12!\n\x16tensor_parallel_degree\x18\x01 \x01(\x05:\x01\x31\x12\x1c\n\x10tensor_init_seed\x18\x02 \x01(\x05:\x02-1\"\x8c\x01\n\tQatConfig\x12\"\n\x14\x63hannel_wise_abs_max\x18\x01 \x01(\x08:\x04true\x12\x16\n\x0bweight_bits\x18\x02 \x01(\x05:\x01\x38\x12\x1a\n\x0f\x61\x63tivation_bits\x18\x03 \x01(\x05:\x01\x38\x12\x19\n\x11not_quant_pattern\x18\x04 \x03(\t\x12\x0c\n\x04\x61lgo\x18\x05 \x01(\t\"\x9b\x03\n\x0eTableParameter\x12\x10\n\x08table_id\x18\x01 \x01(\x04\x12\x12\n\ntable_name\x18\x02 \x01(\t\x12\x13\n\x0btable_class\x18\x03 \x01(\t\x12\x17\n\tshard_num\x18\x04 \x01(\x04:\x04\x31\x30\x30\x30\x12%\n\x04type\x18\x05 \x01(\x0e\x32\x17.paddle.fleet.TableType\x12\x36\n\x08\x61\x63\x63\x65ssor\x18\x06 \x01(\x0b\x32$.paddle.fleet.TableAccessorParameter\x12\x1f\n\x10\x63ompress_in_save\x18\x07 \x01(\x08:\x05\x66\x61lse\x12\'\n\x19\x65nable_sparse_table_cache\x18\n \x01(\x08:\x04true\x12(\n\x17sparse_table_cache_rate\x18\x0b \x01(\x01:\x07\x30.00055\x12\'\n\x1bsparse_table_cache_file_num\x18\x0c \x01(\r:\x02\x31\x36\x12\x1c\n\renable_revert\x18\r \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x10shard_merge_rate\x18\x0e \x01(\x02:\x01\x31\"\xac\x03\n\x16TableAccessorParameter\x12\x16\n\x0e\x61\x63\x63\x65ssor_class\x18\x01 \x01(\t\x12\x13\n\x07\x66\x65\x61_dim\x18\x04 \x01(\r:\x02\x31\x31\x12\x15\n\nembedx_dim\x18\x05 \x01(\r:\x01\x38\x12\x1c\n\x10\x65mbedx_threshold\x18\x06 \x01(\r:\x02\x31\x30\x12>\n\x12\x63tr_accessor_param\x18\x07 \x01(\x0b\x32\".paddle.fleet.CtrAccessorParameter\x12K\n\x19table_accessor_save_param\x18\x08 \x03(\x0b\x32(.paddle.fleet.TableAccessorSaveParameter\x12\x33\n\x0f\x65mbed_sgd_param\x18\n \x01(\x0b\x32\x1a.paddle.fleet.SGDParameter\x12\x34\n\x10\x65mbedx_sgd_param\x18\x0b \x01(\x0b\x32\x1a.paddle.fleet.SGDParameter\x12\x38\n\x0fgraph_sgd_param\x18\x0c \x01(\x0b\x32\x1f.paddle.fleet.GraphSGDParameter\"S\n\x11GraphSGDParameter\x12\x19\n\x0bnodeid_slot\x18\x01 \x01(\r:\x04\x39\x30\x30\x38\x12#\n\x15\x66\x65\x61ture_learning_rate\x18\x02 \x01(\x02:\x04\x30.05\"\xc8\x01\n\x0cSGDParameter\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x38\n\x05naive\x18\x02 \x01(\x0b\x32).paddle.fleet.SparseNaiveSGDRuleParameter\x12<\n\x07\x61\x64\x61grad\x18\x03 \x01(\x0b\x32+.paddle.fleet.SparseAdagradSGDRuleParameter\x12\x32\n\x04\x61\x64\x61m\x18\x04 \x01(\x0b\x32$.paddle.fleet.SparseAdamSGDParameter\"p\n\x1bSparseNaiveSGDRuleParameter\x12\x1b\n\rlearning_rate\x18\x01 \x01(\x01:\x04\x30.05\x12\x1d\n\rinitial_range\x18\x02 \x01(\x01:\x06\x30.0001\x12\x15\n\rweight_bounds\x18\x03 \x03(\x02\"\x8c\x01\n\x1dSparseAdagradSGDRuleParameter\x12\x1b\n\rlearning_rate\x18\x01 \x01(\x01:\x04\x30.05\x12\x18\n\rinitial_g2sum\x18\x02 \x01(\x01:\x01\x33\x12\x1d\n\rinitial_range\x18\x03 \x01(\x01:\x06\x30.0001\x12\x15\n\rweight_bounds\x18\x04 \x03(\x02\"\xc8\x01\n\x16SparseAdamSGDParameter\x12\x1c\n\rlearning_rate\x18\x01 \x01(\x01:\x05\x30.001\x12\x1d\n\rinitial_range\x18\x02 \x01(\x01:\x06\x30.0001\x12\x1d\n\x10\x62\x65ta1_decay_rate\x18\x03 \x01(\x01:\x03\x30.9\x12\x1f\n\x10\x62\x65ta2_decay_rate\x18\x04 \x01(\x01:\x05\x30.999\x12\x1a\n\x0b\x61\x64\x61_epsilon\x18\x05 \x01(\x01:\x05\x31\x65-08\x12\x15\n\rweight_bounds\x18\x06 \x03(\x02\"\xca\x02\n\x14\x43trAccessorParameter\x12\x19\n\x0cnonclk_coeff\x18\x01 \x01(\x02:\x03\x30.1\x12\x16\n\x0b\x63lick_coeff\x18\x02 \x01(\x02:\x01\x31\x12\x1b\n\x0e\x62\x61se_threshold\x18\x03 \x01(\x02:\x03\x31.5\x12\x1d\n\x0f\x64\x65lta_threshold\x18\x04 \x01(\x02:\x04\x30.25\x12\x1b\n\x0f\x64\x65lta_keep_days\x18\x05 \x01(\x02:\x02\x31\x36\x12#\n\x15show_click_decay_rate\x18\x06 \x01(\x02:\x04\x30.98\x12\x1d\n\x10\x64\x65lete_threshold\x18\x07 \x01(\x02:\x03\x30.8\x12$\n\x18\x64\x65lete_after_unseen_days\x18\x08 \x01(\x02:\x02\x33\x30\x12\"\n\x17ssd_unseenday_threshold\x18\t \x01(\x05:\x01\x31\x12\x18\n\nshow_scale\x18\n \x01(\x08:\x04true\"S\n\x1aTableAccessorSaveParameter\x12\r\n\x05param\x18\x01 \x01(\r\x12\x11\n\tconverter\x18\x02 \x01(\t\x12\x13\n\x0b\x64\x65\x63onverter\x18\x03 \x01(\t\"R\n\x11\x46sClientParameter\x12\x0b\n\x03uri\x18\x01 \x01(\t\x12\x0c\n\x04user\x18\x02 \x01(\t\x12\x0e\n\x06passwd\x18\x03 \x01(\t\x12\x12\n\nhadoop_bin\x18\x04 \x01(\t\"\xa3\x13\n\x13\x44istributedStrategy\x12,\n\x04mode\x18\x01 \x01(\x0e\x32\x12.paddle.fleet.Mode:\nCOLLECTIVE\x12\x12\n\x03\x61mp\x18\x02 \x01(\x08:\x05\x66\x61lse\x12\x18\n\trecompute\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x17\n\x08localsgd\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x12\n\x03\x64gc\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1d\n\x0egradient_merge\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x13\n\x04lars\x18\x07 \x01(\x08:\x05\x66\x61lse\x12\x13\n\x04lamb\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x17\n\x08pipeline\x18\t \x01(\x08:\x05\x66\x61lse\x12\x16\n\x07\x65lastic\x18\n \x01(\x08:\x05\x66\x61lse\x12\x13\n\x04\x61uto\x18\x0b \x01(\x08:\x05\x66\x61lse\x12\x14\n\x06\x61_sync\x18\x0c \x01(\x08:\x04true\x12!\n\x13sync_nccl_allreduce\x18\r \x01(\x08:\x04true\x12\x18\n\rnccl_comm_num\x18\x0e \x01(\x05:\x01\x31\x12)\n\x1ause_hierarchical_allreduce\x18\x0f \x01(\x08:\x05\x66\x61lse\x12.\n#hierarchical_allreduce_inter_nranks\x18\x10 \x01(\x05:\x01\x31\x12\x1e\n\x0fsync_batch_norm\x18\x11 \x01(\x08:\x05\x66\x61lse\x12!\n\x13\x66use_all_reduce_ops\x18\x12 \x01(\x08:\x04true\x12 \n\x14\x66use_grad_size_in_MB\x18\x13 \x01(\x05:\x02\x33\x32\x12$\n\x18\x66use_grad_size_in_TFLOPS\x18\x14 \x01(\x02:\x02\x35\x30\x12&\n\x17\x63udnn_exhaustive_search\x18\x15 \x01(\x08:\x05\x66\x61lse\x12&\n\x19\x63onv_workspace_size_limit\x18\x16 \x01(\x05:\x03\x35\x31\x32\x12\x31\n\"cudnn_batchnorm_spatial_persistent\x18\x17 \x01(\x08:\x05\x66\x61lse\x12 \n\x11\x61\x64\x61ptive_localsgd\x18\x18 \x01(\x08:\x05\x66\x61lse\x12\x1d\n\x0e\x66p16_allreduce\x18\x19 \x01(\x08:\x05\x66\x61lse\x12\x17\n\x08sharding\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\"\n\x17last_comm_group_size_MB\x18\x1b \x01(\x02:\x01\x31\x12%\n\x16\x66ind_unused_parameters\x18\x1c \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0ftensor_parallel\x18\x1d \x01(\x08:\x05\x66\x61lse\x12)\n\x1awithout_graph_optimization\x18\x1e \x01(\x08:\x05\x66\x61lse\x12 \n\x15\x66use_grad_size_in_num\x18\x1f \x01(\x05:\x01\x38\x12$\n\x15\x63\x61lc_comm_same_stream\x18 \x01(\x08:\x05\x66\x61lse\x12\x12\n\x03\x61sp\x18! \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0f\x66use_grad_merge\x18\" \x01(\x08:\x05\x66\x61lse\x12\x18\n\tsemi_auto\x18# \x01(\x08:\x05\x66\x61lse\x12\x19\n\nadam_d2sum\x18$ \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x0b\x61uto_search\x18% \x01(\x08:\x05\x66\x61lse\x12\x1d\n\x0eheter_ccl_mode\x18& \x01(\x08:\x05\x66\x61lse\x12\x1c\n\ris_fl_ps_mode\x18\' \x01(\x08:\x05\x66\x61lse\x12\x1f\n\x10with_coordinator\x18( \x01(\x08:\x05\x66\x61lse\x12\x12\n\x03qat\x18) \x01(\x08:\x05\x66\x61lse\x12\x18\n\nsplit_data\x18* \x01(\x08:\x04true\x12\x38\n\x11recompute_configs\x18\x65 \x01(\x0b\x32\x1d.paddle.fleet.RecomputeConfig\x12,\n\x0b\x61mp_configs\x18\x66 \x01(\x0b\x32\x17.paddle.fleet.AMPConfig\x12\x36\n\x10localsgd_configs\x18g \x01(\x0b\x32\x1c.paddle.fleet.LocalSGDConfig\x12\x41\n\x16gradient_merge_configs\x18h \x01(\x0b\x32!.paddle.fleet.GradientMergeConfig\x12,\n\x0b\x64gc_configs\x18i \x01(\x0b\x32\x17.paddle.fleet.DGCConfig\x12\x36\n\x10pipeline_configs\x18j \x01(\x0b\x32\x1c.paddle.fleet.PipelineConfig\x12\x31\n\x0e\x61_sync_configs\x18k \x01(\x0b\x32\x19.paddle.fleet.AsyncConfig\x12.\n\x0clars_configs\x18l \x01(\x0b\x32\x18.paddle.fleet.LarsConfig\x12.\n\x0clamb_configs\x18m \x01(\x0b\x32\x18.paddle.fleet.LambConfig\x12G\n\x19\x61\x64\x61ptive_localsgd_configs\x18n \x01(\x0b\x32$.paddle.fleet.AdaptiveLocalSGDConfig\x12\x36\n\x10sharding_configs\x18o \x01(\x0b\x32\x1c.paddle.fleet.ShardingConfig\x12\x32\n\x0ehybrid_configs\x18p \x01(\x0b\x32\x1a.paddle.fleet.HybridConfig\x12\x43\n\x17tensor_parallel_configs\x18q \x01(\x0b\x32\".paddle.fleet.TensorParallelConfig\x12=\n\x14trainer_desc_configs\x18r \x01(\x0b\x32\x1f.paddle.fleet.TrainerDescConfig\x12:\n\x14\x64ownpour_table_param\x18s \x03(\x0b\x32\x1c.paddle.fleet.TableParameter\x12\x38\n\x0f\x66s_client_param\x18t \x01(\x0b\x32\x1f.paddle.fleet.FsClientParameter\x12,\n\x0bqat_configs\x18u \x01(\x0b\x32\x17.paddle.fleet.QatConfig\x12\x34\n\x0e\x62uild_strategy\x18\xc9\x01 \x01(\x0b\x32\x1b.paddle.fleet.BuildStrategy\x12<\n\x12\x65xecution_strategy\x18\xca\x01 \x01(\x0b\x32\x1f.paddle.fleet.ExecutionStrategy\x12\x42\n\x16gradient_scale_configs\x18\xcb\x01 \x01(\x0b\x32!.paddle.fleet.GradientScaleConfig\"\xfe\x01\n\x12\x44istributedJobInfo\x12\x12\n\nworker_num\x18\x01 \x01(\x05\x12\x12\n\nserver_num\x18\x02 \x01(\x05\x12\x12\n\nworker_ips\x18\x03 \x03(\t\x12\x18\n\x10server_endpoints\x18\x04 \x03(\t\x12\x16\n\x0eorigin_startup\x18\x05 \x01(\t\x12\x13\n\x0borigin_main\x18\x06 \x01(\t\x12\x18\n\x10\x64istributed_main\x18\x07 \x01(\t\x12\x16\n\x0eoptimizer_name\x18\x08 \x01(\t\x12\x33\n\x08strategy\x18\x65 \x01(\x0b\x32!.paddle.fleet.DistributedStrategy*7\n\x04Mode\x12\x0e\n\nCOLLECTIVE\x10\x01\x12\x06\n\x02PS\x10\x02\x12\x0c\n\x08PIPELINE\x10\x03\x12\t\n\x05HETER\x10\x04*4\n\tTableType\x12\x13\n\x0fPS_SPARSE_TABLE\x10\x00\x12\x12\n\x0ePS_DENSE_TABLE\x10\x01')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_MODE = _descriptor.EnumDescriptor(
+ name='Mode',
+ full_name='paddle.fleet.Mode',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='COLLECTIVE', index=0, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PS', index=1, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PIPELINE', index=2, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='HETER', index=3, number=4,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=8347,
+ serialized_end=8402,
+)
+_sym_db.RegisterEnumDescriptor(_MODE)
+
+Mode = enum_type_wrapper.EnumTypeWrapper(_MODE)
+_TABLETYPE = _descriptor.EnumDescriptor(
+ name='TableType',
+ full_name='paddle.fleet.TableType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='PS_SPARSE_TABLE', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PS_DENSE_TABLE', index=1, number=1,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=8404,
+ serialized_end=8456,
+)
+_sym_db.RegisterEnumDescriptor(_TABLETYPE)
+
+TableType = enum_type_wrapper.EnumTypeWrapper(_TABLETYPE)
+COLLECTIVE = 1
+PS = 2
+PIPELINE = 3
+HETER = 4
+PS_SPARSE_TABLE = 0
+PS_DENSE_TABLE = 1
+
+
+
+_RECOMPUTECONFIG = _descriptor.Descriptor(
+ name='RecomputeConfig',
+ full_name='paddle.fleet.RecomputeConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='checkpoints', full_name='paddle.fleet.RecomputeConfig.checkpoints', index=0,
+ number=1, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_offload', full_name='paddle.fleet.RecomputeConfig.enable_offload', index=1,
+ number=2, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='checkpoint_shape', full_name='paddle.fleet.RecomputeConfig.checkpoint_shape', index=2,
+ number=3, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_tuning', full_name='paddle.fleet.RecomputeConfig.enable_tuning', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=44,
+ serialized_end=169,
+)
+
+
+_SHARDINGCONFIG = _descriptor.Descriptor(
+ name='ShardingConfig',
+ full_name='paddle.fleet.ShardingConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='sharding_segment_strategy', full_name='paddle.fleet.ShardingConfig.sharding_segment_strategy', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("segment_broadcast_MB").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='segment_broadcast_MB', full_name='paddle.fleet.ShardingConfig.segment_broadcast_MB', index=1,
+ number=2, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(32),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='segment_anchors', full_name='paddle.fleet.ShardingConfig.segment_anchors', index=2,
+ number=3, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sharding_degree', full_name='paddle.fleet.ShardingConfig.sharding_degree', index=3,
+ number=4, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=8,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mp_degree', full_name='paddle.fleet.ShardingConfig.mp_degree', index=4,
+ number=5, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dp_degree', full_name='paddle.fleet.ShardingConfig.dp_degree', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hybrid_dp', full_name='paddle.fleet.ShardingConfig.hybrid_dp', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='gradient_merge_acc_step', full_name='paddle.fleet.ShardingConfig.gradient_merge_acc_step', index=7,
+ number=8, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='optimize_offload', full_name='paddle.fleet.ShardingConfig.optimize_offload', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pp_allreduce_in_optimize', full_name='paddle.fleet.ShardingConfig.pp_allreduce_in_optimize', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pp_degree', full_name='paddle.fleet.ShardingConfig.pp_degree', index=10,
+ number=11, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='optimize_cast', full_name='paddle.fleet.ShardingConfig.optimize_cast', index=11,
+ number=12, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='_dp_as_optimizer_sharding', full_name='paddle.fleet.ShardingConfig._dp_as_optimizer_sharding', index=12,
+ number=13, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='stage', full_name='paddle.fleet.ShardingConfig.stage', index=13,
+ number=14, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_tuning', full_name='paddle.fleet.ShardingConfig.enable_tuning', index=14,
+ number=15, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=172,
+ serialized_end=654,
+)
+
+
+_HYBRIDCONFIG = _descriptor.Descriptor(
+ name='HybridConfig',
+ full_name='paddle.fleet.HybridConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='dp_degree', full_name='paddle.fleet.HybridConfig.dp_degree', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mp_degree', full_name='paddle.fleet.HybridConfig.mp_degree', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pp_degree', full_name='paddle.fleet.HybridConfig.pp_degree', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sharding_degree', full_name='paddle.fleet.HybridConfig.sharding_degree', index=3,
+ number=4, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=656,
+ serialized_end=765,
+)
+
+
+_AMPCONFIG = _descriptor.Descriptor(
+ name='AMPConfig',
+ full_name='paddle.fleet.AMPConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='init_loss_scaling', full_name='paddle.fleet.AMPConfig.init_loss_scaling', index=0,
+ number=1, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(32768),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='incr_every_n_steps', full_name='paddle.fleet.AMPConfig.incr_every_n_steps', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1000,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='decr_every_n_nan_or_inf', full_name='paddle.fleet.AMPConfig.decr_every_n_nan_or_inf', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=2,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='incr_ratio', full_name='paddle.fleet.AMPConfig.incr_ratio', index=3,
+ number=4, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(2),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='decr_ratio', full_name='paddle.fleet.AMPConfig.decr_ratio', index=4,
+ number=5, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.8),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_dynamic_loss_scaling', full_name='paddle.fleet.AMPConfig.use_dynamic_loss_scaling', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='custom_white_list', full_name='paddle.fleet.AMPConfig.custom_white_list', index=6,
+ number=7, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='custom_black_list', full_name='paddle.fleet.AMPConfig.custom_black_list', index=7,
+ number=8, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='custom_black_varnames', full_name='paddle.fleet.AMPConfig.custom_black_varnames', index=8,
+ number=9, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_pure_fp16', full_name='paddle.fleet.AMPConfig.use_pure_fp16', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_fp16_guard', full_name='paddle.fleet.AMPConfig.use_fp16_guard', index=10,
+ number=11, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_optimizer_fp16', full_name='paddle.fleet.AMPConfig.use_optimizer_fp16', index=11,
+ number=12, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=768,
+ serialized_end=1151,
+)
+
+
+_LOCALSGDCONFIG = _descriptor.Descriptor(
+ name='LocalSGDConfig',
+ full_name='paddle.fleet.LocalSGDConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='k_steps', full_name='paddle.fleet.LocalSGDConfig.k_steps', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='begin_step', full_name='paddle.fleet.LocalSGDConfig.begin_step', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1153,
+ serialized_end=1212,
+)
+
+
+_ADAPTIVELOCALSGDCONFIG = _descriptor.Descriptor(
+ name='AdaptiveLocalSGDConfig',
+ full_name='paddle.fleet.AdaptiveLocalSGDConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='init_k_steps', full_name='paddle.fleet.AdaptiveLocalSGDConfig.init_k_steps', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='begin_step', full_name='paddle.fleet.AdaptiveLocalSGDConfig.begin_step', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1214,
+ serialized_end=1286,
+)
+
+
+_GRADIENTMERGECONFIG = _descriptor.Descriptor(
+ name='GradientMergeConfig',
+ full_name='paddle.fleet.GradientMergeConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='k_steps', full_name='paddle.fleet.GradientMergeConfig.k_steps', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='avg', full_name='paddle.fleet.GradientMergeConfig.avg', index=1,
+ number=2, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1288,
+ serialized_end=1348,
+)
+
+
+_DGCCONFIG = _descriptor.Descriptor(
+ name='DGCConfig',
+ full_name='paddle.fleet.DGCConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='rampup_begin_step', full_name='paddle.fleet.DGCConfig.rampup_begin_step', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='rampup_step', full_name='paddle.fleet.DGCConfig.rampup_step', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparsity', full_name='paddle.fleet.DGCConfig.sparsity', index=2,
+ number=3, type=2, cpp_type=6, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1350,
+ serialized_end=1433,
+)
+
+
+_LARSCONFIG = _descriptor.Descriptor(
+ name='LarsConfig',
+ full_name='paddle.fleet.LarsConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='lars_coeff', full_name='paddle.fleet.LarsConfig.lars_coeff', index=0,
+ number=1, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.001),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lars_weight_decay', full_name='paddle.fleet.LarsConfig.lars_weight_decay', index=1,
+ number=2, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.0005),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='epsilon', full_name='paddle.fleet.LarsConfig.epsilon', index=2,
+ number=3, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='exclude_from_weight_decay', full_name='paddle.fleet.LarsConfig.exclude_from_weight_decay', index=3,
+ number=4, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1436,
+ serialized_end=1565,
+)
+
+
+_LAMBCONFIG = _descriptor.Descriptor(
+ name='LambConfig',
+ full_name='paddle.fleet.LambConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='lamb_weight_decay', full_name='paddle.fleet.LambConfig.lamb_weight_decay', index=0,
+ number=1, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.01),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='exclude_from_weight_decay', full_name='paddle.fleet.LambConfig.exclude_from_weight_decay', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1567,
+ serialized_end=1647,
+)
+
+
+_BUILDSTRATEGY = _descriptor.Descriptor(
+ name='BuildStrategy',
+ full_name='paddle.fleet.BuildStrategy',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='enable_sequential_execution', full_name='paddle.fleet.BuildStrategy.enable_sequential_execution', index=0,
+ number=1, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_elewise_add_act_ops', full_name='paddle.fleet.BuildStrategy.fuse_elewise_add_act_ops', index=1,
+ number=2, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_bn_act_ops', full_name='paddle.fleet.BuildStrategy.fuse_bn_act_ops', index=2,
+ number=3, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_relu_depthwise_conv', full_name='paddle.fleet.BuildStrategy.fuse_relu_depthwise_conv', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_broadcast_ops', full_name='paddle.fleet.BuildStrategy.fuse_broadcast_ops', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_all_optimizer_ops', full_name='paddle.fleet.BuildStrategy.fuse_all_optimizer_ops', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_inplace', full_name='paddle.fleet.BuildStrategy.enable_inplace', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_backward_optimizer_op_deps', full_name='paddle.fleet.BuildStrategy.enable_backward_optimizer_op_deps', index=7,
+ number=8, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='cache_runtime_context', full_name='paddle.fleet.BuildStrategy.cache_runtime_context', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_bn_add_act_ops', full_name='paddle.fleet.BuildStrategy.fuse_bn_add_act_ops', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_auto_fusion', full_name='paddle.fleet.BuildStrategy.enable_auto_fusion', index=10,
+ number=11, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_addto', full_name='paddle.fleet.BuildStrategy.enable_addto', index=11,
+ number=12, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fix_op_run_order', full_name='paddle.fleet.BuildStrategy.fix_op_run_order', index=12,
+ number=13, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='allow_cuda_graph_capture', full_name='paddle.fleet.BuildStrategy.allow_cuda_graph_capture', index=13,
+ number=14, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='reduce_strategy', full_name='paddle.fleet.BuildStrategy.reduce_strategy', index=14,
+ number=15, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_gemm_epilogue', full_name='paddle.fleet.BuildStrategy.fuse_gemm_epilogue', index=15,
+ number=16, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='debug_graphviz_path', full_name='paddle.fleet.BuildStrategy.debug_graphviz_path', index=16,
+ number=17, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1650,
+ serialized_end=2280,
+)
+
+
+_EXECUTIONSTRATEGY = _descriptor.Descriptor(
+ name='ExecutionStrategy',
+ full_name='paddle.fleet.ExecutionStrategy',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='num_threads', full_name='paddle.fleet.ExecutionStrategy.num_threads', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_iteration_per_drop_scope', full_name='paddle.fleet.ExecutionStrategy.num_iteration_per_drop_scope', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=10,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_iteration_per_run', full_name='paddle.fleet.ExecutionStrategy.num_iteration_per_run', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_thread_barrier', full_name='paddle.fleet.ExecutionStrategy.use_thread_barrier', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2283,
+ serialized_end=2437,
+)
+
+
+_GRADIENTSCALECONFIG = _descriptor.Descriptor(
+ name='GradientScaleConfig',
+ full_name='paddle.fleet.GradientScaleConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='scale_strategy', full_name='paddle.fleet.GradientScaleConfig.scale_strategy', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("avg").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='scale_gradient', full_name='paddle.fleet.GradientScaleConfig.scale_gradient', index=1,
+ number=2, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2439,
+ serialized_end=2520,
+)
+
+
+_ASYNCCONFIG = _descriptor.Descriptor(
+ name='AsyncConfig',
+ full_name='paddle.fleet.AsyncConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='k_steps', full_name='paddle.fleet.AsyncConfig.k_steps', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='max_merge_var_num', full_name='paddle.fleet.AsyncConfig.max_merge_var_num', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='send_queue_size', full_name='paddle.fleet.AsyncConfig.send_queue_size', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=16,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='independent_recv_thread', full_name='paddle.fleet.AsyncConfig.independent_recv_thread', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='min_send_grad_num_before_recv', full_name='paddle.fleet.AsyncConfig.min_send_grad_num_before_recv', index=4,
+ number=5, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='thread_pool_size', full_name='paddle.fleet.AsyncConfig.thread_pool_size', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='send_wait_times', full_name='paddle.fleet.AsyncConfig.send_wait_times', index=6,
+ number=7, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='runtime_split_send_recv', full_name='paddle.fleet.AsyncConfig.runtime_split_send_recv', index=7,
+ number=8, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='launch_barrier', full_name='paddle.fleet.AsyncConfig.launch_barrier', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='heter_worker_device_guard', full_name='paddle.fleet.AsyncConfig.heter_worker_device_guard', index=9,
+ number=10, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("cpu").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lr_decay_steps', full_name='paddle.fleet.AsyncConfig.lr_decay_steps', index=10,
+ number=11, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=10,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_ps_gpu', full_name='paddle.fleet.AsyncConfig.use_ps_gpu', index=11,
+ number=12, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2523,
+ serialized_end=2916,
+)
+
+
+_TRAINERDESCCONFIG = _descriptor.Descriptor(
+ name='TrainerDescConfig',
+ full_name='paddle.fleet.TrainerDescConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='dump_fields_path', full_name='paddle.fleet.TrainerDescConfig.dump_fields_path', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_fields', full_name='paddle.fleet.TrainerDescConfig.dump_fields', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_param', full_name='paddle.fleet.TrainerDescConfig.dump_param', index=2,
+ number=3, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='stat_var_names', full_name='paddle.fleet.TrainerDescConfig.stat_var_names', index=3,
+ number=4, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='trainer', full_name='paddle.fleet.TrainerDescConfig.trainer', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='device_worker', full_name='paddle.fleet.TrainerDescConfig.device_worker', index=5,
+ number=6, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='local_sparse', full_name='paddle.fleet.TrainerDescConfig.local_sparse', index=6,
+ number=7, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='remote_sparse', full_name='paddle.fleet.TrainerDescConfig.remote_sparse', index=7,
+ number=8, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2919,
+ serialized_end=3114,
+)
+
+
+_PIPELINECONFIG = _descriptor.Descriptor(
+ name='PipelineConfig',
+ full_name='paddle.fleet.PipelineConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='micro_batch_size', full_name='paddle.fleet.PipelineConfig.micro_batch_size', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='accumulate_steps', full_name='paddle.fleet.PipelineConfig.accumulate_steps', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='schedule_mode', full_name='paddle.fleet.PipelineConfig.schedule_mode', index=2,
+ number=3, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("1F1B").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='p2p_cache_shape', full_name='paddle.fleet.PipelineConfig.p2p_cache_shape', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_partial_send_recv', full_name='paddle.fleet.PipelineConfig.enable_partial_send_recv', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3117,
+ serialized_end=3291,
+)
+
+
+_TENSORPARALLELCONFIG = _descriptor.Descriptor(
+ name='TensorParallelConfig',
+ full_name='paddle.fleet.TensorParallelConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='tensor_parallel_degree', full_name='paddle.fleet.TensorParallelConfig.tensor_parallel_degree', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='tensor_init_seed', full_name='paddle.fleet.TensorParallelConfig.tensor_init_seed', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3293,
+ serialized_end=3380,
+)
+
+
+_QATCONFIG = _descriptor.Descriptor(
+ name='QatConfig',
+ full_name='paddle.fleet.QatConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='channel_wise_abs_max', full_name='paddle.fleet.QatConfig.channel_wise_abs_max', index=0,
+ number=1, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bits', full_name='paddle.fleet.QatConfig.weight_bits', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=8,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='activation_bits', full_name='paddle.fleet.QatConfig.activation_bits', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=8,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='not_quant_pattern', full_name='paddle.fleet.QatConfig.not_quant_pattern', index=3,
+ number=4, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='algo', full_name='paddle.fleet.QatConfig.algo', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3383,
+ serialized_end=3523,
+)
+
+
+_TABLEPARAMETER = _descriptor.Descriptor(
+ name='TableParameter',
+ full_name='paddle.fleet.TableParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='table_id', full_name='paddle.fleet.TableParameter.table_id', index=0,
+ number=1, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_name', full_name='paddle.fleet.TableParameter.table_name', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_class', full_name='paddle.fleet.TableParameter.table_class', index=2,
+ number=3, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='shard_num', full_name='paddle.fleet.TableParameter.shard_num', index=3,
+ number=4, type=4, cpp_type=4, label=1,
+ has_default_value=True, default_value=1000,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.fleet.TableParameter.type', index=4,
+ number=5, type=14, cpp_type=8, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='accessor', full_name='paddle.fleet.TableParameter.accessor', index=5,
+ number=6, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='compress_in_save', full_name='paddle.fleet.TableParameter.compress_in_save', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_sparse_table_cache', full_name='paddle.fleet.TableParameter.enable_sparse_table_cache', index=7,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_table_cache_rate', full_name='paddle.fleet.TableParameter.sparse_table_cache_rate', index=8,
+ number=11, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.00055),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_table_cache_file_num', full_name='paddle.fleet.TableParameter.sparse_table_cache_file_num', index=9,
+ number=12, type=13, cpp_type=3, label=1,
+ has_default_value=True, default_value=16,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_revert', full_name='paddle.fleet.TableParameter.enable_revert', index=10,
+ number=13, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='shard_merge_rate', full_name='paddle.fleet.TableParameter.shard_merge_rate', index=11,
+ number=14, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(1),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3526,
+ serialized_end=3937,
+)
+
+
+_TABLEACCESSORPARAMETER = _descriptor.Descriptor(
+ name='TableAccessorParameter',
+ full_name='paddle.fleet.TableAccessorParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='accessor_class', full_name='paddle.fleet.TableAccessorParameter.accessor_class', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fea_dim', full_name='paddle.fleet.TableAccessorParameter.fea_dim', index=1,
+ number=4, type=13, cpp_type=3, label=1,
+ has_default_value=True, default_value=11,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_dim', full_name='paddle.fleet.TableAccessorParameter.embedx_dim', index=2,
+ number=5, type=13, cpp_type=3, label=1,
+ has_default_value=True, default_value=8,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_threshold', full_name='paddle.fleet.TableAccessorParameter.embedx_threshold', index=3,
+ number=6, type=13, cpp_type=3, label=1,
+ has_default_value=True, default_value=10,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ctr_accessor_param', full_name='paddle.fleet.TableAccessorParameter.ctr_accessor_param', index=4,
+ number=7, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_accessor_save_param', full_name='paddle.fleet.TableAccessorParameter.table_accessor_save_param', index=5,
+ number=8, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embed_sgd_param', full_name='paddle.fleet.TableAccessorParameter.embed_sgd_param', index=6,
+ number=10, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='embedx_sgd_param', full_name='paddle.fleet.TableAccessorParameter.embedx_sgd_param', index=7,
+ number=11, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='graph_sgd_param', full_name='paddle.fleet.TableAccessorParameter.graph_sgd_param', index=8,
+ number=12, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3940,
+ serialized_end=4368,
+)
+
+
+_GRAPHSGDPARAMETER = _descriptor.Descriptor(
+ name='GraphSGDParameter',
+ full_name='paddle.fleet.GraphSGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='nodeid_slot', full_name='paddle.fleet.GraphSGDParameter.nodeid_slot', index=0,
+ number=1, type=13, cpp_type=3, label=1,
+ has_default_value=True, default_value=9008,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='feature_learning_rate', full_name='paddle.fleet.GraphSGDParameter.feature_learning_rate', index=1,
+ number=2, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.05),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4370,
+ serialized_end=4453,
+)
+
+
+_SGDPARAMETER = _descriptor.Descriptor(
+ name='SGDParameter',
+ full_name='paddle.fleet.SGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.fleet.SGDParameter.name', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='naive', full_name='paddle.fleet.SGDParameter.naive', index=1,
+ number=2, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adagrad', full_name='paddle.fleet.SGDParameter.adagrad', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adam', full_name='paddle.fleet.SGDParameter.adam', index=3,
+ number=4, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4456,
+ serialized_end=4656,
+)
+
+
+_SPARSENAIVESGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseNaiveSGDRuleParameter',
+ full_name='paddle.fleet.SparseNaiveSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate', full_name='paddle.fleet.SparseNaiveSGDRuleParameter.learning_rate', index=0,
+ number=1, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.05),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range', full_name='paddle.fleet.SparseNaiveSGDRuleParameter.initial_range', index=1,
+ number=2, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.0001),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds', full_name='paddle.fleet.SparseNaiveSGDRuleParameter.weight_bounds', index=2,
+ number=3, type=2, cpp_type=6, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4658,
+ serialized_end=4770,
+)
+
+
+_SPARSEADAGRADSGDRULEPARAMETER = _descriptor.Descriptor(
+ name='SparseAdagradSGDRuleParameter',
+ full_name='paddle.fleet.SparseAdagradSGDRuleParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate', full_name='paddle.fleet.SparseAdagradSGDRuleParameter.learning_rate', index=0,
+ number=1, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.05),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_g2sum', full_name='paddle.fleet.SparseAdagradSGDRuleParameter.initial_g2sum', index=1,
+ number=2, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(3),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range', full_name='paddle.fleet.SparseAdagradSGDRuleParameter.initial_range', index=2,
+ number=3, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.0001),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds', full_name='paddle.fleet.SparseAdagradSGDRuleParameter.weight_bounds', index=3,
+ number=4, type=2, cpp_type=6, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4773,
+ serialized_end=4913,
+)
+
+
+_SPARSEADAMSGDPARAMETER = _descriptor.Descriptor(
+ name='SparseAdamSGDParameter',
+ full_name='paddle.fleet.SparseAdamSGDParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='learning_rate', full_name='paddle.fleet.SparseAdamSGDParameter.learning_rate', index=0,
+ number=1, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.001),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='initial_range', full_name='paddle.fleet.SparseAdamSGDParameter.initial_range', index=1,
+ number=2, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.0001),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='beta1_decay_rate', full_name='paddle.fleet.SparseAdamSGDParameter.beta1_decay_rate', index=2,
+ number=3, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.9),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='beta2_decay_rate', full_name='paddle.fleet.SparseAdamSGDParameter.beta2_decay_rate', index=3,
+ number=4, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(0.999),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ada_epsilon', full_name='paddle.fleet.SparseAdamSGDParameter.ada_epsilon', index=4,
+ number=5, type=1, cpp_type=5, label=1,
+ has_default_value=True, default_value=float(1e-08),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='weight_bounds', full_name='paddle.fleet.SparseAdamSGDParameter.weight_bounds', index=5,
+ number=6, type=2, cpp_type=6, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4916,
+ serialized_end=5116,
+)
+
+
+_CTRACCESSORPARAMETER = _descriptor.Descriptor(
+ name='CtrAccessorParameter',
+ full_name='paddle.fleet.CtrAccessorParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='nonclk_coeff', full_name='paddle.fleet.CtrAccessorParameter.nonclk_coeff', index=0,
+ number=1, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.1),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='click_coeff', full_name='paddle.fleet.CtrAccessorParameter.click_coeff', index=1,
+ number=2, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(1),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='base_threshold', full_name='paddle.fleet.CtrAccessorParameter.base_threshold', index=2,
+ number=3, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(1.5),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delta_threshold', full_name='paddle.fleet.CtrAccessorParameter.delta_threshold', index=3,
+ number=4, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.25),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delta_keep_days', full_name='paddle.fleet.CtrAccessorParameter.delta_keep_days', index=4,
+ number=5, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(16),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='show_click_decay_rate', full_name='paddle.fleet.CtrAccessorParameter.show_click_decay_rate', index=5,
+ number=6, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.98),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delete_threshold', full_name='paddle.fleet.CtrAccessorParameter.delete_threshold', index=6,
+ number=7, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0.8),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='delete_after_unseen_days', full_name='paddle.fleet.CtrAccessorParameter.delete_after_unseen_days', index=7,
+ number=8, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(30),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ssd_unseenday_threshold', full_name='paddle.fleet.CtrAccessorParameter.ssd_unseenday_threshold', index=8,
+ number=9, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='show_scale', full_name='paddle.fleet.CtrAccessorParameter.show_scale', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=5119,
+ serialized_end=5449,
+)
+
+
+_TABLEACCESSORSAVEPARAMETER = _descriptor.Descriptor(
+ name='TableAccessorSaveParameter',
+ full_name='paddle.fleet.TableAccessorSaveParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='param', full_name='paddle.fleet.TableAccessorSaveParameter.param', index=0,
+ number=1, type=13, cpp_type=3, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='converter', full_name='paddle.fleet.TableAccessorSaveParameter.converter', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='deconverter', full_name='paddle.fleet.TableAccessorSaveParameter.deconverter', index=2,
+ number=3, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=5451,
+ serialized_end=5534,
+)
+
+
+_FSCLIENTPARAMETER = _descriptor.Descriptor(
+ name='FsClientParameter',
+ full_name='paddle.fleet.FsClientParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='uri', full_name='paddle.fleet.FsClientParameter.uri', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='user', full_name='paddle.fleet.FsClientParameter.user', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='passwd', full_name='paddle.fleet.FsClientParameter.passwd', index=2,
+ number=3, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hadoop_bin', full_name='paddle.fleet.FsClientParameter.hadoop_bin', index=3,
+ number=4, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=5536,
+ serialized_end=5618,
+)
+
+
+_DISTRIBUTEDSTRATEGY = _descriptor.Descriptor(
+ name='DistributedStrategy',
+ full_name='paddle.fleet.DistributedStrategy',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='mode', full_name='paddle.fleet.DistributedStrategy.mode', index=0,
+ number=1, type=14, cpp_type=8, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='amp', full_name='paddle.fleet.DistributedStrategy.amp', index=1,
+ number=2, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='recompute', full_name='paddle.fleet.DistributedStrategy.recompute', index=2,
+ number=3, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='localsgd', full_name='paddle.fleet.DistributedStrategy.localsgd', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dgc', full_name='paddle.fleet.DistributedStrategy.dgc', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='gradient_merge', full_name='paddle.fleet.DistributedStrategy.gradient_merge', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lars', full_name='paddle.fleet.DistributedStrategy.lars', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lamb', full_name='paddle.fleet.DistributedStrategy.lamb', index=7,
+ number=8, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pipeline', full_name='paddle.fleet.DistributedStrategy.pipeline', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='elastic', full_name='paddle.fleet.DistributedStrategy.elastic', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='auto', full_name='paddle.fleet.DistributedStrategy.auto', index=10,
+ number=11, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='a_sync', full_name='paddle.fleet.DistributedStrategy.a_sync', index=11,
+ number=12, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sync_nccl_allreduce', full_name='paddle.fleet.DistributedStrategy.sync_nccl_allreduce', index=12,
+ number=13, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='nccl_comm_num', full_name='paddle.fleet.DistributedStrategy.nccl_comm_num', index=13,
+ number=14, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_hierarchical_allreduce', full_name='paddle.fleet.DistributedStrategy.use_hierarchical_allreduce', index=14,
+ number=15, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hierarchical_allreduce_inter_nranks', full_name='paddle.fleet.DistributedStrategy.hierarchical_allreduce_inter_nranks', index=15,
+ number=16, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sync_batch_norm', full_name='paddle.fleet.DistributedStrategy.sync_batch_norm', index=16,
+ number=17, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_all_reduce_ops', full_name='paddle.fleet.DistributedStrategy.fuse_all_reduce_ops', index=17,
+ number=18, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_grad_size_in_MB', full_name='paddle.fleet.DistributedStrategy.fuse_grad_size_in_MB', index=18,
+ number=19, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=32,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_grad_size_in_TFLOPS', full_name='paddle.fleet.DistributedStrategy.fuse_grad_size_in_TFLOPS', index=19,
+ number=20, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(50),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='cudnn_exhaustive_search', full_name='paddle.fleet.DistributedStrategy.cudnn_exhaustive_search', index=20,
+ number=21, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='conv_workspace_size_limit', full_name='paddle.fleet.DistributedStrategy.conv_workspace_size_limit', index=21,
+ number=22, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=512,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='cudnn_batchnorm_spatial_persistent', full_name='paddle.fleet.DistributedStrategy.cudnn_batchnorm_spatial_persistent', index=22,
+ number=23, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adaptive_localsgd', full_name='paddle.fleet.DistributedStrategy.adaptive_localsgd', index=23,
+ number=24, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fp16_allreduce', full_name='paddle.fleet.DistributedStrategy.fp16_allreduce', index=24,
+ number=25, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sharding', full_name='paddle.fleet.DistributedStrategy.sharding', index=25,
+ number=26, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='last_comm_group_size_MB', full_name='paddle.fleet.DistributedStrategy.last_comm_group_size_MB', index=26,
+ number=27, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(1),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='find_unused_parameters', full_name='paddle.fleet.DistributedStrategy.find_unused_parameters', index=27,
+ number=28, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='tensor_parallel', full_name='paddle.fleet.DistributedStrategy.tensor_parallel', index=28,
+ number=29, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='without_graph_optimization', full_name='paddle.fleet.DistributedStrategy.without_graph_optimization', index=29,
+ number=30, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_grad_size_in_num', full_name='paddle.fleet.DistributedStrategy.fuse_grad_size_in_num', index=30,
+ number=31, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=8,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='calc_comm_same_stream', full_name='paddle.fleet.DistributedStrategy.calc_comm_same_stream', index=31,
+ number=32, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='asp', full_name='paddle.fleet.DistributedStrategy.asp', index=32,
+ number=33, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fuse_grad_merge', full_name='paddle.fleet.DistributedStrategy.fuse_grad_merge', index=33,
+ number=34, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='semi_auto', full_name='paddle.fleet.DistributedStrategy.semi_auto', index=34,
+ number=35, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adam_d2sum', full_name='paddle.fleet.DistributedStrategy.adam_d2sum', index=35,
+ number=36, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='auto_search', full_name='paddle.fleet.DistributedStrategy.auto_search', index=36,
+ number=37, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='heter_ccl_mode', full_name='paddle.fleet.DistributedStrategy.heter_ccl_mode', index=37,
+ number=38, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_fl_ps_mode', full_name='paddle.fleet.DistributedStrategy.is_fl_ps_mode', index=38,
+ number=39, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='with_coordinator', full_name='paddle.fleet.DistributedStrategy.with_coordinator', index=39,
+ number=40, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='qat', full_name='paddle.fleet.DistributedStrategy.qat', index=40,
+ number=41, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='split_data', full_name='paddle.fleet.DistributedStrategy.split_data', index=41,
+ number=42, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='recompute_configs', full_name='paddle.fleet.DistributedStrategy.recompute_configs', index=42,
+ number=101, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='amp_configs', full_name='paddle.fleet.DistributedStrategy.amp_configs', index=43,
+ number=102, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='localsgd_configs', full_name='paddle.fleet.DistributedStrategy.localsgd_configs', index=44,
+ number=103, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='gradient_merge_configs', full_name='paddle.fleet.DistributedStrategy.gradient_merge_configs', index=45,
+ number=104, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dgc_configs', full_name='paddle.fleet.DistributedStrategy.dgc_configs', index=46,
+ number=105, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pipeline_configs', full_name='paddle.fleet.DistributedStrategy.pipeline_configs', index=47,
+ number=106, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='a_sync_configs', full_name='paddle.fleet.DistributedStrategy.a_sync_configs', index=48,
+ number=107, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lars_configs', full_name='paddle.fleet.DistributedStrategy.lars_configs', index=49,
+ number=108, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lamb_configs', full_name='paddle.fleet.DistributedStrategy.lamb_configs', index=50,
+ number=109, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adaptive_localsgd_configs', full_name='paddle.fleet.DistributedStrategy.adaptive_localsgd_configs', index=51,
+ number=110, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sharding_configs', full_name='paddle.fleet.DistributedStrategy.sharding_configs', index=52,
+ number=111, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hybrid_configs', full_name='paddle.fleet.DistributedStrategy.hybrid_configs', index=53,
+ number=112, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='tensor_parallel_configs', full_name='paddle.fleet.DistributedStrategy.tensor_parallel_configs', index=54,
+ number=113, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='trainer_desc_configs', full_name='paddle.fleet.DistributedStrategy.trainer_desc_configs', index=55,
+ number=114, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='downpour_table_param', full_name='paddle.fleet.DistributedStrategy.downpour_table_param', index=56,
+ number=115, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fs_client_param', full_name='paddle.fleet.DistributedStrategy.fs_client_param', index=57,
+ number=116, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='qat_configs', full_name='paddle.fleet.DistributedStrategy.qat_configs', index=58,
+ number=117, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='build_strategy', full_name='paddle.fleet.DistributedStrategy.build_strategy', index=59,
+ number=201, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='execution_strategy', full_name='paddle.fleet.DistributedStrategy.execution_strategy', index=60,
+ number=202, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='gradient_scale_configs', full_name='paddle.fleet.DistributedStrategy.gradient_scale_configs', index=61,
+ number=203, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=5621,
+ serialized_end=8088,
+)
+
+
+_DISTRIBUTEDJOBINFO = _descriptor.Descriptor(
+ name='DistributedJobInfo',
+ full_name='paddle.fleet.DistributedJobInfo',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='worker_num', full_name='paddle.fleet.DistributedJobInfo.worker_num', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='server_num', full_name='paddle.fleet.DistributedJobInfo.server_num', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='worker_ips', full_name='paddle.fleet.DistributedJobInfo.worker_ips', index=2,
+ number=3, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='server_endpoints', full_name='paddle.fleet.DistributedJobInfo.server_endpoints', index=3,
+ number=4, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='origin_startup', full_name='paddle.fleet.DistributedJobInfo.origin_startup', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='origin_main', full_name='paddle.fleet.DistributedJobInfo.origin_main', index=5,
+ number=6, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='distributed_main', full_name='paddle.fleet.DistributedJobInfo.distributed_main', index=6,
+ number=7, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='optimizer_name', full_name='paddle.fleet.DistributedJobInfo.optimizer_name', index=7,
+ number=8, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='strategy', full_name='paddle.fleet.DistributedJobInfo.strategy', index=8,
+ number=101, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=8091,
+ serialized_end=8345,
+)
+
+_TABLEPARAMETER.fields_by_name['type'].enum_type = _TABLETYPE
+_TABLEPARAMETER.fields_by_name['accessor'].message_type = _TABLEACCESSORPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name['ctr_accessor_param'].message_type = _CTRACCESSORPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name['table_accessor_save_param'].message_type = _TABLEACCESSORSAVEPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name['embed_sgd_param'].message_type = _SGDPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name['embedx_sgd_param'].message_type = _SGDPARAMETER
+_TABLEACCESSORPARAMETER.fields_by_name['graph_sgd_param'].message_type = _GRAPHSGDPARAMETER
+_SGDPARAMETER.fields_by_name['naive'].message_type = _SPARSENAIVESGDRULEPARAMETER
+_SGDPARAMETER.fields_by_name['adagrad'].message_type = _SPARSEADAGRADSGDRULEPARAMETER
+_SGDPARAMETER.fields_by_name['adam'].message_type = _SPARSEADAMSGDPARAMETER
+_DISTRIBUTEDSTRATEGY.fields_by_name['mode'].enum_type = _MODE
+_DISTRIBUTEDSTRATEGY.fields_by_name['recompute_configs'].message_type = _RECOMPUTECONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['amp_configs'].message_type = _AMPCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['localsgd_configs'].message_type = _LOCALSGDCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['gradient_merge_configs'].message_type = _GRADIENTMERGECONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['dgc_configs'].message_type = _DGCCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['pipeline_configs'].message_type = _PIPELINECONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['a_sync_configs'].message_type = _ASYNCCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['lars_configs'].message_type = _LARSCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['lamb_configs'].message_type = _LAMBCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['adaptive_localsgd_configs'].message_type = _ADAPTIVELOCALSGDCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['sharding_configs'].message_type = _SHARDINGCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['hybrid_configs'].message_type = _HYBRIDCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['tensor_parallel_configs'].message_type = _TENSORPARALLELCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['trainer_desc_configs'].message_type = _TRAINERDESCCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['downpour_table_param'].message_type = _TABLEPARAMETER
+_DISTRIBUTEDSTRATEGY.fields_by_name['fs_client_param'].message_type = _FSCLIENTPARAMETER
+_DISTRIBUTEDSTRATEGY.fields_by_name['qat_configs'].message_type = _QATCONFIG
+_DISTRIBUTEDSTRATEGY.fields_by_name['build_strategy'].message_type = _BUILDSTRATEGY
+_DISTRIBUTEDSTRATEGY.fields_by_name['execution_strategy'].message_type = _EXECUTIONSTRATEGY
+_DISTRIBUTEDSTRATEGY.fields_by_name['gradient_scale_configs'].message_type = _GRADIENTSCALECONFIG
+_DISTRIBUTEDJOBINFO.fields_by_name['strategy'].message_type = _DISTRIBUTEDSTRATEGY
+DESCRIPTOR.message_types_by_name['RecomputeConfig'] = _RECOMPUTECONFIG
+DESCRIPTOR.message_types_by_name['ShardingConfig'] = _SHARDINGCONFIG
+DESCRIPTOR.message_types_by_name['HybridConfig'] = _HYBRIDCONFIG
+DESCRIPTOR.message_types_by_name['AMPConfig'] = _AMPCONFIG
+DESCRIPTOR.message_types_by_name['LocalSGDConfig'] = _LOCALSGDCONFIG
+DESCRIPTOR.message_types_by_name['AdaptiveLocalSGDConfig'] = _ADAPTIVELOCALSGDCONFIG
+DESCRIPTOR.message_types_by_name['GradientMergeConfig'] = _GRADIENTMERGECONFIG
+DESCRIPTOR.message_types_by_name['DGCConfig'] = _DGCCONFIG
+DESCRIPTOR.message_types_by_name['LarsConfig'] = _LARSCONFIG
+DESCRIPTOR.message_types_by_name['LambConfig'] = _LAMBCONFIG
+DESCRIPTOR.message_types_by_name['BuildStrategy'] = _BUILDSTRATEGY
+DESCRIPTOR.message_types_by_name['ExecutionStrategy'] = _EXECUTIONSTRATEGY
+DESCRIPTOR.message_types_by_name['GradientScaleConfig'] = _GRADIENTSCALECONFIG
+DESCRIPTOR.message_types_by_name['AsyncConfig'] = _ASYNCCONFIG
+DESCRIPTOR.message_types_by_name['TrainerDescConfig'] = _TRAINERDESCCONFIG
+DESCRIPTOR.message_types_by_name['PipelineConfig'] = _PIPELINECONFIG
+DESCRIPTOR.message_types_by_name['TensorParallelConfig'] = _TENSORPARALLELCONFIG
+DESCRIPTOR.message_types_by_name['QatConfig'] = _QATCONFIG
+DESCRIPTOR.message_types_by_name['TableParameter'] = _TABLEPARAMETER
+DESCRIPTOR.message_types_by_name['TableAccessorParameter'] = _TABLEACCESSORPARAMETER
+DESCRIPTOR.message_types_by_name['GraphSGDParameter'] = _GRAPHSGDPARAMETER
+DESCRIPTOR.message_types_by_name['SGDParameter'] = _SGDPARAMETER
+DESCRIPTOR.message_types_by_name['SparseNaiveSGDRuleParameter'] = _SPARSENAIVESGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name['SparseAdagradSGDRuleParameter'] = _SPARSEADAGRADSGDRULEPARAMETER
+DESCRIPTOR.message_types_by_name['SparseAdamSGDParameter'] = _SPARSEADAMSGDPARAMETER
+DESCRIPTOR.message_types_by_name['CtrAccessorParameter'] = _CTRACCESSORPARAMETER
+DESCRIPTOR.message_types_by_name['TableAccessorSaveParameter'] = _TABLEACCESSORSAVEPARAMETER
+DESCRIPTOR.message_types_by_name['FsClientParameter'] = _FSCLIENTPARAMETER
+DESCRIPTOR.message_types_by_name['DistributedStrategy'] = _DISTRIBUTEDSTRATEGY
+DESCRIPTOR.message_types_by_name['DistributedJobInfo'] = _DISTRIBUTEDJOBINFO
+DESCRIPTOR.enum_types_by_name['Mode'] = _MODE
+DESCRIPTOR.enum_types_by_name['TableType'] = _TABLETYPE
+
+RecomputeConfig = _reflection.GeneratedProtocolMessageType('RecomputeConfig', (_message.Message,), dict(
+ DESCRIPTOR = _RECOMPUTECONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.RecomputeConfig)
+ ))
+_sym_db.RegisterMessage(RecomputeConfig)
+
+ShardingConfig = _reflection.GeneratedProtocolMessageType('ShardingConfig', (_message.Message,), dict(
+ DESCRIPTOR = _SHARDINGCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.ShardingConfig)
+ ))
+_sym_db.RegisterMessage(ShardingConfig)
+
+HybridConfig = _reflection.GeneratedProtocolMessageType('HybridConfig', (_message.Message,), dict(
+ DESCRIPTOR = _HYBRIDCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.HybridConfig)
+ ))
+_sym_db.RegisterMessage(HybridConfig)
+
+AMPConfig = _reflection.GeneratedProtocolMessageType('AMPConfig', (_message.Message,), dict(
+ DESCRIPTOR = _AMPCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.AMPConfig)
+ ))
+_sym_db.RegisterMessage(AMPConfig)
+
+LocalSGDConfig = _reflection.GeneratedProtocolMessageType('LocalSGDConfig', (_message.Message,), dict(
+ DESCRIPTOR = _LOCALSGDCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.LocalSGDConfig)
+ ))
+_sym_db.RegisterMessage(LocalSGDConfig)
+
+AdaptiveLocalSGDConfig = _reflection.GeneratedProtocolMessageType('AdaptiveLocalSGDConfig', (_message.Message,), dict(
+ DESCRIPTOR = _ADAPTIVELOCALSGDCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.AdaptiveLocalSGDConfig)
+ ))
+_sym_db.RegisterMessage(AdaptiveLocalSGDConfig)
+
+GradientMergeConfig = _reflection.GeneratedProtocolMessageType('GradientMergeConfig', (_message.Message,), dict(
+ DESCRIPTOR = _GRADIENTMERGECONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.GradientMergeConfig)
+ ))
+_sym_db.RegisterMessage(GradientMergeConfig)
+
+DGCConfig = _reflection.GeneratedProtocolMessageType('DGCConfig', (_message.Message,), dict(
+ DESCRIPTOR = _DGCCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.DGCConfig)
+ ))
+_sym_db.RegisterMessage(DGCConfig)
+
+LarsConfig = _reflection.GeneratedProtocolMessageType('LarsConfig', (_message.Message,), dict(
+ DESCRIPTOR = _LARSCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.LarsConfig)
+ ))
+_sym_db.RegisterMessage(LarsConfig)
+
+LambConfig = _reflection.GeneratedProtocolMessageType('LambConfig', (_message.Message,), dict(
+ DESCRIPTOR = _LAMBCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.LambConfig)
+ ))
+_sym_db.RegisterMessage(LambConfig)
+
+BuildStrategy = _reflection.GeneratedProtocolMessageType('BuildStrategy', (_message.Message,), dict(
+ DESCRIPTOR = _BUILDSTRATEGY,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.BuildStrategy)
+ ))
+_sym_db.RegisterMessage(BuildStrategy)
+
+ExecutionStrategy = _reflection.GeneratedProtocolMessageType('ExecutionStrategy', (_message.Message,), dict(
+ DESCRIPTOR = _EXECUTIONSTRATEGY,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.ExecutionStrategy)
+ ))
+_sym_db.RegisterMessage(ExecutionStrategy)
+
+GradientScaleConfig = _reflection.GeneratedProtocolMessageType('GradientScaleConfig', (_message.Message,), dict(
+ DESCRIPTOR = _GRADIENTSCALECONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.GradientScaleConfig)
+ ))
+_sym_db.RegisterMessage(GradientScaleConfig)
+
+AsyncConfig = _reflection.GeneratedProtocolMessageType('AsyncConfig', (_message.Message,), dict(
+ DESCRIPTOR = _ASYNCCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.AsyncConfig)
+ ))
+_sym_db.RegisterMessage(AsyncConfig)
+
+TrainerDescConfig = _reflection.GeneratedProtocolMessageType('TrainerDescConfig', (_message.Message,), dict(
+ DESCRIPTOR = _TRAINERDESCCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.TrainerDescConfig)
+ ))
+_sym_db.RegisterMessage(TrainerDescConfig)
+
+PipelineConfig = _reflection.GeneratedProtocolMessageType('PipelineConfig', (_message.Message,), dict(
+ DESCRIPTOR = _PIPELINECONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.PipelineConfig)
+ ))
+_sym_db.RegisterMessage(PipelineConfig)
+
+TensorParallelConfig = _reflection.GeneratedProtocolMessageType('TensorParallelConfig', (_message.Message,), dict(
+ DESCRIPTOR = _TENSORPARALLELCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.TensorParallelConfig)
+ ))
+_sym_db.RegisterMessage(TensorParallelConfig)
+
+QatConfig = _reflection.GeneratedProtocolMessageType('QatConfig', (_message.Message,), dict(
+ DESCRIPTOR = _QATCONFIG,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.QatConfig)
+ ))
+_sym_db.RegisterMessage(QatConfig)
+
+TableParameter = _reflection.GeneratedProtocolMessageType('TableParameter', (_message.Message,), dict(
+ DESCRIPTOR = _TABLEPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.TableParameter)
+ ))
+_sym_db.RegisterMessage(TableParameter)
+
+TableAccessorParameter = _reflection.GeneratedProtocolMessageType('TableAccessorParameter', (_message.Message,), dict(
+ DESCRIPTOR = _TABLEACCESSORPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.TableAccessorParameter)
+ ))
+_sym_db.RegisterMessage(TableAccessorParameter)
+
+GraphSGDParameter = _reflection.GeneratedProtocolMessageType('GraphSGDParameter', (_message.Message,), dict(
+ DESCRIPTOR = _GRAPHSGDPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.GraphSGDParameter)
+ ))
+_sym_db.RegisterMessage(GraphSGDParameter)
+
+SGDParameter = _reflection.GeneratedProtocolMessageType('SGDParameter', (_message.Message,), dict(
+ DESCRIPTOR = _SGDPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.SGDParameter)
+ ))
+_sym_db.RegisterMessage(SGDParameter)
+
+SparseNaiveSGDRuleParameter = _reflection.GeneratedProtocolMessageType('SparseNaiveSGDRuleParameter', (_message.Message,), dict(
+ DESCRIPTOR = _SPARSENAIVESGDRULEPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.SparseNaiveSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseNaiveSGDRuleParameter)
+
+SparseAdagradSGDRuleParameter = _reflection.GeneratedProtocolMessageType('SparseAdagradSGDRuleParameter', (_message.Message,), dict(
+ DESCRIPTOR = _SPARSEADAGRADSGDRULEPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.SparseAdagradSGDRuleParameter)
+ ))
+_sym_db.RegisterMessage(SparseAdagradSGDRuleParameter)
+
+SparseAdamSGDParameter = _reflection.GeneratedProtocolMessageType('SparseAdamSGDParameter', (_message.Message,), dict(
+ DESCRIPTOR = _SPARSEADAMSGDPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.SparseAdamSGDParameter)
+ ))
+_sym_db.RegisterMessage(SparseAdamSGDParameter)
+
+CtrAccessorParameter = _reflection.GeneratedProtocolMessageType('CtrAccessorParameter', (_message.Message,), dict(
+ DESCRIPTOR = _CTRACCESSORPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.CtrAccessorParameter)
+ ))
+_sym_db.RegisterMessage(CtrAccessorParameter)
+
+TableAccessorSaveParameter = _reflection.GeneratedProtocolMessageType('TableAccessorSaveParameter', (_message.Message,), dict(
+ DESCRIPTOR = _TABLEACCESSORSAVEPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.TableAccessorSaveParameter)
+ ))
+_sym_db.RegisterMessage(TableAccessorSaveParameter)
+
+FsClientParameter = _reflection.GeneratedProtocolMessageType('FsClientParameter', (_message.Message,), dict(
+ DESCRIPTOR = _FSCLIENTPARAMETER,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.FsClientParameter)
+ ))
+_sym_db.RegisterMessage(FsClientParameter)
+
+DistributedStrategy = _reflection.GeneratedProtocolMessageType('DistributedStrategy', (_message.Message,), dict(
+ DESCRIPTOR = _DISTRIBUTEDSTRATEGY,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.DistributedStrategy)
+ ))
+_sym_db.RegisterMessage(DistributedStrategy)
+
+DistributedJobInfo = _reflection.GeneratedProtocolMessageType('DistributedJobInfo', (_message.Message,), dict(
+ DESCRIPTOR = _DISTRIBUTEDJOBINFO,
+ __module__ = 'distributed_strategy_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.fleet.DistributedJobInfo)
+ ))
+_sym_db.RegisterMessage(DistributedJobInfo)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/framework_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/framework_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..bedb01b926e229bcb605abf0fb2a840337572b67
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/framework_pb2.py
@@ -0,0 +1,1557 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: framework.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='framework.proto',
+ package='paddle.framework.proto',
+ syntax='proto2',
+ serialized_pb=_b('\n\x0f\x66ramework.proto\x12\x16paddle.framework.proto\"\x1d\n\x07Version\x12\x12\n\x07version\x18\x01 \x01(\x03:\x01\x30\"\xb4\x04\n\x06OpDesc\x12\x0c\n\x04type\x18\x03 \x02(\t\x12\x32\n\x06inputs\x18\x01 \x03(\x0b\x32\".paddle.framework.proto.OpDesc.Var\x12\x33\n\x07outputs\x18\x02 \x03(\x0b\x32\".paddle.framework.proto.OpDesc.Var\x12\x32\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32#.paddle.framework.proto.OpDesc.Attr\x12\x18\n\tis_target\x18\x05 \x01(\x08:\x05\x66\x61lse\x1a\xb7\x02\n\x04\x41ttr\x12\x0c\n\x04name\x18\x01 \x02(\t\x12.\n\x04type\x18\x02 \x02(\x0e\x32 .paddle.framework.proto.AttrType\x12\t\n\x01i\x18\x03 \x01(\x05\x12\t\n\x01\x66\x18\x04 \x01(\x02\x12\t\n\x01s\x18\x05 \x01(\t\x12\x0c\n\x04ints\x18\x06 \x03(\x05\x12\x0e\n\x06\x66loats\x18\x07 \x03(\x02\x12\x0f\n\x07strings\x18\x08 \x03(\t\x12\t\n\x01\x62\x18\n \x01(\x08\x12\r\n\x05\x62ools\x18\x0b \x03(\x08\x12\x11\n\tblock_idx\x18\x0c \x01(\x05\x12\t\n\x01l\x18\r \x01(\x03\x12\x12\n\nblocks_idx\x18\x0e \x03(\x05\x12\r\n\x05longs\x18\x0f \x03(\x03\x12\x10\n\x08\x66loat64s\x18\x10 \x03(\x01\x12\x10\n\x08var_name\x18\x11 \x01(\t\x12\x11\n\tvars_name\x18\x12 \x03(\t\x12\x0f\n\x07\x66loat64\x18\x13 \x01(\x01\x1a+\n\x03Var\x12\x11\n\tparameter\x18\x01 \x02(\t\x12\x11\n\targuments\x18\x02 \x03(\t\"\xac\x04\n\x07OpProto\x12\x0c\n\x04type\x18\x01 \x02(\t\x12\x33\n\x06inputs\x18\x02 \x03(\x0b\x32#.paddle.framework.proto.OpProto.Var\x12\x34\n\x07outputs\x18\x03 \x03(\x0b\x32#.paddle.framework.proto.OpProto.Var\x12\x33\n\x05\x61ttrs\x18\x04 \x03(\x0b\x32$.paddle.framework.proto.OpProto.Attr\x12\x0f\n\x07\x63omment\x18\x05 \x02(\t\x1a\xa4\x01\n\x03Var\x12\x0c\n\x04name\x18\x01 \x02(\t\x12\x0f\n\x07\x63omment\x18\x02 \x02(\t\x12\x19\n\nduplicable\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0cintermediate\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x0b\x64ispensable\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x14\n\x05\x65xtra\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x14\n\x05quant\x18\x07 \x01(\x08:\x05\x66\x61lse\x1a\xba\x01\n\x04\x41ttr\x12\x0c\n\x04name\x18\x01 \x02(\t\x12.\n\x04type\x18\x02 \x02(\x0e\x32 .paddle.framework.proto.AttrType\x12\x0f\n\x07\x63omment\x18\x03 \x02(\t\x12\x18\n\tgenerated\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x14\n\x05\x65xtra\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x14\n\x05quant\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x1d\n\x0esupport_tensor\x18\x07 \x01(\x08:\x05\x66\x61lse\"\x97\x0c\n\x07VarType\x12\x32\n\x04type\x18\x01 \x02(\x0e\x32$.paddle.framework.proto.VarType.Type\x12\x41\n\rselected_rows\x18\x02 \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12\x41\n\nlod_tensor\x18\x03 \x01(\x0b\x32-.paddle.framework.proto.VarType.LoDTensorDesc\x12H\n\x0ctensor_array\x18\x04 \x01(\x0b\x32\x32.paddle.framework.proto.VarType.LoDTensorArrayDesc\x12:\n\x06reader\x18\x05 \x01(\x0b\x32*.paddle.framework.proto.VarType.ReaderDesc\x12\x34\n\x05tuple\x18\x07 \x01(\x0b\x32%.paddle.framework.proto.VarType.Tuple\x12:\n\x06string\x18\x08 \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12;\n\x07strings\x18\t \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12\x39\n\x05vocab\x18\n \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12>\n\nsparse_coo\x18\x0b \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12>\n\nsparse_csr\x18\x0c \x01(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x1aS\n\nTensorDesc\x12\x37\n\tdata_type\x18\x01 \x02(\x0e\x32$.paddle.framework.proto.VarType.Type\x12\x0c\n\x04\x64ims\x18\x02 \x03(\x03\x1a\x61\n\rLoDTensorDesc\x12:\n\x06tensor\x18\x01 \x02(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12\x14\n\tlod_level\x18\x02 \x01(\x05:\x01\x30\x1a\x66\n\x12LoDTensorArrayDesc\x12:\n\x06tensor\x18\x01 \x02(\x0b\x32*.paddle.framework.proto.VarType.TensorDesc\x12\x14\n\tlod_level\x18\x02 \x01(\x05:\x01\x30\x1aO\n\nReaderDesc\x12\x41\n\nlod_tensor\x18\x01 \x03(\x0b\x32-.paddle.framework.proto.VarType.LoDTensorDesc\x1a\x43\n\x05Tuple\x12:\n\x0c\x65lement_type\x18\x01 \x03(\x0e\x32$.paddle.framework.proto.VarType.Type\"\xab\x03\n\x04Type\x12\x08\n\x04\x42OOL\x10\x00\x12\t\n\x05INT16\x10\x01\x12\t\n\x05INT32\x10\x02\x12\t\n\x05INT64\x10\x03\x12\x08\n\x04\x46P16\x10\x04\x12\x08\n\x04\x46P32\x10\x05\x12\x08\n\x04\x46P64\x10\x06\x12\n\n\x06SIZE_T\x10\x13\x12\t\n\x05UINT8\x10\x14\x12\x08\n\x04INT8\x10\x15\x12\x08\n\x04\x42\x46\x31\x36\x10\x16\x12\r\n\tCOMPLEX64\x10\x17\x12\x0e\n\nCOMPLEX128\x10\x18\x12\x0e\n\nLOD_TENSOR\x10\x07\x12\x11\n\rSELECTED_ROWS\x10\x08\x12\x12\n\x0e\x46\x45\x45\x44_MINIBATCH\x10\t\x12\x0e\n\nFETCH_LIST\x10\n\x12\x0f\n\x0bSTEP_SCOPES\x10\x0b\x12\x12\n\x0eLOD_RANK_TABLE\x10\x0c\x12\x14\n\x10LOD_TENSOR_ARRAY\x10\r\x12\x0e\n\nPLACE_LIST\x10\x0e\x12\n\n\x06READER\x10\x0f\x12\x07\n\x03RAW\x10\x11\x12\t\n\x05TUPLE\x10\x12\x12\n\n\x06STRING\x10\x19\x12\x0b\n\x07STRINGS\x10\x1a\x12\t\n\x05VOCAB\x10\x1b\x12\r\n\tFEED_LIST\x10\x1c\x12\x0b\n\x07PSTRING\x10\x1d\x12\x0e\n\nSPARSE_COO\x10\x1e\x12\x0e\n\nSPARSE_CSR\x10\x1f\"\xdc\x02\n\x07VarDesc\x12\x0c\n\x04name\x18\x01 \x02(\t\x12-\n\x04type\x18\x02 \x02(\x0b\x32\x1f.paddle.framework.proto.VarType\x12\x1a\n\x0bpersistable\x18\x03 \x01(\x08:\x05\x66\x61lse\x12\x1e\n\x0fneed_check_feed\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0cis_parameter\x18\x05 \x01(\x08:\x05\x66\x61lse\x12\x1c\n\rstop_gradient\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x33\n\x05\x61ttrs\x18\x07 \x03(\x0b\x32$.paddle.framework.proto.VarDesc.Attr\x1ah\n\x04\x41ttr\x12\x0c\n\x04name\x18\x01 \x02(\t\x12.\n\x04type\x18\x02 \x02(\x0e\x32 .paddle.framework.proto.AttrType\x12\t\n\x01i\x18\x03 \x01(\x05\x12\t\n\x01s\x18\x04 \x01(\t\x12\x0c\n\x04ints\x18\x05 \x03(\x05\"\xa7\x01\n\tBlockDesc\x12\x0b\n\x03idx\x18\x01 \x02(\x05\x12\x12\n\nparent_idx\x18\x02 \x02(\x05\x12-\n\x04vars\x18\x03 \x03(\x0b\x32\x1f.paddle.framework.proto.VarDesc\x12+\n\x03ops\x18\x04 \x03(\x0b\x32\x1e.paddle.framework.proto.OpDesc\x12\x1d\n\x11\x66orward_block_idx\x18\x05 \x01(\x05:\x02-1\"\x1c\n\tOpVersion\x12\x0f\n\x07version\x18\x01 \x02(\x05\"\xa9\x01\n\x0cOpVersionMap\x12@\n\x04pair\x18\x01 \x03(\x0b\x32\x32.paddle.framework.proto.OpVersionMap.OpVersionPair\x1aW\n\rOpVersionPair\x12\x0f\n\x07op_name\x18\x01 \x02(\t\x12\x35\n\nop_version\x18\x02 \x02(\x0b\x32!.paddle.framework.proto.OpVersion\"\xbc\x01\n\x0bProgramDesc\x12\x31\n\x06\x62locks\x18\x01 \x03(\x0b\x32!.paddle.framework.proto.BlockDesc\x12\x30\n\x07version\x18\x04 \x01(\x0b\x32\x1f.paddle.framework.proto.Version\x12<\n\x0eop_version_map\x18\x05 \x01(\x0b\x32$.paddle.framework.proto.OpVersionMapJ\x04\x08\x02\x10\x03J\x04\x08\x03\x10\x04*\xc2\x01\n\x08\x41ttrType\x12\x07\n\x03INT\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\n\n\x06STRING\x10\x02\x12\x08\n\x04INTS\x10\x03\x12\n\n\x06\x46LOATS\x10\x04\x12\x0b\n\x07STRINGS\x10\x05\x12\x0b\n\x07\x42OOLEAN\x10\x06\x12\x0c\n\x08\x42OOLEANS\x10\x07\x12\t\n\x05\x42LOCK\x10\x08\x12\x08\n\x04LONG\x10\t\x12\n\n\x06\x42LOCKS\x10\n\x12\t\n\x05LONGS\x10\x0b\x12\x0c\n\x08\x46LOAT64S\x10\x0c\x12\x07\n\x03VAR\x10\r\x12\x08\n\x04VARS\x10\x0e\x12\x0b\n\x07\x46LOAT64\x10\x0f')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_ATTRTYPE = _descriptor.EnumDescriptor(
+ name='AttrType',
+ full_name='paddle.framework.proto.AttrType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='INT', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FLOAT', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='STRING', index=2, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='INTS', index=3, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FLOATS', index=4, number=4,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='STRINGS', index=5, number=5,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='BOOLEAN', index=6, number=6,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='BOOLEANS', index=7, number=7,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='BLOCK', index=8, number=8,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='LONG', index=9, number=9,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='BLOCKS', index=10, number=10,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='LONGS', index=11, number=11,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FLOAT64S', index=12, number=12,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='VAR', index=13, number=13,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='VARS', index=14, number=14,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FLOAT64', index=15, number=15,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=3677,
+ serialized_end=3871,
+)
+_sym_db.RegisterEnumDescriptor(_ATTRTYPE)
+
+AttrType = enum_type_wrapper.EnumTypeWrapper(_ATTRTYPE)
+INT = 0
+FLOAT = 1
+STRING = 2
+INTS = 3
+FLOATS = 4
+STRINGS = 5
+BOOLEAN = 6
+BOOLEANS = 7
+BLOCK = 8
+LONG = 9
+BLOCKS = 10
+LONGS = 11
+FLOAT64S = 12
+VAR = 13
+VARS = 14
+FLOAT64 = 15
+
+
+_VARTYPE_TYPE = _descriptor.EnumDescriptor(
+ name='Type',
+ full_name='paddle.framework.proto.VarType.Type',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='BOOL', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='INT16', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='INT32', index=2, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='INT64', index=3, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FP16', index=4, number=4,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FP32', index=5, number=5,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FP64', index=6, number=6,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='SIZE_T', index=7, number=19,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='UINT8', index=8, number=20,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='INT8', index=9, number=21,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='BF16', index=10, number=22,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='COMPLEX64', index=11, number=23,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='COMPLEX128', index=12, number=24,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='LOD_TENSOR', index=13, number=7,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='SELECTED_ROWS', index=14, number=8,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FEED_MINIBATCH', index=15, number=9,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FETCH_LIST', index=16, number=10,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='STEP_SCOPES', index=17, number=11,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='LOD_RANK_TABLE', index=18, number=12,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='LOD_TENSOR_ARRAY', index=19, number=13,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PLACE_LIST', index=20, number=14,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='READER', index=21, number=15,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='RAW', index=22, number=17,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='TUPLE', index=23, number=18,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='STRING', index=24, number=25,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='STRINGS', index=25, number=26,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='VOCAB', index=26, number=27,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='FEED_LIST', index=27, number=28,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='PSTRING', index=28, number=29,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='SPARSE_COO', index=29, number=30,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='SPARSE_CSR', index=30, number=31,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=2333,
+ serialized_end=2760,
+)
+_sym_db.RegisterEnumDescriptor(_VARTYPE_TYPE)
+
+
+_VERSION = _descriptor.Descriptor(
+ name='Version',
+ full_name='paddle.framework.proto.Version',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='version', full_name='paddle.framework.proto.Version.version', index=0,
+ number=1, type=3, cpp_type=2, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=43,
+ serialized_end=72,
+)
+
+
+_OPDESC_ATTR = _descriptor.Descriptor(
+ name='Attr',
+ full_name='paddle.framework.proto.OpDesc.Attr',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.OpDesc.Attr.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.OpDesc.Attr.type', index=1,
+ number=2, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='i', full_name='paddle.framework.proto.OpDesc.Attr.i', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='f', full_name='paddle.framework.proto.OpDesc.Attr.f', index=3,
+ number=4, type=2, cpp_type=6, label=1,
+ has_default_value=False, default_value=float(0),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='s', full_name='paddle.framework.proto.OpDesc.Attr.s', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ints', full_name='paddle.framework.proto.OpDesc.Attr.ints', index=5,
+ number=6, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='floats', full_name='paddle.framework.proto.OpDesc.Attr.floats', index=6,
+ number=7, type=2, cpp_type=6, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='strings', full_name='paddle.framework.proto.OpDesc.Attr.strings', index=7,
+ number=8, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='b', full_name='paddle.framework.proto.OpDesc.Attr.b', index=8,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=False, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='bools', full_name='paddle.framework.proto.OpDesc.Attr.bools', index=9,
+ number=11, type=8, cpp_type=7, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='block_idx', full_name='paddle.framework.proto.OpDesc.Attr.block_idx', index=10,
+ number=12, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='l', full_name='paddle.framework.proto.OpDesc.Attr.l', index=11,
+ number=13, type=3, cpp_type=2, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='blocks_idx', full_name='paddle.framework.proto.OpDesc.Attr.blocks_idx', index=12,
+ number=14, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='longs', full_name='paddle.framework.proto.OpDesc.Attr.longs', index=13,
+ number=15, type=3, cpp_type=2, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='float64s', full_name='paddle.framework.proto.OpDesc.Attr.float64s', index=14,
+ number=16, type=1, cpp_type=5, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='var_name', full_name='paddle.framework.proto.OpDesc.Attr.var_name', index=15,
+ number=17, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='vars_name', full_name='paddle.framework.proto.OpDesc.Attr.vars_name', index=16,
+ number=18, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='float64', full_name='paddle.framework.proto.OpDesc.Attr.float64', index=17,
+ number=19, type=1, cpp_type=5, label=1,
+ has_default_value=False, default_value=float(0),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=283,
+ serialized_end=594,
+)
+
+_OPDESC_VAR = _descriptor.Descriptor(
+ name='Var',
+ full_name='paddle.framework.proto.OpDesc.Var',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='parameter', full_name='paddle.framework.proto.OpDesc.Var.parameter', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='arguments', full_name='paddle.framework.proto.OpDesc.Var.arguments', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=596,
+ serialized_end=639,
+)
+
+_OPDESC = _descriptor.Descriptor(
+ name='OpDesc',
+ full_name='paddle.framework.proto.OpDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.OpDesc.type', index=0,
+ number=3, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='inputs', full_name='paddle.framework.proto.OpDesc.inputs', index=1,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='outputs', full_name='paddle.framework.proto.OpDesc.outputs', index=2,
+ number=2, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='attrs', full_name='paddle.framework.proto.OpDesc.attrs', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_target', full_name='paddle.framework.proto.OpDesc.is_target', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_OPDESC_ATTR, _OPDESC_VAR, ],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=75,
+ serialized_end=639,
+)
+
+
+_OPPROTO_VAR = _descriptor.Descriptor(
+ name='Var',
+ full_name='paddle.framework.proto.OpProto.Var',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.OpProto.Var.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='comment', full_name='paddle.framework.proto.OpProto.Var.comment', index=1,
+ number=2, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='duplicable', full_name='paddle.framework.proto.OpProto.Var.duplicable', index=2,
+ number=3, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='intermediate', full_name='paddle.framework.proto.OpProto.Var.intermediate', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dispensable', full_name='paddle.framework.proto.OpProto.Var.dispensable', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='extra', full_name='paddle.framework.proto.OpProto.Var.extra', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='quant', full_name='paddle.framework.proto.OpProto.Var.quant', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=845,
+ serialized_end=1009,
+)
+
+_OPPROTO_ATTR = _descriptor.Descriptor(
+ name='Attr',
+ full_name='paddle.framework.proto.OpProto.Attr',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.OpProto.Attr.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.OpProto.Attr.type', index=1,
+ number=2, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='comment', full_name='paddle.framework.proto.OpProto.Attr.comment', index=2,
+ number=3, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='generated', full_name='paddle.framework.proto.OpProto.Attr.generated', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='extra', full_name='paddle.framework.proto.OpProto.Attr.extra', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='quant', full_name='paddle.framework.proto.OpProto.Attr.quant', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='support_tensor', full_name='paddle.framework.proto.OpProto.Attr.support_tensor', index=6,
+ number=7, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1012,
+ serialized_end=1198,
+)
+
+_OPPROTO = _descriptor.Descriptor(
+ name='OpProto',
+ full_name='paddle.framework.proto.OpProto',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.OpProto.type', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='inputs', full_name='paddle.framework.proto.OpProto.inputs', index=1,
+ number=2, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='outputs', full_name='paddle.framework.proto.OpProto.outputs', index=2,
+ number=3, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='attrs', full_name='paddle.framework.proto.OpProto.attrs', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='comment', full_name='paddle.framework.proto.OpProto.comment', index=4,
+ number=5, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_OPPROTO_VAR, _OPPROTO_ATTR, ],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=642,
+ serialized_end=1198,
+)
+
+
+_VARTYPE_TENSORDESC = _descriptor.Descriptor(
+ name='TensorDesc',
+ full_name='paddle.framework.proto.VarType.TensorDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='data_type', full_name='paddle.framework.proto.VarType.TensorDesc.data_type', index=0,
+ number=1, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dims', full_name='paddle.framework.proto.VarType.TensorDesc.dims', index=1,
+ number=2, type=3, cpp_type=2, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1894,
+ serialized_end=1977,
+)
+
+_VARTYPE_LODTENSORDESC = _descriptor.Descriptor(
+ name='LoDTensorDesc',
+ full_name='paddle.framework.proto.VarType.LoDTensorDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='tensor', full_name='paddle.framework.proto.VarType.LoDTensorDesc.tensor', index=0,
+ number=1, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lod_level', full_name='paddle.framework.proto.VarType.LoDTensorDesc.lod_level', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1979,
+ serialized_end=2076,
+)
+
+_VARTYPE_LODTENSORARRAYDESC = _descriptor.Descriptor(
+ name='LoDTensorArrayDesc',
+ full_name='paddle.framework.proto.VarType.LoDTensorArrayDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='tensor', full_name='paddle.framework.proto.VarType.LoDTensorArrayDesc.tensor', index=0,
+ number=1, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lod_level', full_name='paddle.framework.proto.VarType.LoDTensorArrayDesc.lod_level', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2078,
+ serialized_end=2180,
+)
+
+_VARTYPE_READERDESC = _descriptor.Descriptor(
+ name='ReaderDesc',
+ full_name='paddle.framework.proto.VarType.ReaderDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='lod_tensor', full_name='paddle.framework.proto.VarType.ReaderDesc.lod_tensor', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2182,
+ serialized_end=2261,
+)
+
+_VARTYPE_TUPLE = _descriptor.Descriptor(
+ name='Tuple',
+ full_name='paddle.framework.proto.VarType.Tuple',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='element_type', full_name='paddle.framework.proto.VarType.Tuple.element_type', index=0,
+ number=1, type=14, cpp_type=8, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2263,
+ serialized_end=2330,
+)
+
+_VARTYPE = _descriptor.Descriptor(
+ name='VarType',
+ full_name='paddle.framework.proto.VarType',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.VarType.type', index=0,
+ number=1, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='selected_rows', full_name='paddle.framework.proto.VarType.selected_rows', index=1,
+ number=2, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='lod_tensor', full_name='paddle.framework.proto.VarType.lod_tensor', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='tensor_array', full_name='paddle.framework.proto.VarType.tensor_array', index=3,
+ number=4, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='reader', full_name='paddle.framework.proto.VarType.reader', index=4,
+ number=5, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='tuple', full_name='paddle.framework.proto.VarType.tuple', index=5,
+ number=7, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='string', full_name='paddle.framework.proto.VarType.string', index=6,
+ number=8, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='strings', full_name='paddle.framework.proto.VarType.strings', index=7,
+ number=9, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='vocab', full_name='paddle.framework.proto.VarType.vocab', index=8,
+ number=10, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_coo', full_name='paddle.framework.proto.VarType.sparse_coo', index=9,
+ number=11, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_csr', full_name='paddle.framework.proto.VarType.sparse_csr', index=10,
+ number=12, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_VARTYPE_TENSORDESC, _VARTYPE_LODTENSORDESC, _VARTYPE_LODTENSORARRAYDESC, _VARTYPE_READERDESC, _VARTYPE_TUPLE, ],
+ enum_types=[
+ _VARTYPE_TYPE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1201,
+ serialized_end=2760,
+)
+
+
+_VARDESC_ATTR = _descriptor.Descriptor(
+ name='Attr',
+ full_name='paddle.framework.proto.VarDesc.Attr',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.VarDesc.Attr.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.VarDesc.Attr.type', index=1,
+ number=2, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='i', full_name='paddle.framework.proto.VarDesc.Attr.i', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='s', full_name='paddle.framework.proto.VarDesc.Attr.s', index=3,
+ number=4, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ints', full_name='paddle.framework.proto.VarDesc.Attr.ints', index=4,
+ number=5, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3007,
+ serialized_end=3111,
+)
+
+_VARDESC = _descriptor.Descriptor(
+ name='VarDesc',
+ full_name='paddle.framework.proto.VarDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.VarDesc.name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.VarDesc.type', index=1,
+ number=2, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='persistable', full_name='paddle.framework.proto.VarDesc.persistable', index=2,
+ number=3, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='need_check_feed', full_name='paddle.framework.proto.VarDesc.need_check_feed', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_parameter', full_name='paddle.framework.proto.VarDesc.is_parameter', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='stop_gradient', full_name='paddle.framework.proto.VarDesc.stop_gradient', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='attrs', full_name='paddle.framework.proto.VarDesc.attrs', index=6,
+ number=7, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_VARDESC_ATTR, ],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2763,
+ serialized_end=3111,
+)
+
+
+_BLOCKDESC = _descriptor.Descriptor(
+ name='BlockDesc',
+ full_name='paddle.framework.proto.BlockDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='idx', full_name='paddle.framework.proto.BlockDesc.idx', index=0,
+ number=1, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='parent_idx', full_name='paddle.framework.proto.BlockDesc.parent_idx', index=1,
+ number=2, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='vars', full_name='paddle.framework.proto.BlockDesc.vars', index=2,
+ number=3, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ops', full_name='paddle.framework.proto.BlockDesc.ops', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='forward_block_idx', full_name='paddle.framework.proto.BlockDesc.forward_block_idx', index=4,
+ number=5, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3114,
+ serialized_end=3281,
+)
+
+
+_OPVERSION = _descriptor.Descriptor(
+ name='OpVersion',
+ full_name='paddle.framework.proto.OpVersion',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='version', full_name='paddle.framework.proto.OpVersion.version', index=0,
+ number=1, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3283,
+ serialized_end=3311,
+)
+
+
+_OPVERSIONMAP_OPVERSIONPAIR = _descriptor.Descriptor(
+ name='OpVersionPair',
+ full_name='paddle.framework.proto.OpVersionMap.OpVersionPair',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='op_name', full_name='paddle.framework.proto.OpVersionMap.OpVersionPair.op_name', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='op_version', full_name='paddle.framework.proto.OpVersionMap.OpVersionPair.op_version', index=1,
+ number=2, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3396,
+ serialized_end=3483,
+)
+
+_OPVERSIONMAP = _descriptor.Descriptor(
+ name='OpVersionMap',
+ full_name='paddle.framework.proto.OpVersionMap',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='pair', full_name='paddle.framework.proto.OpVersionMap.pair', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_OPVERSIONMAP_OPVERSIONPAIR, ],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3314,
+ serialized_end=3483,
+)
+
+
+_PROGRAMDESC = _descriptor.Descriptor(
+ name='ProgramDesc',
+ full_name='paddle.framework.proto.ProgramDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='blocks', full_name='paddle.framework.proto.ProgramDesc.blocks', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='version', full_name='paddle.framework.proto.ProgramDesc.version', index=1,
+ number=4, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='op_version_map', full_name='paddle.framework.proto.ProgramDesc.op_version_map', index=2,
+ number=5, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3486,
+ serialized_end=3674,
+)
+
+_OPDESC_ATTR.fields_by_name['type'].enum_type = _ATTRTYPE
+_OPDESC_ATTR.containing_type = _OPDESC
+_OPDESC_VAR.containing_type = _OPDESC
+_OPDESC.fields_by_name['inputs'].message_type = _OPDESC_VAR
+_OPDESC.fields_by_name['outputs'].message_type = _OPDESC_VAR
+_OPDESC.fields_by_name['attrs'].message_type = _OPDESC_ATTR
+_OPPROTO_VAR.containing_type = _OPPROTO
+_OPPROTO_ATTR.fields_by_name['type'].enum_type = _ATTRTYPE
+_OPPROTO_ATTR.containing_type = _OPPROTO
+_OPPROTO.fields_by_name['inputs'].message_type = _OPPROTO_VAR
+_OPPROTO.fields_by_name['outputs'].message_type = _OPPROTO_VAR
+_OPPROTO.fields_by_name['attrs'].message_type = _OPPROTO_ATTR
+_VARTYPE_TENSORDESC.fields_by_name['data_type'].enum_type = _VARTYPE_TYPE
+_VARTYPE_TENSORDESC.containing_type = _VARTYPE
+_VARTYPE_LODTENSORDESC.fields_by_name['tensor'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE_LODTENSORDESC.containing_type = _VARTYPE
+_VARTYPE_LODTENSORARRAYDESC.fields_by_name['tensor'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE_LODTENSORARRAYDESC.containing_type = _VARTYPE
+_VARTYPE_READERDESC.fields_by_name['lod_tensor'].message_type = _VARTYPE_LODTENSORDESC
+_VARTYPE_READERDESC.containing_type = _VARTYPE
+_VARTYPE_TUPLE.fields_by_name['element_type'].enum_type = _VARTYPE_TYPE
+_VARTYPE_TUPLE.containing_type = _VARTYPE
+_VARTYPE.fields_by_name['type'].enum_type = _VARTYPE_TYPE
+_VARTYPE.fields_by_name['selected_rows'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE.fields_by_name['lod_tensor'].message_type = _VARTYPE_LODTENSORDESC
+_VARTYPE.fields_by_name['tensor_array'].message_type = _VARTYPE_LODTENSORARRAYDESC
+_VARTYPE.fields_by_name['reader'].message_type = _VARTYPE_READERDESC
+_VARTYPE.fields_by_name['tuple'].message_type = _VARTYPE_TUPLE
+_VARTYPE.fields_by_name['string'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE.fields_by_name['strings'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE.fields_by_name['vocab'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE.fields_by_name['sparse_coo'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE.fields_by_name['sparse_csr'].message_type = _VARTYPE_TENSORDESC
+_VARTYPE_TYPE.containing_type = _VARTYPE
+_VARDESC_ATTR.fields_by_name['type'].enum_type = _ATTRTYPE
+_VARDESC_ATTR.containing_type = _VARDESC
+_VARDESC.fields_by_name['type'].message_type = _VARTYPE
+_VARDESC.fields_by_name['attrs'].message_type = _VARDESC_ATTR
+_BLOCKDESC.fields_by_name['vars'].message_type = _VARDESC
+_BLOCKDESC.fields_by_name['ops'].message_type = _OPDESC
+_OPVERSIONMAP_OPVERSIONPAIR.fields_by_name['op_version'].message_type = _OPVERSION
+_OPVERSIONMAP_OPVERSIONPAIR.containing_type = _OPVERSIONMAP
+_OPVERSIONMAP.fields_by_name['pair'].message_type = _OPVERSIONMAP_OPVERSIONPAIR
+_PROGRAMDESC.fields_by_name['blocks'].message_type = _BLOCKDESC
+_PROGRAMDESC.fields_by_name['version'].message_type = _VERSION
+_PROGRAMDESC.fields_by_name['op_version_map'].message_type = _OPVERSIONMAP
+DESCRIPTOR.message_types_by_name['Version'] = _VERSION
+DESCRIPTOR.message_types_by_name['OpDesc'] = _OPDESC
+DESCRIPTOR.message_types_by_name['OpProto'] = _OPPROTO
+DESCRIPTOR.message_types_by_name['VarType'] = _VARTYPE
+DESCRIPTOR.message_types_by_name['VarDesc'] = _VARDESC
+DESCRIPTOR.message_types_by_name['BlockDesc'] = _BLOCKDESC
+DESCRIPTOR.message_types_by_name['OpVersion'] = _OPVERSION
+DESCRIPTOR.message_types_by_name['OpVersionMap'] = _OPVERSIONMAP
+DESCRIPTOR.message_types_by_name['ProgramDesc'] = _PROGRAMDESC
+DESCRIPTOR.enum_types_by_name['AttrType'] = _ATTRTYPE
+
+Version = _reflection.GeneratedProtocolMessageType('Version', (_message.Message,), dict(
+ DESCRIPTOR = _VERSION,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.Version)
+ ))
+_sym_db.RegisterMessage(Version)
+
+OpDesc = _reflection.GeneratedProtocolMessageType('OpDesc', (_message.Message,), dict(
+
+ Attr = _reflection.GeneratedProtocolMessageType('Attr', (_message.Message,), dict(
+ DESCRIPTOR = _OPDESC_ATTR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpDesc.Attr)
+ ))
+ ,
+
+ Var = _reflection.GeneratedProtocolMessageType('Var', (_message.Message,), dict(
+ DESCRIPTOR = _OPDESC_VAR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpDesc.Var)
+ ))
+ ,
+ DESCRIPTOR = _OPDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpDesc)
+ ))
+_sym_db.RegisterMessage(OpDesc)
+_sym_db.RegisterMessage(OpDesc.Attr)
+_sym_db.RegisterMessage(OpDesc.Var)
+
+OpProto = _reflection.GeneratedProtocolMessageType('OpProto', (_message.Message,), dict(
+
+ Var = _reflection.GeneratedProtocolMessageType('Var', (_message.Message,), dict(
+ DESCRIPTOR = _OPPROTO_VAR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpProto.Var)
+ ))
+ ,
+
+ Attr = _reflection.GeneratedProtocolMessageType('Attr', (_message.Message,), dict(
+ DESCRIPTOR = _OPPROTO_ATTR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpProto.Attr)
+ ))
+ ,
+ DESCRIPTOR = _OPPROTO,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpProto)
+ ))
+_sym_db.RegisterMessage(OpProto)
+_sym_db.RegisterMessage(OpProto.Var)
+_sym_db.RegisterMessage(OpProto.Attr)
+
+VarType = _reflection.GeneratedProtocolMessageType('VarType', (_message.Message,), dict(
+
+ TensorDesc = _reflection.GeneratedProtocolMessageType('TensorDesc', (_message.Message,), dict(
+ DESCRIPTOR = _VARTYPE_TENSORDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType.TensorDesc)
+ ))
+ ,
+
+ LoDTensorDesc = _reflection.GeneratedProtocolMessageType('LoDTensorDesc', (_message.Message,), dict(
+ DESCRIPTOR = _VARTYPE_LODTENSORDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType.LoDTensorDesc)
+ ))
+ ,
+
+ LoDTensorArrayDesc = _reflection.GeneratedProtocolMessageType('LoDTensorArrayDesc', (_message.Message,), dict(
+ DESCRIPTOR = _VARTYPE_LODTENSORARRAYDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType.LoDTensorArrayDesc)
+ ))
+ ,
+
+ ReaderDesc = _reflection.GeneratedProtocolMessageType('ReaderDesc', (_message.Message,), dict(
+ DESCRIPTOR = _VARTYPE_READERDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType.ReaderDesc)
+ ))
+ ,
+
+ Tuple = _reflection.GeneratedProtocolMessageType('Tuple', (_message.Message,), dict(
+ DESCRIPTOR = _VARTYPE_TUPLE,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType.Tuple)
+ ))
+ ,
+ DESCRIPTOR = _VARTYPE,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarType)
+ ))
+_sym_db.RegisterMessage(VarType)
+_sym_db.RegisterMessage(VarType.TensorDesc)
+_sym_db.RegisterMessage(VarType.LoDTensorDesc)
+_sym_db.RegisterMessage(VarType.LoDTensorArrayDesc)
+_sym_db.RegisterMessage(VarType.ReaderDesc)
+_sym_db.RegisterMessage(VarType.Tuple)
+
+VarDesc = _reflection.GeneratedProtocolMessageType('VarDesc', (_message.Message,), dict(
+
+ Attr = _reflection.GeneratedProtocolMessageType('Attr', (_message.Message,), dict(
+ DESCRIPTOR = _VARDESC_ATTR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarDesc.Attr)
+ ))
+ ,
+ DESCRIPTOR = _VARDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.VarDesc)
+ ))
+_sym_db.RegisterMessage(VarDesc)
+_sym_db.RegisterMessage(VarDesc.Attr)
+
+BlockDesc = _reflection.GeneratedProtocolMessageType('BlockDesc', (_message.Message,), dict(
+ DESCRIPTOR = _BLOCKDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.BlockDesc)
+ ))
+_sym_db.RegisterMessage(BlockDesc)
+
+OpVersion = _reflection.GeneratedProtocolMessageType('OpVersion', (_message.Message,), dict(
+ DESCRIPTOR = _OPVERSION,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpVersion)
+ ))
+_sym_db.RegisterMessage(OpVersion)
+
+OpVersionMap = _reflection.GeneratedProtocolMessageType('OpVersionMap', (_message.Message,), dict(
+
+ OpVersionPair = _reflection.GeneratedProtocolMessageType('OpVersionPair', (_message.Message,), dict(
+ DESCRIPTOR = _OPVERSIONMAP_OPVERSIONPAIR,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpVersionMap.OpVersionPair)
+ ))
+ ,
+ DESCRIPTOR = _OPVERSIONMAP,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.OpVersionMap)
+ ))
+_sym_db.RegisterMessage(OpVersionMap)
+_sym_db.RegisterMessage(OpVersionMap.OpVersionPair)
+
+ProgramDesc = _reflection.GeneratedProtocolMessageType('ProgramDesc', (_message.Message,), dict(
+ DESCRIPTOR = _PROGRAMDESC,
+ __module__ = 'framework_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.ProgramDesc)
+ ))
+_sym_db.RegisterMessage(ProgramDesc)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/pass_desc_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/pass_desc_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..36810ba0d60860c2fe1b168a2b6673fc1192c30f
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/pass_desc_pb2.py
@@ -0,0 +1,584 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: pass_desc.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+import framework_pb2 as framework__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='pass_desc.proto',
+ package='paddle.framework.proto',
+ syntax='proto2',
+ serialized_pb=_b('\n\x0fpass_desc.proto\x12\x16paddle.framework.proto\x1a\x0f\x66ramework.proto\"\xd3\x0c\n\x08PassDesc\x12/\n\x07pattern\x18\x01 \x03(\x0b\x32\x1e.paddle.framework.proto.OpDesc\x12/\n\x07replace\x18\x02 \x03(\x0b\x32\x1e.paddle.framework.proto.OpDesc\x12\x39\n\x08var_maps\x18\x03 \x03(\x0b\x32\'.paddle.framework.proto.PassDesc.VarMap\x12?\n\rvar_attr_maps\x18\x04 \x03(\x0b\x32(.paddle.framework.proto.PassDesc.AttrMap\x12>\n\x0cop_attr_maps\x18\x05 \x03(\x0b\x32(.paddle.framework.proto.PassDesc.AttrMap\x12K\n\x13var_attr_conditions\x18\x06 \x03(\x0b\x32..paddle.framework.proto.PassDesc.AttrCondition\x12J\n\x12op_attr_conditions\x18\x07 \x03(\x0b\x32..paddle.framework.proto.PassDesc.AttrCondition\x1a\xe1\x01\n\x04\x41ttr\x12\x37\n\x04role\x18\x01 \x02(\x0e\x32).paddle.framework.proto.PassDesc.RoleType\x12\x10\n\x08var_name\x18\x02 \x01(\t\x12\x10\n\x08op_index\x18\x03 \x01(\x05\x12\x0c\n\x04name\x18\x04 \x02(\t\x12\x14\n\x0c\x65lement_name\x18\x05 \x01(\t\x12\x15\n\relement_index\x18\x06 \x01(\x05\x12\x41\n\toperation\x18\x07 \x01(\x0e\x32..paddle.framework.proto.PassDesc.OperationType\x1a\xb2\x01\n\tOperation\x12<\n\x04type\x18\x01 \x02(\x0e\x32..paddle.framework.proto.PassDesc.OperationType\x12\x33\n\x04\x61ttr\x18\x02 \x01(\x0b\x32%.paddle.framework.proto.PassDesc.Attr\x12\x32\n\x05value\x18\x03 \x01(\x0b\x32#.paddle.framework.proto.OpDesc.Attr\x1a\x32\n\x06VarMap\x12\x13\n\x0bpattern_var\x18\x01 \x02(\t\x12\x13\n\x0breplace_var\x18\x02 \x02(\t\x1a\xc2\x01\n\x07\x41ttrMap\x12;\n\x0cpattern_attr\x18\x01 \x02(\x0b\x32%.paddle.framework.proto.PassDesc.Attr\x12;\n\x0creplace_attr\x18\x02 \x02(\x0b\x32%.paddle.framework.proto.PassDesc.Attr\x12=\n\toperation\x18\x03 \x01(\x0b\x32*.paddle.framework.proto.PassDesc.Operation\x1a\xbe\x02\n\rAttrCondition\x12\x33\n\x04\x61ttr\x18\x01 \x02(\x0b\x32%.paddle.framework.proto.PassDesc.Attr\x12<\n\x04type\x18\x02 \x02(\x0e\x32..paddle.framework.proto.PassDesc.ConditionType\x12=\n\x0e\x63ondition_attr\x18\x03 \x01(\x0b\x32%.paddle.framework.proto.PassDesc.Attr\x12<\n\x0f\x63ondition_value\x18\x04 \x01(\x0b\x32#.paddle.framework.proto.OpDesc.Attr\x12=\n\toperation\x18\x05 \x01(\x0b\x32*.paddle.framework.proto.PassDesc.Operation\"(\n\x08RoleType\x12\r\n\tkVariable\x10\x00\x12\r\n\tkOperator\x10\x01\"L\n\rOperationType\x12\x08\n\x04kAdd\x10\x00\x12\x08\n\x04kSub\x10\x01\x12\x08\n\x04kMul\x10\x02\x12\x08\n\x04kDiv\x10\x03\x12\t\n\x05kSize\x10\x04\x12\x08\n\x04kMod\x10\x05\"E\n\rConditionType\x12\x07\n\x03kEQ\x10\x00\x12\x07\n\x03kNE\x10\x01\x12\x07\n\x03kGT\x10\x02\x12\x07\n\x03kGE\x10\x03\x12\x07\n\x03kLT\x10\x04\x12\x07\n\x03kLE\x10\x05\"X\n\rMultiPassDesc\x12\x11\n\tpass_type\x18\x01 \x01(\t\x12\x34\n\npass_descs\x18\x02 \x03(\x0b\x32 .paddle.framework.proto.PassDesc')
+ ,
+ dependencies=[framework__pb2.DESCRIPTOR,])
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+_PASSDESC_ROLETYPE = _descriptor.EnumDescriptor(
+ name='RoleType',
+ full_name='paddle.framework.proto.PassDesc.RoleType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='kVariable', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kOperator', index=1, number=1,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=1491,
+ serialized_end=1531,
+)
+_sym_db.RegisterEnumDescriptor(_PASSDESC_ROLETYPE)
+
+_PASSDESC_OPERATIONTYPE = _descriptor.EnumDescriptor(
+ name='OperationType',
+ full_name='paddle.framework.proto.PassDesc.OperationType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='kAdd', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kSub', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kMul', index=2, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kDiv', index=3, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kSize', index=4, number=4,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kMod', index=5, number=5,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=1533,
+ serialized_end=1609,
+)
+_sym_db.RegisterEnumDescriptor(_PASSDESC_OPERATIONTYPE)
+
+_PASSDESC_CONDITIONTYPE = _descriptor.EnumDescriptor(
+ name='ConditionType',
+ full_name='paddle.framework.proto.PassDesc.ConditionType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='kEQ', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kNE', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kGT', index=2, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kGE', index=3, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kLT', index=4, number=4,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='kLE', index=5, number=5,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=1611,
+ serialized_end=1680,
+)
+_sym_db.RegisterEnumDescriptor(_PASSDESC_CONDITIONTYPE)
+
+
+_PASSDESC_ATTR = _descriptor.Descriptor(
+ name='Attr',
+ full_name='paddle.framework.proto.PassDesc.Attr',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='role', full_name='paddle.framework.proto.PassDesc.Attr.role', index=0,
+ number=1, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='var_name', full_name='paddle.framework.proto.PassDesc.Attr.var_name', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='op_index', full_name='paddle.framework.proto.PassDesc.Attr.op_index', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.framework.proto.PassDesc.Attr.name', index=3,
+ number=4, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='element_name', full_name='paddle.framework.proto.PassDesc.Attr.element_name', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='element_index', full_name='paddle.framework.proto.PassDesc.Attr.element_index', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='operation', full_name='paddle.framework.proto.PassDesc.Attr.operation', index=6,
+ number=7, type=14, cpp_type=8, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=513,
+ serialized_end=738,
+)
+
+_PASSDESC_OPERATION = _descriptor.Descriptor(
+ name='Operation',
+ full_name='paddle.framework.proto.PassDesc.Operation',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.PassDesc.Operation.type', index=0,
+ number=1, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='attr', full_name='paddle.framework.proto.PassDesc.Operation.attr', index=1,
+ number=2, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='value', full_name='paddle.framework.proto.PassDesc.Operation.value', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=741,
+ serialized_end=919,
+)
+
+_PASSDESC_VARMAP = _descriptor.Descriptor(
+ name='VarMap',
+ full_name='paddle.framework.proto.PassDesc.VarMap',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='pattern_var', full_name='paddle.framework.proto.PassDesc.VarMap.pattern_var', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='replace_var', full_name='paddle.framework.proto.PassDesc.VarMap.replace_var', index=1,
+ number=2, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=921,
+ serialized_end=971,
+)
+
+_PASSDESC_ATTRMAP = _descriptor.Descriptor(
+ name='AttrMap',
+ full_name='paddle.framework.proto.PassDesc.AttrMap',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='pattern_attr', full_name='paddle.framework.proto.PassDesc.AttrMap.pattern_attr', index=0,
+ number=1, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='replace_attr', full_name='paddle.framework.proto.PassDesc.AttrMap.replace_attr', index=1,
+ number=2, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='operation', full_name='paddle.framework.proto.PassDesc.AttrMap.operation', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=974,
+ serialized_end=1168,
+)
+
+_PASSDESC_ATTRCONDITION = _descriptor.Descriptor(
+ name='AttrCondition',
+ full_name='paddle.framework.proto.PassDesc.AttrCondition',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='attr', full_name='paddle.framework.proto.PassDesc.AttrCondition.attr', index=0,
+ number=1, type=11, cpp_type=10, label=2,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.framework.proto.PassDesc.AttrCondition.type', index=1,
+ number=2, type=14, cpp_type=8, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='condition_attr', full_name='paddle.framework.proto.PassDesc.AttrCondition.condition_attr', index=2,
+ number=3, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='condition_value', full_name='paddle.framework.proto.PassDesc.AttrCondition.condition_value', index=3,
+ number=4, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='operation', full_name='paddle.framework.proto.PassDesc.AttrCondition.operation', index=4,
+ number=5, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1171,
+ serialized_end=1489,
+)
+
+_PASSDESC = _descriptor.Descriptor(
+ name='PassDesc',
+ full_name='paddle.framework.proto.PassDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='pattern', full_name='paddle.framework.proto.PassDesc.pattern', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='replace', full_name='paddle.framework.proto.PassDesc.replace', index=1,
+ number=2, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='var_maps', full_name='paddle.framework.proto.PassDesc.var_maps', index=2,
+ number=3, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='var_attr_maps', full_name='paddle.framework.proto.PassDesc.var_attr_maps', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='op_attr_maps', full_name='paddle.framework.proto.PassDesc.op_attr_maps', index=4,
+ number=5, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='var_attr_conditions', full_name='paddle.framework.proto.PassDesc.var_attr_conditions', index=5,
+ number=6, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='op_attr_conditions', full_name='paddle.framework.proto.PassDesc.op_attr_conditions', index=6,
+ number=7, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[_PASSDESC_ATTR, _PASSDESC_OPERATION, _PASSDESC_VARMAP, _PASSDESC_ATTRMAP, _PASSDESC_ATTRCONDITION, ],
+ enum_types=[
+ _PASSDESC_ROLETYPE,
+ _PASSDESC_OPERATIONTYPE,
+ _PASSDESC_CONDITIONTYPE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=61,
+ serialized_end=1680,
+)
+
+
+_MULTIPASSDESC = _descriptor.Descriptor(
+ name='MultiPassDesc',
+ full_name='paddle.framework.proto.MultiPassDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='pass_type', full_name='paddle.framework.proto.MultiPassDesc.pass_type', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pass_descs', full_name='paddle.framework.proto.MultiPassDesc.pass_descs', index=1,
+ number=2, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1682,
+ serialized_end=1770,
+)
+
+_PASSDESC_ATTR.fields_by_name['role'].enum_type = _PASSDESC_ROLETYPE
+_PASSDESC_ATTR.fields_by_name['operation'].enum_type = _PASSDESC_OPERATIONTYPE
+_PASSDESC_ATTR.containing_type = _PASSDESC
+_PASSDESC_OPERATION.fields_by_name['type'].enum_type = _PASSDESC_OPERATIONTYPE
+_PASSDESC_OPERATION.fields_by_name['attr'].message_type = _PASSDESC_ATTR
+_PASSDESC_OPERATION.fields_by_name['value'].message_type = framework__pb2._OPDESC_ATTR
+_PASSDESC_OPERATION.containing_type = _PASSDESC
+_PASSDESC_VARMAP.containing_type = _PASSDESC
+_PASSDESC_ATTRMAP.fields_by_name['pattern_attr'].message_type = _PASSDESC_ATTR
+_PASSDESC_ATTRMAP.fields_by_name['replace_attr'].message_type = _PASSDESC_ATTR
+_PASSDESC_ATTRMAP.fields_by_name['operation'].message_type = _PASSDESC_OPERATION
+_PASSDESC_ATTRMAP.containing_type = _PASSDESC
+_PASSDESC_ATTRCONDITION.fields_by_name['attr'].message_type = _PASSDESC_ATTR
+_PASSDESC_ATTRCONDITION.fields_by_name['type'].enum_type = _PASSDESC_CONDITIONTYPE
+_PASSDESC_ATTRCONDITION.fields_by_name['condition_attr'].message_type = _PASSDESC_ATTR
+_PASSDESC_ATTRCONDITION.fields_by_name['condition_value'].message_type = framework__pb2._OPDESC_ATTR
+_PASSDESC_ATTRCONDITION.fields_by_name['operation'].message_type = _PASSDESC_OPERATION
+_PASSDESC_ATTRCONDITION.containing_type = _PASSDESC
+_PASSDESC.fields_by_name['pattern'].message_type = framework__pb2._OPDESC
+_PASSDESC.fields_by_name['replace'].message_type = framework__pb2._OPDESC
+_PASSDESC.fields_by_name['var_maps'].message_type = _PASSDESC_VARMAP
+_PASSDESC.fields_by_name['var_attr_maps'].message_type = _PASSDESC_ATTRMAP
+_PASSDESC.fields_by_name['op_attr_maps'].message_type = _PASSDESC_ATTRMAP
+_PASSDESC.fields_by_name['var_attr_conditions'].message_type = _PASSDESC_ATTRCONDITION
+_PASSDESC.fields_by_name['op_attr_conditions'].message_type = _PASSDESC_ATTRCONDITION
+_PASSDESC_ROLETYPE.containing_type = _PASSDESC
+_PASSDESC_OPERATIONTYPE.containing_type = _PASSDESC
+_PASSDESC_CONDITIONTYPE.containing_type = _PASSDESC
+_MULTIPASSDESC.fields_by_name['pass_descs'].message_type = _PASSDESC
+DESCRIPTOR.message_types_by_name['PassDesc'] = _PASSDESC
+DESCRIPTOR.message_types_by_name['MultiPassDesc'] = _MULTIPASSDESC
+
+PassDesc = _reflection.GeneratedProtocolMessageType('PassDesc', (_message.Message,), dict(
+
+ Attr = _reflection.GeneratedProtocolMessageType('Attr', (_message.Message,), dict(
+ DESCRIPTOR = _PASSDESC_ATTR,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc.Attr)
+ ))
+ ,
+
+ Operation = _reflection.GeneratedProtocolMessageType('Operation', (_message.Message,), dict(
+ DESCRIPTOR = _PASSDESC_OPERATION,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc.Operation)
+ ))
+ ,
+
+ VarMap = _reflection.GeneratedProtocolMessageType('VarMap', (_message.Message,), dict(
+ DESCRIPTOR = _PASSDESC_VARMAP,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc.VarMap)
+ ))
+ ,
+
+ AttrMap = _reflection.GeneratedProtocolMessageType('AttrMap', (_message.Message,), dict(
+ DESCRIPTOR = _PASSDESC_ATTRMAP,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc.AttrMap)
+ ))
+ ,
+
+ AttrCondition = _reflection.GeneratedProtocolMessageType('AttrCondition', (_message.Message,), dict(
+ DESCRIPTOR = _PASSDESC_ATTRCONDITION,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc.AttrCondition)
+ ))
+ ,
+ DESCRIPTOR = _PASSDESC,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.PassDesc)
+ ))
+_sym_db.RegisterMessage(PassDesc)
+_sym_db.RegisterMessage(PassDesc.Attr)
+_sym_db.RegisterMessage(PassDesc.Operation)
+_sym_db.RegisterMessage(PassDesc.VarMap)
+_sym_db.RegisterMessage(PassDesc.AttrMap)
+_sym_db.RegisterMessage(PassDesc.AttrCondition)
+
+MultiPassDesc = _reflection.GeneratedProtocolMessageType('MultiPassDesc', (_message.Message,), dict(
+ DESCRIPTOR = _MULTIPASSDESC,
+ __module__ = 'pass_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.proto.MultiPassDesc)
+ ))
+_sym_db.RegisterMessage(MultiPassDesc)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/profiler/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/profiler/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/profiler/profiler_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/profiler/profiler_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d27f28543f4040ef4a6b14c633f07044c1dd4548
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/profiler/profiler_pb2.py
@@ -0,0 +1,374 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: profiler.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='profiler.proto',
+ package='paddle.platform.proto',
+ syntax='proto2',
+ serialized_pb=_b('\n\x0eprofiler.proto\x12\x15paddle.platform.proto\"\x18\n\x07MemCopy\x12\r\n\x05\x62ytes\x18\x01 \x01(\x04\"\x91\x02\n\x05\x45vent\x12\x34\n\x04type\x18\x08 \x01(\x0e\x32&.paddle.platform.proto.Event.EventType\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x10\n\x08start_ns\x18\x02 \x01(\x04\x12\x0e\n\x06\x65nd_ns\x18\x03 \x01(\x04\x12\x11\n\tdevice_id\x18\x05 \x01(\x03\x12\x15\n\rsub_device_id\x18\x06 \x01(\x03\x12/\n\x07memcopy\x18\x07 \x01(\x0b\x32\x1e.paddle.platform.proto.MemCopy\x12\x13\n\x0b\x64\x65tail_info\x18\t \x01(\t\"2\n\tEventType\x12\x07\n\x03\x43PU\x10\x00\x12\r\n\tGPUKernel\x10\x01\x12\r\n\tNPUKernel\x10\x02\"\x91\x02\n\x08MemEvent\x12\x10\n\x08start_ns\x18\x01 \x01(\x04\x12\x0e\n\x06\x65nd_ns\x18\x02 \x01(\x04\x12\r\n\x05\x62ytes\x18\x03 \x01(\x04\x12\x34\n\x05place\x18\x04 \x01(\x0e\x32%.paddle.platform.proto.MemEvent.Place\x12\x11\n\tthread_id\x18\x05 \x01(\x04\x12\x11\n\tdevice_id\x18\x06 \x01(\r\x12\x10\n\x08\x61lloc_in\x18\x07 \x01(\t\x12\x0f\n\x07\x66ree_in\x18\x08 \x01(\t\"U\n\x05Place\x12\r\n\tCUDAPlace\x10\x00\x12\x0c\n\x08\x43PUPlace\x10\x01\x12\x13\n\x0f\x43UDAPinnedPlace\x10\x02\x12\x0c\n\x08XPUPlace\x10\x03\x12\x0c\n\x08NPUPlace\x10\x04\"\x8e\x01\n\x07Profile\x12,\n\x06\x65vents\x18\x01 \x03(\x0b\x32\x1c.paddle.platform.proto.Event\x12\x10\n\x08start_ns\x18\x02 \x01(\x04\x12\x0e\n\x06\x65nd_ns\x18\x03 \x01(\x04\x12\x33\n\nmem_events\x18\x04 \x03(\x0b\x32\x1f.paddle.platform.proto.MemEvent')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+_EVENT_EVENTTYPE = _descriptor.EnumDescriptor(
+ name='EventType',
+ full_name='paddle.platform.proto.Event.EventType',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='CPU', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='GPUKernel', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='NPUKernel', index=2, number=2,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=291,
+ serialized_end=341,
+)
+_sym_db.RegisterEnumDescriptor(_EVENT_EVENTTYPE)
+
+_MEMEVENT_PLACE = _descriptor.EnumDescriptor(
+ name='Place',
+ full_name='paddle.platform.proto.MemEvent.Place',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='CUDAPlace', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='CPUPlace', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='CUDAPinnedPlace', index=2, number=2,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='XPUPlace', index=3, number=3,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='NPUPlace', index=4, number=4,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=532,
+ serialized_end=617,
+)
+_sym_db.RegisterEnumDescriptor(_MEMEVENT_PLACE)
+
+
+_MEMCOPY = _descriptor.Descriptor(
+ name='MemCopy',
+ full_name='paddle.platform.proto.MemCopy',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='bytes', full_name='paddle.platform.proto.MemCopy.bytes', index=0,
+ number=1, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=41,
+ serialized_end=65,
+)
+
+
+_EVENT = _descriptor.Descriptor(
+ name='Event',
+ full_name='paddle.platform.proto.Event',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='type', full_name='paddle.platform.proto.Event.type', index=0,
+ number=8, type=14, cpp_type=8, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='name', full_name='paddle.platform.proto.Event.name', index=1,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='start_ns', full_name='paddle.platform.proto.Event.start_ns', index=2,
+ number=2, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='end_ns', full_name='paddle.platform.proto.Event.end_ns', index=3,
+ number=3, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='device_id', full_name='paddle.platform.proto.Event.device_id', index=4,
+ number=5, type=3, cpp_type=2, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sub_device_id', full_name='paddle.platform.proto.Event.sub_device_id', index=5,
+ number=6, type=3, cpp_type=2, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='memcopy', full_name='paddle.platform.proto.Event.memcopy', index=6,
+ number=7, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='detail_info', full_name='paddle.platform.proto.Event.detail_info', index=7,
+ number=9, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ _EVENT_EVENTTYPE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=68,
+ serialized_end=341,
+)
+
+
+_MEMEVENT = _descriptor.Descriptor(
+ name='MemEvent',
+ full_name='paddle.platform.proto.MemEvent',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='start_ns', full_name='paddle.platform.proto.MemEvent.start_ns', index=0,
+ number=1, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='end_ns', full_name='paddle.platform.proto.MemEvent.end_ns', index=1,
+ number=2, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='bytes', full_name='paddle.platform.proto.MemEvent.bytes', index=2,
+ number=3, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='place', full_name='paddle.platform.proto.MemEvent.place', index=3,
+ number=4, type=14, cpp_type=8, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='thread_id', full_name='paddle.platform.proto.MemEvent.thread_id', index=4,
+ number=5, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='device_id', full_name='paddle.platform.proto.MemEvent.device_id', index=5,
+ number=6, type=13, cpp_type=3, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='alloc_in', full_name='paddle.platform.proto.MemEvent.alloc_in', index=6,
+ number=7, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='free_in', full_name='paddle.platform.proto.MemEvent.free_in', index=7,
+ number=8, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ _MEMEVENT_PLACE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=344,
+ serialized_end=617,
+)
+
+
+_PROFILE = _descriptor.Descriptor(
+ name='Profile',
+ full_name='paddle.platform.proto.Profile',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='events', full_name='paddle.platform.proto.Profile.events', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='start_ns', full_name='paddle.platform.proto.Profile.start_ns', index=1,
+ number=2, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='end_ns', full_name='paddle.platform.proto.Profile.end_ns', index=2,
+ number=3, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mem_events', full_name='paddle.platform.proto.Profile.mem_events', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=620,
+ serialized_end=762,
+)
+
+_EVENT.fields_by_name['type'].enum_type = _EVENT_EVENTTYPE
+_EVENT.fields_by_name['memcopy'].message_type = _MEMCOPY
+_EVENT_EVENTTYPE.containing_type = _EVENT
+_MEMEVENT.fields_by_name['place'].enum_type = _MEMEVENT_PLACE
+_MEMEVENT_PLACE.containing_type = _MEMEVENT
+_PROFILE.fields_by_name['events'].message_type = _EVENT
+_PROFILE.fields_by_name['mem_events'].message_type = _MEMEVENT
+DESCRIPTOR.message_types_by_name['MemCopy'] = _MEMCOPY
+DESCRIPTOR.message_types_by_name['Event'] = _EVENT
+DESCRIPTOR.message_types_by_name['MemEvent'] = _MEMEVENT
+DESCRIPTOR.message_types_by_name['Profile'] = _PROFILE
+
+MemCopy = _reflection.GeneratedProtocolMessageType('MemCopy', (_message.Message,), dict(
+ DESCRIPTOR = _MEMCOPY,
+ __module__ = 'profiler_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.platform.proto.MemCopy)
+ ))
+_sym_db.RegisterMessage(MemCopy)
+
+Event = _reflection.GeneratedProtocolMessageType('Event', (_message.Message,), dict(
+ DESCRIPTOR = _EVENT,
+ __module__ = 'profiler_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.platform.proto.Event)
+ ))
+_sym_db.RegisterMessage(Event)
+
+MemEvent = _reflection.GeneratedProtocolMessageType('MemEvent', (_message.Message,), dict(
+ DESCRIPTOR = _MEMEVENT,
+ __module__ = 'profiler_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.platform.proto.MemEvent)
+ ))
+_sym_db.RegisterMessage(MemEvent)
+
+Profile = _reflection.GeneratedProtocolMessageType('Profile', (_message.Message,), dict(
+ DESCRIPTOR = _PROFILE,
+ __module__ = 'profiler_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.platform.proto.Profile)
+ ))
+_sym_db.RegisterMessage(Profile)
+
+
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/trainer_desc_pb2.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/trainer_desc_pb2.py
new file mode 100644
index 0000000000000000000000000000000000000000..93a29fa0ed34c2297172784d747bc4959565915b
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/proto/trainer_desc_pb2.py
@@ -0,0 +1,1426 @@
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+# source: trainer_desc.proto
+
+import sys
+_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+import data_feed_pb2 as data__feed__pb2
+import framework_pb2 as framework__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+ name='trainer_desc.proto',
+ package='paddle.framework',
+ syntax='proto2',
+ serialized_pb=_b('\n\x12trainer_desc.proto\x12\x10paddle.framework\x1a\x0f\x64\x61ta_feed.proto\x1a\x0f\x66ramework.proto\"\xd7\x0b\n\x0bTrainerDesc\x12\x12\n\nclass_name\x18\x01 \x01(\t\x12\x1a\n\x12\x64\x65vice_worker_name\x18\x02 \x01(\t\x12\x12\n\nthread_num\x18\x03 \x01(\x05\x12\x1a\n\x0b\x62inding_cpu\x18\x04 \x01(\x08:\x05\x66\x61lse\x12\x10\n\x08\x66ilelist\x18\x05 \x03(\t\x12\x14\n\x05\x64\x65\x62ug\x18\x06 \x01(\x08:\x05\x66\x61lse\x12\x33\n\x0c\x66\x65tch_config\x18\x07 \x01(\x0b\x32\x1d.paddle.framework.FetchConfig\x12\x16\n\x07use_cvm\x18\x08 \x01(\x08:\x05\x66\x61lse\x12\x18\n\tdump_slot\x18\t \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x0escale_datanorm\x18\n \x01(\x02:\x02-1\x12\x14\n\x08mpi_rank\x18\x0b \x01(\x05:\x02-1\x12\x18\n\x10\x64ump_fields_path\x18\x0c \x01(\t\x12\x13\n\x0b\x64ump_fields\x18\r \x03(\t\x12\x16\n\x0e\x64ump_converter\x18\x0e \x01(\t\x12\x12\n\ndump_param\x18\x0f \x03(\t\x12\x14\n\x08mpi_size\x18\x10 \x01(\x05:\x02-1\x12\x19\n\rdump_file_num\x18\x11 \x01(\x05:\x02\x31\x36\x12\x1b\n\x13\x63heck_nan_var_names\x18\x12 \x03(\t\x12<\n\x11\x63opy_table_config\x18\x13 \x01(\x0b\x32!.paddle.framework.CopyTableConfig\x12I\n\x18\x61\x64just_ins_weight_config\x18\x14 \x01(\x0b\x32\'.paddle.framework.AdjustInsWeightConfig\x12\x15\n\x06no_cvm\x18\x15 \x01(\x08:\x05\x66\x61lse\x12\x16\n\x0ethread_barrier\x18\x16 \x01(\x08\x12\x12\n\nloss_names\x18\x17 \x03(\t\x12!\n\x12\x65nable_random_dump\x18\x18 \x01(\x08:\x05\x66\x61lse\x12!\n\x12random_with_lineid\x18\x19 \x01(\x08:\x05\x66\x61lse\x12\x1c\n\rdump_interval\x18\x1a \x01(\x05:\x05\x31\x30\x30\x30\x30\x12\x15\n\rworker_places\x18\x1b \x03(\x05\x12\x15\n\rxpu_send_list\x18\x1c \x03(\t\x12\x15\n\rxpu_recv_list\x18\x1d \x03(\t\x12\x15\n\rxpu_start_idx\x18\x1e \x01(\x05\x12\x13\n\x0bxpu_end_idx\x18\x1f \x01(\x05\x12\x19\n\nuse_ps_gpu\x18 \x01(\x08:\x05\x66\x61lse\x12!\n\x19user_define_dump_filename\x18! \x01(\t\x12\x33\n%scale_sparse_gradient_with_batch_size\x18\" \x01(\x08:\x04true\x12\x10\n\x08trainers\x18# \x03(\x05\x12\x12\n\ntrainer_id\x18$ \x01(\x05\x12\x12\n\nfleet_desc\x18% \x01(\t\x12%\n\x16is_dump_in_simple_mode\x18& \x01(\x08:\x05\x66\x61lse\x12?\n\rhogwild_param\x18\x65 \x01(\x0b\x32(.paddle.framework.HogwildWorkerParameter\x12\x41\n\x0e\x64ownpour_param\x18g \x01(\x0b\x32).paddle.framework.DownpourWorkerParameter\x12\x44\n\x10pull_dense_param\x18\x66 \x01(\x0b\x32*.paddle.framework.PullDenseWorkerParameter\x12?\n\rsection_param\x18h \x01(\x0b\x32(.paddle.framework.SectionWorkerParameter\x12J\n\x13heter_section_param\x18i \x01(\x0b\x32-.paddle.framework.HeterSectionWorkerParameter\x12\x32\n\tdata_desc\x18\xc9\x01 \x01(\x0b\x32\x1e.paddle.framework.DataFeedDesc\"B\n\x16HogwildWorkerParameter\x12\x10\n\x08skip_ops\x18\x01 \x03(\t\x12\x16\n\x0estat_var_names\x18\x02 \x03(\t\"\xa0\x02\n\x17\x44ownpourWorkerParameter\x12\x36\n\x0csparse_table\x18\x01 \x03(\x0b\x32 .paddle.framework.TableParameter\x12\x35\n\x0b\x64\x65nse_table\x18\x02 \x03(\x0b\x32 .paddle.framework.TableParameter\x12\x10\n\x08skip_ops\x18\x03 \x03(\t\x12\x37\n\x0eprogram_config\x18\x04 \x03(\x0b\x32\x1f.paddle.framework.ProgramConfig\x12\x19\n\x0bpush_sparse\x18\x05 \x01(\x08:\x04true\x12\x18\n\npush_dense\x18\x06 \x01(\x08:\x04true\x12\x16\n\x0estat_var_names\x18\x07 \x03(\t\"\xa5\x02\n\x16SectionWorkerParameter\x12\x37\n\x0esection_config\x18\x01 \x01(\x0b\x32\x1f.paddle.framework.SectionConfig\x12\x15\n\nqueue_size\x18\x02 \x01(\x05:\x01\x31\x12\x15\n\nsync_steps\x18\x03 \x01(\x03:\x01\x31\x12\x1c\n\x11start_cpu_core_id\x18\x04 \x01(\x05:\x01\x31\x12\x17\n\x0fparam_need_sync\x18\x05 \x03(\t\x12\x18\n\x10num_microbatches\x18\x06 \x01(\x05\x12\x1e\n\x13num_pipeline_stages\x18\x07 \x01(\x05:\x01\x31\x12\x19\n\x0epipeline_stage\x18\x08 \x01(\x05:\x01\x31\x12\x18\n\rschedule_mode\x18\t \x01(\x05:\x01\x30\"\x90\x02\n\x1bHeterSectionWorkerParameter\x12\x37\n\x0esection_config\x18\x01 \x01(\x0b\x32\x1f.paddle.framework.SectionConfig\x12\x15\n\nqueue_size\x18\x02 \x01(\x05:\x01\x31\x12\x15\n\nsync_steps\x18\x03 \x01(\x03:\x01\x31\x12\x1c\n\x11start_cpu_core_id\x18\x04 \x01(\x05:\x01\x31\x12\x17\n\x0fparam_need_sync\x18\x05 \x03(\t\x12\x18\n\x10num_microbatches\x18\x06 \x01(\x05\x12\x1e\n\x13num_pipeline_stages\x18\x07 \x01(\x05:\x01\x31\x12\x19\n\x0epipeline_stage\x18\x08 \x01(\x05:\x01\x31\"\xa6\x02\n\rSectionConfig\x12\x39\n\x0cprogram_desc\x18\x01 \x01(\x0b\x32#.paddle.framework.proto.ProgramDesc\x12\x34\n\x05place\x18\x02 \x01(\x0e\x32%.paddle.framework.SectionConfig.Place\x12\x16\n\x0b\x63oncurrency\x18\x03 \x01(\x05:\x01\x31\x12\x1c\n\x14section_in_var_names\x18\x04 \x03(\t\x12\x1d\n\x15section_out_var_names\x18\x05 \x03(\t\x12\x14\n\x08place_id\x18\x06 \x01(\x05:\x02-1\"9\n\x05Place\x12\x0c\n\x08\x43PUPlace\x10\x00\x12\r\n\tCUDAPlace\x10\x01\x12\x13\n\x0f\x43UDAPinnedPlace\x10\x02\"\xb1\x01\n\x0b\x46\x65tchConfig\x12\x17\n\x0f\x66\x65tch_var_names\x18\x01 \x03(\t\x12\x1c\n\x14\x66\x65tch_var_str_format\x18\x02 \x03(\t\x12\x19\n\x0cprint_period\x18\x03 \x01(\x05:\x03\x31\x30\x30\x12;\n\x06method\x18\x04 \x01(\x0e\x32$.paddle.framework.FetchConfig.Method:\x05PRINT\"\x13\n\x06Method\x12\t\n\x05PRINT\x10\x00\"\x9c\x01\n\x15\x41\x64justInsWeightConfig\x12\x1a\n\x0bneed_adjust\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x12\n\x08nid_slot\x18\x02 \x01(\t:\x00\x12\x1d\n\x12nid_adjw_threshold\x18\x03 \x01(\x02:\x01\x30\x12\x19\n\x0enid_adjw_ratio\x18\x04 \x01(\x02:\x01\x30\x12\x19\n\x0fins_weight_slot\x18\x05 \x01(\t:\x00\"1\n\x12TableDependencyMap\x12\x0b\n\x03key\x18\x01 \x02(\x05\x12\x0e\n\x06values\x18\x02 \x03(\x05\"\x8f\x03\n\x0f\x43opyTableConfig\x12\x18\n\tneed_copy\x18\x01 \x01(\x08:\x05\x66\x61lse\x12\x16\n\tbatch_num\x18\x02 \x01(\x05:\x03\x31\x30\x30\x12\x19\n\x11src_sparse_tables\x18\x03 \x03(\x05\x12\x1a\n\x12\x64\x65st_sparse_tables\x18\x04 \x03(\x05\x12\x18\n\x10src_dense_tables\x18\x05 \x03(\x05\x12\x19\n\x11\x64\x65st_dense_tables\x18\x06 \x03(\x05\x12\x14\n\x0csrc_var_list\x18\x07 \x03(\t\x12\x15\n\rdest_var_list\x18\x08 \x03(\t\x12$\n\x15\x64\x65nse_pull_after_copy\x18\t \x01(\x08:\x05\x66\x61lse\x12$\n\x16sparse_copy_by_feasign\x18\n \x01(\x08:\x04true\x12 \n\x11\x65nable_dependency\x18\x0b \x01(\x08:\x05\x66\x61lse\x12\x43\n\x15table_denpendency_map\x18\x0c \x03(\x0b\x32$.paddle.framework.TableDependencyMap\"*\n\x0c\x43ondTableMap\x12\x0b\n\x03key\x18\x01 \x02(\x05\x12\r\n\x05value\x18\x02 \x02(\x05\"\xe2\x01\n\rProgramConfig\x12\x12\n\nprogram_id\x18\x01 \x02(\t\x12\x1c\n\x14push_sparse_table_id\x18\x02 \x03(\x05\x12\x1b\n\x13push_dense_table_id\x18\x03 \x03(\x05\x12\x1c\n\x14pull_sparse_table_id\x18\x04 \x03(\x05\x12\x1b\n\x13pull_dense_table_id\x18\x05 \x03(\x05\x12G\n\x1fpartial_pushdense_condtable_map\x18\n \x03(\x0b\x32\x1e.paddle.framework.CondTableMap\"\x95\x01\n\x18PullDenseWorkerParameter\x12\x14\n\tthreshold\x18\x01 \x01(\x05:\x01\x31\x12\x12\n\ndevice_num\x18\x02 \x01(\x05\x12\x18\n\rsleep_time_ms\x18\x03 \x01(\x05:\x01\x32\x12\x35\n\x0b\x64\x65nse_table\x18\x04 \x03(\x0b\x32 .paddle.framework.TableParameter\"\xea\x02\n\x0eTableParameter\x12\x10\n\x08table_id\x18\x01 \x01(\x04\x12\x18\n\x10\x64\x65nse_value_name\x18\x02 \x03(\t\x12\x17\n\x0f\x64\x65nse_grad_name\x18\x03 \x03(\t\x12\x1d\n\x15push_dense_wait_times\x18\x05 \x03(\x05\x12\x17\n\x0fsparse_key_name\x18\x06 \x03(\t\x12\x19\n\x11sparse_value_name\x18\x07 \x03(\t\x12\x18\n\x10sparse_grad_name\x18\x08 \x03(\t\x12\x1e\n\x16push_sparse_wait_times\x18\t \x03(\x05\x12\x0f\n\x07\x65mb_dim\x18\n \x01(\x05\x12\x0f\n\x07\x66\x65\x61_dim\x18\x0b \x01(\x05\x12\x16\n\x0elabel_var_name\x18\x0c \x01(\t\x12\x17\n\x08is_local\x18\r \x01(\x08:\x05\x66\x61lse\x12\x17\n\x08is_async\x18\x0e \x01(\x08:\x05\x66\x61lse\x12\x1a\n\x12\x61sync_wait_op_name\x18\x0f \x01(\tB\x02H\x03')
+ ,
+ dependencies=[data__feed__pb2.DESCRIPTOR,framework__pb2.DESCRIPTOR,])
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+
+
+_SECTIONCONFIG_PLACE = _descriptor.EnumDescriptor(
+ name='Place',
+ full_name='paddle.framework.SectionConfig.Place',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='CPUPlace', index=0, number=0,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='CUDAPlace', index=1, number=1,
+ options=None,
+ type=None),
+ _descriptor.EnumValueDescriptor(
+ name='CUDAPinnedPlace', index=2, number=2,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=2740,
+ serialized_end=2797,
+)
+_sym_db.RegisterEnumDescriptor(_SECTIONCONFIG_PLACE)
+
+_FETCHCONFIG_METHOD = _descriptor.EnumDescriptor(
+ name='Method',
+ full_name='paddle.framework.FetchConfig.Method',
+ filename=None,
+ file=DESCRIPTOR,
+ values=[
+ _descriptor.EnumValueDescriptor(
+ name='PRINT', index=0, number=0,
+ options=None,
+ type=None),
+ ],
+ containing_type=None,
+ options=None,
+ serialized_start=2958,
+ serialized_end=2977,
+)
+_sym_db.RegisterEnumDescriptor(_FETCHCONFIG_METHOD)
+
+
+_TRAINERDESC = _descriptor.Descriptor(
+ name='TrainerDesc',
+ full_name='paddle.framework.TrainerDesc',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='class_name', full_name='paddle.framework.TrainerDesc.class_name', index=0,
+ number=1, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='device_worker_name', full_name='paddle.framework.TrainerDesc.device_worker_name', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='thread_num', full_name='paddle.framework.TrainerDesc.thread_num', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='binding_cpu', full_name='paddle.framework.TrainerDesc.binding_cpu', index=3,
+ number=4, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='filelist', full_name='paddle.framework.TrainerDesc.filelist', index=4,
+ number=5, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='debug', full_name='paddle.framework.TrainerDesc.debug', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fetch_config', full_name='paddle.framework.TrainerDesc.fetch_config', index=6,
+ number=7, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_cvm', full_name='paddle.framework.TrainerDesc.use_cvm', index=7,
+ number=8, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_slot', full_name='paddle.framework.TrainerDesc.dump_slot', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='scale_datanorm', full_name='paddle.framework.TrainerDesc.scale_datanorm', index=9,
+ number=10, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(-1),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mpi_rank', full_name='paddle.framework.TrainerDesc.mpi_rank', index=10,
+ number=11, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_fields_path', full_name='paddle.framework.TrainerDesc.dump_fields_path', index=11,
+ number=12, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_fields', full_name='paddle.framework.TrainerDesc.dump_fields', index=12,
+ number=13, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_converter', full_name='paddle.framework.TrainerDesc.dump_converter', index=13,
+ number=14, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_param', full_name='paddle.framework.TrainerDesc.dump_param', index=14,
+ number=15, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='mpi_size', full_name='paddle.framework.TrainerDesc.mpi_size', index=15,
+ number=16, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_file_num', full_name='paddle.framework.TrainerDesc.dump_file_num', index=16,
+ number=17, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=16,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='check_nan_var_names', full_name='paddle.framework.TrainerDesc.check_nan_var_names', index=17,
+ number=18, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='copy_table_config', full_name='paddle.framework.TrainerDesc.copy_table_config', index=18,
+ number=19, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='adjust_ins_weight_config', full_name='paddle.framework.TrainerDesc.adjust_ins_weight_config', index=19,
+ number=20, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='no_cvm', full_name='paddle.framework.TrainerDesc.no_cvm', index=20,
+ number=21, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='thread_barrier', full_name='paddle.framework.TrainerDesc.thread_barrier', index=21,
+ number=22, type=8, cpp_type=7, label=1,
+ has_default_value=False, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='loss_names', full_name='paddle.framework.TrainerDesc.loss_names', index=22,
+ number=23, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_random_dump', full_name='paddle.framework.TrainerDesc.enable_random_dump', index=23,
+ number=24, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='random_with_lineid', full_name='paddle.framework.TrainerDesc.random_with_lineid', index=24,
+ number=25, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dump_interval', full_name='paddle.framework.TrainerDesc.dump_interval', index=25,
+ number=26, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=10000,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='worker_places', full_name='paddle.framework.TrainerDesc.worker_places', index=26,
+ number=27, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='xpu_send_list', full_name='paddle.framework.TrainerDesc.xpu_send_list', index=27,
+ number=28, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='xpu_recv_list', full_name='paddle.framework.TrainerDesc.xpu_recv_list', index=28,
+ number=29, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='xpu_start_idx', full_name='paddle.framework.TrainerDesc.xpu_start_idx', index=29,
+ number=30, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='xpu_end_idx', full_name='paddle.framework.TrainerDesc.xpu_end_idx', index=30,
+ number=31, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='use_ps_gpu', full_name='paddle.framework.TrainerDesc.use_ps_gpu', index=31,
+ number=32, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='user_define_dump_filename', full_name='paddle.framework.TrainerDesc.user_define_dump_filename', index=32,
+ number=33, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='scale_sparse_gradient_with_batch_size', full_name='paddle.framework.TrainerDesc.scale_sparse_gradient_with_batch_size', index=33,
+ number=34, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='trainers', full_name='paddle.framework.TrainerDesc.trainers', index=34,
+ number=35, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='trainer_id', full_name='paddle.framework.TrainerDesc.trainer_id', index=35,
+ number=36, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fleet_desc', full_name='paddle.framework.TrainerDesc.fleet_desc', index=36,
+ number=37, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_dump_in_simple_mode', full_name='paddle.framework.TrainerDesc.is_dump_in_simple_mode', index=37,
+ number=38, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='hogwild_param', full_name='paddle.framework.TrainerDesc.hogwild_param', index=38,
+ number=101, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='downpour_param', full_name='paddle.framework.TrainerDesc.downpour_param', index=39,
+ number=103, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pull_dense_param', full_name='paddle.framework.TrainerDesc.pull_dense_param', index=40,
+ number=102, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='section_param', full_name='paddle.framework.TrainerDesc.section_param', index=41,
+ number=104, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='heter_section_param', full_name='paddle.framework.TrainerDesc.heter_section_param', index=42,
+ number=105, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='data_desc', full_name='paddle.framework.TrainerDesc.data_desc', index=43,
+ number=201, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=75,
+ serialized_end=1570,
+)
+
+
+_HOGWILDWORKERPARAMETER = _descriptor.Descriptor(
+ name='HogwildWorkerParameter',
+ full_name='paddle.framework.HogwildWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='skip_ops', full_name='paddle.framework.HogwildWorkerParameter.skip_ops', index=0,
+ number=1, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='stat_var_names', full_name='paddle.framework.HogwildWorkerParameter.stat_var_names', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1572,
+ serialized_end=1638,
+)
+
+
+_DOWNPOURWORKERPARAMETER = _descriptor.Descriptor(
+ name='DownpourWorkerParameter',
+ full_name='paddle.framework.DownpourWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='sparse_table', full_name='paddle.framework.DownpourWorkerParameter.sparse_table', index=0,
+ number=1, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_table', full_name='paddle.framework.DownpourWorkerParameter.dense_table', index=1,
+ number=2, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='skip_ops', full_name='paddle.framework.DownpourWorkerParameter.skip_ops', index=2,
+ number=3, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='program_config', full_name='paddle.framework.DownpourWorkerParameter.program_config', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_sparse', full_name='paddle.framework.DownpourWorkerParameter.push_sparse', index=4,
+ number=5, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_dense', full_name='paddle.framework.DownpourWorkerParameter.push_dense', index=5,
+ number=6, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='stat_var_names', full_name='paddle.framework.DownpourWorkerParameter.stat_var_names', index=6,
+ number=7, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1641,
+ serialized_end=1929,
+)
+
+
+_SECTIONWORKERPARAMETER = _descriptor.Descriptor(
+ name='SectionWorkerParameter',
+ full_name='paddle.framework.SectionWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='section_config', full_name='paddle.framework.SectionWorkerParameter.section_config', index=0,
+ number=1, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='queue_size', full_name='paddle.framework.SectionWorkerParameter.queue_size', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sync_steps', full_name='paddle.framework.SectionWorkerParameter.sync_steps', index=2,
+ number=3, type=3, cpp_type=2, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='start_cpu_core_id', full_name='paddle.framework.SectionWorkerParameter.start_cpu_core_id', index=3,
+ number=4, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='param_need_sync', full_name='paddle.framework.SectionWorkerParameter.param_need_sync', index=4,
+ number=5, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_microbatches', full_name='paddle.framework.SectionWorkerParameter.num_microbatches', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_pipeline_stages', full_name='paddle.framework.SectionWorkerParameter.num_pipeline_stages', index=6,
+ number=7, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pipeline_stage', full_name='paddle.framework.SectionWorkerParameter.pipeline_stage', index=7,
+ number=8, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='schedule_mode', full_name='paddle.framework.SectionWorkerParameter.schedule_mode', index=8,
+ number=9, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=1932,
+ serialized_end=2225,
+)
+
+
+_HETERSECTIONWORKERPARAMETER = _descriptor.Descriptor(
+ name='HeterSectionWorkerParameter',
+ full_name='paddle.framework.HeterSectionWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='section_config', full_name='paddle.framework.HeterSectionWorkerParameter.section_config', index=0,
+ number=1, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='queue_size', full_name='paddle.framework.HeterSectionWorkerParameter.queue_size', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sync_steps', full_name='paddle.framework.HeterSectionWorkerParameter.sync_steps', index=2,
+ number=3, type=3, cpp_type=2, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='start_cpu_core_id', full_name='paddle.framework.HeterSectionWorkerParameter.start_cpu_core_id', index=3,
+ number=4, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='param_need_sync', full_name='paddle.framework.HeterSectionWorkerParameter.param_need_sync', index=4,
+ number=5, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_microbatches', full_name='paddle.framework.HeterSectionWorkerParameter.num_microbatches', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='num_pipeline_stages', full_name='paddle.framework.HeterSectionWorkerParameter.num_pipeline_stages', index=6,
+ number=7, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pipeline_stage', full_name='paddle.framework.HeterSectionWorkerParameter.pipeline_stage', index=7,
+ number=8, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2228,
+ serialized_end=2500,
+)
+
+
+_SECTIONCONFIG = _descriptor.Descriptor(
+ name='SectionConfig',
+ full_name='paddle.framework.SectionConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='program_desc', full_name='paddle.framework.SectionConfig.program_desc', index=0,
+ number=1, type=11, cpp_type=10, label=1,
+ has_default_value=False, default_value=None,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='place', full_name='paddle.framework.SectionConfig.place', index=1,
+ number=2, type=14, cpp_type=8, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='concurrency', full_name='paddle.framework.SectionConfig.concurrency', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='section_in_var_names', full_name='paddle.framework.SectionConfig.section_in_var_names', index=3,
+ number=4, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='section_out_var_names', full_name='paddle.framework.SectionConfig.section_out_var_names', index=4,
+ number=5, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='place_id', full_name='paddle.framework.SectionConfig.place_id', index=5,
+ number=6, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=-1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ _SECTIONCONFIG_PLACE,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2503,
+ serialized_end=2797,
+)
+
+
+_FETCHCONFIG = _descriptor.Descriptor(
+ name='FetchConfig',
+ full_name='paddle.framework.FetchConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='fetch_var_names', full_name='paddle.framework.FetchConfig.fetch_var_names', index=0,
+ number=1, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fetch_var_str_format', full_name='paddle.framework.FetchConfig.fetch_var_str_format', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='print_period', full_name='paddle.framework.FetchConfig.print_period', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=100,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='method', full_name='paddle.framework.FetchConfig.method', index=3,
+ number=4, type=14, cpp_type=8, label=1,
+ has_default_value=True, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ _FETCHCONFIG_METHOD,
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2800,
+ serialized_end=2977,
+)
+
+
+_ADJUSTINSWEIGHTCONFIG = _descriptor.Descriptor(
+ name='AdjustInsWeightConfig',
+ full_name='paddle.framework.AdjustInsWeightConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='need_adjust', full_name='paddle.framework.AdjustInsWeightConfig.need_adjust', index=0,
+ number=1, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='nid_slot', full_name='paddle.framework.AdjustInsWeightConfig.nid_slot', index=1,
+ number=2, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='nid_adjw_threshold', full_name='paddle.framework.AdjustInsWeightConfig.nid_adjw_threshold', index=2,
+ number=3, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='nid_adjw_ratio', full_name='paddle.framework.AdjustInsWeightConfig.nid_adjw_ratio', index=3,
+ number=4, type=2, cpp_type=6, label=1,
+ has_default_value=True, default_value=float(0),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='ins_weight_slot', full_name='paddle.framework.AdjustInsWeightConfig.ins_weight_slot', index=4,
+ number=5, type=9, cpp_type=9, label=1,
+ has_default_value=True, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=2980,
+ serialized_end=3136,
+)
+
+
+_TABLEDEPENDENCYMAP = _descriptor.Descriptor(
+ name='TableDependencyMap',
+ full_name='paddle.framework.TableDependencyMap',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='key', full_name='paddle.framework.TableDependencyMap.key', index=0,
+ number=1, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='values', full_name='paddle.framework.TableDependencyMap.values', index=1,
+ number=2, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3138,
+ serialized_end=3187,
+)
+
+
+_COPYTABLECONFIG = _descriptor.Descriptor(
+ name='CopyTableConfig',
+ full_name='paddle.framework.CopyTableConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='need_copy', full_name='paddle.framework.CopyTableConfig.need_copy', index=0,
+ number=1, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='batch_num', full_name='paddle.framework.CopyTableConfig.batch_num', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=100,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='src_sparse_tables', full_name='paddle.framework.CopyTableConfig.src_sparse_tables', index=2,
+ number=3, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dest_sparse_tables', full_name='paddle.framework.CopyTableConfig.dest_sparse_tables', index=3,
+ number=4, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='src_dense_tables', full_name='paddle.framework.CopyTableConfig.src_dense_tables', index=4,
+ number=5, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dest_dense_tables', full_name='paddle.framework.CopyTableConfig.dest_dense_tables', index=5,
+ number=6, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='src_var_list', full_name='paddle.framework.CopyTableConfig.src_var_list', index=6,
+ number=7, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dest_var_list', full_name='paddle.framework.CopyTableConfig.dest_var_list', index=7,
+ number=8, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_pull_after_copy', full_name='paddle.framework.CopyTableConfig.dense_pull_after_copy', index=8,
+ number=9, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_copy_by_feasign', full_name='paddle.framework.CopyTableConfig.sparse_copy_by_feasign', index=9,
+ number=10, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=True,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='enable_dependency', full_name='paddle.framework.CopyTableConfig.enable_dependency', index=10,
+ number=11, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='table_denpendency_map', full_name='paddle.framework.CopyTableConfig.table_denpendency_map', index=11,
+ number=12, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3190,
+ serialized_end=3589,
+)
+
+
+_CONDTABLEMAP = _descriptor.Descriptor(
+ name='CondTableMap',
+ full_name='paddle.framework.CondTableMap',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='key', full_name='paddle.framework.CondTableMap.key', index=0,
+ number=1, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='value', full_name='paddle.framework.CondTableMap.value', index=1,
+ number=2, type=5, cpp_type=1, label=2,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3591,
+ serialized_end=3633,
+)
+
+
+_PROGRAMCONFIG = _descriptor.Descriptor(
+ name='ProgramConfig',
+ full_name='paddle.framework.ProgramConfig',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='program_id', full_name='paddle.framework.ProgramConfig.program_id', index=0,
+ number=1, type=9, cpp_type=9, label=2,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_sparse_table_id', full_name='paddle.framework.ProgramConfig.push_sparse_table_id', index=1,
+ number=2, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_dense_table_id', full_name='paddle.framework.ProgramConfig.push_dense_table_id', index=2,
+ number=3, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pull_sparse_table_id', full_name='paddle.framework.ProgramConfig.pull_sparse_table_id', index=3,
+ number=4, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='pull_dense_table_id', full_name='paddle.framework.ProgramConfig.pull_dense_table_id', index=4,
+ number=5, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='partial_pushdense_condtable_map', full_name='paddle.framework.ProgramConfig.partial_pushdense_condtable_map', index=5,
+ number=10, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3636,
+ serialized_end=3862,
+)
+
+
+_PULLDENSEWORKERPARAMETER = _descriptor.Descriptor(
+ name='PullDenseWorkerParameter',
+ full_name='paddle.framework.PullDenseWorkerParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='threshold', full_name='paddle.framework.PullDenseWorkerParameter.threshold', index=0,
+ number=1, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=1,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='device_num', full_name='paddle.framework.PullDenseWorkerParameter.device_num', index=1,
+ number=2, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sleep_time_ms', full_name='paddle.framework.PullDenseWorkerParameter.sleep_time_ms', index=2,
+ number=3, type=5, cpp_type=1, label=1,
+ has_default_value=True, default_value=2,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_table', full_name='paddle.framework.PullDenseWorkerParameter.dense_table', index=3,
+ number=4, type=11, cpp_type=10, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=3865,
+ serialized_end=4014,
+)
+
+
+_TABLEPARAMETER = _descriptor.Descriptor(
+ name='TableParameter',
+ full_name='paddle.framework.TableParameter',
+ filename=None,
+ file=DESCRIPTOR,
+ containing_type=None,
+ fields=[
+ _descriptor.FieldDescriptor(
+ name='table_id', full_name='paddle.framework.TableParameter.table_id', index=0,
+ number=1, type=4, cpp_type=4, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_value_name', full_name='paddle.framework.TableParameter.dense_value_name', index=1,
+ number=2, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='dense_grad_name', full_name='paddle.framework.TableParameter.dense_grad_name', index=2,
+ number=3, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_dense_wait_times', full_name='paddle.framework.TableParameter.push_dense_wait_times', index=3,
+ number=5, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_key_name', full_name='paddle.framework.TableParameter.sparse_key_name', index=4,
+ number=6, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_value_name', full_name='paddle.framework.TableParameter.sparse_value_name', index=5,
+ number=7, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='sparse_grad_name', full_name='paddle.framework.TableParameter.sparse_grad_name', index=6,
+ number=8, type=9, cpp_type=9, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='push_sparse_wait_times', full_name='paddle.framework.TableParameter.push_sparse_wait_times', index=7,
+ number=9, type=5, cpp_type=1, label=3,
+ has_default_value=False, default_value=[],
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='emb_dim', full_name='paddle.framework.TableParameter.emb_dim', index=8,
+ number=10, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='fea_dim', full_name='paddle.framework.TableParameter.fea_dim', index=9,
+ number=11, type=5, cpp_type=1, label=1,
+ has_default_value=False, default_value=0,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='label_var_name', full_name='paddle.framework.TableParameter.label_var_name', index=10,
+ number=12, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_local', full_name='paddle.framework.TableParameter.is_local', index=11,
+ number=13, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='is_async', full_name='paddle.framework.TableParameter.is_async', index=12,
+ number=14, type=8, cpp_type=7, label=1,
+ has_default_value=True, default_value=False,
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ _descriptor.FieldDescriptor(
+ name='async_wait_op_name', full_name='paddle.framework.TableParameter.async_wait_op_name', index=13,
+ number=15, type=9, cpp_type=9, label=1,
+ has_default_value=False, default_value=_b("").decode('utf-8'),
+ message_type=None, enum_type=None, containing_type=None,
+ is_extension=False, extension_scope=None,
+ options=None),
+ ],
+ extensions=[
+ ],
+ nested_types=[],
+ enum_types=[
+ ],
+ options=None,
+ is_extendable=False,
+ syntax='proto2',
+ extension_ranges=[],
+ oneofs=[
+ ],
+ serialized_start=4017,
+ serialized_end=4379,
+)
+
+_TRAINERDESC.fields_by_name['fetch_config'].message_type = _FETCHCONFIG
+_TRAINERDESC.fields_by_name['copy_table_config'].message_type = _COPYTABLECONFIG
+_TRAINERDESC.fields_by_name['adjust_ins_weight_config'].message_type = _ADJUSTINSWEIGHTCONFIG
+_TRAINERDESC.fields_by_name['hogwild_param'].message_type = _HOGWILDWORKERPARAMETER
+_TRAINERDESC.fields_by_name['downpour_param'].message_type = _DOWNPOURWORKERPARAMETER
+_TRAINERDESC.fields_by_name['pull_dense_param'].message_type = _PULLDENSEWORKERPARAMETER
+_TRAINERDESC.fields_by_name['section_param'].message_type = _SECTIONWORKERPARAMETER
+_TRAINERDESC.fields_by_name['heter_section_param'].message_type = _HETERSECTIONWORKERPARAMETER
+_TRAINERDESC.fields_by_name['data_desc'].message_type = data__feed__pb2._DATAFEEDDESC
+_DOWNPOURWORKERPARAMETER.fields_by_name['sparse_table'].message_type = _TABLEPARAMETER
+_DOWNPOURWORKERPARAMETER.fields_by_name['dense_table'].message_type = _TABLEPARAMETER
+_DOWNPOURWORKERPARAMETER.fields_by_name['program_config'].message_type = _PROGRAMCONFIG
+_SECTIONWORKERPARAMETER.fields_by_name['section_config'].message_type = _SECTIONCONFIG
+_HETERSECTIONWORKERPARAMETER.fields_by_name['section_config'].message_type = _SECTIONCONFIG
+_SECTIONCONFIG.fields_by_name['program_desc'].message_type = framework__pb2._PROGRAMDESC
+_SECTIONCONFIG.fields_by_name['place'].enum_type = _SECTIONCONFIG_PLACE
+_SECTIONCONFIG_PLACE.containing_type = _SECTIONCONFIG
+_FETCHCONFIG.fields_by_name['method'].enum_type = _FETCHCONFIG_METHOD
+_FETCHCONFIG_METHOD.containing_type = _FETCHCONFIG
+_COPYTABLECONFIG.fields_by_name['table_denpendency_map'].message_type = _TABLEDEPENDENCYMAP
+_PROGRAMCONFIG.fields_by_name['partial_pushdense_condtable_map'].message_type = _CONDTABLEMAP
+_PULLDENSEWORKERPARAMETER.fields_by_name['dense_table'].message_type = _TABLEPARAMETER
+DESCRIPTOR.message_types_by_name['TrainerDesc'] = _TRAINERDESC
+DESCRIPTOR.message_types_by_name['HogwildWorkerParameter'] = _HOGWILDWORKERPARAMETER
+DESCRIPTOR.message_types_by_name['DownpourWorkerParameter'] = _DOWNPOURWORKERPARAMETER
+DESCRIPTOR.message_types_by_name['SectionWorkerParameter'] = _SECTIONWORKERPARAMETER
+DESCRIPTOR.message_types_by_name['HeterSectionWorkerParameter'] = _HETERSECTIONWORKERPARAMETER
+DESCRIPTOR.message_types_by_name['SectionConfig'] = _SECTIONCONFIG
+DESCRIPTOR.message_types_by_name['FetchConfig'] = _FETCHCONFIG
+DESCRIPTOR.message_types_by_name['AdjustInsWeightConfig'] = _ADJUSTINSWEIGHTCONFIG
+DESCRIPTOR.message_types_by_name['TableDependencyMap'] = _TABLEDEPENDENCYMAP
+DESCRIPTOR.message_types_by_name['CopyTableConfig'] = _COPYTABLECONFIG
+DESCRIPTOR.message_types_by_name['CondTableMap'] = _CONDTABLEMAP
+DESCRIPTOR.message_types_by_name['ProgramConfig'] = _PROGRAMCONFIG
+DESCRIPTOR.message_types_by_name['PullDenseWorkerParameter'] = _PULLDENSEWORKERPARAMETER
+DESCRIPTOR.message_types_by_name['TableParameter'] = _TABLEPARAMETER
+
+TrainerDesc = _reflection.GeneratedProtocolMessageType('TrainerDesc', (_message.Message,), dict(
+ DESCRIPTOR = _TRAINERDESC,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.TrainerDesc)
+ ))
+_sym_db.RegisterMessage(TrainerDesc)
+
+HogwildWorkerParameter = _reflection.GeneratedProtocolMessageType('HogwildWorkerParameter', (_message.Message,), dict(
+ DESCRIPTOR = _HOGWILDWORKERPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.HogwildWorkerParameter)
+ ))
+_sym_db.RegisterMessage(HogwildWorkerParameter)
+
+DownpourWorkerParameter = _reflection.GeneratedProtocolMessageType('DownpourWorkerParameter', (_message.Message,), dict(
+ DESCRIPTOR = _DOWNPOURWORKERPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.DownpourWorkerParameter)
+ ))
+_sym_db.RegisterMessage(DownpourWorkerParameter)
+
+SectionWorkerParameter = _reflection.GeneratedProtocolMessageType('SectionWorkerParameter', (_message.Message,), dict(
+ DESCRIPTOR = _SECTIONWORKERPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.SectionWorkerParameter)
+ ))
+_sym_db.RegisterMessage(SectionWorkerParameter)
+
+HeterSectionWorkerParameter = _reflection.GeneratedProtocolMessageType('HeterSectionWorkerParameter', (_message.Message,), dict(
+ DESCRIPTOR = _HETERSECTIONWORKERPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.HeterSectionWorkerParameter)
+ ))
+_sym_db.RegisterMessage(HeterSectionWorkerParameter)
+
+SectionConfig = _reflection.GeneratedProtocolMessageType('SectionConfig', (_message.Message,), dict(
+ DESCRIPTOR = _SECTIONCONFIG,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.SectionConfig)
+ ))
+_sym_db.RegisterMessage(SectionConfig)
+
+FetchConfig = _reflection.GeneratedProtocolMessageType('FetchConfig', (_message.Message,), dict(
+ DESCRIPTOR = _FETCHCONFIG,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.FetchConfig)
+ ))
+_sym_db.RegisterMessage(FetchConfig)
+
+AdjustInsWeightConfig = _reflection.GeneratedProtocolMessageType('AdjustInsWeightConfig', (_message.Message,), dict(
+ DESCRIPTOR = _ADJUSTINSWEIGHTCONFIG,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.AdjustInsWeightConfig)
+ ))
+_sym_db.RegisterMessage(AdjustInsWeightConfig)
+
+TableDependencyMap = _reflection.GeneratedProtocolMessageType('TableDependencyMap', (_message.Message,), dict(
+ DESCRIPTOR = _TABLEDEPENDENCYMAP,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.TableDependencyMap)
+ ))
+_sym_db.RegisterMessage(TableDependencyMap)
+
+CopyTableConfig = _reflection.GeneratedProtocolMessageType('CopyTableConfig', (_message.Message,), dict(
+ DESCRIPTOR = _COPYTABLECONFIG,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.CopyTableConfig)
+ ))
+_sym_db.RegisterMessage(CopyTableConfig)
+
+CondTableMap = _reflection.GeneratedProtocolMessageType('CondTableMap', (_message.Message,), dict(
+ DESCRIPTOR = _CONDTABLEMAP,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.CondTableMap)
+ ))
+_sym_db.RegisterMessage(CondTableMap)
+
+ProgramConfig = _reflection.GeneratedProtocolMessageType('ProgramConfig', (_message.Message,), dict(
+ DESCRIPTOR = _PROGRAMCONFIG,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.ProgramConfig)
+ ))
+_sym_db.RegisterMessage(ProgramConfig)
+
+PullDenseWorkerParameter = _reflection.GeneratedProtocolMessageType('PullDenseWorkerParameter', (_message.Message,), dict(
+ DESCRIPTOR = _PULLDENSEWORKERPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.PullDenseWorkerParameter)
+ ))
+_sym_db.RegisterMessage(PullDenseWorkerParameter)
+
+TableParameter = _reflection.GeneratedProtocolMessageType('TableParameter', (_message.Message,), dict(
+ DESCRIPTOR = _TABLEPARAMETER,
+ __module__ = 'trainer_desc_pb2'
+ # @@protoc_insertion_point(class_scope:paddle.framework.TableParameter)
+ ))
+_sym_db.RegisterMessage(TableParameter)
+
+
+DESCRIPTOR.has_options = True
+DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('H\003'))
+# @@protoc_insertion_point(module_scope)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/reader.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/reader.py
new file mode 100644
index 0000000000000000000000000000000000000000..c590d69a621de631274346cf973ac1ed4373b723
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/reader.py
@@ -0,0 +1,2034 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import core
+import sys
+import six
+import numpy as np
+import threading
+import paddle
+import time
+import copy
+
+from .framework import Program, Variable, program_guard, default_main_program, default_startup_program, _non_static_mode, cpu_places, _current_expected_place, _in_eager_without_dygraph_check
+from .executor import global_scope
+from .data_feeder import DataFeeder, BatchedTensorProvider
+from .multiprocess_utils import multiprocess_queue_set, CleanupFuncRegistrar, _cleanup_mmap, _cleanup, _set_SIGCHLD_handler
+from .dataloader import BatchSampler, Dataset, IterableDataset, Subset
+from .dataloader.dataloader_iter import _DataLoaderIterSingleProcess, _DataLoaderIterMultiProcess, _DatasetKind, default_collate_fn
+from .dataloader.batch_sampler import _InfiniteIterableSampler
+from .layers.io import monkey_patch_reader_methods, _copy_reader_var_, double_buffer
+from .unique_name import UniqueNameGenerator
+from .framework import _get_paddle_place, _get_paddle_place_list
+from paddle.fluid.framework import _set_expected_place, _current_expected_place
+import logging
+import warnings
+
+### Dygraph DataLoader configs ###
+import os
+import multiprocessing
+import signal
+# NOTE: queue has a different name in python2 and python3
+import queue
+# NOTE: [ avoid hanging & failed quickly ] These value is used in getting data from another process
+QUEUE_GET_TIMEOUT = 60
+
+__all__ = ['PyReader', 'DataLoader', 'default_collate_fn']
+
+data_loader_unique_name_generator = UniqueNameGenerator()
+
+KEEP_DATA_LOADER_ORDER = True
+USE_PINNED_MEMORY = None
+# AutoTune Flags
+USE_AUTOTUNE = False
+TUNING_STEPS = 500
+
+
+def set_autotune_config(use_autotune, tuning_steps=500):
+ global USE_AUTOTUNE
+ USE_AUTOTUNE = use_autotune
+ global TUNING_STEPS
+ TUNING_STEPS = tuning_steps
+
+
+def keep_data_loader_order(*args):
+ global KEEP_DATA_LOADER_ORDER
+ if len(args) == 0:
+ return KEEP_DATA_LOADER_ORDER
+ else:
+ assert len(args) == 1 and isinstance(args[0], bool)
+ KEEP_DATA_LOADER_ORDER = args[0]
+
+
+def use_pinned_memory(*args):
+ global USE_PINNED_MEMORY
+ if len(args) == 0:
+ return USE_PINNED_MEMORY
+ else:
+ assert len(args) == 1 and isinstance(args[0], bool)
+ USE_PINNED_MEMORY = args[0]
+
+
+def _convert_places(places):
+ if not isinstance(places, (list, tuple)):
+ places = [places]
+
+ ret = []
+ for p in places:
+ if not isinstance(p, core.Place):
+ tmp = core.Place()
+ tmp.set_place(p)
+ p = tmp
+
+ ret.append(p)
+ return ret
+
+
+# NOTE(chenweihang): _reader_process_loop must be top level method to be pickled
+def _reader_process_loop(batch_reader, data_queue):
+ try:
+ # set signal handler
+ core._set_process_signal_handler()
+
+ # NOTE: [ mmap files clear ] When the child process exits unexpectedly,
+ # some shared memory objects may have been applied for but have not yet
+ # been put into the inter-process Queue. This part of the object needs
+ # to be cleaned up when the process ends.
+ CleanupFuncRegistrar.register(_cleanup_mmap)
+
+ for batch in batch_reader():
+ tensor_list = core._convert_to_tensor_list(batch)
+ data_queue.put(tensor_list)
+ core._remove_tensor_list_mmap_fds(tensor_list)
+ data_queue.put(None)
+ except KeyboardInterrupt:
+ # NOTE: Main process will raise KeyboardInterrupt anyways, ignore it in child process
+ pass
+ except:
+ six.reraise(*sys.exc_info())
+
+
+class DataLoaderBase(object):
+
+ def __init__(self):
+ self._places = None
+
+ def __call__(self):
+ return self
+
+ def next(self):
+ '''
+ Get the next item in the DataLoader object. This method
+ should not be called by users directly. It is used for
+ implementing iterator protocol of Python 2.x inside
+ PaddlePaddle framework.
+ '''
+ return self.__next__()
+
+ def __iter__(self):
+ raise NotImplementedError()
+
+ def __next__(self):
+ raise NotImplementedError()
+
+ @classmethod
+ def _check_input_array(cls, item):
+ arr = np.asarray(item)
+ if arr.dtype == np.object_:
+ raise TypeError(
+ "\n\tFaild to convert input data to a regular ndarray :\n\t* Usually "
+ "this means the input data contains nested lists with different lengths. "
+ "\n\t* Check the reader function passed to 'decorate_batch_generator'"
+ " to locate the data causes this issue.\n\t* Please consider using "
+ "'fluid.create_lod_tensor' to convert it to a LoD-Tensor.")
+ return arr
+
+
+class AuToTune(object):
+
+ def __init__(self, loader):
+ self.loader = loader
+ self.max_num_worker = multiprocessing.cpu_count() / 2
+
+ def __call__(self):
+ # use default loader
+ if (not USE_AUTOTUNE) or (not self.need_autotune()):
+ return self.loader.num_workers
+
+ # get autotune loader
+ auto_tune_loader = self.get_autotune_loader()
+ if auto_tune_loader is None:
+ return self.loader.num_workers
+
+ # pick the best num_workers
+ auto_tune_start = time.time()
+ logging.debug("========= DataLoader Auto Tune =========")
+ logging.debug("User config for DataLoader: " +
+ str(self.loader.num_workers))
+ best_num_workers = 0
+ min_cost = float("inf")
+ logging.debug("Tuning Range for num_workers: 0 ~ " +
+ str(self.max_num_worker))
+ num_workers = 0
+ while num_workers < self.max_num_worker:
+ auto_tune_loader.num_workers = num_workers
+ avg_cost = self.evaluate_reader_cost(auto_tune_loader)
+ if min_cost * 0.75 > avg_cost:
+ min_cost = avg_cost
+ best_num_workers = num_workers
+ else:
+ update_num = self.is_best(auto_tune_loader, best_num_workers,
+ min_cost, self.max_num_worker)
+ if update_num == best_num_workers:
+ break
+ else:
+ best_num_workers = update_num
+ logging.debug("num_workers: " + str(num_workers) + " avg_cost: " +
+ str(avg_cost))
+ num_workers += 2
+ logging.info("auto_tune dataLoader best_num_workers: " +
+ str(best_num_workers))
+ logging.debug("AutoTuning Cost for DataLoader: " +
+ str(time.time() - auto_tune_start) + ' seconds')
+
+ # tune the default loader's num_workers
+ return best_num_workers
+
+ def need_autotune(self):
+ if (sys.platform == 'darwin' or sys.platform == 'win32'):
+ return False
+ else:
+ return True
+
+ def get_sub_dataset(self, dataset, batch_size):
+ num_samples = min(batch_size * TUNING_STEPS, len(dataset))
+ sub_dataset = Subset(dataset, indices=list(range(num_samples)))
+ return sub_dataset
+
+ def get_autotune_loader(self):
+ loader = copy.copy(self.loader)
+ batch_size = self.loader.batch_sampler.batch_size
+ if isinstance(self.loader.batch_sampler,
+ paddle.io.DistributedBatchSampler):
+ dataset = self.loader.batch_sampler.dataset
+ sub_dataset = self.get_sub_dataset(dataset, batch_size)
+ loader.batch_sampler = paddle.io.DistributedBatchSampler(
+ dataset=sub_dataset,
+ batch_size=batch_size,
+ num_replicas=self.loader.batch_sampler.nranks,
+ rank=self.loader.batch_sampler.local_rank,
+ shuffle=self.loader.batch_sampler.shuffle,
+ drop_last=self.loader.batch_sampler.drop_last)
+ elif isinstance(self.loader.batch_sampler, paddle.io.BatchSampler):
+ dataset = self.loader.batch_sampler.sampler.data_source
+ sub_dataset = self.get_sub_dataset(dataset, batch_size)
+ loader.batch_sampler = paddle.io.BatchSampler(
+ dataset=sub_dataset,
+ batch_size=batch_size,
+ drop_last=self.loader.batch_sampler.drop_last)
+ else:
+ loader = None
+ return loader
+
+ def evaluate_reader_cost(self, reader):
+ costs = []
+ avg_cost = 0
+ start = time.time()
+ for i, data in enumerate(reader):
+ costs.append(time.time() - start)
+ start = time.time()
+ if len(costs) > 2:
+ avg_cost = sum(costs[2:]) / len(costs[2:])
+ else:
+ avg_cost = sum(costs[0:]) / len(costs[0:])
+ return avg_cost
+
+ def is_best(self, reader, best_workers, best_time, num_work_boundary):
+ step = 0
+ num_workers = best_workers + 1
+ boundary = 1
+ while num_workers < num_work_boundary and step < 5:
+ self.loader.num_workers = num_workers
+ time = self.evaluate_reader_cost(reader)
+ logging.debug("for back num_workers: " + str(num_workers) +
+ " avg_cost: " + str(time))
+ step += 1
+ if (time < best_time * 0.70 * boundary):
+ return num_workers
+ else:
+ num_workers += 1
+ boundary *= 0.80
+ return best_workers
+
+
+class DataLoader(object):
+ """
+ DataLoader prodives an iterator which iterates given dataset
+ once by the batch_sampler.
+
+ DataLoader supports single-process and multi-prcess data loading,
+ multi-process workers will be used to load data asynchronously if
+ :attr:`num_workers` is set as a positive number.
+
+ DataLoader supports map-style dataset and iterable-style dataset.
+
+ For map-style datast(can get a sample from dataset with a given
+ index), please see :code:`paddle.io.Dataset`.
+
+ For iterable-style datast(get samples from dataset iteratively,
+ like a Python iterator), please see :code:`paddle.io.IterableDataset`.
+
+ For :code:`batch_sampler` please see :code:`paddle.io.BatchSampler`
+
+ .. note::
+ GPU tensor operation is not supported in subprocess currently,
+ please don't use GPU tensor operations in pipeline which will
+ be performed in subprocess, such as dataset transforms, collte_fn,
+ etc. Numpy array and CPU tensor operation is supported.
+
+ **Disable automatic batching**
+
+ In certain cases such as some NLP tasks, instead of automatic batching,
+ handling batching manually in dataset is needed by users. For these
+ cases, automatic batching is disabled if both :attr:`batch_size` and
+ :attr:`batch_sampler` is set as None, each data got from :attr:`dataset`
+ should be batched data and will be processed with function define by
+ :attr:`collate_fn` or :attr:`default_collate_fn`.
+
+
+ .. note::
+ When automatic batching is disabled, :attr:`default_collate_fn` will
+ do nothing to data from dataset.
+
+
+ Args:
+ dataset(Dataset): the dataset to load data from, should be an
+ instance of subclass of :code:`paddle.io.Dataset` or
+ :code:`paddle.io.IterableDataset`.
+ feed_list (list(Tensor)|tuple(Tensor), optional): feed Tensor list.
+ The Tensors should be created by :code:`paddle.static.data()`.
+ :attr:`feed_list` must be set if :attr:`return_list` is
+ False. Default None.
+ places(list(Place)|tuple(Place)|list(str), optional): a list of Place,
+ to put data onto, :attr:`places` can be None, if
+ :attr:`places` is None, default place(CPUPlace or CUDAPlace(0))
+ will be used. Default None. If ``places`` is list of string,
+ the string in the list can be ``cpu``, ``gpu:x`` and ``gpu_pinned``,
+ where ``x`` is the index of the GPUs.
+ return_list (bool, optional): whether the return value on each device is
+ presented as a list. If :attr:`return_list=False`, the return
+ value on each device would be a dict of str -> Tensor, where
+ the key of the dict is the name of each fed Tensors. If
+ :attr:`return_list=True`, the return value on each device would
+ be a list(Tensor). :attr:`return_list` can only be True
+ in dynamic graph mode. Default True.
+ batch_sampler(BatchSampler, optional): an instance of `paddle.io.BatchSampler`
+ to generate batch indices to draw samples from :attr:`dataset`
+ and combine a batch. Default None.
+ batch_size(int|None, optional): sample number in a mini-batch, a substitution
+ parameter for :attr:`batch_sampler`, if :attr:`batch_sampler`
+ is not set, a default `paddle.io.BatchSampler` will be used
+ and initialize by :attr:`batch_size`, :attr:`shuffle` and
+ :attr:`drop_last`. Default 1.
+ shuffle(bool, optional): whther to shuffle indices order before genrate
+ batch indices, a substitution parameter for :attr:`batch_sampler`
+ see :attr:`batch_size`. Default False.
+ drop_last(bool, optional): whether drop the last incomplete batch dataset size
+ is not divisible by the batch size, a substitution parameter
+ for :attr:`batch_sampler`, see :attr:`batch_size`. Default False
+ collate_fn(callable, optional): function to generate mini-batch data by merging
+ the sample list, None for only stack each fields of sample in axis
+ 0(same as :attr::`np.stack(..., axis=0)`). Default None
+ num_workers(int, optional): the number of subprocess to load data, 0 for no
+ subprocess used and loading data in main process. Default 0
+ use_buffer_reader (bool, optional): whether to use bufferred reader.
+ If use_buffer_reader=True, the DataLoader would prefetch
+ batch data asynchronously, so it would speed up data feeding
+ and occupies a little more CPU or GPU memory, i.e., the memory
+ of one batch input data. Default True.
+ prefetch_factor (int, optional): Number of batch data the DataLoader would prefetch
+ if use_buffer_reader=True. Default 2.
+ use_shared_memory (bool, optional): whether to use shared memory to speed up
+ putting data into inter-process queue, set :attr:`use_shared_memory`
+ as True only when the shared memory space on your machine(e.g.
+ space of '/dev/shm' on Linux operating sysytem) is large enough.
+ Shared memory will only be enabled in multi-process mode(num_workers
+ > 0). Default True.
+ timeout(int, optional): the timeout value for getting data form output queue
+ of subprocesses. Default 0.
+ worker_init_fn(callable, optional): init function which will be called with
+ worker id on each subproces starting if not set as None. Default
+ None.
+
+ Returns:
+ DataLoader: an iterable object for data iterating, each elemnet of the generated data is a Tensor.
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy as np
+
+ import paddle
+ import paddle.nn as nn
+ import paddle.nn.functional as F
+ from paddle.io import Dataset, BatchSampler, DataLoader
+
+ BATCH_NUM = 20
+ BATCH_SIZE = 16
+ EPOCH_NUM = 4
+
+ IMAGE_SIZE = 784
+ CLASS_NUM = 10
+
+ # define a random dataset
+ class RandomDataset(Dataset):
+ def __init__(self, num_samples):
+ self.num_samples = num_samples
+
+ def __getitem__(self, idx):
+ image = np.random.random([IMAGE_SIZE]).astype('float32')
+ label = np.random.randint(0, CLASS_NUM - 1, (1, )).astype('int64')
+ return image, label
+
+ def __len__(self):
+ return self.num_samples
+
+ dataset = RandomDataset(BATCH_NUM * BATCH_SIZE)
+
+ class SimpleNet(nn.Layer):
+ def __init__(self):
+ super(SimpleNet, self).__init__()
+ self.fc = nn.Linear(IMAGE_SIZE, CLASS_NUM)
+
+ def forward(self, image, label=None):
+ return self.fc(image)
+
+ simple_net = SimpleNet()
+ opt = paddle.optimizer.SGD(learning_rate=1e-3,
+ parameters=simple_net.parameters())
+
+ loader = DataLoader(dataset,
+ batch_size=BATCH_SIZE,
+ shuffle=True,
+ drop_last=True,
+ num_workers=2)
+
+ for e in range(EPOCH_NUM):
+ for i, (image, label) in enumerate(loader()):
+ out = simple_net(image)
+ loss = F.cross_entropy(out, label)
+ avg_loss = paddle.mean(loss)
+ avg_loss.backward()
+ opt.minimize(avg_loss)
+ simple_net.clear_gradients()
+ print("Epoch {} batch {}: loss = {}".format(e, i, np.mean(loss.numpy())))
+
+
+ .. note::
+ For reading iterable dataset with multiprocess Dataloader,
+ please see :code:`paddle.io.IterableDataset`
+
+ """
+
+ def __init__(self,
+ dataset,
+ feed_list=None,
+ places=None,
+ return_list=True,
+ batch_sampler=None,
+ batch_size=1,
+ shuffle=False,
+ drop_last=False,
+ collate_fn=None,
+ num_workers=0,
+ use_buffer_reader=True,
+ prefetch_factor=2,
+ use_shared_memory=True,
+ timeout=0,
+ worker_init_fn=None,
+ persistent_workers=False):
+ self.return_list = return_list
+ self.collate_fn = collate_fn
+ self.use_buffer_reader = use_buffer_reader
+ self.prefetch_factor = prefetch_factor
+ self.worker_init_fn = worker_init_fn
+
+ self.dataset = dataset
+
+ if not return_list and not _non_static_mode():
+ assert feed_list is not None, \
+ "feed_list should be set when return_list=False"
+ self.feed_list = feed_list
+
+ if places is None:
+ places = _current_expected_place()
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ self.places = _convert_places(places)
+
+ assert num_workers >= 0, "num_workers should be a non-negative value"
+ if num_workers > 0 and (sys.platform == 'darwin'
+ or sys.platform == 'win32'):
+ warnings.warn(
+ "DataLoader with multi-process mode is not supported on MacOs and Windows currently." \
+ " Please use signle-process mode with num_workers = 0 instead")
+ num_workers = 0
+ self.num_workers = num_workers
+
+ assert prefetch_factor > 0, "prefetch_factor should be a positive value"
+
+ self.use_shared_memory = use_shared_memory
+ if use_shared_memory and num_workers == 0:
+ self.use_shared_memory = False
+
+ assert timeout >= 0, "timeout should be a non-negative value"
+ self.timeout = timeout
+
+ if isinstance(dataset, IterableDataset):
+ self.dataset_kind = _DatasetKind.ITER
+ if shuffle:
+ raise ValueError(
+ "IterableDataset not support shuffle, but got shuffle={}".
+ format(shuffle))
+ if batch_sampler is not None:
+ raise ValueError(
+ "IterableDataset expect unspecified batch_sampler")
+ else:
+ self.dataset_kind = _DatasetKind.MAP
+
+ if batch_sampler is not None:
+ assert batch_size == 1 and not shuffle and not drop_last, \
+ "batch_size/shuffle/drop_last should not be set when " \
+ "batch_sampler is given"
+ self.batch_sampler = batch_sampler
+ self.batch_size = None
+ elif batch_size is None:
+ self.batch_sampler = None
+ self.batch_size = None
+ else:
+ assert batch_size > 0, \
+ "batch_size should be None or a positive value when " \
+ "batch_sampler is not given"
+ self.batch_size = batch_size
+ if isinstance(dataset, IterableDataset):
+ self.batch_sampler = _InfiniteIterableSampler(
+ dataset, batch_size)
+ else:
+ self.batch_sampler = BatchSampler(dataset=dataset,
+ batch_size=batch_size,
+ shuffle=shuffle,
+ drop_last=drop_last)
+
+ self.drop_last = drop_last
+ self.auto_collate_batch = self.batch_sampler is not None
+
+ self.pin_memory = False
+ if _non_static_mode():
+ self.pin_memory = True if use_pinned_memory(
+ ) is None else use_pinned_memory()
+
+ self._persistent_workers = persistent_workers
+ self._iterator = None
+ self.num_workers = AuToTune(self).__call__()
+
+ def __len__(self):
+ if self.dataset_kind == _DatasetKind.ITER:
+ raise ValueError("length of IterableDataset not supported")
+ else:
+ if self.auto_collate_batch:
+ return len(self.batch_sampler)
+ else:
+ return len(self.dataset)
+
+ def __iter__(self):
+ if self.num_workers == 0:
+ return _DataLoaderIterSingleProcess(self)
+ elif self._persistent_workers:
+ if self._iterator is None:
+ self._iterator = _DataLoaderIterMultiProcess(self)
+ else:
+ self._iterator._reset()
+ return self._iterator
+ else:
+ return _DataLoaderIterMultiProcess(self)
+
+ def __call__(self):
+ return self.__iter__()
+
+ @staticmethod
+ def from_generator(feed_list=None,
+ capacity=None,
+ use_double_buffer=True,
+ iterable=True,
+ return_list=False,
+ use_multiprocess=False,
+ drop_last=True):
+ """
+ .. warning::
+ This API will be deprecated in the future, it is recommended to use
+ :code:`paddle.io.DataLoader` which supports multi-processes acceleration.
+
+ .. note::
+ **The framework ensures that the data loading order of DataLoader is exactly the same as the user-defined data source.**
+
+ Create a DataLoader object for loading data from Python generator.
+ Data would be prefetched using Python thread and be pushed
+ into a queue asynchronously.
+
+ The created DataLoader object provides 3 methods to set the data source
+ :code:`set_sample_generator` , :code:`set_sample_list_generator` and
+ :code:`set_batch_generator` . Please see the following example codes
+ to know their usages.
+
+ If iterable = True, the created DataLoader object is a Python generator
+ object, which is iterable using for-range loop.
+
+ If iterable = False, the created DataLoader object provides
+ :code:`start()` and :code:`reset()` method to control the data reading
+ process.
+
+ Args:
+ feed_list (list(Tensor)|tuple(Tensor)): feed Tensor list.
+ The Tensors should be created by :code:`fluid.data()`.
+ capacity (int): capacity of the queue maintained in DataLoader.
+ The unit is batch number. Set larger capacity if your reader
+ is fast.
+ use_double_buffer (bool): whether to use double_buffer_reader.
+ If use_double_buffer=True, the DataLoader would prefetch next
+ batch data asynchronously, so it would speed up data feeding
+ and occupies a little more CPU or GPU memory, i.e., the memory
+ of one batch input data.
+ iterable (bool): whether the created DataLoader is iterable.
+ return_list (bool): whether the return value on each device is
+ presented as a list. It is only valid when iterable=True.
+ If return_list=False, the return value on each device would
+ be a dict of str -> LoDTensor, where the key of the dict is
+ the name of each fed Tensors. If return_list=True, the
+ return value on each device would be a list(LoDTensor). It is
+ recommended to use return_list=False in static graph mode and
+ use return_list=True in dygraph mode.
+ use_multiprocess (bool): whether to use multi-process to speed up
+ the data loading process in dygraph. Note: this parameter only
+ can be used in the dygraph mode. In the static graph mode,
+ whether this parameter is set or not has no effect.
+ The Default value is False.
+ drop_last (bool): whether to drop the last batches whose number is
+ less than the CPU core/GPU card number. The default value is
+ True. In training phase, users should not set drop_last=False,
+ because all CPU cores/GPU cards must read data from DataLoader.
+ In inference phase, users can set drop_last=False, so that the
+ last batches whose number is less than the CPU core/GPU card
+ number can be tested.
+
+ Returns:
+ loader (DataLoader): the created DataLoader object.
+
+ Examples 1:
+
+ .. code-block:: python
+
+ '''
+ Example in static graph mode
+ '''
+ import numpy as np
+
+ import paddle
+ import paddle.static as static
+ import paddle.nn.functional as F
+
+
+ BATCH_NUM = 10
+ BATCH_SIZE = 16
+ EPOCH_NUM = 4
+
+ CLASS_NUM = 10
+
+ ITERABLE = True # whether the created DataLoader object is iterable
+ USE_GPU = False # whether to use GPU
+
+ DATA_FORMAT = 'batch_generator' # data format of data source user provides
+
+ paddle.enable_static()
+
+ def simple_net(image, label):
+ fc_tmp = static.nn.fc(image, size=CLASS_NUM)
+ cross_entropy = F.softmax_with_cross_entropy(image, label)
+ loss = paddle.mean(cross_entropy)
+ sgd = paddle.optimizer.SGD(learning_rate=1e-3)
+ sgd.minimize(loss)
+ return loss
+
+ def get_random_images_and_labels(image_shape, label_shape):
+ image = np.random.random(size=image_shape).astype('float32')
+ label = np.random.random(size=label_shape).astype('int64')
+ return image, label
+
+ # If the data generator yields one sample each time,
+ # use DataLoader.set_sample_generator to set the data source.
+ def sample_generator_creator():
+ def __reader__():
+ for _ in range(BATCH_NUM * BATCH_SIZE):
+ image, label = get_random_images_and_labels([784], [1])
+ yield image, label
+
+ return __reader__
+
+ # If the data generator yield list of samples each time,
+ # use DataLoader.set_sample_list_generator to set the data source.
+ def sample_list_generator_creator():
+ def __reader__():
+ for _ in range(BATCH_NUM):
+ sample_list = []
+ for _ in range(BATCH_SIZE):
+ image, label = get_random_images_and_labels([784], [1])
+ sample_list.append([image, label])
+
+ yield sample_list
+
+ return __reader__
+
+ # If the data generator yields a batch each time,
+ # use DataLoader.set_batch_generator to set the data source.
+ def batch_generator_creator():
+ def __reader__():
+ for _ in range(BATCH_NUM):
+ batch_image, batch_label = get_random_images_and_labels([BATCH_SIZE, 784], [BATCH_SIZE, 1])
+ yield batch_image, batch_label
+
+ return __reader__
+
+ # If DataLoader is iterable, use for loop to train the network
+ def train_iterable(exe, prog, loss, loader):
+ for _ in range(EPOCH_NUM):
+ for data in loader():
+ exe.run(prog, feed=data, fetch_list=[loss])
+
+ # If DataLoader is not iterable, use start() and reset() method to control the process
+ def train_non_iterable(exe, prog, loss, loader):
+ for _ in range(EPOCH_NUM):
+ loader.start() # call DataLoader.start() before each epoch starts
+ try:
+ while True:
+ exe.run(prog, fetch_list=[loss])
+ except paddle.core.EOFException:
+ loader.reset() # call DataLoader.reset() after catching EOFException
+
+ def set_data_source(loader, places):
+ if DATA_FORMAT == 'sample_generator':
+ loader.set_sample_generator(sample_generator_creator(), batch_size=BATCH_SIZE, drop_last=True, places=places)
+ elif DATA_FORMAT == 'sample_list_generator':
+ loader.set_sample_list_generator(sample_list_generator_creator(), places=places)
+ elif DATA_FORMAT == 'batch_generator':
+ loader.set_batch_generator(batch_generator_creator(), places=places)
+ else:
+ raise ValueError('Unsupported data format')
+
+ image = static.data(name='image', shape=[None, 784], dtype='float32')
+ label = static.data(name='label', shape=[None, 1], dtype='int64')
+
+ # Define DataLoader
+ loader = paddle.io.DataLoader.from_generator(feed_list=[image, label], capacity=16, iterable=ITERABLE)
+
+ # Define network
+ loss = simple_net(image, label)
+
+ # Set data source of DataLoader
+ #
+ # If DataLoader is iterable, places must be given and the number of places must be the same with device number.
+ # - If you are using GPU, call `paddle.static.cuda_places()` to get all GPU places.
+ # - If you are using CPU, call `paddle.static.cpu_places()` to get all CPU places.
+ #
+ # If DataLoader is not iterable, places can be None.
+ places = static.cuda_places() if USE_GPU else static.cpu_places()
+ set_data_source(loader, places)
+
+ exe = static.Executor(places[0])
+ exe.run(static.default_startup_program())
+
+ prog = static.CompiledProgram(static.default_main_program()).with_data_parallel(loss_name=loss.name)
+
+ if loader.iterable:
+ train_iterable(exe, prog, loss, loader)
+ else:
+ train_non_iterable(exe, prog, loss, loader)
+
+
+ Examples 2:
+
+ .. code-block:: python
+
+ '''
+ Example in dynamic graph mode.
+ '''
+ import numpy as np
+
+ import paddle
+ import paddle.nn as nn
+ import paddle.optimizer as opt
+ import paddle.distributed as dist
+
+ BATCH_SIZE = 16
+ BATCH_NUM = 4
+ EPOCH_NUM = 4
+
+ IMAGE_SIZE = 784
+ CLASS_NUM = 10
+
+ USE_GPU = False # whether to use GPU
+
+ def _get_random_images_and_labels(image_shape, label_shape):
+ image = np.random.random(size=image_shape).astype('float32')
+ label = np.random.random(size=label_shape).astype('int64')
+ return image, label
+
+ def __reader__():
+ for _ in range(BATCH_NUM):
+ batch_image, batch_label = _get_random_images_and_labels(
+ [BATCH_SIZE, IMAGE_SIZE], [BATCH_SIZE, CLASS_NUM])
+ yield batch_image, batch_label
+
+ def random_batch_reader():
+ return __reader__
+
+ class LinearNet(nn.Layer):
+ def __init__(self):
+ super(LinearNet, self).__init__()
+ self._linear = nn.Linear(IMAGE_SIZE, CLASS_NUM)
+
+ @paddle.jit.to_static
+ def forward(self, x):
+ return self._linear(x)
+
+ # set device
+ paddle.set_device('gpu' if USE_GPU else 'cpu')
+
+ # create network
+ layer = LinearNet()
+ dp_layer = paddle.DataParallel(layer)
+ loss_fn = nn.CrossEntropyLoss()
+ adam = opt.Adam(learning_rate=0.001, parameters=dp_layer.parameters())
+
+ # create data loader
+ loader = paddle.io.DataLoader.from_generator(capacity=5)
+ loader.set_batch_generator(random_batch_reader())
+
+ for epoch_id in range(EPOCH_NUM):
+ for batch_id, (image, label) in enumerate(loader()):
+ out = layer(image)
+ loss = loss_fn(out, label)
+
+ loss.backward()
+
+ adam.step()
+ adam.clear_grad()
+ print("Epoch {} batch {}: loss = {}".format(
+ epoch_id, batch_id, np.mean(loss.numpy())))
+
+ Examples 3:
+
+ .. code-block:: python
+
+ '''
+ Example of `drop_last` using in static graph multi-cards mode
+ '''
+ import paddle
+ import paddle.static as static
+ import numpy as np
+ import os
+
+ # We use 2 CPU cores to run inference network
+ os.environ['CPU_NUM'] = '2'
+
+ paddle.enable_static()
+
+ # The data source has only 3 batches, which can not be
+ # divided evenly to each CPU core
+ def batch_generator():
+ for i in range(3):
+ yield np.array([i+1]).astype('float32'),
+
+ x = static.data(name='x', shape=[None], dtype='float32')
+ y = x * x
+
+ def run_inference(drop_last):
+ loader = paddle.io.DataLoader.from_generator(feed_list=[x],
+ capacity=8, drop_last=drop_last)
+ loader.set_batch_generator(batch_generator, static.cpu_places())
+
+ exe = static.Executor(paddle.CPUPlace())
+ prog = static.CompiledProgram(static.default_main_program())
+ prog = prog.with_data_parallel()
+
+ result = []
+ for data in loader():
+ each_ret, = exe.run(prog, feed=data, fetch_list=[y])
+ result.extend(each_ret)
+ return result
+
+ # Set drop_last to True, so that the last batch whose
+ # number is less than CPU core number would be discarded.
+ print(run_inference(drop_last=True)) # [1.0, 4.0]
+
+ # Set drop_last to False, so that the last batch whose
+ # number is less than CPU core number can be tested.
+ print(run_inference(drop_last=False)) # [1.0, 4.0, 9.0]
+ """
+ if _non_static_mode():
+ return DygraphGeneratorLoader(feed_list, capacity,
+ use_double_buffer, iterable,
+ return_list, use_multiprocess)
+ else:
+ return GeneratorLoader(feed_list, capacity, use_double_buffer,
+ iterable, return_list, drop_last)
+
+ @staticmethod
+ def from_dataset(dataset, places, drop_last=True):
+ """
+ .. warning::
+ This API will be deprecated in the future, it is recommended to use
+ :code:`paddle.io.DataLoader` which supports multi-processes acceleration.
+
+ Create an iterable DataLoader object for loading data from Dataset.
+ Dataset is only supported in Linux system currently.
+
+ Args:
+ dataset (InMemoryDataset|QueueDataset): the dataset object.
+ places (list(CUDAPlace)|list(CPUPlace)|list(str)): places where the result
+ data should be converted. If places is list of string, the string in the list
+ can be ``cpu``, ``gpu:x`` and ``gpu_pinned``, where x is the index of the GPUs.
+ drop_last (bool): whether to drop the last batch whose sample
+ number is less than batch size. If drop_last = True, they
+ would be dropped. If drop_last = False, they would be kept.
+
+ Returns:
+ loader (DataLoader): the created DataLoader object, which can be
+ treated as a Python generator.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ image = static.data(name='image', shape=[None, 784], dtype='float32')
+ label = static.data(name='label', shape=[None, 1], dtype='int64')
+
+ dataset = paddle.distributed.QueueDataset()
+ dataset.init(
+ batch_size=32,
+ pipe_command='cat',
+ use_var=[image, label])
+ dataset.set_filelist(['a.txt', 'b.txt', 'c.txt'])
+
+ loader = paddle.io.DataLoader.from_dataset(dataset, static.cpu_places())
+ """
+ return DatasetLoader(dataset, places, drop_last)
+
+
+class DygraphGeneratorLoader(DataLoaderBase):
+ """
+ The GeneratorLoader of dygraph
+
+ The multiprocess dygraph GeneratorLoader's most functions are different from
+ static graph GeneratorLoader, Separate implementation to keep code readable.
+ """
+
+ def __init__(self,
+ feed_list=None,
+ capacity=None,
+ use_double_buffer=True,
+ iterable=True,
+ return_list=True,
+ use_multiprocess=False):
+ self._batch_reader = None
+ self._places = None
+ self._feed_list = feed_list
+
+ if not capacity:
+ raise ValueError("Please give value to capacity.")
+ self._capacity = capacity
+ self._use_double_buffer = use_double_buffer
+
+ if not iterable:
+ warnings.warn(
+ "Please NOTE: DygraphGeneratorLoader supports iterable mode only. Change to iterable mode."
+ )
+ self._iterable = True
+ if not return_list:
+ warnings.warn(
+ "Please NOTE: DygraphGeneratorLoader supports returning as list only. Change to return as list."
+ )
+ self._return_list = True
+
+ # NOTE: the multiprocessing in different platform is incompatible, we will solve it later
+ self._use_multiprocess = use_multiprocess
+ if self._use_multiprocess and (sys.platform == 'darwin'
+ or sys.platform == 'win32'):
+ warnings.warn(
+ "NOTE: DygraphGeneratorLoader with multiprocess mode is not currently supported on MacOs and Windows."
+ )
+ self._use_multiprocess = False
+
+ if self._use_multiprocess:
+ # NOTE: the multiprocessing.Queue used to save loading data in self._process
+ self._data_queue = None
+ # NOTE: this process is used to load data asynchronously from self._batch_reader
+ self._process = None
+
+ # NOTE: the C++ LoDTensorBlockingQueue instance
+ self._blocking_queue = None
+ # NOTE: 1. In multiprocess mode, this thread is used to get next batch data from
+ # self._data_queue, then push it into self._blocking_queue; 2. In singleprocess
+ # mode, this thread is used to get next batch data from self._batch_reader, then
+ # push it into self._blocking_queue
+ self._thread = None
+ self._pin_memory = True if use_pinned_memory(
+ ) is None else use_pinned_memory()
+
+ @property
+ def queue(self):
+ return self._blocking_queue
+
+ @property
+ def iterable(self):
+ return self._iterable
+
+ def _clear_and_remove_data_queue(self):
+ if self._data_queue is not None:
+ while True:
+ try:
+ self._data_queue.get_nowait()
+ except queue.Empty:
+ break
+ global multiprocess_queue_set
+ multiprocess_queue_set.remove(self._data_queue)
+
+ def _wait_thread_ends(self):
+ thread = self._thread
+ if thread is not None:
+ self._blocking_queue.close()
+ thread.join()
+
+ def _wait_process_ends(self):
+ process = self._process
+ if process is not None:
+ process.join()
+ # erase process id
+ core._erase_process_pids(id(self))
+
+ def _init_iterable(self):
+ self._wait_thread_ends()
+ if self._use_multiprocess:
+ self._wait_process_ends()
+ self._var_names = []
+ self._shapes = []
+ self._dtypes = []
+ self._need_check_feed = []
+ self._blocking_queue = core.init_lod_tensor_blocking_queue(
+ core.Variable(), self._capacity, False)
+ self._reader = None
+ self._reader = core.create_py_reader(self.queue, self._var_names,
+ self._shapes, self._dtypes,
+ self._need_check_feed,
+ self._places,
+ self._use_double_buffer, True,
+ self._pin_memory)
+
+ def _start(self):
+ if self._use_multiprocess:
+ # clear old _data_queue and remove it from multiprocess_queue_set
+ self._clear_and_remove_data_queue()
+ # set data_queue and process
+ self._data_queue = multiprocessing.Queue(self._capacity)
+ # add _data_queue into global queue set
+ global multiprocess_queue_set
+ multiprocess_queue_set.add(self._data_queue)
+ self._process = multiprocessing.Process(target=_reader_process_loop,
+ args=(self._batch_reader,
+ self._data_queue))
+ self._process.daemon = True
+ self._process.start()
+
+ # Set child process signal handler
+ # NOTE: [ avoiding hang ] 1. if the child process dies due to bus error/segfault
+ # or just hang, the main process will hang waiting for data, so here need to deal
+ # with SIGSEGV and SIGBUS of child process; 2. if the main process end before child
+ # process, it shuts the all its daemonic children down with a SIGTERM (instead of
+ # joining them without a timeout), so here nedd to deal with SIGTERM.
+ core._set_process_pids(id(self), [self._process.pid])
+ _set_SIGCHLD_handler()
+
+ # Set reader_thread
+ self._thread_done_event = threading.Event()
+ self._thread = threading.Thread(
+ target=self._reader_thread_loop_for_multiprocess,
+ args=(_current_expected_place(), ))
+ self._thread.daemon = True
+ self._thread.start()
+ else:
+ self._thread = threading.Thread(
+ target=self._reader_thread_loop_for_singleprocess,
+ args=(_current_expected_place(), ))
+ self._thread.daemon = True
+ self._thread.start()
+
+ def _reset(self):
+ self._reader.reset()
+ self._wait_thread_ends()
+ if self._use_multiprocess:
+ self._wait_process_ends()
+
+ def __iter__(self):
+ assert self.iterable, "DataLoader is not iterable"
+ assert self._batch_reader is not None, \
+ "Data source of DataLoader has not set yet"
+
+ self._init_iterable()
+ self._start()
+ return self
+
+ def __next__(self):
+ try:
+ if _in_eager_without_dygraph_check():
+ return core.eager.read_next_tensor_list(
+ self._reader.read_next_list()[0])
+ else:
+ return self._reader.read_next_var_list()
+ except StopIteration:
+ self._reset()
+ six.reraise(*sys.exc_info())
+
+ def _exit_thread_expectedly(self):
+ self._thread_done_event.set()
+ self._blocking_queue.close()
+
+ def _exit_thread_unexpectedly(self):
+ self._thread_done_event.set()
+ self._blocking_queue.kill()
+ logging.error("DataLoader reader thread raised an exception!")
+
+ def _reader_thread_loop_for_multiprocess(self, legacy_expected_place):
+ # See _DataLoaderIterSingleProcess._thread_loop() for why set expected place here.
+ _set_expected_place(legacy_expected_place)
+
+ while not self._thread_done_event.is_set():
+ try:
+ # NOTE: [ avoid hanging ] Even with carefully designed data dependencies
+ # (i.e., a put() always corresponding to a get()), hanging on get() can
+ # still happen when data in queue is corrupted (e.g., due to
+ # Queue.cancel_join_thread or unexpected exit). So we set a timeout whenever
+ # we try to get data from `data_queue`
+ # NOTE: [ avoid failed quickly ] Here, the time setting of QUEUE_GET_TIMEOUT
+ # is relatively long, currently it is 60 seconds, because in some models,
+ # if the reader child process starts with a heavy burden, the child process
+ # has no enough time to put the data in the queue when the main process
+ # start trying to get data from queue. At this time, the child thread needs
+ # to wait slightly longer
+ tensor_list = self._data_queue.get(timeout=QUEUE_GET_TIMEOUT)
+ except:
+ # NOTE [ avoid handing ] After adding the shared memory mechanism, not only
+ # the queue.Empty exception will occur here, but other exceptions will also
+ # occur, such as mmap failure. If it is not handled here, it will hang.
+ self._exit_thread_unexpectedly()
+ logging.error(
+ "DataLoader reader thread failed to read data from the multiprocessing.Queue."
+ )
+ six.reraise(*sys.exc_info())
+
+ if not self._thread_done_event.is_set():
+ if tensor_list is not None:
+ try:
+ array = core.LoDTensorArray()
+ for tensor in tensor_list:
+ array.append(tensor)
+ if not self._blocking_queue.push(array):
+ self._blocking_queue.close()
+ except:
+ self._exit_thread_unexpectedly()
+ six.reraise(*sys.exc_info())
+ else:
+ self._exit_thread_expectedly()
+
+ def _reader_thread_loop_for_singleprocess(self, legacy_expected_place):
+ try:
+ # See _DataLoaderIterSingleProcess._thread_loop() for why set expected place here.
+ _set_expected_place(legacy_expected_place)
+
+ for sample in self._batch_reader():
+ array = core.LoDTensorArray()
+ for item in sample:
+ if not isinstance(item, core.LoDTensor):
+ item = self._check_input_array(item)
+ tmp = core.LoDTensor()
+ tmp.set(item, core.CPUPlace())
+ item = tmp
+
+ array.append(item)
+
+ if not self._blocking_queue.push(array):
+ break
+
+ self._blocking_queue.close()
+ self._thread = None
+ except Exception:
+ self._blocking_queue.kill()
+ self._thread = None
+ logging.warning(
+ "DygraphDataLoader reader thread raised an exception.")
+ six.reraise(*sys.exc_info())
+
+ def set_sample_generator(self,
+ reader,
+ batch_size,
+ drop_last=True,
+ places=None):
+ assert batch_size > 0, "batch_size must be larger than 0"
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ self.set_sample_list_generator(paddle.batch(reader,
+ batch_size=batch_size,
+ drop_last=drop_last),
+ places=places)
+ return self
+
+ def set_sample_list_generator(self, reader, places=None):
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+
+ def __batch_reader_impl__():
+ for batch in reader():
+ slots = []
+ for items in batch:
+ for i, item in enumerate(items):
+ if len(slots) < len(items):
+ slots.append([item])
+ else:
+ slots[i].append(item)
+ yield slots
+
+ self.set_batch_generator(__batch_reader_impl__, places)
+ return self
+
+ def set_batch_generator(self, reader, places=None):
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ self._batch_reader = reader
+ if places is None:
+ places = _current_expected_place()
+ self._places = _convert_places(places)
+ assert len(self._places) == 1, \
+ "Number of places must be 1 in imperative mode"
+ return self
+
+
+class GeneratorLoader(DataLoaderBase):
+
+ def __init__(self,
+ feed_list=None,
+ capacity=None,
+ use_double_buffer=True,
+ iterable=True,
+ return_list=False,
+ drop_last=True):
+ self._tensor_reader = None
+ self._places = None
+ self._thread = None
+ self._queue = None
+ self._feed_list = feed_list
+ self._exited = False
+ self._drop_last = drop_last
+ self._keep_order = keep_data_loader_order()
+ if not capacity:
+ raise ValueError("Please give value to capacity.")
+ self._iterable = iterable
+ self._return_list = return_list
+ if not self._feed_list:
+ raise Exception("Feed list must be given under static mode.")
+ self._use_double_buffer = use_double_buffer
+ self._capacity = capacity
+ if not self._iterable:
+ self._init_non_iterable()
+
+ def _wait_thread_ends(self):
+ # Get self._thread first to prevent data race, because __thread_main__
+ # would set self._thread be None at the end
+ thread = self._thread
+ if thread is not None and self._iterable:
+ self._queue.close()
+ thread.join()
+
+ def _init_iterable(self):
+ self._wait_thread_ends()
+ self._var_names = [v.name for v in self._feed_list]
+ self._shapes = [v.shape for v in self._feed_list]
+ self._dtypes = [v.dtype for v in self._feed_list]
+ self._need_check_feed = [
+ v.desc.need_check_feed() for v in self._feed_list
+ ]
+ self._queue = core.init_lod_tensor_blocking_queue(
+ core.Variable(), self._capacity, self._keep_order)
+ self._reader = None
+ self._reader = core.create_py_reader(self.queue, self._var_names,
+ self._shapes, self._dtypes,
+ self._need_check_feed,
+ self._places,
+ self._use_double_buffer,
+ self._drop_last, False)
+
+ def _init_non_iterable(self):
+ lod_levels = []
+ dtypes = []
+ shape_concat = []
+ ranks = []
+ shapes = []
+ need_check_feed = []
+
+ for feed_data in self._feed_list:
+ dtypes.append(feed_data.dtype)
+ shape_concat.extend(feed_data.shape)
+ ranks.append(len(feed_data.shape))
+ shapes.append(feed_data.shape)
+ lod_levels.append(feed_data.lod_level)
+ need_check_feed.append(int(feed_data.desc.need_check_feed()))
+
+ queue_name = data_loader_unique_name_generator(
+ 'lod_tensor_blocking_queue')
+ reader_name = data_loader_unique_name_generator('create_py_reader')
+ double_buffer_name = data_loader_unique_name_generator('double_buffer')
+
+ var = global_scope().var(queue_name)
+ self._queue = core.init_lod_tensor_blocking_queue(
+ var, self._capacity, self._keep_order)
+
+ if self._keep_order:
+ block = default_main_program().current_block()
+ else:
+ block = default_startup_program().current_block()
+
+ reader_var = block.create_var(name=reader_name)
+
+ dtype_int = [int(t) for t in dtypes]
+ block.append_op(type='create_py_reader',
+ inputs={'blocking_queue': [queue_name]},
+ outputs={'Out': [reader_var]},
+ attrs={
+ 'shape_concat': shape_concat,
+ 'lod_levels': lod_levels,
+ 'dtypes': dtype_int,
+ 'need_check_feed': need_check_feed,
+ 'ranks': ranks
+ })
+
+ reader_var.desc.set_dtypes(dtypes)
+ reader_var.persistable = True
+ reader_var.stop_gradient = True
+
+ if self._keep_order:
+ main_prog_var = reader_var
+ reader = main_prog_var
+ reader.reset = self._queue.reset
+ else:
+ main_prog_var = _copy_reader_var_(
+ default_main_program().current_block(), reader_var)
+
+ main_prog_var.stop_gradient = True
+ main_prog_var.persistable = True
+
+ reader = monkey_patch_reader_methods(main_prog_var)
+
+ if self._use_double_buffer:
+ double_buffer_reader = double_buffer(reader,
+ name=double_buffer_name)
+ # we return a double buffer reader. However, the reset method comes from
+ # py_reader.
+ double_buffer_reader.reset = reader.reset
+ reader = double_buffer_reader
+
+ self._reader = reader
+
+ default_main_program().current_block().append_op(
+ type='read',
+ inputs={'Reader': [self._reader]},
+ outputs={'Out': self._feed_list},
+ attrs={'drop_last': self._drop_last})
+
+ @property
+ def queue(self):
+ return self._queue
+
+ @property
+ def iterable(self):
+ return self._iterable
+
+ def __iter__(self):
+ assert self.iterable, "DataLoader is not iterable"
+ assert self._tensor_reader is not None, \
+ "Data source of DataLoader has not set yet"
+
+ self._init_iterable()
+ self._start()
+ return self
+
+ def __next__(self):
+ try:
+ if self._return_list:
+ data = self._reader.read_next_list()
+ for i in range(len(data)):
+ data[i] = data[i]._move_to_list()
+ return data
+ else:
+ return self._reader.read_next()
+ except StopIteration:
+ self._queue.close()
+ self._reset()
+ six.reraise(*sys.exc_info())
+
+ def start(self):
+ assert not self._iterable, "start() cannot be called when DataLoader is iterable"
+ self._start()
+
+ def reset(self):
+ assert not self._iterable, "reset() cannot be called when DataLoader is iterable"
+ self._reset()
+
+ def _start(self):
+
+ def __thread_main__(legacy_expected_place):
+ try:
+ # See _DataLoaderIterSingleProcess._thread_loop() for why set expected place here.
+ _set_expected_place(legacy_expected_place)
+
+ while not self._queue.wait_for_inited(1):
+ if self._exited:
+ return
+
+ for tensors in self._tensor_reader():
+ array = core.LoDTensorArray()
+ for item in tensors:
+ if not isinstance(item, core.LoDTensor):
+ item = self._check_input_array(item)
+ tmp = core.LoDTensor()
+ tmp.set(item, core.CPUPlace())
+ item = tmp
+
+ array.append(item)
+
+ if not self._queue.push(array):
+ break
+
+ self._queue.close()
+ self._thread = None
+ except Exception as ex:
+ self._queue.kill()
+ self._thread = None
+ logging.warning('Your reader has raised an exception!')
+ six.reraise(*sys.exc_info())
+
+ self._thread = threading.Thread(target=__thread_main__,
+ args=(_current_expected_place(), ))
+ self._thread.daemon = True
+ self._thread.start()
+
+ def _reset(self):
+ self._queue.close()
+ self._exited = True
+ thread = self._thread
+ if thread is not None:
+ thread.join()
+
+ self._exited = False
+ self._reader.reset()
+
+ def set_sample_generator(self,
+ reader,
+ batch_size,
+ drop_last=True,
+ places=None):
+ assert batch_size > 0, "batch_size must be larger than 0"
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ has_lod = False
+ for f in self._feed_list:
+ if f.lod_level != 0:
+ has_lod = True
+ break
+
+ if has_lod:
+ self.set_sample_list_generator(paddle.batch(reader,
+ batch_size=batch_size,
+ drop_last=drop_last),
+ places=places)
+ else:
+ reader = BatchedTensorProvider(feed_list=self._feed_list,
+ place=core.CPUPlace(),
+ batch_size=batch_size,
+ generator=reader,
+ drop_last=drop_last)
+ self.set_batch_generator(reader, places=places)
+ return self
+
+ def set_sample_list_generator(self, reader, places=None):
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ with program_guard(Program(), Program()):
+ feeder = DataFeeder(feed_list=self._feed_list,
+ place=core.CPUPlace())
+ paddle_reader = feeder.decorate_reader(reader, multi_devices=False)
+
+ def __tensor_reader_impl__():
+ for slots in paddle_reader():
+ yield [slots[var.name] for var in self._feed_list]
+
+ self.set_batch_generator(__tensor_reader_impl__, places)
+ return self
+
+ def set_batch_generator(self, reader, places=None):
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+ self._tensor_reader = reader
+ if self._iterable:
+ assert places is not None, "Places cannot be None when DataLoader is iterable"
+ self._places = _convert_places(places)
+ else:
+ if places is not None:
+ logging.info(
+ 'places would be ommited when DataLoader is not iterable')
+ return self
+
+
+class PyReader(DataLoaderBase):
+ r"""
+ Create a reader object for data feeding in Python.
+ Data would be prefetched using Python thread and be pushed
+ into a queue asynchronously. Data in the queue would be extracted
+ automatically when `Executor.run(...)` is called.
+
+ Args:
+ feed_list (list(Variable)|tuple(Variable)): feed variable list.
+ The variables should be created by :code:`fluid.layers.data()`.
+ capacity (int): capacity of the queue maintained in PyReader.
+ The unit is batch number. Set larger capacity if your reader
+ is fast.
+ use_double_buffer (bool): whether to use double_buffer_reader.
+ If use_double_buffer=True, PyReader would prefetch next
+ batch data asynchronously, so it would speed up data feeding
+ and occupies a little more CPU or GPU memory, i.e., the memory
+ of one batch input data.
+ iterable (bool): whether the created PyReader is iterable.
+ return_list (bool): whether the return value on each device is
+ presented as a list. It is only valid when iterable=True.
+ If return_list=False, the return value on each device would
+ be a dict of str -> LoDTensor, where the key of the dict is
+ the name of each fed variables. If return_list=True, the
+ return value on each device would be a list(LoDTensor). It is
+ recommended to use return_list=False in static graph mode and
+ use return_list=True in dygraph mode.
+
+ Returns:
+ the created reader object.
+
+ Return type:
+ reader(Reader)
+
+ Examples:
+ 1. If iterable = False, the created PyReader object is almost the
+ same as :code:`fluid.layers.py_reader()`. Operators would be
+ inserted into the program. User should call :code:`start()`
+ before each epoch and catch :code:`fluid.core.EOFException`
+ thrown by :code:`Executor.run()` when epoch ends. Once the
+ exception is caught, user should call :code:`reset()` to reset
+ the reader manually.
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ EPOCH_NUM = 3
+ ITER_NUM = 5
+ BATCH_SIZE = 3
+
+ def network(image, label):
+ # User-defined network, here is an example of softmax regression.
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ def reader_creator_random_image_and_label(height, width):
+ def reader():
+ for i in range(ITER_NUM):
+ fake_image = np.random.uniform(low=0,
+ high=255,
+ size=[height, width])
+ fake_label = np.ones([1])
+ yield fake_image, fake_label
+ return reader
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+
+ reader = fluid.io.PyReader(feed_list=[image, label],
+ capacity=4,
+ iterable=False)
+
+ user_defined_reader = reader_creator_random_image_and_label(784, 784)
+ reader.decorate_sample_list_generator(
+ paddle.batch(user_defined_reader, batch_size=BATCH_SIZE))
+ loss = network(image, label)
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+ for i in range(EPOCH_NUM):
+ reader.start()
+ while True:
+ try:
+ executor.run(feed=None)
+ except fluid.core.EOFException:
+ reader.reset()
+ break
+
+
+ 2. If iterable=True, the created PyReader object is decoupled with
+ the program. No operator would be inserted into the program.
+ In this case, the created reader is a Python generator, which
+ is iterable. User should feed the data yielded from PyReader
+ object into :code:`Executor.run(feed=...)`.
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ EPOCH_NUM = 3
+ ITER_NUM = 5
+ BATCH_SIZE = 10
+
+ def network(image, label):
+ # User-defined network, here is an example of softmax regression.
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ def reader_creator_random_image(height, width):
+ def reader():
+ for i in range(ITER_NUM):
+ fake_image = np.random.uniform(low=0, high=255, size=[height, width])
+ fake_label = np.ones([1])
+ yield fake_image, fake_label
+ return reader
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True, return_list=False)
+
+ user_defined_reader = reader_creator_random_image(784, 784)
+ reader.decorate_sample_list_generator(
+ paddle.batch(user_defined_reader, batch_size=BATCH_SIZE),
+ fluid.core.CPUPlace())
+
+ loss = network(image, label)
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+
+ for _ in range(EPOCH_NUM):
+ for data in reader():
+ executor.run(feed=data, fetch_list=[loss])
+
+
+ 3. If return_list=True, the return values would be presented as list instead of dict.
+ This is usually used in dygraph mode.
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ ITER_NUM = 5
+ BATCH_SIZE = 10
+
+ def reader_creator_random_image(height, width):
+ def reader():
+ for i in range(ITER_NUM):
+ yield np.random.uniform(low=0, high=255, size=[height, width]), \
+ np.random.random_integers(low=0, high=9, size=[1])
+ return reader
+
+ place = fluid.CPUPlace()
+ with fluid.dygraph.guard(place):
+ py_reader = fluid.io.PyReader(capacity=2, return_list=True)
+ user_defined_reader = reader_creator_random_image(784, 784)
+ py_reader.decorate_sample_list_generator(
+ paddle.batch(user_defined_reader, batch_size=BATCH_SIZE),
+ place)
+ for image, label in py_reader():
+ relu = fluid.layers.relu(image)
+ """
+
+ def __init__(self,
+ feed_list=None,
+ capacity=None,
+ use_double_buffer=True,
+ iterable=True,
+ return_list=False):
+ self._loader = DataLoader.from_generator(feed_list, capacity,
+ use_double_buffer, iterable,
+ return_list)
+
+ @property
+ def queue(self):
+ return self._loader.queue
+
+ @property
+ def iterable(self):
+ return self._loader.iterable
+
+ def __iter__(self):
+ return self._loader.__iter__()
+
+ def __next__(self):
+ return self._loader.__next__()
+
+ def start(self):
+ '''
+ Start the data feeding thread.
+ Can only call when the reader object is not iterable.
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ BATCH_SIZE = 10
+
+ def generator():
+ for i in range(5):
+ yield np.random.uniform(low=0, high=255, size=[784, 784]),
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=False)
+ reader.decorate_sample_list_generator(
+ paddle.batch(generator, batch_size=BATCH_SIZE))
+
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+ for i in range(3):
+ reader.start()
+ while True:
+ try:
+ executor.run(feed=None)
+ except fluid.core.EOFException:
+ reader.reset()
+ break
+
+ '''
+ self._loader.start()
+
+ def reset(self):
+ '''
+ Reset the reader object when :code:`fluid.core.EOFException` raises.
+ Can only call when the reader object is not iterable.
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ BATCH_SIZE = 10
+
+ def generator():
+ for i in range(5):
+ yield np.random.uniform(low=0, high=255, size=[784, 784]),
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=False)
+ reader.decorate_sample_list_generator(
+ paddle.batch(generator, batch_size=BATCH_SIZE))
+
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+ for i in range(3):
+ reader.start()
+ while True:
+ try:
+ executor.run(feed=None)
+ except fluid.core.EOFException:
+ reader.reset()
+ break
+
+ '''
+ self._loader.reset()
+
+ def decorate_sample_generator(self,
+ sample_generator,
+ batch_size,
+ drop_last=True,
+ places=None):
+ '''
+ Set the data source of the PyReader object.
+
+ The provided :code:`sample_generator` should be a Python generator,
+ which yields list(numpy.ndarray)-typed data of each sample.
+
+ :code:`places` must be set when the PyReader object is iterable.
+
+ If all inputs have no lods, this method is faster than
+ :code:`decorate_sample_list_generator(paddle.batch(sample_generator, ...))` .
+
+ Args:
+ sample_generator (generator): Python generator that yields
+ list(numpy.ndarray)-typed sample data.
+ batch_size (int): batch size. Must be larger than 0.
+ drop_last (bool): Whether to drop the last batch when sample number
+ is less than batch_size.
+ places (None|list(CUDAPlace)|list(CPUPlace)): place list. Must
+ be provided when PyReader is iterable.
+
+ Example:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ EPOCH_NUM = 3
+ ITER_NUM = 15
+ BATCH_SIZE = 3
+
+ def network(image, label):
+ # User-defined network, here is an example of softmax regression.
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ def random_image_and_label_generator(height, width):
+ def generator():
+ for i in range(ITER_NUM):
+ fake_image = np.random.uniform(low=0,
+ high=255,
+ size=[height, width])
+ fake_label = np.array([1])
+ yield fake_image, fake_label
+ return generator
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
+
+ user_defined_generator = random_image_and_label_generator(784, 784)
+ reader.decorate_sample_generator(user_defined_generator,
+ batch_size=BATCH_SIZE,
+ places=[fluid.CPUPlace()])
+ loss = network(image, label)
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+
+ for _ in range(EPOCH_NUM):
+ for data in reader():
+ executor.run(feed=data, fetch_list=[loss])
+
+ '''
+ self._loader.set_sample_generator(sample_generator, batch_size,
+ drop_last, places)
+
+ def decorate_sample_list_generator(self, reader, places=None):
+ '''
+ Set the data source of the PyReader object.
+
+ The provided :code:`reader` should be a Python generator,
+ which yields list(numpy.ndarray) typed batched data.
+
+ :code:`places` must be set when the PyReader object is iterable.
+
+ Args:
+ reader (generator): Python generator that yields
+ list(numpy.ndarray)-typed batched data.
+ places (None|list(CUDAPlace)|list(CPUPlace)): place list. Must
+ be provided when PyReader is iterable.
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+ import paddle.fluid as fluid
+ import numpy as np
+
+ EPOCH_NUM = 3
+ ITER_NUM = 15
+ BATCH_SIZE = 3
+
+ def network(image, label):
+ # User-defined network, here is an example of softmax regression.
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ def random_image_and_label_generator(height, width):
+ def generator():
+ for i in range(ITER_NUM):
+ fake_image = np.random.uniform(low=0,
+ high=255,
+ size=[height, width])
+ fake_label = np.ones([1])
+ yield fake_image, fake_label
+ return generator
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
+
+ user_defined_generator = random_image_and_label_generator(784, 784)
+ reader.decorate_sample_list_generator(
+ paddle.batch(user_defined_generator, batch_size=BATCH_SIZE),
+ fluid.core.CPUPlace())
+
+ loss = network(image, label)
+ executor = fluid.Executor(fluid.core.CPUPlace())
+ executor.run(fluid.default_startup_program())
+
+ for _ in range(EPOCH_NUM):
+ for data in reader():
+ executor.run(feed=data, fetch_list=[loss])
+
+ '''
+ self._loader.set_sample_list_generator(reader, places)
+
+ def decorate_batch_generator(self, reader, places=None):
+ '''
+ Set the data source of the PyReader object.
+
+ The provided :code:`reader` should be a Python generator,
+ which yields numpy.ndarray-typed or LoDTensor-typed batched data.
+
+ :code:`places` must be set when the PyReader object is iterable.
+
+ Args:
+ reader (generator): Python generator that yields LoDTensor-typed
+ batched data.
+ places (None|list(CUDAPlace)|list(CPUPlace)): place list. Must
+ be provided when PyReader is iterable.
+
+ Example:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ import numpy as np
+
+ EPOCH_NUM = 3
+ ITER_NUM = 15
+ BATCH_SIZE = 3
+
+ def network(image, label):
+ # User-defined network, here is an example of softmax regression.
+ predict = fluid.layers.fc(input=image, size=10, act='softmax')
+ return fluid.layers.cross_entropy(input=predict, label=label)
+
+ def random_image_and_label_generator(height, width):
+ def generator():
+ for i in range(ITER_NUM):
+ batch_image = np.random.uniform(low=0,
+ high=255,
+ size=[BATCH_SIZE, height, width])
+ batch_label = np.ones([BATCH_SIZE, 1])
+ batch_image = batch_image.astype('float32')
+ batch_label = batch_label.astype('int64')
+ yield batch_image, batch_label
+ return generator
+
+ image = fluid.data(name='image', shape=[None, 784, 784], dtype='float32')
+ label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+ reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
+
+ user_defined_generator = random_image_and_label_generator(784, 784)
+ reader.decorate_batch_generator(user_defined_generator, fluid.CPUPlace())
+
+ loss = network(image, label)
+ executor = fluid.Executor(fluid.CPUPlace())
+ executor.run(fluid.default_startup_program())
+
+ for _ in range(EPOCH_NUM):
+ for data in reader():
+ executor.run(feed=data, fetch_list=[loss])
+
+ '''
+ self._loader.set_batch_generator(reader, places)
+
+
+class DatasetLoader(DataLoaderBase):
+
+ def __init__(self, dataset, places, drop_last):
+ assert isinstance(dataset, paddle.distributed.fleet.dataset.DatasetBase
+ ), "dataset must be type of DatasetBase"
+ assert not _non_static_mode(
+ ), "DatasetLoader is not supported in dygraph mode yet"
+ if isinstance(places, (list, tuple)):
+ places = _get_paddle_place_list(places)
+ else:
+ places = _get_paddle_place(places)
+
+ thread_num = len(places)
+
+ assert len(dataset.filelist) >= thread_num, \
+ "Filelist number of dataset {} must be not less than place number {}".format(len(dataset.filelist), thread_num)
+
+ if dataset.thread_num != 0 and dataset.thread_num != thread_num:
+ logging.warn(
+ 'thread_num {} which is set in Dataset is ignored'.format(
+ dataset.thread_num))
+
+ dataset._set_thread(thread_num)
+
+ if isinstance(dataset, paddle.distributed.fleet.dataset.InMemoryDataset
+ ) and dataset.queue_num > thread_num:
+ logging.warn(
+ "queue_num {} which is set in Dataset is ignored".format(
+ dataset.queue_num))
+ dataset._set_queue_num(thread_num)
+
+ self._dataset = dataset
+ use_slots = [
+ slot.name for slot in dataset.proto_desc.multi_slot_desc.slots
+ if slot.is_used
+ ]
+
+ self._iterable_dataset = core.IterableDatasetWrapper(
+ dataset.dataset, use_slots, _convert_places(places),
+ dataset.proto_desc.batch_size, drop_last)
+
+ def __iter__(self):
+ self._dataset._finish_to_run()
+ self._dataset._prepare_to_run()
+ self._iterable_dataset._start()
+ return self
+
+ def __next__(self):
+ return self._iterable_dataset._next()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/regularizer.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/regularizer.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c7b3558753de8b8a41862ee1324b341a6b21d83
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/regularizer.py
@@ -0,0 +1,284 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import logging
+
+from . import framework
+from .framework import _non_static_mode, _varbase_creator, in_dygraph_mode
+from . import core
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = ['L1Decay', 'L2Decay', 'L1DecayRegularizer', 'L2DecayRegularizer']
+
+
+class WeightDecayRegularizer(object):
+ """Base class for weight decay regularizers
+
+ Defines the common interface of weight-decay regularizers.
+ Weight-decay regularizers are added only during the backward
+ pass for faster regularization. They add operations to the network
+ that correspond to gradient of the regularization function.
+ Users should not use this class directly, but need to use one
+ of its implementations
+ """
+
+ def __init__(self):
+ pass
+
+ def __call__(self, param, grad, block):
+ """Add corresponding weight decay operations to the network
+ """
+ raise NotImplementedError()
+
+ def __str__(self):
+ """Debug string
+ """
+ raise NotImplementedError()
+
+
+class L2DecayRegularizer(WeightDecayRegularizer):
+ r"""
+ Implement the L2 Weight Decay Regularization, which helps to prevent the model over-fitting.
+
+ It can be set in :ref:`api_fluid_ParamAttr` or ``optimizer`` (such as :ref:`api_fluid_optimizer_SGDOptimizer` ).
+ When set in ``ParamAttr`` , it only takes effect for trainable parameters in this layer. When set in
+ ``optimizer`` , it takes effect for all trainable parameters. When set together, ``ParamAttr`` has
+ higher priority than ``optimizer`` .
+
+ In the implementation, the formula of L2 Weight Decay Regularization is as follows:
+
+ .. math::
+
+ L2WeightDecay = reg\_coeff * parameter
+
+ Args:
+ regularization_coeff(float, optional): regularization coeff. Default:0.0
+
+ Examples:
+ .. code-block:: python
+
+ # Example1: set Regularizer in optimizer
+ import paddle.fluid as fluid
+
+ main_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(main_prog, startup_prog):
+ data = fluid.layers.data(name='image', shape=[3, 28, 28], dtype='float32')
+ label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+ hidden = fluid.layers.fc(input=data, size=128, act='relu')
+ prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
+ loss = fluid.layers.cross_entropy(input=prediction, label=label)
+ avg_loss = fluid.layers.mean(loss)
+ optimizer = fluid.optimizer.Adagrad(
+ learning_rate=1e-4,
+ regularization=fluid.regularizer.L2Decay(
+ regularization_coeff=0.1))
+ optimizer.minimize(avg_loss)
+
+
+ # Example2: set Regularizer both in ParamAttr and optimizer
+ import paddle.fluid as fluid
+
+ l1 = fluid.regularizer.L1Decay(regularization_coeff=0.1)
+ l2 = fluid.regularizer.L2Decay(regularization_coeff=0.1)
+ x = fluid.layers.uniform_random([3,4])
+
+ # set L1 regularization in fluid.ParamAttr
+ w_param = fluid.ParamAttr(regularizer=l1)
+ hidden1 = fluid.layers.fc(x, 8, param_attr=w_param) # fc_0.w_0(L1), fc_0.b_0
+ hidden2 = fluid.layers.fc(hidden1, 16, param_attr=w_param) # fc_1.w_0(L1), fc_1.b_0
+ predict = fluid.layers.fc(hidden2, 32) # fc_3.w_0, fc_3.b_0
+ avg_loss = fluid.layers.mean(predict)
+
+ # set L2 regularization in optimizer
+ optimizer = fluid.optimizer.SGD(learning_rate=1e-4, regularization=l2)
+ optimizer.minimize(avg_loss)
+
+ # it will Print Message:
+ # Regularization of [fc_0.w_0, fc_1.w_0] have been set by ParamAttr or WeightNormParamAttr already.
+ # So, the Regularization of Optimizer will not take effect for these parameters!
+
+ """
+
+ def __init__(self, regularization_coeff=0.0):
+ assert regularization_coeff is not None
+ super(L2DecayRegularizer, self).__init__()
+ self._regularization_coeff = regularization_coeff
+
+ def __call__(self, param, grad, block):
+ """Add L2 weight decay ops to network
+
+ Adds L2 weight decay ops.
+ L2WeightDecay = reg_coeff * parameter
+
+ Args:
+ param: parameter variable for which regularization is applied
+ block: block in which variable is to be created
+
+ Returns:
+ new variable for weight decay
+ """
+ assert isinstance(param, framework.Variable)
+ assert isinstance(block, framework.Block)
+
+ if framework._non_static_mode():
+ if framework.in_dygraph_mode():
+ return _C_ops.scale(param, self._regularization_coeff, 0.0,
+ True)
+ else:
+ return _legacy_C_ops.scale(param, "scale",
+ self._regularization_coeff)
+ else:
+ decay = block.create_var(dtype=param.dtype,
+ shape=param.shape,
+ lod_level=param.lod_level)
+
+ # Append Op to calculate decay
+ block.append_op(type='scale',
+ inputs={"X": param},
+ outputs={"Out": decay},
+ attrs={"scale": self._regularization_coeff})
+
+ return decay
+
+ def __str__(self):
+ return "L2Decay, regularization_coeff=%f" % self._regularization_coeff
+
+
+class L1DecayRegularizer(WeightDecayRegularizer):
+ r"""
+ Implement the L1 Weight Decay Regularization, which encourages the weights to be sparse.
+
+ It can be set in :ref:`api_fluid_ParamAttr` or ``optimizer`` (such as :ref:`api_fluid_optimizer_SGDOptimizer` ).
+ When set in ``ParamAttr`` , it only takes effect for trainable parameters in this layer. When set in
+ ``optimizer`` , it takes effect for all trainable parameters. When set together, ``ParamAttr`` has
+ higher priority than ``optimizer`` .
+
+ In the implementation, the formula of L1 Weight Decay Regularization is as follows:
+
+ .. math::
+
+ L1WeightDecay = reg\_coeff * sign(parameter)
+
+ Args:
+ regularization_coeff(float, optional): regularization coeff. Default:0.0.
+
+ Examples:
+ .. code-block:: python
+
+ # Example1: set Regularizer in optimizer
+ import paddle.fluid as fluid
+
+ main_prog = fluid.Program()
+ startup_prog = fluid.Program()
+ with fluid.program_guard(main_prog, startup_prog):
+ data = fluid.layers.data(name='image', shape=[3, 28, 28], dtype='float32')
+ label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+ hidden = fluid.layers.fc(input=data, size=128, act='relu')
+ prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
+ loss = fluid.layers.cross_entropy(input=prediction, label=label)
+ avg_loss = fluid.layers.mean(loss)
+ optimizer = fluid.optimizer.Adagrad(
+ learning_rate=1e-4,
+ regularization=fluid.regularizer.L1DecayRegularizer(
+ regularization_coeff=0.1))
+ optimizer.minimize(avg_loss)
+
+
+ # Example2: set Regularizer both in ParamAttr and optimizer
+ import paddle.fluid as fluid
+
+ l1 = fluid.regularizer.L1Decay(regularization_coeff=0.1)
+ l2 = fluid.regularizer.L2Decay(regularization_coeff=0.1)
+ x = fluid.layers.uniform_random([3,4])
+
+ # set L1 regularization in fluid.ParamAttr
+ w_param = fluid.ParamAttr(regularizer=l1)
+ hidden1 = fluid.layers.fc(x, 8, param_attr=w_param) # fc_0.w_0(L1), fc_0.b_0
+ hidden2 = fluid.layers.fc(hidden1, 16, param_attr=w_param) # fc_1.w_0(L1), fc_1.b_0
+ predict = fluid.layers.fc(hidden2, 32) # fc_3.w_0, fc_3.b_0
+ avg_loss = fluid.layers.mean(predict)
+
+ # set L2 regularization in optimizer
+ optimizer = fluid.optimizer.SGD(learning_rate=1e-4, regularization=l2)
+ optimizer.minimize(avg_loss)
+
+ # it will Print Message:
+ # Regularization of [fc_0.w_0, fc_1.w_0] have been set by ParamAttr or WeightNormParamAttr already.
+ # So, the Regularization of Optimizer will not take effect for these parameters!
+
+ """
+
+ def __init__(self, regularization_coeff=0.0):
+ assert regularization_coeff is not None
+ super(L1DecayRegularizer, self).__init__()
+ self._regularization_coeff = regularization_coeff
+
+ def __call__(self, param, grad, block):
+ """Add L1 weight decay ops to network
+
+ Adds L1 weight decay ops.
+ L1WeightDecay = reg_coeff * sign(parameter)
+
+ Args:
+ param: parameter variable for which regularization is applied
+ block: block in which variable is to be created
+
+ Returns:
+ new variable for weight decay
+ """
+ assert isinstance(param, framework.Variable)
+ assert isinstance(block, framework.Block)
+
+ if framework._non_static_mode():
+ sign = block.create_var(dtype=param.dtype, shape=param.shape)
+ decay = block.create_var(dtype=param.dtype, shape=param.shape)
+ else:
+ sign = block.create_var(dtype=param.dtype,
+ shape=param.shape,
+ lod_level=param.lod_level)
+ decay = block.create_var(dtype=param.dtype,
+ shape=param.shape,
+ lod_level=param.lod_level)
+ if in_dygraph_mode():
+ sign = _C_ops.sign(param)
+ return _C_ops.scale(sign, self._regularization_coeff, 0.0, True)
+
+ # Append sign op
+ block.append_op(type='sign', inputs={"X": param}, outputs={"Out": sign})
+
+ # Append scale op to the output of sign op
+ block.append_op(type='scale',
+ inputs={"X": sign},
+ outputs={"Out": decay},
+ attrs={"scale": self._regularization_coeff})
+
+ return decay
+
+ def __str__(self):
+ return "L1Decay, regularization_coeff=%f" % self._regularization_coeff
+
+
+# We short the class name, since users will use the regulaizer with the package
+# name. The sample code:
+#
+# import paddle.fluid as fluid
+#
+# hidden = fluid.layers.fc(...,
+# param_attr=fluid.regularizer.Xavier())
+#
+# It is no need to add a `Regularizer` as the class suffix
+L1Decay = L1DecayRegularizer
+L2Decay = L2DecayRegularizer
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_desc.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_desc.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4c17c7095aa093276086b375d742e8e8b1f33ac
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_desc.py
@@ -0,0 +1,437 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+"""Defination of trainers."""
+
+import sys
+import os
+
+__all__ = [
+ 'TrainerDesc', 'MultiTrainer', 'DistMultiTrainer', 'PipelineTrainer',
+ 'HeterXpuTrainer', 'HeterPipelineTrainer'
+]
+
+
+class TrainerDesc(object):
+ '''
+ Set proto from python to c++.
+ Can be initialized from train_desc.
+ '''
+
+ def __init__(self):
+ '''
+ self.proto_desc = data_feed_pb2.DataFeedDesc()
+ with open(proto_file, 'r') as f:
+ text_format.Parse(f.read(), self.proto_desc)
+ '''
+ # Workaround for relative import in protobuf under python3
+ # TODO: should be fixed
+ cur_path = os.path.dirname(__file__)
+ if cur_path not in sys.path:
+ sys.path.append(cur_path)
+ if cur_path + "/proto" not in sys.path:
+ sys.path.append(cur_path + "/proto")
+
+ from proto import trainer_desc_pb2
+ self.proto_desc = trainer_desc_pb2.TrainerDesc()
+ import multiprocessing as mp
+ # set default thread num == cpu count
+ self.proto_desc.thread_num = mp.cpu_count()
+ self._fleet_desc = None
+ self._device_worker = None
+ self._program = None
+ self._infer = False
+
+ def _set_heter_info(self, ret):
+ #ret = = fu.split_program_by_device(program)
+ #start_list, end_list, send_list, recv_list, program_list = fu.split_program_by_device(program)
+ #if len(start_list) != 3:
+ # print("start_list len=", len(start_list), " will not set heter info")
+ # return
+ #for i in start_list[0]:
+ # self.proto_desc.op_run_start_idx.append(i)
+ #for i in end_list[0]:
+ # self.proto_desc.op_run_end_idx.append(i)
+ #for i in send_list[0]:
+ # self.proto_desc.op_run_send_list.append(i)
+ #for i in recv_list[0]:
+ # self.proto_desc.op_run_recv_list.append(i)
+ if ret is None:
+ return
+ #for i in ret[0]: # start_list[1]:
+ # self.proto_desc.xpu_start_idx.append(i)
+ self.proto_desc.xpu_start_idx = ret[0]
+
+ #for i in ret[1]: #end_list[1]:
+ # self.proto_desc.o_end_idx.append(i)
+ self.proto_desc.xpu_end_idx = ret[1]
+ for i in ret[2]: # send_list[1]:
+ self.proto_desc.xpu_send_list.append(i)
+ for i in ret[3]: # recv_list[1]:
+ self.proto_desc.xpu_recv_list.append(i)
+
+ #for i in start_list[2]:
+ # self.proto_desc.op_run_end_start_idx.append(i)
+ #for i in end_list[2]:
+ # self.proto_desc.op_run_end_idx.append(i)
+ #for i in send_list[2]:
+ # self.proto_desc.op_run_end_send_list.append(i)
+ #for i in recv_list[2]:
+ # self.proto_desc.op_run_end_recv_list.append(i)
+
+ def _set_fetch_var_and_info(self, fetch_vars, fetch_info, print_period):
+ # convert fetch_info to list
+ fetch_info = list(fetch_info)
+ for i, v in enumerate(fetch_vars):
+ self.proto_desc.fetch_config.fetch_var_names.extend([v.name])
+ self.proto_desc.fetch_config.fetch_var_str_format.extend(
+ [fetch_info[i]])
+ self.proto_desc.fetch_config.print_period = print_period
+
+ def _set_debug(self, debug):
+ self.proto_desc.debug = debug
+
+ def _set_thread(self, thread_num):
+ self.proto_desc.thread_num = thread_num
+
+ def _set_device_worker(self, device_worker):
+ self._device_worker = device_worker
+
+ def _set_infer(self, infer):
+ self._infer = infer
+
+ def _set_fleet_desc(self, fleet_desc):
+ self._fleet_desc = fleet_desc
+ ## serialize fleet_desc
+ from google.protobuf import text_format
+ fleet_desc_str = text_format.MessageToString(fleet_desc)
+ self.proto_desc.fleet_desc = fleet_desc_str
+
+ def _gen_trainer_desc(self):
+ pass
+
+ def _set_program(self, program):
+ self._program = program
+
+ def _set_trainer_id(self, trainer_id):
+ self.proto_desc.trainer_id = trainer_id
+
+ def _set_trainers(self, trainers):
+ for trainer_num in trainers:
+ self.proto_desc.trainers.append(trainer_num)
+
+ def _set_use_cvm(self, use_cvm=False):
+ self.proto_desc.use_cvm = use_cvm
+
+ def _set_no_cvm(self, no_cvm=False):
+ self.proto_desc.no_cvm = no_cvm
+
+ def _set_scale_sparse_grad_with_batch_size(
+ self, scale_sparse_gradient_with_batch_size=True):
+ self.proto_desc.scale_sparse_gradient_with_batch_size = scale_sparse_gradient_with_batch_size
+
+ def _set_scale_datanorm(self, scale_datanorm=-1):
+ self.proto_desc.scale_datanorm = scale_datanorm
+
+ def _set_dump_slot(self, dump_slot):
+ self.proto_desc.dump_slot = dump_slot
+
+ def _set_mpi_rank(self, mpi_rank):
+ self.proto_desc.mpi_rank = mpi_rank
+
+ def _set_mpi_size(self, mpi_size):
+ self.proto_desc.mpi_size = mpi_size
+
+ def _set_dump_fields(self, dump_fields):
+ for field in dump_fields:
+ self.proto_desc.dump_fields.append(field)
+
+ def _set_is_dump_in_simple_mode(self, is_dump_in_simple_mode):
+ self.proto_desc.is_dump_in_simple_mode = is_dump_in_simple_mode
+
+ def _set_dump_fields_path(self, path):
+ self.proto_desc.dump_fields_path = path
+
+ def _set_dump_file_num(self, dump_file_num):
+ self.proto_desc.dump_file_num = dump_file_num
+
+ def _set_user_define_dump_filename(self, user_define_dump_filename):
+ self.proto_desc.user_define_dump_filename = user_define_dump_filename
+
+ def _set_dump_converter(self, converter):
+ self.proto_desc.dump_converter = converter
+
+ def _set_enable_random_dump(self, enable_random_dump):
+ self.proto_desc.enable_random_dump = enable_random_dump
+
+ def _set_dump_interval(self, dump_interval):
+ self.proto_desc.dump_interval = dump_interval
+
+ def _set_random_with_lineid(self, random_with_lineid):
+ self.proto_desc.random_with_lineid = random_with_lineid
+
+ def _set_dump_param(self, dump_param):
+ for param in dump_param:
+ self.proto_desc.dump_param.append(param)
+
+ def _set_worker_places(self, worker_places):
+ for place in worker_places:
+ self.proto_desc.worker_places.append(place)
+
+ def _set_use_ps_gpu(self, use_ps_gpu=False):
+ self.proto_desc.use_ps_gpu = use_ps_gpu
+
+ def _set_thread_barrier(self, thread_barrier):
+ self.proto_desc.thread_barrier = thread_barrier
+
+ def _set_check_nan_var_names(self, check_nan_var_names):
+ for var in check_nan_var_names:
+ self.proto_desc.check_nan_var_names.append(var)
+
+ def _set_loss_names(self, loss_names):
+ for loss in loss_names:
+ self.proto_desc.loss_names.append(loss)
+
+ def _set_adjust_ins_weight(self, config_dict):
+ self.proto_desc.adjust_ins_weight_config.need_adjust = \
+ config_dict.get("need_adjust", False)
+ self.proto_desc.adjust_ins_weight_config.nid_slot = \
+ config_dict.get("nid_slot", "")
+ self.proto_desc.adjust_ins_weight_config.nid_adjw_threshold = \
+ config_dict.get("nid_adjw_threshold", 0.0)
+ self.proto_desc.adjust_ins_weight_config.nid_adjw_ratio = \
+ config_dict.get("nid_adjw_ratio", 0.0)
+ self.proto_desc.adjust_ins_weight_config.ins_weight_slot = \
+ config_dict.get("ins_weight_slot", "")
+
+ def _set_copy_table_config(self, config_dict):
+ config = self.proto_desc.copy_table_config
+ config.need_copy = config_dict.get("need_copy", False)
+ config.batch_num = config_dict.get("batch_num", 100)
+
+ src_sparse_tables = config_dict.get("src_sparse_tables", [])
+ if not isinstance(src_sparse_tables, list):
+ src_sparse_tables = [src_sparse_tables]
+ dest_sparse_tables = config_dict.get("dest_sparse_tables", [])
+ if not isinstance(dest_sparse_tables, list):
+ dest_sparse_tables = [dest_sparse_tables]
+ if len(src_sparse_tables) != len(dest_sparse_tables):
+ raise ValueError(
+ "len(src_sparse_tables) != len(dest_sparse_tables)," \
+ " %s vs %s" % (len(src_sparse_tables), \
+ len(dest_sparse_tables)))
+ for i in src_sparse_tables:
+ config.src_sparse_tables.append(i)
+ for i in dest_sparse_tables:
+ config.dest_sparse_tables.append(i)
+
+ src_dense_tables = config_dict.get("src_dense_tables", [])
+ if not isinstance(src_dense_tables, list):
+ src_dense_tables = [src_dense_tables]
+ dest_dense_tables = config_dict.get("dest_dense_tables", [])
+ if not isinstance(dest_dense_tables, list):
+ dest_dense_tables = [dest_dense_tables]
+ if len(src_dense_tables) != len(dest_dense_tables):
+ raise ValueError(
+ "len(src_dense_tables) != len(dest_dense_tables)," \
+ " %s vs %s" % (len(src_dense_tables), \
+ len(dest_dense_tables)))
+ for i in src_dense_tables:
+ config.src_dense_tables.append(i)
+ for i in dest_dense_tables:
+ config.dest_dense_tables.append(i)
+
+ # user can also specify dense variables to copy,
+ # instead of copy dense table
+ src_var_list = config_dict.get("src_var_list", [])
+ if not isinstance(src_var_list, list):
+ src_var_list = [src_var_list]
+ dest_var_list = config_dict.get("dest_var_list", [])
+ if not isinstance(dest_var_list, list):
+ dest_var_list = [dest_var_list]
+ if len(src_var_list) != len(dest_var_list):
+ raise ValueError(
+ "len(src_var_list) != len(dest_var_list), %s vs" \
+ " %s" % (len(src_var_list), len(dest_var_list)))
+ for i in src_var_list:
+ config.src_var_list.append(i)
+ for i in dest_var_list:
+ config.dest_var_list.append(i)
+
+ dependency_map = config_dict.get("dependency_map", {})
+ for key in dependency_map:
+ m = config.table_denpendency_map.add()
+ m.key = key
+ values = dependency_map[key]
+ if not isinstance(values, list):
+ values = [values]
+ if len(values) != 1:
+ raise ValueError("dependency len %s != 1" % len(values))
+ for value in values:
+ m.values.append(value)
+ config.dense_pull_after_copy = \
+ config_dict.get("dense_pull_after_copy", True)
+ config.enable_dependency = \
+ config_dict.get("enable_dependency", False)
+ config.sparse_copy_by_feasign = \
+ config_dict.get("sparse_copy_by_feasign", True)
+
+ def _desc(self):
+ from google.protobuf import text_format
+ return self.proto_desc.SerializeToString()
+
+ def __str__(self):
+ from google.protobuf import text_format
+ return text_format.MessageToString(self.proto_desc)
+
+
+class MultiTrainer(TrainerDesc):
+ '''
+ Implement of MultiTrainer.
+ Can be init from TrainerDesc.
+ '''
+
+ def __init__(self):
+ super(MultiTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(MultiTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(MultiTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "MultiTrainer"
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
+
+
+class DistMultiTrainer(TrainerDesc):
+ """
+ Implement of DistMultiTrainer.
+ It's for Distributed training.
+ """
+
+ def __init__(self):
+ super(DistMultiTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(DistMultiTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(DistMultiTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "DistMultiTrainer"
+ if self._program == None:
+ raise RuntimeError("None Program")
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
+
+
+class HeterXpuTrainer(TrainerDesc):
+ """
+ Implement of HeterXpuTrainer.
+ It's for Distributed training.
+ """
+
+ def __init__(self):
+ super(HeterXpuTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(HeterXpuTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(HeterXpuTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "HeterXpuTrainer"
+ if self._program == None:
+ raise RuntimeError("None Program")
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
+
+
+class PSGPUTrainer(TrainerDesc):
+ """
+ Implement of PSGPUTrainer.
+ It's for Distributed training.
+ """
+
+ def __init__(self):
+ super(PSGPUTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(PSGPUTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(PSGPUTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "PSGPUTrainer"
+ if self._program == None:
+ raise RuntimeError("None Program")
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
+
+
+class HeterPipelineTrainer(TrainerDesc):
+ """
+ Implement of HeterPipelineTrainer.
+ It's for HeterPS Pipeline training.
+ """
+
+ def __init__(self):
+ super(HeterPipelineTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(HeterPipelineTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(HeterPipelineTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "HeterPipelineTrainer"
+ if self._program == None:
+ raise RuntimeError("None Program")
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
+
+
+class PipelineTrainer(TrainerDesc):
+ """
+ Implement of PipelineTrainer.
+ It's for Pipeline.
+ """
+
+ def __init__(self):
+ super(PipelineTrainer, self).__init__()
+ pass
+
+ def _set_program(self, program):
+ super(PipelineTrainer, self)._set_program(program)
+ self._program = program
+
+ def _gen_trainer_desc(self):
+ super(PipelineTrainer, self)._gen_trainer_desc()
+ self.proto_desc.class_name = "PipelineTrainer"
+ if self._program == None:
+ raise RuntimeError("None Program")
+ self._device_worker._set_infer(self._infer)
+ self._device_worker._set_program(self._program)
+ self._device_worker._gen_worker_desc(self.proto_desc)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_factory.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ba9f9eea46d1bbf759cc5414a595d00aa148460
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/trainer_factory.py
@@ -0,0 +1,207 @@
+# Copyright (c) 2019 PaddlePaddle 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.
+"""Defination of TrainerFactory."""
+
+import threading
+import time
+import logging
+import numpy as np
+from paddle.fluid.log_helper import get_logger
+
+local_logger = get_logger(__name__,
+ logging.INFO,
+ fmt='%(asctime)s-%(levelname)s: %(message)s')
+
+from .trainer_desc import MultiTrainer, DistMultiTrainer, PipelineTrainer, HeterXpuTrainer, PSGPUTrainer, HeterPipelineTrainer
+from .device_worker import Hogwild, DownpourSGD, DownpourLite, Section, DownpourSGDOPT, HeterSection
+from .framework import Variable
+from multiprocessing import Process, Manager
+
+__all__ = ["TrainerFactory", "FetchHandlerMonitor"]
+
+
+class TrainerFactory(object):
+ """
+ Create trainer and device worker.
+ If opt_info is not None, it will get configs from opt_info,
+ otherwise create MultiTrainer and Hogwild.
+ """
+
+ def __init__(self):
+ pass
+
+ def _create_trainer(self, opt_info=None):
+ trainer = None
+ device_worker = None
+ if not opt_info:
+ # default is MultiTrainer + Hogwild
+ trainer = MultiTrainer()
+ device_worker = Hogwild()
+ trainer._set_device_worker(device_worker)
+ else:
+ trainer_class = opt_info.get("trainer", "MultiTrainer")
+ device_worker_class = opt_info.get("device_worker", "Hogwild")
+ trainer = globals()[trainer_class]()
+ device_worker = globals()[device_worker_class]()
+
+ # for debug tools
+ if opt_info is not None:
+ if opt_info.get("trainers") is not None:
+ trainer._set_trainers(opt_info["trainers"])
+ if opt_info.get("trainer_id") is not None:
+ trainer._set_trainer_id(opt_info["trainer_id"])
+ if opt_info.get("dump_slot") is not None:
+ trainer._set_dump_slot(opt_info["dump_slot"])
+ if opt_info.get("mpi_rank") is not None:
+ trainer._set_mpi_rank(opt_info["mpi_rank"])
+ if opt_info.get("mpi_size") is not None:
+ trainer._set_mpi_size(opt_info["mpi_size"])
+ if opt_info.get("dump_fields") is not None and len(
+ opt_info.get("dump_fields")) != 0:
+ trainer._set_dump_fields(opt_info["dump_fields"])
+ if opt_info.get("dump_fields_path") is not None and len(
+ opt_info.get("dump_fields_path")) != 0:
+ trainer._set_dump_fields_path(opt_info["dump_fields_path"])
+ if opt_info.get("dump_file_num") is not None:
+ trainer._set_dump_file_num(opt_info["dump_file_num"])
+ if opt_info.get("dump_converter") is not None:
+ trainer._set_dump_converter(opt_info["dump_converter"])
+ if opt_info.get("dump_param") is not None and len(
+ opt_info.get("dump_param")) != 0:
+ trainer._set_dump_param(opt_info["dump_param"])
+ if opt_info.get("worker_places") is not None:
+ trainer._set_worker_places(opt_info["worker_places"])
+ if opt_info.get("use_ps_gpu") is not None:
+ trainer._set_use_ps_gpu(opt_info["use_ps_gpu"])
+ if opt_info.get("is_dump_in_simple_mode") is not None:
+ trainer._set_is_dump_in_simple_mode(
+ opt_info["is_dump_in_simple_mode"])
+ if opt_info.get("enable_random_dump") is not None:
+ trainer._set_enable_random_dump(
+ opt_info["enable_random_dump"])
+ if opt_info.get("dump_interval") is not None:
+ trainer._set_dump_interval(opt_info["dump_interval"])
+ if opt_info.get("random_with_lineid") is not None:
+ trainer._set_random_with_lineid(
+ opt_info["random_with_lineid"])
+
+ if "fleet_desc" in opt_info:
+ device_worker._set_fleet_desc(opt_info["fleet_desc"])
+ trainer._set_fleet_desc(opt_info["fleet_desc"])
+ if opt_info.get("use_cvm") is not None:
+ trainer._set_use_cvm(opt_info["use_cvm"])
+ if opt_info.get("no_cvm") is not None:
+ trainer._set_no_cvm(opt_info["no_cvm"])
+ if opt_info.get(
+ "scale_sparse_gradient_with_batch_size") is not None:
+ trainer._set_scale_sparse_grad_with_batch_size(
+ opt_info["scale_sparse_gradient_with_batch_size"])
+ if opt_info.get("scale_datanorm") is not None:
+ trainer._set_scale_datanorm(opt_info["scale_datanorm"])
+ if opt_info.get("adjust_ins_weight") is not None:
+ trainer._set_adjust_ins_weight(
+ opt_info["adjust_ins_weight"])
+ if opt_info.get("copy_table") is not None:
+ trainer._set_copy_table_config(opt_info["copy_table"])
+ if opt_info.get("check_nan_var_names") is not None:
+ trainer._set_check_nan_var_names(
+ opt_info["check_nan_var_names"])
+ if opt_info.get("loss_names") is not None:
+ trainer._set_loss_names(opt_info["loss_names"])
+ trainer._set_device_worker(device_worker)
+ return trainer
+
+
+class FetchHandlerMonitor(object):
+ """
+ Defination of FetchHandlerMonitor class,
+ it's for fetch handler.
+ """
+
+ def __init__(self, scope, handler):
+ self.fetch_instance = handler
+ self.fetch_thread = threading.Thread(target=self.handler_launch_func,
+ args=(scope, self.fetch_instance))
+ self.running_lock = threading.Lock()
+ self.running = False
+
+ def handler_launch_func(self, scope, handler):
+ fetch_instance = handler
+ period_secs = fetch_instance.period_secs
+ var_name_to_key = {}
+ for key in fetch_instance.var_dict:
+ if isinstance(fetch_instance.var_dict[key], Variable):
+ var_name_to_key[fetch_instance.var_dict[key].name] = key
+ else:
+ local_logger.warning(
+ "the value of {} is not a Variable".format(key))
+ var_name_to_key["None.var"] = key
+ elapsed_secs = 0
+ while True:
+ self.running_lock.acquire()
+ if self.running == False:
+ break
+ if elapsed_secs < period_secs:
+ # TODO(guru4elephant): needs customized condition
+ time.sleep(1)
+ elapsed_secs += 1
+ else:
+ elapsed_secs = 0
+ fetch_dict = {}
+ for key in var_name_to_key:
+ var = scope.find_var(key)
+ fetch_dict[key] = var
+ if var == None:
+ local_logger.warning(
+ "{} value currently not available".format(
+ var_name_to_key[key]))
+ res_dict = {}
+ for key in fetch_dict:
+ user_name = var_name_to_key[key]
+ if fetch_dict[key] == None:
+ res_dict[user_name] = None
+ continue
+ else:
+ res_dict[user_name] = fetch_dict[key].get_tensor()
+
+ lod = res_dict[user_name].lod()
+ if len(lod) > 0:
+ raise RuntimeError("Some of your fetched tensors \
+ hold LoD information. \
+ They can not be completely cast \
+ to Python ndarray. We can \
+ not return LoDTensor itself directly, \
+ please choose another targets")
+ if res_dict[user_name]._is_initialized():
+ res_dict[user_name] = np.array(res_dict[user_name])
+ else:
+ res_dict[user_name] = None
+ fetch_instance.handler(res_dict)
+ self.running_lock.release()
+
+ def start(self):
+ """
+ start monitor,
+ it will start a monitor thread.
+ """
+ self.running_lock.acquire()
+ self.running = True
+ self.running_lock.release()
+ self.fetch_thread.setDaemon(True)
+ self.fetch_thread.start()
+
+ def stop(self):
+ self.running_lock.acquire()
+ self.running = False
+ self.running_lock.release()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5d2502ddbb4afa1dba1f97e8867174469382abe
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/__init__.py
@@ -0,0 +1,28 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from .distribute_transpiler import DistributeTranspiler, DistributeTranspilerConfig
+from .memory_optimization_transpiler import memory_optimize, release_memory
+from .ps_dispatcher import HashName, RoundRobin
+
+__all__ = [
+ "DistributeTranspiler",
+ "memory_optimize",
+ "release_memory",
+ "HashName",
+ "RoundRobin",
+ "DistributeTranspilerConfig",
+]
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ascend_transpiler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ascend_transpiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..69fb2b1833655382d0b64202388ccae745638451
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ascend_transpiler.py
@@ -0,0 +1,74 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import collective
+from .. import core
+
+OpRole = core.op_proto_and_checker_maker.OpRole
+from paddle.distributed import fleet
+
+
+class AscendTranspiler(collective.Collective):
+
+ def __init__(self, startup_program, main_program):
+ self.nrings = 1
+ super(AscendTranspiler, self).__init__(self.nrings)
+ self._startup_program = startup_program
+ self._main_program = main_program
+
+ def _insert_allreduce_ops(self):
+ block = self._main_program.global_block()
+ ring_id = -1
+ grad = None
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_backward_op(op) and \
+ self.op_role_var_key in op.attr_names:
+ op_role_var = op.all_attrs()[self.op_role_var_key]
+
+ if len(op_role_var) == 0:
+ continue
+ assert len(op_role_var) % 2 == 0
+
+ offset = idx
+ for i in range(0, len(op_role_var), 2):
+ param = block.vars[op_role_var[i]]
+ grad = block.vars[op_role_var[i + 1]]
+ if param.is_distributed:
+ continue
+
+ # As we search ops reversedly, we should insert c_allreduce_sum
+ # op in the same way to keep the ring_id alternate
+ ring_id = (ring_id + 1) % self.nrings
+ block._insert_op(offset + 1,
+ type='c_allreduce_sum',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+ block._insert_op(offset + 2,
+ type='scale',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={
+ 'scale': 1.0 / fleet.worker_num(),
+ self.op_role_key: OpRole.Backward
+ })
+
+ if grad is None:
+ return
+
+ def transpile(self):
+ self._insert_allreduce_ops()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/collective.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/collective.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb57ea2a421cbad4a0b7daa815c341815f2249e4
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/collective.py
@@ -0,0 +1,740 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import sys
+import math
+from functools import reduce
+import os
+
+import collections
+import six
+import logging
+
+import numpy as np
+
+from .. import core, unique_name
+from ..framework import Program, default_main_program, default_startup_program
+from .details import wait_server_ready
+
+__all__ = ['GradAllReduce', 'LocalSGD', 'MultiThread']
+
+OpRole = core.op_proto_and_checker_maker.OpRole
+
+
+class Collective(object):
+ '''
+ '''
+
+ def __init__(self, nrings):
+ self.nrings = nrings
+ self.endpoints = None
+ self.current_endpoint = None
+ self.other_endpoints = None
+ self.nranks = None
+ self.rank = None
+ self.startup_program = None
+ self.main_program = None
+ op_maker = core.op_proto_and_checker_maker
+ self.op_role_key = op_maker.kOpRoleAttrName()
+ self.op_role_var_key = op_maker.kOpRoleVarAttrName()
+
+ def transpile(self, startup_program, main_program, rank, endpoints,
+ current_endpoint, wait_port):
+ # in case of '127.0.0.1:6700,127.0.0.1:6701,...'
+ if isinstance(endpoints, str):
+ endpoints = endpoints.split(',')
+
+ self.startup_program = startup_program
+ if startup_program is None:
+ self.startup_program = default_startup_program()
+
+ self.main_program = main_program
+ if main_program is None:
+ self.main_program = default_main_program()
+
+ self.nranks = len(endpoints)
+ if self.nranks == 1 and self.mode != "single_process_multi_thread" and self.mode != "box":
+ raise ValueError('the number of endpoints must > 1')
+
+ if rank < 0:
+ raise ValueError('rank must >= 0')
+ self.rank = rank
+
+ if current_endpoint not in endpoints:
+ raise ValueError('current endpoint %s is not in %s',
+ current_endpoint, str(endpoints))
+
+ self.endpoints = endpoints
+ self.current_endpoint = current_endpoint
+
+ if current_endpoint:
+ nranks = len(endpoints)
+ other_endpoints = endpoints[:]
+ other_endpoints.remove(current_endpoint)
+ self.other_endpoints = other_endpoints
+
+ self.wait_port = wait_port
+
+ self.startup_program._origin_program = self.startup_program.clone()
+ self._transpile_startup_program()
+
+ self.main_program._origin_program = self.main_program.clone()
+ self._transpile_main_program()
+
+ def _transpile_main_program(self):
+ raise NotImplementedError('call the inherited method of subclasses')
+
+ def _transpile_startup_program(self):
+ for ring_id in range(self.nrings):
+ self._init_communicator(self.startup_program, self.current_endpoint,
+ self.endpoints, self.rank, ring_id,
+ self.wait_port)
+ self._broadcast_params()
+
+ def _init_communicator(self,
+ program,
+ current_endpoint,
+ endpoints,
+ rank,
+ ring_id,
+ wait_port,
+ has_multitrainer=False):
+ nranks = len(endpoints)
+ other_endpoints = endpoints[:]
+ other_endpoints.remove(current_endpoint)
+ block = program.global_block()
+
+ if rank == 0 and wait_port:
+ wait_server_ready(other_endpoints)
+
+ block = program.global_block()
+ if core.is_compiled_with_npu():
+ hccl_id_var = block.create_var(name=unique_name.generate('hccl_id'),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+ endpoint_to_index_map = {e: idx for idx, e in enumerate(endpoints)}
+ block.append_op(type='c_gen_hccl_id',
+ inputs={},
+ outputs={'Out': hccl_id_var},
+ attrs={
+ 'rank': rank,
+ 'endpoint': current_endpoint,
+ 'other_endpoints': other_endpoints,
+ self.op_role_key: OpRole.Forward
+ })
+ block.append_op(type='c_comm_init_hccl',
+ inputs={'X': hccl_id_var},
+ outputs={},
+ attrs={
+ 'rank': rank,
+ 'ring_id': ring_id,
+ 'device_id':
+ int(os.getenv("FLAGS_selected_npus")),
+ 'rank_ids': nranks,
+ self.op_role_key: OpRole.Forward
+ })
+ else:
+ nccl_id_var = block.create_var(name=unique_name.generate('nccl_id'),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+ block.append_op(type='c_gen_nccl_id',
+ inputs={},
+ outputs={'Out': nccl_id_var},
+ attrs={
+ 'rank': rank,
+ 'endpoint': current_endpoint,
+ 'other_endpoints': other_endpoints,
+ self.op_role_key: OpRole.Forward
+ })
+ if not has_multitrainer:
+ block.append_op(type='c_comm_init',
+ inputs={'X': nccl_id_var},
+ outputs={},
+ attrs={
+ 'nranks': nranks,
+ 'rank': rank,
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Forward
+ })
+ else:
+ block.append_op(type='c_comm_init_multitrainer',
+ inputs={'X': nccl_id_var},
+ outputs={},
+ attrs={
+ 'ntrainers': nranks,
+ 'trainer_id': rank,
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Forward
+ })
+
+ def _broadcast_params(self):
+ block = self.startup_program.global_block()
+ ring_id = -1
+ for param in block.iter_parameters():
+ if param.is_distributed:
+ continue
+
+ ring_id = (ring_id + 1) % self.nrings
+ block.append_op(type='c_broadcast',
+ inputs={'X': param},
+ outputs={'Out': param},
+ attrs={
+ 'ring_id': ring_id,
+ 'root': 0,
+ self.op_role_key: OpRole.Forward
+ })
+
+ for ring_id in range(self.nrings):
+ block.append_op(type='c_sync_comm_stream',
+ inputs={'X': param},
+ outputs={'Out': param},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Forward
+ })
+
+ def _is_loss_grad_op(self, op):
+ if self.op_role_key not in op.attr_names:
+ return False
+ op_role = int(op.all_attrs()[self.op_role_key])
+ return op_role & int(OpRole.Backward) and op_role & int(OpRole.Loss)
+
+ def _is_backward_op(self, op):
+ return self.op_role_key in op.attr_names and \
+ int(op.all_attrs()[self.op_role_key]) & int(OpRole.Backward)
+
+ def _is_update_op(self, op):
+ return 'Param' in op.input_names and 'Grad' in op.input_names and \
+ "LearningRate" in op.input_names
+
+ def _is_optimizer_op(self, op):
+ return self.op_role_key in op.attr_names and \
+ int(op.all_attrs()[self.op_role_key]) & int(OpRole.Optimize)
+
+
+class GradAllReduce(Collective):
+ '''
+ '''
+
+ def __init__(self, nrings=2):
+ Collective.__init__(self, nrings)
+ self.mode = "grad_allreduce"
+
+ def _transpile_main_program(self):
+ self._insert_scale_loss_grad_ops()
+ self._insert_allreduce_ops()
+
+ def _insert_scale_loss_grad_ops(self):
+ '''
+ In order to keep the learning rate consistent in different numbers of
+ training workers, we scale the loss grad by the number of workers
+ '''
+ block = self.main_program.global_block()
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_loss_grad_op(op):
+ loss_grad_var = block.vars[op.output_arg_names[0]]
+ block._insert_op(idx + 1,
+ type='scale',
+ inputs={'X': loss_grad_var},
+ outputs={'Out': loss_grad_var},
+ attrs={
+ 'scale': 1.0 / self.nranks,
+ self.op_role_key: OpRole.Backward
+ })
+
+ def _insert_allreduce_ops(self):
+ block = self.main_program.global_block()
+ ring_id = -1
+ grad = None
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_backward_op(op) and \
+ self.op_role_var_key in op.attr_names:
+ op_role_var = op.all_attrs()[self.op_role_var_key]
+
+ if len(op_role_var) == 0:
+ continue
+ assert len(op_role_var) % 2 == 0
+
+ offset = idx
+ for i in range(0, len(op_role_var), 2):
+ param = block.vars[op_role_var[i]]
+ grad = block.vars[op_role_var[i + 1]]
+ if param.is_distributed:
+ continue
+
+ if offset == idx:
+ offset += 1
+ block._insert_op(
+ offset,
+ type='c_sync_calc_stream',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={self.op_role_key: OpRole.Backward})
+ offset += 1
+
+ # As we search ops reversedly, we should insert c_allreduce_sum
+ # op in the same way to keep the ring_id alternate
+ ring_id = (ring_id + 1) % self.nrings
+ block._insert_op(offset,
+ type='c_allreduce_sum',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+
+ if grad is None:
+ return
+
+ for idx, op in enumerate(block.ops):
+ if self._is_optimizer_op(op):
+ for ring_id in range(self.nrings):
+ block._insert_op(idx + ring_id,
+ type='c_sync_comm_stream',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+ break
+
+
+class LocalSGD(Collective):
+ '''
+ '''
+
+ def __init__(self, nrings=2):
+ Collective.__init__(self, nrings)
+ self.snapshot_key = '@SNAPSHOT'
+ self.mode = "local_sgd"
+
+ def _transpile_startup_program(self):
+ Collective._transpile_startup_program(self)
+
+ block = self.startup_program.global_block()
+ non_dist_params = []
+ for param in block.iter_parameters():
+ if not param.is_distributed:
+ non_dist_params.append(param)
+
+ for param in non_dist_params:
+ snapshot = block.create_var(name=self.snapshot_name(param.name),
+ shape=param.shape,
+ persistable=True,
+ stop_gradient=True)
+ block.append_op(type='assign',
+ inputs={'X': [param]},
+ outputs={'Out': [snapshot]},
+ attrs={self.op_role_key: OpRole.Forward})
+
+ def snapshot_name(self, param_name):
+ return param_name + self.snapshot_key
+
+ def _transpile_main_program(self):
+ block = self.main_program.global_block()
+ ordered_param_snapshot = []
+ ring_id = -1
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_update_op(op):
+ param = block.vars[op.input('Param')[0]]
+ if param.is_distributed:
+ continue
+
+ snapshot = block.create_var(name=self.snapshot_name(param.name),
+ shape=param.shape,
+ persistable=True,
+ stop_gradient=True,
+ dtype=param.dtype)
+
+ block._insert_op(idx + 1,
+ type='elementwise_sub',
+ inputs={
+ 'X': [snapshot],
+ 'Y': [param]
+ },
+ outputs={'Out': [param]},
+ attrs={self.op_role_key: OpRole.Optimize})
+ block._insert_op(idx + 2,
+ type='c_sync_calc_stream',
+ inputs={'X': param},
+ outputs={'Out': param},
+ attrs={self.op_role_key: OpRole.Optimize})
+ ring_id = (ring_id + 1) % self.nrings
+ block._insert_op(idx + 3,
+ type='c_allreduce_sum',
+ inputs={'X': [param]},
+ outputs={'Out': [param]},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Optimize
+ })
+
+ ordered_param_snapshot.append((param, snapshot))
+
+ for ring_id in range(self.nrings):
+ block.append_op(type='c_sync_comm_stream',
+ inputs={'X': param},
+ outputs={'Out': param},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Optimize
+ })
+
+ for param_snapshot in reversed(ordered_param_snapshot):
+ param = param_snapshot[0]
+ snapshot = param_snapshot[1]
+ block.append_op(type='scale',
+ inputs={'X': [param]},
+ outputs={'Out': [param]},
+ attrs={
+ 'scale': 1.0 / self.nranks,
+ self.op_role_key: OpRole.Optimize
+ })
+ block.append_op(type='elementwise_sub',
+ inputs={
+ 'X': [snapshot],
+ 'Y': [param]
+ },
+ outputs={'Out': [param]},
+ attrs={self.op_role_key: OpRole.Optimize})
+ block.append_op(type='assign',
+ inputs={'X': [param]},
+ outputs={'Out': [snapshot]},
+ attrs={self.op_role_key: OpRole.Optimize})
+
+
+class SingleProcessMultiThread(GradAllReduce):
+ '''
+ '''
+
+ def __init__(self):
+ GradAllReduce.__init__(self, 1)
+ self.mode = "single_process_multi_thread"
+
+ def _transpile_startup_program(self):
+ block = self.startup_program.global_block()
+ block.append_op(type='c_comm_init_all', attrs={'ring_id': 0})
+
+
+class MultiThread(GradAllReduce):
+ '''
+ '''
+
+ def __init__(self, nrings=1, trans_mode="all_reduce"):
+ GradAllReduce.__init__(self, nrings)
+ self.mode = "box"
+ self.trans_mode = trans_mode
+ self.fuse_grad_size_in_num = 128
+ gpu_nums = os.getenv("FLAGS_selected_gpus",
+ "0,1,2,3,4,5,6,7,8").split(",")
+ self.gpu_num = len(gpu_nums)
+
+ def _transpile_startup_program(self):
+ if len(self.endpoints) > 1:
+ print("begin to _transpile_startup_program for multi-node")
+ print("current_endpoint: ", self.current_endpoint)
+ print("total endpoints: ", self.endpoints)
+ print("rank: %d, ring_id: %d" % (self.rank, self.nrings))
+ for ring_id in range(self.nrings):
+ self._init_communicator(self.startup_program,
+ self.current_endpoint, self.endpoints,
+ self.rank, ring_id, self.wait_port,
+ True)
+
+ else:
+ if "xpu" in self.trans_mode:
+ print(
+ "begin to _transpile_startup_program for single-node in XPU"
+ )
+ block = self.startup_program.global_block()
+ block.append_op(
+ type='c_comm_init_all',
+ attrs={
+ 'devices':
+ list(
+ map(int,
+ os.getenv("FLAGS_selected_gpus").split(","))),
+ 'ring_id':
+ 0
+ })
+ else:
+ print("begin to _transpile_startup_program for single-node")
+ block = self.startup_program.global_block()
+ block.append_op(type='c_comm_init_all', attrs={'ring_id': 0})
+
+ def _transpile_main_program(self):
+ self._insert_scale_loss_grad_ops()
+ if self.trans_mode == "all_gather":
+ print("begin to transpile in all-gather mode")
+ self.allgather_ranks = self.nranks * self.gpu_num
+ self._insert_allgather_ops()
+ self._update_adam_ops()
+ elif self.trans_mode == "fuse_all_reduce":
+ print("begin to transpile in fuse all-reduce mode")
+ self._insert_fuse_allreduce_ops()
+ elif self.trans_mode == "all_reduce_xpu" and len(
+ os.getenv("FLAGS_selected_gpus").split(",")) == 1:
+ print(
+ "skip transpile in all-reduce-xpu mode when number of devices is only one"
+ )
+ else:
+ print("begin to transpile in all-reduce mode")
+ self._insert_allreduce_ops()
+
+ def _insert_allgather_ops(self):
+ """
+ insert allgather op to the main_program
+ """
+ block = self.main_program.global_block()
+ ring_id = -1
+ grad = None
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_backward_op(op) and \
+ self.op_role_var_key in op.attr_names:
+ op_role_var = op.all_attrs()[self.op_role_var_key]
+ if len(op_role_var) == 0:
+ continue
+ assert len(op_role_var) % 2 == 0
+
+ offset = idx
+ for i in range(0, len(op_role_var), 2):
+ param = block.vars[op_role_var[i]]
+ new_grad_var = block.create_var(
+ name=op_role_var[i] + "_allgather",
+ shape=[self.allgather_ranks] + list(param.shape),
+ persistable=False,
+ dtype=core.VarDesc.VarType.FP32,
+ stop_gradient=True)
+ grad = block.vars[op_role_var[i + 1]]
+ if param.is_distributed: # no need to care: used in PLSC
+ continue
+
+ if offset == idx:
+ offset += 1
+ block._insert_op(
+ offset,
+ type='c_sync_calc_stream',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={self.op_role_key: OpRole.Backward})
+ offset += 1
+
+ # As we search ops reversedly, we should insert c_allgather
+ # op in the same way to keep the ring_id alternate
+ ring_id = (ring_id + 1) % self.nrings
+ block._insert_op(offset,
+ type='c_allgather',
+ inputs={'X': grad},
+ outputs={'Out': new_grad_var},
+ attrs={
+ 'nranks': self.allgather_ranks,
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+
+ if grad is None:
+ return
+
+ for idx, op in enumerate(block.ops):
+ if self._is_optimizer_op(op):
+ for ring_id in range(self.nrings):
+ block._insert_op(idx + ring_id,
+ type='c_sync_comm_stream',
+ inputs={'X': grad},
+ outputs={'Out': grad},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+ break
+
+ def _update_adam_ops(self):
+ """
+ remove the original adam op, and add new adam ops
+ """
+ block = self.main_program.global_block()
+
+ for idx, op in reversed(list(enumerate(block.ops))):
+ if self._is_optimizer_op(op):
+ offset = idx
+ if op.type != 'adam' and op.type != 'lamb': # filter out scale op
+ continue
+ param_name = op.input("Param")[0]
+ inputs = {
+ "Param": block.vars[op.input("Param")[0]],
+ "LearningRate": block.vars[op.input("LearningRate")[0]],
+ "Moment1": block.vars[op.input("Moment1")[0]],
+ "Moment2": block.vars[op.input("Moment2")[0]],
+ "Beta1Pow": block.vars[op.input("Beta1Pow")[0]],
+ "Beta2Pow": block.vars[op.input("Beta2Pow")[0]]
+ }
+ outputs = {
+ "ParamOut": block.vars[op.output("ParamOut")[0]],
+ "Moment1Out": block.vars[op.output("Moment1Out")[0]],
+ "Moment2Out": block.vars[op.output("Moment2Out")[0]],
+ "Beta1PowOut": block.vars[op.output("Beta1PowOut")[0]],
+ "Beta2PowOut": block.vars[op.output("Beta2PowOut")[0]]
+ }
+ attrs = {
+ "epsilon":
+ op.attr('epsilon'),
+ "beta1":
+ op.attr('beta1'),
+ "beta2":
+ op.attr('beta2'),
+ "lazy_mode":
+ op.attr('lazy_mode'),
+ "min_row_size_to_use_multithread":
+ op.attr('min_row_size_to_use_multithread')
+ }
+ split_vars = [
+ block.create_var(
+ name=param_name + "_" + str(i),
+ shape=block.vars[op.input("Param")[0]].shape,
+ persistable=False,
+ dtype=core.VarDesc.VarType.FP32,
+ stop_gradient=True) for i in range(self.allgather_ranks)
+ ]
+ block._insert_op(offset,
+ type="split",
+ inputs={
+ 'X':
+ block.vars[op.input("Param")[0] +
+ "_allgather"]
+ },
+ outputs={'Out': split_vars},
+ attrs={
+ 'num': self.allgather_ranks,
+ 'axis': 0
+ })
+ offset += 1
+
+ for i in range(self.allgather_ranks):
+ inputs["Grad"] = split_vars[i]
+ block._insert_op(offset,
+ type=op.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=attrs)
+ offset += 1
+ # remove the original adam op
+ block._remove_op(offset)
+
+ def _insert_fuse_allreduce_ops(self):
+ """
+ insert coalesce_tensor and all reduce ops
+ """
+ block = self.main_program.global_block()
+ ring_id = 0 % self.nrings
+ grad = None
+ param_grads = []
+ # find all grad params
+ for op in reversed(block.ops):
+ if self._is_backward_op(op) and \
+ self.op_role_var_key in op.attr_names:
+ op_role_var = op.all_attrs()[self.op_role_var_key]
+ if len(op_role_var) == 0:
+ continue
+ assert len(op_role_var) % 2 == 0, "vars need to be one param var followed by one grad var, " \
+ "but got odd number of vars"
+ for i in range(0, len(op_role_var), 2):
+ param_name = op_role_var[i]
+ param = block.var(param_name)
+ grad_name = op_role_var[i + 1]
+ grad = block.var(grad_name)
+ if param.is_distributed:
+ continue
+ param_grads.append(grad)
+ if grad is None:
+ return
+
+ segments = []
+ last_dtype = None
+ # split the grad based on dtype and fused size
+ for var in param_grads:
+ if len(segments) == 0 \
+ or len(segments[-1]) == self.fuse_grad_size_in_num \
+ or var.dtype != last_dtype:
+ segments.append([var])
+ last_dtype = var.dtype
+ else:
+ segments[-1].append(var)
+
+ fused_vars = []
+ for idx, op in enumerate(block.ops):
+ if self._is_optimizer_op(op):
+ for segment in segments:
+ # insert coalesce tensor
+ tmp_var = block.create_var(name=unique_name.generate(
+ 'FusedOutput_{}'.format(segment[0].name)),
+ dtype=segment[0].dtype,
+ persistable=False,
+ stop_gradient=True)
+ fused_vars.append(tmp_var)
+ block._insert_op(idx,
+ type="coalesce_tensor",
+ inputs={"Input": segment},
+ outputs={
+ "Output": segment,
+ "FusedOutput": tmp_var
+ },
+ attrs={
+ "copy_data": True,
+ "use_align": True,
+ "dtype": segment[0].dtype,
+ self.op_role_key: OpRole.Backward
+ })
+ break
+
+ # insert the allreduce_sum op
+ for idx, op in enumerate(block.ops):
+ if self._is_optimizer_op(op):
+ for fused_var in fused_vars:
+ block._insert_op(idx,
+ type='c_allreduce_sum',
+ inputs={'X': fused_var},
+ outputs={'Out': fused_var},
+ attrs={
+ 'ring_id': ring_id,
+ 'use_calc_stream': False,
+ self.op_role_key: OpRole.Backward
+ })
+ block._insert_op(idx,
+ type='c_sync_calc_stream',
+ inputs={'X': fused_var},
+ outputs={'Out': fused_var},
+ attrs={self.op_role_key: OpRole.Backward})
+ break
+
+ if len(fused_vars) == 0:
+ block._sync_with_cpp()
+ return
+
+ # insert the sync comm op
+ for idx, op in enumerate(block.ops):
+ if self._is_optimizer_op(op):
+ block._insert_op(idx,
+ type='c_sync_comm_stream',
+ inputs={'X': fused_vars[0]},
+ outputs={'Out': fused_vars[0]},
+ attrs={
+ 'ring_id': ring_id,
+ self.op_role_key: OpRole.Backward
+ })
+ break
+ block._sync_with_cpp()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..82d0d336e523ec48c5ceca3b92ff0963c4499123
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/__init__.py
@@ -0,0 +1,20 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from .program_utils import *
+from .ufind import *
+from .checkport import *
+from .vars_distributed import *
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/checkport.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/checkport.py
new file mode 100644
index 0000000000000000000000000000000000000000..1341bdaedf99e3aa40d0159634a4246d0ee4e2f0
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/checkport.py
@@ -0,0 +1,60 @@
+# Copyright (c) 2018 PaddlePaddle 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 sys
+import time
+import socket
+from contextlib import closing
+from six import string_types
+
+
+def wait_server_ready(endpoints):
+ """
+ Wait until parameter servers are ready, use connext_ex to detect
+ port readiness.
+
+ Args:
+ endpoints (list): endpoints string list, like:
+ ["127.0.0.1:8080", "127.0.0.1:8081"]
+
+ Examples:
+ .. code-block:: python
+
+ wait_server_ready(["127.0.0.1:8080", "127.0.0.1:8081"])
+ """
+ assert not isinstance(endpoints, string_types)
+ while True:
+ all_ok = True
+ not_ready_endpoints = []
+ for ep in endpoints:
+ ip_port = ep.split(":")
+ with closing(socket.socket(socket.AF_INET,
+ socket.SOCK_STREAM)) as sock:
+ sock.settimeout(2)
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ if hasattr(socket, 'SO_REUSEPORT'):
+ sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+ result = sock.connect_ex((ip_port[0], int(ip_port[1])))
+ if result != 0:
+ all_ok = False
+ not_ready_endpoints.append(ep)
+ if not all_ok:
+ sys.stderr.write("server not ready, wait 3 sec to retry...\n")
+ sys.stderr.write("not ready endpoints:" + str(not_ready_endpoints) +
+ "\n")
+ sys.stderr.flush()
+ time.sleep(3)
+ else:
+ break
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/program_utils.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/program_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc7b9ed661ab3b15c1b393acae46ec71d1fea4aa
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/program_utils.py
@@ -0,0 +1,51 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import six
+
+from paddle.fluid import core
+import paddle
+
+
+def delete_ops(block, ops):
+ for op in ops:
+ try:
+ idx = list(block.ops).index(op)
+ block._remove_op(idx)
+ except Exception as e:
+ print(e)
+
+
+def find_op_by_input_arg(block, arg_name):
+ for index, op in enumerate(block.ops):
+ if arg_name in op.input_arg_names:
+ return index
+ return -1
+
+
+def find_op_by_output_arg(block, arg_name, reverse=False):
+ if reverse:
+ pos = len(block.ops) - 1
+ while pos >= 0:
+ op = block.ops[pos]
+ if arg_name in op.output_arg_names:
+ return pos
+ pos -= 1
+ else:
+ for index, op in enumerate(block.ops):
+ if arg_name in op.output_arg_names:
+ return index
+ return -1
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/ufind.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/ufind.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa63af7dcf7ac85031fb00ca4c39fb36d7e588b8
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/ufind.py
@@ -0,0 +1,66 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+
+class UnionFind(object):
+ """ Union-find data structure.
+
+ Union-find is a data structure that keeps track of a set of elements partitioned
+ into a number of disjoint (non-overlapping) subsets.
+
+ Reference:
+ https://en.wikipedia.org/wiki/Disjoint-set_data_structure
+
+ Args:
+ elements(list): The initialize element list.
+ """
+
+ def __init__(self, elementes=None):
+ self._parents = [] # index -> parent index
+ self._index = {} # element -> index
+ self._curr_idx = 0
+ if not elementes:
+ elementes = []
+ for ele in elementes:
+ self._parents.append(self._curr_idx)
+ self._index.update({ele: self._curr_idx})
+ self._curr_idx += 1
+
+ def find(self, x):
+ # Find the root index of given element x,
+ # execute the path compress while findind the root index
+ if not x in self._index:
+ return -1
+ idx = self._index[x]
+ while idx != self._parents[idx]:
+ t = self._parents[idx]
+ self._parents[idx] = self._parents[t]
+ idx = t
+ return idx
+
+ def union(self, x, y):
+ # Union two given element
+ x_root = self.find(x)
+ y_root = self.find(y)
+
+ if x_root == y_root:
+ return
+ self._parents[x_root] = y_root
+
+ def is_connected(self, x, y):
+ # If two given elements have the same root index,
+ # then they are connected.
+ return self.find(x) == self.find(y)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/vars_distributed.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/vars_distributed.py
new file mode 100644
index 0000000000000000000000000000000000000000..05e7f6e3e706376efc8af870a780d96c45642514
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/details/vars_distributed.py
@@ -0,0 +1,269 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import print_function
+from paddle.fluid.framework import Variable
+
+
+class VarStruct(object):
+ """
+ record part properties of a Variable in python.
+ """
+
+ def __init__(self, name, shape, dtype, type, lod_level, persistable):
+ self.name = name
+ self.shape = shape
+ self.dtype = dtype
+ self.type = type
+ self.lod_level = lod_level
+ self.persistable = persistable
+
+
+class VarDistributed(object):
+ """
+ a class to record the var distributed on parameter servers.
+ the class will record the relationship between origin var and slice var.
+ the slice var's properties, such as type/shape/offset/endpoint.
+ """
+
+ def __init__(self,
+ origin_var,
+ slice_var,
+ is_slice=None,
+ block_id=None,
+ offset=None,
+ vtype=None,
+ endpoint=None):
+ """
+ Args:
+ origin_var(Variable|VarStruct): origin var properties
+ slice_var(Variable|VarStruct): slice var properties
+ is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard.
+ block_id(int|None): the number about the slice var.
+ offset(int|None): if the slice var is sliced, offset is the numel before the var.
+ vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch.
+ endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001"
+ """
+
+ if isinstance(origin_var, Variable):
+ self.origin = self.__create_var_struct(origin_var)
+ else:
+ self.origin = origin_var
+
+ if isinstance(slice_var, Variable):
+ self.slice = self.__create_var_struct(slice_var)
+ else:
+ self.slice = slice_var
+
+ if self.equal(self.origin, self.slice):
+ self.is_slice = False
+ self.block_id = 0
+ self.offset = 0
+ else:
+ self.is_slice = True
+ self.block_id = 0
+ self.offset = 0
+
+ if is_slice is not None:
+ self.is_slice = is_slice
+ if block_id is not None:
+ self.block_id = block_id
+ if offset is not None:
+ self.offset = offset
+
+ self.vtype = vtype
+ self.endpoint = endpoint
+
+ @staticmethod
+ def __create_var_struct(var):
+ return VarStruct(var.name, var.shape, var.dtype, var.type,
+ var.lod_level, var.persistable)
+
+ @staticmethod
+ def equal(var1, var2):
+ """
+ the two var is equal or not.
+ Returns:
+ bool: equal will return True else False
+ """
+ assert isinstance(var1, VarStruct) and isinstance(var2, VarStruct)
+
+ return var1.name == var2.name and \
+ var1.type == var2.type and \
+ var1.shape == var2.shape and \
+ var1.dtype == var2.dtype and \
+ var1.lod_level == var2.lod_level and \
+ var1.persistable == var2.persistable
+
+ def __str__(self):
+ origin_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})". \
+ format(i="{", e="}", name=self.origin.name, type=self.origin.type,
+ shape=self.origin.shape, dtype=self.origin.dtype)
+
+ slice_var_str = "{name} : fluid.{type}.shape{shape}.astype({dtype})" \
+ ".slice({is_slice}).block({block_id}).offset({offset})". \
+ format(i="{", e="}", name=self.slice.name, type=self.slice.type,
+ shape=self.slice.shape, dtype=self.slice.dtype,
+ is_slice=self.is_slice, block_id=self.block_id, offset=self.offset)
+
+ return "var owned: {}, origin var: ( {} ), slice var: ( {} ), endpoint: {} ".format(
+ self.vtype, origin_var_str, slice_var_str, self.endpoint)
+
+
+class VarsDistributed(object):
+ """
+ a gather about VarDistributed with many methods to find distributed vars.
+ through the class, we can get overview about the distributed parameters on parameter servers.
+ this class may centralized and convenient for developer to manage and get variable's distribute.
+ other module can also use this to find variables such io.py.
+ """
+
+ def __init__(self):
+ self.distributed_vars = []
+
+ def add_distributed_var(self,
+ origin_var,
+ slice_var,
+ is_slice=None,
+ block_id=None,
+ offset=None,
+ vtype=None,
+ endpoint=None):
+ """
+ add distributed var in this.
+
+ Args:
+ origin_var(Variable|VarStruct): origin var properties
+ slice_var(Variable|VarStruct): slice var properties
+ is_slice(bool|None): slice or not, slice_var=True/False and its block size > 8192 are the judgement standard.
+ block_id(int|None): the number about the slice var.
+ offset(int|None): if the slice var is sliced, offset is the numel before the var.
+ vtype(str|None): a tag, such as Optimizer/Param/RemoteProfetch.
+ endpoint(str|None): which parameter the slice var on, such as "127.0.0.1:1001"
+ Returns:
+ None
+ """
+ self.distributed_vars.append(
+ VarDistributed(origin_var, slice_var, is_slice, block_id, offset,
+ vtype, endpoint))
+
+ def get_distributed_var_by_slice(self, var_name):
+ """
+ get distributed var by conditions.
+
+ Args:
+ var_name(str): slice var name, such as "w.traier0.block1"
+ Returns:
+ VarDistributed: distributed var.
+ """
+ for dist_var in self.distributed_vars:
+ if dist_var.slice.name == var_name:
+ return dist_var
+ return None
+
+ @staticmethod
+ def equal(var1, var2):
+ """
+ the two var is equal or not.
+ Returns:
+ bool: equal will return True else False
+ """
+ return var1.name == var2.name and \
+ var1.type == var2.type and \
+ var1.shape == var2.shape and \
+ var1.dtype == var2.dtype and \
+ var1.lod_level == var2.lod_level and \
+ var1.persistable == var2.persistable
+
+ def get_distributed_var_by_origin_and_ep(self, origin_var_name, endpoint):
+ """
+ get distributed var by conditions.
+
+ Args:
+ origin_var_name(str):
+ endpoint(str): the parameter endpoint, such as "127.0.0.1:1001"
+ Returns:
+ VarDistributed: distributed var.
+ """
+ for dist_var in self.distributed_vars:
+ if dist_var.origin.name == origin_var_name and dist_var.endpoint == endpoint:
+ return dist_var
+ return None
+
+ def get_distributed_vars_by_vtypes(self, vtypes, groupby=False):
+ """
+ get distributed vars by conditions.
+
+ Args:
+ vtype(str|None): distributed var's vtype, such as "Optimizer", "RemotePrefetch"
+ groupby(bool|False): group by origin var or not.
+
+ Returns:
+ list: distributed var list.
+ dict: distributed var map when groupby=True
+ """
+ vtype_vars = []
+ for var in self.distributed_vars:
+ if var.vtype in vtypes:
+ vtype_vars.append(var)
+ if not groupby:
+ return vtype_vars
+
+ params_map = {}
+ for var in vtype_vars:
+ origin_var_name = var.origin.name
+
+ if origin_var_name in params_map.keys():
+ optimizers = params_map.get(origin_var_name)
+ else:
+ optimizers = []
+ optimizers.append(var)
+ params_map[origin_var_name] = optimizers
+ return params_map
+
+ def get_distributed_vars_by_ep(self, endpoint, vtype=None):
+ """
+ get distributed vars by conditions.
+
+ Args:
+ endpoint(str): the parameter server endpoint, such as "127.0.0.1:2001"
+ vtype(str|None): distributed var's vtype, such as "Optimizer", "RemotePrefetch"
+
+ Returns:
+ list: distributed var list.
+ """
+ endpoint_vars = []
+ for var in self.distributed_vars:
+ if var.endpoint == endpoint:
+ endpoint_vars.append(var)
+ if not vtype:
+ return endpoint_vars
+
+ vtype_vars = []
+ for var in endpoint_vars:
+ if var.vtype == vtype:
+ vtype_vars.append(var)
+ return vtype_vars
+
+ def overview(self):
+ """
+ get the overview string about all params on all parameter servers.
+
+ Returns:
+ Str: overview string.
+
+ """
+ vars_str = []
+ for var in self.distributed_vars:
+ vars_str.append(str(var))
+ return "\n".join(vars_str)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/distribute_transpiler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/distribute_transpiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..31d3c817d1ed5bf44d2fc7fbd4442565d000f150
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/distribute_transpiler.py
@@ -0,0 +1,2749 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+"""
+Steps to transpile trainer:
+1. split variable to multiple blocks, aligned by product(dim[1:]) (width).
+2. rename split grad variables to add trainer_id suffix ".trainer_%d".
+3. modify trainer program add split_op to each grad variable.
+4. append send_op to send split variables to server and
+5. add recv_op to fetch params(split blocks or origin param) from server.
+6. append concat_op to merge split blocks to update local weights.
+
+Steps to transpile pserver:
+1. create new program for parameter server.
+2. create params and grad variables that assigned to current server instance.
+3. create a sub-block in the server side program
+4. append ops that should run on current server instance.
+5. add listen_and_serv op
+"""
+
+import os
+import sys
+import math
+from functools import reduce
+
+import collections
+import six
+import logging
+
+import numpy as np
+
+from .ps_dispatcher import RoundRobin, PSDispatcher
+from .. import core, framework, unique_name, initializer
+from ..framework import Program, default_main_program, \
+ default_startup_program, Block, Parameter, grad_var_name
+from .details import wait_server_ready, UnionFind, VarStruct, VarsDistributed
+from .details import delete_ops, find_op_by_output_arg
+from ..distribute_lookup_table import find_distributed_lookup_table
+from . import collective
+
+LOOKUP_TABLE_TYPE = ["lookup_table", "lookup_table_v2"]
+LOOKUP_TABLE_GRAD_TYPE = ["lookup_table_grad", "lookup_table_v2_grad"]
+OP_NAME_SCOPE = "op_namescope"
+CLIP_OP_NAME_SCOPE = "@CLIP"
+OP_ROLE_VAR_ATTR_NAME = core.op_proto_and_checker_maker.kOpRoleVarAttrName()
+RPC_OP_ROLE_ATTR_NAME = op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName(
+)
+OPT_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Optimize
+RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC
+DIST_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.Dist
+LR_SCHED_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.LRSched
+
+PRINT_LOG = False
+
+
+class DistributedMode:
+ SYNC = 0
+ ASYNC = 1
+ HALF_ASYNC = 2
+ GEO = 3
+
+
+def log(*args):
+ if PRINT_LOG:
+ print(args)
+
+
+class VarBlock:
+
+ def __init__(self, varname, offset, size):
+ self.varname = varname
+ # NOTE: real offset is offset * size
+ self.offset = offset
+ self.size = size
+
+ def __str__(self):
+ return "%s:%d:%d" % (self.varname, self.offset, self.size)
+
+
+def same_or_split_var(p_name, var_name):
+ return p_name == var_name or p_name.startswith(var_name + ".block")
+
+
+def slice_variable(var_list, slice_count, min_block_size):
+ """
+ We may need to split dense tensor to one or more blocks and put
+ them equally onto parameter server. One block is a sub-tensor
+ aligned by dim[0] of the tensor.
+
+ We need to have a minimal block size so that the calculations in
+ the parameter server side can gain better performance. By default
+ minimum block size 8K elements (maybe 16bit or 32bit or 64bit).
+
+ Args:
+ var_list (list): List of variables.
+ slice_count (int): Numel of count that variables will be sliced, which
+ could be the pserver services' count.
+ min_block_size (int): Minimum split block size.
+ Returns:
+ blocks (list[(varname, block_id, current_block_size)]): A list
+ of VarBlocks. Each VarBlock specifies a shard of the var.
+ """
+ blocks = []
+ for var in var_list:
+ split_count = slice_count
+ var_numel = reduce(lambda x, y: x * y, var.shape)
+ max_pserver_count = int(math.floor(var_numel / float(min_block_size)))
+ if max_pserver_count == 0:
+ max_pserver_count = 1
+ if max_pserver_count < slice_count:
+ split_count = max_pserver_count
+ block_size = int(math.ceil(var_numel / float(split_count)))
+
+ if len(var.shape) >= 2:
+ # align by dim1(width)
+ dim1 = reduce(lambda x, y: x * y, var.shape[1:])
+ remains = block_size % dim1
+ if remains != 0:
+ block_size += dim1 - remains
+ # update split_count after aligning
+ split_count = int(math.ceil(var_numel / float(block_size)))
+ for block_id in range(split_count):
+ curr_block_size = min(block_size,
+ var_numel - ((block_id) * block_size))
+ block = VarBlock(var.name, block_id, curr_block_size)
+ blocks.append(str(block))
+ return blocks
+
+
+class DistributeTranspilerConfig(object):
+ """
+ :api_attr: Static Graph
+
+ A configuration class that provide support for transpiler distributed jobs.
+ Some important parameters are explained as follows:
+
+
+ .. py:attribute:: slice_var_up (bool)
+
+ Whether to do Tensor slice for parameter servers, default is True.
+
+ .. py:attribute:: split_method (PSDispatcher)
+
+ Methods of dispatching parameters for server,
+ :ref:`api_fluid_transpiler_RoundRobin` or
+ :ref:`api_fluid_transpiler_HashName` can be used and default is RoundRobin.
+ Try to choose the best method to balance loads for parameter servers.
+
+ .. py:attribute:: min_block_size (int)
+
+ Minimum number of split elements in block, default is 8192.
+
+ According to : https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156
+ We can use bandwidth efficiently when data size is larger than 2MB.If you
+ want to change it, please be sure you have read the slice_variable function. You can find
+ the definition of slice_variable in
+ https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/transpiler/distribute_transpiler.py
+ .
+
+ Examples:
+ .. code-block:: python
+
+ from paddle.fluid.transpiler.ps_dispatcher import RoundRobin
+ import paddle.fluid as fluid
+
+ config = fluid.DistributeTranspilerConfig()
+ config.slice_var_up = True
+ config.split_method = RoundRobin
+ config.min_block_size = 81920
+ """
+
+ slice_var_up = True
+ split_method = None
+ min_block_size = 8192
+ enable_dc_asgd = False
+ # supported modes: pserver, nccl2, collective
+ mode = "pserver"
+ print_log = False
+ wait_port = True
+ # split the send recv var in runtime
+ __runtime_split_send_recv = False
+ __sync_mode = True
+
+ # half_async
+ half_async = False
+ completely_not_async = False
+
+ # Geo-sgd algorithm
+ geo_sgd_mode = False
+ geo_sgd_need_push_nums = 100
+
+ nccl_comm_num = 1
+ # The picture here illustrates the principle:
+ # https://github.com/PaddlePaddle/Paddle/pull/17263#discussion_r285411396
+ use_hierarchical_allreduce = False
+ # Nccl ranks in a node when use hierarchical allreduce, it's set to gpu cards' number in most cases.
+ hierarchical_allreduce_inter_nranks = 0
+
+ # if mode is collective
+ # supported modes: grad_allreduce, local_sgd
+ collective_mode = None
+
+ def __init__(self):
+ pass
+
+ @property
+ def runtime_split_send_recv(self):
+ return self.__runtime_split_send_recv
+
+ @runtime_split_send_recv.setter
+ def runtime_split_send_recv(self, value):
+ if value is None:
+ raise ValueError("runtime_split_send_recv can't be None")
+ if value and self.__sync_mode:
+ raise ValueError(
+ "if you want to set runtime_split_send_recv to be true, make ensure config.sync_mode is false at first"
+ )
+ self.__runtime_split_send_recv = value
+
+ @property
+ def sync_mode(self):
+ return self.__sync_mode
+
+ @sync_mode.setter
+ def sync_mode(self, value):
+ if value is None:
+ raise ValueError("sync_mode can't be None")
+ if value and self.__runtime_split_send_recv:
+ raise ValueError(
+ "if you want to set sync_mode to be true, make ensure config.runtime_split_send_recv is false at first"
+ )
+ self.__sync_mode = value
+
+
+class ServerRuntimeConfig(object):
+
+ def __init__(self):
+ self._rpc_send_thread_num = int(
+ os.getenv("FLAGS_rpc_send_thread_num", "12"))
+ self._rpc_get_thread_num = int(
+ os.getenv("FLAGS_rpc_get_thread_num", "12"))
+ self._rpc_prefetch_thread_num = int(
+ os.getenv("FLAGS_rpc_prefetch_thread_num", "12"))
+
+
+class DistributeTranspiler(object):
+ """
+ :api_attr: Static Graph
+
+ **DistributeTranspiler**
+
+ Convert the fluid program to distributed data-parallelism programs.
+ Supports two modes: parameter server(pserver) mode and nccl2 mode.
+
+ In pserver mode, the main_program will be transformed to use a remote
+ parameter server to do parameter optimization. And the optimization
+ graph will be put into a parameter server program.
+
+ In nccl2 mode, the transpiler will append a NCCL_ID broadcasting
+ op in startup_program to share the NCCL_ID across the job nodes.
+ After transpile_nccl2 called, you ***must*** pass trainer_id and
+ num_trainers argument to ParallelExecutor to enable NCCL2 distributed
+ mode.
+
+ Examples:
+ .. code-block:: python
+
+ x = fluid.data(name='x', shape=[13], dtype='float32')
+ y = fluid.data(name='y', shape=[1], dtype='float32')
+ y_predict = fluid.layers.fc(input=x, size=1, act=None)
+
+ cost = fluid.layers.square_error_cost(input=y_predict, label=y)
+ avg_loss = fluid.layers.mean(cost)
+
+ sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
+ sgd_optimizer.minimize(avg_loss)
+
+ # for pserver mode
+ pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ current_endpoint = "192.168.0.1:6174"
+ trainer_id = 0
+ trainers = 4
+ role = "PSERVER"
+ t = fluid.DistributeTranspiler()
+ t.transpile(
+ trainer_id, pservers=pserver_endpoints, trainers=trainers)
+ if role == "PSERVER":
+ pserver_program = t.get_pserver_program(current_endpoint)
+ pserver_startup_program = t.get_startup_program(current_endpoint,
+ pserver_program)
+ elif role == "TRAINER":
+ trainer_program = t.get_trainer_program()
+
+ # for nccl2 mode
+ trainer_num = 2
+ trainer_id = 0
+ config = fluid.DistributeTranspilerConfig()
+ config.mode = "nccl2"
+ trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ t = fluid.DistributeTranspiler(config=config)
+ t.transpile(trainer_id=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174")
+ exe = fluid.ParallelExecutor(
+ use_cuda=True,
+ loss_name=avg_loss.name,
+ num_trainers=trainer_num,
+ trainer_id=trainer_id
+ )
+ """
+
+ def __init__(self, config=None):
+ if config is not None:
+ self.config = config
+ else:
+ self.config = DistributeTranspilerConfig()
+ self._set_server_config()
+
+ if self.config.split_method is None:
+ self.config.split_method = RoundRobin
+
+ if self.config.sync_mode or self.config.completely_not_async:
+ self.distributed_mode = DistributedMode.SYNC
+ elif self.config.runtime_split_send_recv:
+ self.distributed_mode = DistributedMode.ASYNC
+ else:
+ self.distributed_mode = DistributedMode.HALF_ASYNC
+
+ global PRINT_LOG
+ if self.config.print_log:
+ PRINT_LOG = True
+ assert (self.config.min_block_size >= 8192)
+ assert (self.config.split_method.__bases__[0] == PSDispatcher)
+ self.counter_var = None
+
+ def _set_server_config(self, server_config=None):
+ if server_config is None:
+ self.server_config = ServerRuntimeConfig()
+ elif isinstance(server_config, ServerRuntimeConfig):
+ self.server_config = server_config
+ else:
+ raise TypeError(
+ "In DistributeTranspiler, server_config must be an instance of ServerRuntimeConfig"
+ )
+
+ def _transpile_nccl2(self,
+ trainer_id,
+ trainers,
+ current_endpoint,
+ startup_program=None,
+ wait_port=True):
+ if not startup_program:
+ startup_program = default_startup_program()
+ if trainer_id >= 0:
+ worker_endpoints = trainers.split(",")
+ # send NCCL_ID to others or recv from trainer 0
+ worker_endpoints.remove(current_endpoint)
+ if trainer_id == 0 and wait_port:
+ wait_server_ready(worker_endpoints)
+
+ nccl_id_var = startup_program.global_block().create_var(
+ name="NCCLID", persistable=True, type=core.VarDesc.VarType.RAW)
+
+ for i in range(1, self.config.nccl_comm_num):
+ startup_program.global_block().create_var(
+ name="NCCLID_{}".format(i),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+
+ if self.config.use_hierarchical_allreduce:
+ for i in range(0, self.config.nccl_comm_num):
+ startup_program.global_block().create_var(
+ name="Hierarchical_inter_NCCLID_{}".format(i),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+ startup_program.global_block().create_var(
+ name="Hierarchical_exter_NCCLID_{}".format(i),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+
+ startup_program.global_block().append_op(
+ type="gen_nccl_id",
+ inputs={},
+ outputs={"NCCLID": nccl_id_var},
+ attrs={
+ "trainers":
+ trainers.split(","),
+ "trainer_id":
+ trainer_id,
+ "nccl_comm_num":
+ self.config.nccl_comm_num,
+ "use_hierarchical_allreduce":
+ self.config.use_hierarchical_allreduce,
+ "hierarchical_allreduce_inter_nranks":
+ self.config.hierarchical_allreduce_inter_nranks
+ })
+ return nccl_id_var
+ else:
+ raise ValueError("must set trainer_id > 0")
+
+ def _transpile_collective(self,
+ collective_mode,
+ trainer_id,
+ trainers,
+ current_endpoint,
+ startup_program=None,
+ main_program=None,
+ wait_port=True):
+ if isinstance(trainers, str):
+ endpoints = trainers.split(",")
+ elif isinstance(trainers, list):
+ endpoints = trainers
+ elif collective_mode != "single_process_multi_thread":
+ raise ValueError('invalid trainers config: ' + str(trainers))
+
+ if len(endpoints
+ ) == 1 and collective_mode != "single_process_multi_thread":
+ raise ValueError('invalid trainer number in distributed: 1')
+
+ if startup_program is None:
+ startup_program = default_startup_program()
+
+ if main_program is None:
+ main_program = default_main_program()
+
+ transpiler = None
+ if collective_mode == 'grad_allreduce':
+ transpiler = collective.GradAllReduce(self.config.nccl_comm_num)
+ elif collective_mode == 'local_sgd':
+ transpiler = collective.LocalSGD(self.config.nccl_comm_num)
+ elif collective_mode == "single_process_multi_thread":
+ transpiler = collective.SingleProcessMultiThread()
+ else:
+ raise ValueError('invalid collective_mode: %s' % collective_mode)
+
+ transpiler.transpile(startup_program=startup_program,
+ main_program=main_program,
+ rank=trainer_id,
+ endpoints=endpoints,
+ current_endpoint=current_endpoint,
+ wait_port=wait_port)
+
+ def _get_all_remote_sparse_update_op(self, main_program):
+ sparse_update_ops = []
+ sparse_update_op_types = ["lookup_table", "nce", "lookup_table_v2"]
+ for op in main_program.global_block().ops:
+ if op.type in sparse_update_op_types and op.attr(
+ 'remote_prefetch') is True:
+ sparse_update_ops.append(op)
+ return sparse_update_ops
+
+ def _update_remote_sparse_update_op(self, program,
+ need_sparse_update_params):
+
+ for param_varname, attrs in need_sparse_update_params.items():
+ height_sections = self.sparse_param_to_height_sections[
+ param_varname]
+ endpoints = attrs[0]
+ table_names = attrs[1]
+
+ ops = []
+ op_type = ""
+ used_ops = []
+
+ for idx, op in enumerate(self.sparse_update_ops):
+ if param_varname in op.input_arg_names and op_type == "":
+ op_type = op.type
+ ops.append(op)
+ used_ops.append(idx)
+
+ elif param_varname in op.input_arg_names and op_type == op.type:
+ ops.append(op)
+ used_ops.append(idx)
+
+ if op_type in LOOKUP_TABLE_TYPE:
+ all_ops = program.global_block().ops
+ op_idxs = [all_ops.index(op) for op in ops]
+ inputs = [
+ program.global_block().vars[op.input("Ids")[0]]
+ for op in ops
+ ]
+ w = program.global_block().vars[ops[0].input("W")[0]]
+ padding_idx = ops[0].attr("padding_idx")
+ outputs = [
+ program.global_block().vars[op.output("Out")[0]]
+ for op in ops
+ ]
+
+ for idx in op_idxs[::-1]:
+ program.global_block()._remove_op(idx)
+
+ inputs_idxs = [-1] * len(inputs)
+ outputs_idxs = [-1] * len(outputs)
+
+ for idx, op in enumerate(program.global_block().ops):
+ for i in range(0, len(op.output_names)):
+ outs = op.output(op.output_names[i])
+ for in_id, in_var in enumerate(inputs):
+ if in_var.name in outs:
+ inputs_idxs[in_id] = idx
+ for i in range(0, len(op.input_names)):
+ ins = op.input(op.input_names[i])
+ for out_id, out_var in enumerate(outputs):
+ if out_var.name in ins:
+ outputs_idxs[out_id] = idx
+
+ if min(outputs_idxs) - max(inputs_idxs) >= 1:
+ distributed_idx = max(inputs_idxs) + 1
+
+ program.global_block()._insert_op(
+ index=distributed_idx,
+ type="distributed_lookup_table",
+ inputs={
+ "Ids": inputs,
+ 'W': w
+ },
+ outputs={"Outputs": outputs},
+ attrs={
+ "table_names": table_names,
+ "height_sections": height_sections,
+ "endpoints": endpoints,
+ "padding_idx": padding_idx,
+ "trainer_id": self.trainer_id,
+ "lookup_table_version": op_type
+ })
+ else:
+ raise ValueError(
+ "something wrong with distribute_transpiler, submit a issue is recommended"
+ )
+
+ for idx in used_ops[::-1]:
+ self.sparse_update_ops.pop(idx)
+
+ def _is_input_of_remote_sparse_update_op(self, param_name):
+ for op in self.sparse_update_ops:
+ if param_name in op.input_arg_names:
+ return True
+ return False
+
+ def transpile(self,
+ trainer_id,
+ program=None,
+ pservers="127.0.0.1:6174",
+ trainers=1,
+ sync_mode=True,
+ startup_program=None,
+ current_endpoint="127.0.0.1:6174"):
+ """
+ Transpile the input program to distributed programs with config and arguments.
+
+ Args:
+ trainer_id (int): id for current trainer worker, if you have
+ n workers, the id may range from 0 ~ n-1
+ program (Program|None): program to transpile,
+ default is fluid.default_main_program().
+ startup_program (Program|None): startup_program to transpile,
+ default is fluid.default_startup_program().
+ pservers (str): comma separated ip:port string for the pserver
+ list.
+ trainers (int|str): in pserver mode this is the number of
+ trainers, in nccl2 mode this is a string of trainer
+ endpoints.
+ sync_mode (bool): Do sync training or not, default is True.
+ startup_program (Program|None): startup_program to transpile,
+ default is fluid.default_main_program().
+ current_endpoint (str): need pass current endpoint when
+ transpile as nccl2 distributed mode. In pserver mode
+ this argument is not used.
+
+ Examples:
+ .. code-block:: python
+
+ transpiler = fluid.DistributeTranspiler()
+ t.transpile(
+ trainer_id=0,
+ pservers="127.0.0.1:7000,127.0.0.1:7001",
+ trainers=2,
+ sync_mode=False,
+ current_endpoint="127.0.0.1:7000")
+ """
+
+ err_msg = """
+
+API is deprecated since 2.0.0 Please use FleetAPI instead.
+WIKI: https://github.com/PaddlePaddle/Fleet/blob/develop/markdown_doc/transpiler
+
+ """
+ print(err_msg, file=sys.stderr)
+
+ if program is None:
+ program = default_main_program()
+ if startup_program is None:
+ startup_program = default_startup_program()
+ self.origin_program = program
+ self.startup_program = startup_program
+ self.origin_startup_program = self.startup_program.clone()
+
+ if self.config.mode == "nccl2":
+ assert (isinstance(trainers, str))
+ self.origin_program._trainers_endpoints = trainers.split(",")
+ self.origin_program._nccl_comm_num = self.config.nccl_comm_num
+ self.origin_program._use_hierarchical_allreduce = self.config.use_hierarchical_allreduce
+ # check use_hierarchical_allreduce options
+ if self.config.use_hierarchical_allreduce:
+ trainers_num = len(self.origin_program._trainers_endpoints)
+ # selected automaticly
+ if self.config.hierarchical_allreduce_inter_nranks <= 1:
+ self.config.hierarchical_allreduce_inter_nranks = core.get_cuda_device_count(
+ )
+
+ assert trainers_num > self.config.hierarchical_allreduce_inter_nranks, \
+ "trainers_num:{} < hierarchical_allreduce_inter_nranks:{}".format(
+ trainers_num, self.config.hierarchical_allreduce_inter_nranks)
+
+ assert trainers_num % self.config.hierarchical_allreduce_inter_nranks == 0, \
+ "trainers_num:{} mod hierarchical_allreduce_inter_nranks:{} != 0".format(
+ trainers_num, self.config.hierarchical_allreduce_inter_nranks)
+
+ self.origin_program._hierarchical_allreduce_inter_nranks = \
+ int(self.config.hierarchical_allreduce_inter_nranks)
+
+ self._transpile_nccl2(trainer_id,
+ trainers,
+ current_endpoint,
+ startup_program=startup_program,
+ wait_port=self.config.wait_port)
+ return
+
+ if self.config.mode == "collective":
+ self._transpile_collective(
+ collective_mode=self.config.collective_mode,
+ trainer_id=trainer_id,
+ trainers=trainers,
+ current_endpoint=current_endpoint,
+ startup_program=startup_program,
+ main_program=program,
+ wait_port=self.config.wait_port)
+ return
+
+ self.trainer_num = trainers
+ self.sync_mode = sync_mode
+ self.trainer_id = trainer_id
+ pserver_endpoints = pservers.split(",")
+ self.pserver_endpoints = pserver_endpoints
+ self.vars_overview = VarsDistributed()
+ self.optimize_ops, self.params_grads = self._get_optimize_pass()
+
+ ps_dispatcher = self.config.split_method(self.pserver_endpoints)
+ self.table_name = find_distributed_lookup_table(self.origin_program)
+ self.has_distributed_lookup_table = self.table_name != None
+ self.param_name_to_grad_name = dict()
+ self.grad_name_to_param_name = dict()
+ for param_var, grad_var in self.params_grads:
+ self.param_name_to_grad_name[param_var.name] = grad_var.name
+ self.grad_name_to_param_name[grad_var.name] = param_var.name
+
+ # get all sparse update ops
+ self.sparse_update_ops = self._get_all_remote_sparse_update_op(
+ self.origin_program)
+ # use_sparse_update_param_name -> split_height_section
+ self.sparse_param_to_height_sections = dict()
+ self.need_delete_optimize_vars = []
+
+ # add distributed attrs to program
+ self.origin_program._is_distributed = True
+ self.origin_program._endpoints = self.pserver_endpoints
+ self.origin_program._ps_endpoint = current_endpoint
+ self.origin_program._is_chief = self.trainer_id == 0
+ self.origin_program._distributed_lookup_table = self.table_name if self.table_name else None
+
+ # split and create vars, then put split vars in dicts for later use.
+ # step 1: split and create vars, then put split vars in dicts for later use.
+ self._init_splited_vars()
+
+ # step 2: insert send op to send gradient vars to parameter servers
+ ps_dispatcher.reset()
+ send_vars = []
+
+ # in general cases, the number of pservers is times of 2, and this
+ # will lead to uneven distribution among weights and bias:
+ # fc_w@GRAD_trainer_0, fc_w@GRAD_trainer_1 --> pserver1
+ # fc_b@GRAD_trainer_0, fc_b@GRAD_trainer_1 --> pserver2
+ # shuffle the map will avoid the uneven distribution above
+ grad_var_mapping_items = list(six.iteritems(self.grad_var_mapping))
+
+ if not self.config.slice_var_up:
+ np.random.seed(self.origin_program.random_seed)
+ np.random.shuffle(grad_var_mapping_items)
+
+ self.grad_name_to_send_dummy_out = dict()
+
+ for grad_varname, splited_vars in grad_var_mapping_items:
+ eplist = ps_dispatcher.dispatch(splited_vars)
+
+ if not self.config.slice_var_up:
+ assert (len(splited_vars) == 1)
+
+ splited_grad_varname = grad_varname
+ if len(splited_vars) == 1:
+ splited_grad_varname = splited_vars[0].name
+ index = find_op_by_output_arg(program.global_block(),
+ splited_grad_varname,
+ reverse=True)
+
+ elif len(splited_vars) > 1:
+ orig_var = program.global_block().vars[splited_grad_varname]
+ index = find_op_by_output_arg(program.global_block(),
+ splited_grad_varname,
+ reverse=True)
+
+ if not self.config.runtime_split_send_recv:
+ self._insert_split_op(program, orig_var, index,
+ splited_vars)
+ index += 1
+ else:
+ AssertionError(
+ "Can not insert the send op by original "
+ "variable name :", splited_grad_varname)
+
+ if splited_vars[0].type == core.VarDesc.VarType.SELECTED_ROWS:
+ sparse_param_name = self.grad_name_to_param_name[grad_varname]
+ if self._is_input_of_remote_sparse_update_op(sparse_param_name):
+ self.sparse_param_to_height_sections[sparse_param_name] = [
+ splited_var.shape[0] for splited_var in splited_vars
+ ]
+
+ dummy_output = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ self.grad_name_to_send_dummy_out[grad_varname] = dummy_output
+
+ if self.config.runtime_split_send_recv:
+ send_input_vars = [
+ program.global_block().vars[splited_grad_varname]
+ ]
+ sections = self._get_splited_var_sections(splited_vars)
+
+ if self.config.completely_not_async and self.trainer_num > 1:
+ send_varnames = [
+ "{}.trainer_{}".format(var.name, self.trainer_id)
+ for var in splited_vars
+ ]
+ else:
+ send_varnames = [var.name for var in splited_vars]
+ else:
+ send_input_vars = splited_vars
+ sections = []
+ send_varnames = []
+
+ # get send op_role_var, if not split, the grad should have .trainer suffix
+ # if split, grad should be the original grad var name (split_by_ref and send
+ # will be on the same place). ParallelExecutor
+ # will use op_role_var to get expected device place to run this op.
+ program.global_block()._insert_op(
+ index=index + 1,
+ type="send",
+ inputs={"X": send_input_vars},
+ outputs={"Out": dummy_output},
+ attrs={
+ "epmap":
+ eplist,
+ "sections":
+ sections,
+ "send_varnames":
+ send_varnames,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE,
+ OP_ROLE_VAR_ATTR_NAME: [
+ self.grad_name_to_param_name[grad_varname],
+ splited_grad_varname
+ ]
+ })
+ for _, var in enumerate(splited_vars):
+ send_vars.append(var)
+
+ send_barrier_out = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ if self.has_distributed_lookup_table:
+ self.grad_name_to_send_dummy_out[
+ self.table_name] = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ input_deps = list(self.grad_name_to_send_dummy_out.values())
+
+ if not self.sync_mode:
+ lr_ops = self._get_lr_ops()
+ if len(lr_ops) > 0 and self.counter_var:
+ decay_dummy_output = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ if self.config.runtime_split_send_recv:
+ # async mode, using communicator to merge and send
+ send_varnames = [self.counter_var.name]
+ else:
+ send_varnames = []
+ sections = []
+ program.global_block().append_op(
+ type="send",
+ inputs={"X": self.counter_var},
+ outputs={"Out": decay_dummy_output},
+ attrs={
+ "epmap":
+ pserver_endpoints,
+ "sections":
+ sections,
+ "send_varnames":
+ send_varnames,
+ "merge_add":
+ True,
+ "use_send_handler":
+ False,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE,
+ OP_ROLE_VAR_ATTR_NAME:
+ [self.counter_var.name, self.counter_var.name]
+ })
+ input_deps.append(decay_dummy_output)
+
+ if self.sync_mode:
+ fetch_barrier_input = []
+
+ program.global_block().append_op(type="send_barrier",
+ inputs={"X": list(input_deps)},
+ outputs={"Out": send_barrier_out},
+ attrs={
+ "endpoints":
+ pserver_endpoints,
+ "trainer_id":
+ self.trainer_id,
+ "half_async":
+ False,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ fetch_barrier_input.append(send_barrier_out)
+ else:
+ if self.config.runtime_split_send_recv and self.config.half_async:
+ program.global_block().append_op(
+ type="send_barrier",
+ inputs={"X": list(input_deps)},
+ outputs={"Out": send_barrier_out},
+ attrs={
+ "endpoints": pserver_endpoints,
+ "trainer_id": self.trainer_id,
+ "half_async": True,
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ # step 3: insert recv op to receive parameters from parameter server
+ recv_vars = []
+ for _, var in enumerate(send_vars):
+ recv_vars.append(self.grad_param_mapping[var])
+ ps_dispatcher.reset()
+ eplist = ps_dispatcher.dispatch(recv_vars)
+
+ for i, ep in enumerate(eplist):
+ self.param_grad_ep_mapping[ep]["params"].append(recv_vars[i])
+ self.param_grad_ep_mapping[ep]["grads"].append(send_vars[i])
+
+ distributed_var = self.vars_overview.get_distributed_var_by_slice(
+ recv_vars[i].name)
+ distributed_var.endpoint = ep
+
+ need_sparse_update_params = {}
+
+ # step4: Concat the parameters splits together after recv.
+ all_recv_outputs = []
+ for param_varname, splited_var in six.iteritems(self.param_var_mapping):
+ eps = []
+ table_names = []
+ for var in splited_var:
+ index = [v.name for v in recv_vars].index(var.name)
+ eps.append(eplist[index])
+ table_names.append(var.name)
+ if self.sync_mode:
+ recv_dep_in = send_barrier_out
+ else:
+ # connect deps to send op in async mode
+ recv_dep_in = self.grad_name_to_send_dummy_out[
+ self.param_name_to_grad_name[param_varname]]
+
+ # get recv op_role_var, if not split, the grad should have .trainer suffix
+ # if split, grad should be the original grad var name. ParallelExecutor
+ # will use op_role_var to get expected device place to run this op.
+ orig_grad_name = self.param_name_to_grad_name[param_varname]
+ recv_op_role_var_name = orig_grad_name
+ splited_trainer_grad = self.grad_var_mapping[orig_grad_name]
+ if len(splited_trainer_grad) == 1:
+ recv_op_role_var_name = splited_trainer_grad[0].name
+
+ if param_varname in self.sparse_param_to_height_sections:
+ for table_name in table_names:
+ distributed_var = self.vars_overview.get_distributed_var_by_slice(
+ table_name)
+ distributed_var.vtype = "RemotePrefetch"
+
+ need_sparse_update_params[param_varname] = (eps, table_names)
+ else:
+ recv_varnames = []
+ if self.config.runtime_split_send_recv:
+ orig_param = program.global_block().vars[param_varname]
+ recv_varnames = [var.name for var in splited_var]
+ splited_var = [orig_param]
+ all_recv_outputs.extend(splited_var)
+
+ program.global_block().append_op(
+ type="recv",
+ inputs={"X": [recv_dep_in]},
+ outputs={"Out": splited_var},
+ attrs={
+ "epmap":
+ eps,
+ "recv_varnames":
+ recv_varnames,
+ "trainer_id":
+ self.trainer_id,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE,
+ OP_ROLE_VAR_ATTR_NAME:
+ [param_varname, recv_op_role_var_name]
+ })
+
+ self._update_remote_sparse_update_op(program, need_sparse_update_params)
+
+ if self.sync_mode:
+ # form a WAW dependency
+ program.global_block().append_op(type="fetch_barrier",
+ inputs={"X": fetch_barrier_input},
+ outputs={"Out": all_recv_outputs},
+ attrs={
+ "endpoints":
+ pserver_endpoints,
+ "trainer_id":
+ self.trainer_id,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ for param_varname, splited_var in six.iteritems(self.param_var_mapping):
+ if len(splited_var) <= 1:
+ continue
+ orig_param = program.global_block().vars[param_varname]
+ if param_varname not in self.sparse_param_to_height_sections:
+ if not self.config.runtime_split_send_recv:
+ program.global_block().append_op(
+ type="concat",
+ inputs={"X": splited_var},
+ outputs={"Out": [orig_param]},
+ attrs={
+ "axis": 0,
+ RPC_OP_ROLE_ATTR_NAME: DIST_OP_ROLE_ATTR_VALUE
+ })
+
+ self._get_trainer_startup_program(recv_vars=recv_vars, eplist=eplist)
+
+ if self.has_distributed_lookup_table:
+ self._replace_lookup_table_op_with_prefetch(program,
+ pserver_endpoints)
+ self._split_table_grad_and_add_send_vars(program, pserver_endpoints)
+
+ self._get_distributed_optimizer_vars()
+ self.origin_program._parameters_on_pservers = self.vars_overview
+
+ def _get_sparse_table_names(self):
+ sparse_update_op_types = ["lookup_table", "nce"]
+
+ sparse_table_names = []
+ for op in self.origin_program.global_block().ops:
+ if op.type in sparse_update_op_types and op.attr(
+ 'is_sparse') is True:
+ sparse_table_names.append(op.input("W")[0])
+ if op.type == "distributed_lookup_table":
+ sparse_table_names.append(op.input("W")[0])
+
+ if self.has_distributed_lookup_table:
+ sparse_table_names.append(self.table_name)
+
+ return list(set(sparse_table_names))
+
+ def _fake_init_sparsetable(self, sparse_table_names):
+ # delete table init op
+ for table_name in sparse_table_names:
+ table_var = self.startup_program.global_block().vars[table_name]
+ table_param_init_op = []
+ for op in self.startup_program.global_block().ops:
+ if table_name in op.output_arg_names:
+ table_param_init_op.append(op)
+ init_op_num = len(table_param_init_op)
+ if init_op_num != 1:
+ raise ValueError("table init op num should be 1, now is " +
+ str(init_op_num))
+ table_init_op = table_param_init_op[0]
+ self.startup_program.global_block().append_op(
+ type="fake_init",
+ inputs={},
+ outputs={"Out": table_var},
+ attrs={"shape": table_init_op.attr('shape')})
+ delete_ops(self.startup_program.global_block(), table_param_init_op)
+
+ def _delete_trainer_optimizer(self, is_startup):
+ optimize_vars = []
+ optimize_op_role_vars = []
+ optimize_need_delete_vars = []
+
+ for op in self.optimize_ops:
+ optimize_vars.extend(op.input_arg_names)
+ optimize_op_role_vars.extend(op.attr("op_role_var"))
+
+ optimize_vars = list(set(optimize_vars))
+ optimize_op_role_vars = list(set(optimize_op_role_vars))
+
+ for var in optimize_vars:
+ if var not in optimize_op_role_vars:
+ optimize_need_delete_vars.append(var)
+ need_delete_optimize_vars = list(set(optimize_need_delete_vars))
+
+ if is_startup:
+ init_ops = []
+ for var in need_delete_optimize_vars:
+ param_init_op = []
+ for op in self.startup_program.global_block().ops:
+ if var in op.output_arg_names:
+ param_init_op.append(op)
+ init_ops.extend(param_init_op)
+ delete_ops(self.startup_program.global_block(), init_ops)
+
+ for var in need_delete_optimize_vars:
+ if self.startup_program.global_block().has_var(var):
+ self.startup_program.global_block()._remove_var(var)
+ else:
+ delete_ops(self.origin_program.global_block(), self.optimize_ops)
+ for var in need_delete_optimize_vars:
+ if self.origin_program.global_block().has_var(var):
+ self.origin_program.global_block()._remove_var(var)
+
+ def get_trainer_program(self, wait_port=True):
+ """
+ Get transpiled trainer side program. The program on trainer side compared with origin program
+ has following difference:
+
+ - Delete optimizer related op, because parameter updated on Pserver
+ - After the op which computed gradient of each parameter, add ``Send_op`` and ``Recv_op``
+
+ Args:
+ wait_port(bool): Whether to wait for the parameter server to be ready before returning to program,
+ default is True
+
+ Returns:
+ Program: trainer side program.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ #this is an example, find available endpoints in your case
+ pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ trainer_id = 0
+ trainers = 4
+ t = fluid.DistributeTranspiler()
+ t.transpile(trainer_id, trainers=trainers, pservers=pserver_endpoints)
+ trainer_program = t.get_trainer_program()
+ """
+ # remove optimize ops and add a send op to main_program
+ # FIXME(typhoonzero): Also ops like clip_gradient, lrn_decay?
+
+ self._delete_trainer_optimizer(is_startup=True)
+ sparse_table_names = self._get_sparse_table_names()
+ self._fake_init_sparsetable(sparse_table_names)
+
+ lr_ops = self._get_lr_ops()
+ delete_ops(self.origin_program.global_block(), lr_ops)
+ self._delete_trainer_optimizer(is_startup=False)
+
+ self.origin_program.__str__()
+ self.startup_program.__str__()
+
+ if wait_port:
+ wait_server_ready(self.pserver_endpoints)
+
+ return self.origin_program
+
+ def _get_trainer_startup_program(self, recv_vars, eplist):
+ """
+ Get transpiled trainer side startup program.
+
+ Args:
+ recv_vars (list): Variable list to recv for current trainer_id
+ eplist (list): A list of strings indicating
+
+ Returns:
+ Program: trainer side startup program.
+ """
+ startup_program = self.startup_program
+
+ # FIXME(gongwb): delete not need ops.
+ # note that: some parameter is not trainable and those ops can't be deleted.
+ sparse_table_names = self._get_sparse_table_names()
+
+ # self._fake_init_sparsetable(sparse_table_names)
+ # self._delete_trainer_optimizer(is_startup=True)
+
+ for varname, splited_var in six.iteritems(self.param_var_mapping):
+ if varname in sparse_table_names:
+ continue
+ # Get the eplist of recv vars
+ eps = []
+ for var in splited_var:
+ index = [v.name for v in recv_vars].index(var.name)
+ eps.append(eplist[index])
+
+ for var in splited_var:
+ if startup_program.global_block().has_var(var.name):
+ continue
+
+ startup_program.global_block().create_var(
+ name=var.name,
+ persistable=False,
+ type=var.type,
+ dtype=var.dtype,
+ shape=var.shape,
+ lod_level=var.lod_level)
+
+ op = startup_program.global_block().append_op(
+ type="recv",
+ inputs={"X": []},
+ outputs={"Out": splited_var},
+ attrs={
+ "epmap": eps,
+ "trainer_id": self.trainer_id,
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ fetch_barrier_out = startup_program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ startup_program.global_block().append_op(
+ type="fetch_barrier",
+ inputs={},
+ outputs={"Out": fetch_barrier_out},
+ attrs={
+ "endpoints": self.pserver_endpoints,
+ "trainer_id": self.trainer_id,
+ RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ for varname, splited_var in six.iteritems(self.param_var_mapping):
+ if varname in sparse_table_names:
+ continue
+ # add concat ops to merge split parameters received from parameter servers.
+ if len(splited_var) <= 1:
+ continue
+ # NOTE: if enable memory optimization, origin vars maybe removed.
+ if varname in startup_program.global_block().vars:
+ orig_param = startup_program.global_block().vars[varname]
+ else:
+ origin_param_var = self.origin_program.global_block(
+ ).vars[varname]
+ orig_param = startup_program.global_block().create_var(
+ name=varname,
+ persistable=origin_param_var.persistable,
+ type=origin_param_var.type,
+ dtype=origin_param_var.dtype,
+ shape=origin_param_var.shape)
+ startup_program.global_block().append_op(
+ type="concat",
+ inputs={"X": splited_var},
+ outputs={"Out": [orig_param]},
+ attrs={"axis": 0})
+
+ return startup_program
+
+ def get_pserver_program(self, endpoint):
+ """
+ Get parameter server side program.The program on pserver side compared with origin program
+ has following difference:
+
+ - Only the following op is included: optimize-related op and communication-related op
+ - NO.0 block only has variable definitions and ``listen_and_serv_op``
+ - Every variable which need to be updated has a unique block
+
+ Args:
+ endpoint (str): current parameter server endpoint.
+
+ Returns:
+ Program: the program for current parameter server to run.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ #this is an example, find available endpoints in your case
+ pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ current_endpoint = "192.168.0.1:6174"
+ trainer_id = 0
+ trainers = 4
+ t = fluid.DistributeTranspiler()
+ t.transpile(
+ trainer_id, pservers=pserver_endpoints, trainers=trainers)
+ pserver_program = t.get_pserver_program(current_endpoint)
+ """
+ # TODO(panyx0718): Revisit this assumption. what if #blocks > #pservers.
+ # NOTE: assume blocks of the same variable is not distributed
+ # on the same pserver, only change param/grad varnames for
+ # trainers to fetch.
+ sys.stderr.write(
+ "get_pserver_program() is deprecated, call get_pserver_programs() to get pserver main and startup in a single call.\n"
+ )
+ # step1
+ pserver_program = Program()
+ pserver_program.random_seed = self.origin_program.random_seed
+ pserver_program._copy_dist_param_info_from(self.origin_program)
+
+ # step2: Create vars to receive vars at parameter servers.
+ recv_inputs = []
+ for v in self.param_grad_ep_mapping[endpoint]["params"]:
+ self._clone_var(pserver_program.global_block(), v)
+ for v in self.param_grad_ep_mapping[endpoint]["grads"]:
+ # create vars for each trainer in global scope, so
+ # we don't need to create them when grad arrives.
+ # change client side var name to origin name by
+ # removing ".trainer_%d" suffix
+ suff_idx = v.name.find(".trainer_")
+ if suff_idx >= 0:
+ orig_var_name = v.name[:suff_idx]
+ else:
+ orig_var_name = v.name
+ # NOTE: single_trainer_var must be created for multi-trainer
+ # case to merge grads from multiple trainers
+ single_trainer_var = \
+ pserver_program.global_block().create_var(
+ name=orig_var_name,
+ persistable=True,
+ type=v.type,
+ dtype=v.dtype,
+ shape=v.shape)
+ if self.sync_mode or self.config.completely_not_async and self.trainer_num > 1:
+ for trainer_id in range(self.trainer_num):
+ var = pserver_program.global_block().create_var(
+ name="%s.trainer_%d" % (orig_var_name, trainer_id),
+ persistable=False,
+ type=v.type,
+ dtype=v.dtype,
+ shape=v.shape)
+ recv_inputs.append(var)
+ else:
+ recv_inputs.append(single_trainer_var)
+
+ # step 3
+ # Create a union-find data structure from optimize ops,
+ # If two ops are connected, we could add these two ops
+ # into one set.
+ ufind = self._create_ufind(self.optimize_ops)
+ # step 3.2
+ # Iterate through the ops and append optimize op which
+ # located on current pserver
+ opt_op_on_pserver = []
+ for _, op in enumerate(self.optimize_ops):
+ if self._is_optimizer_op(op) and self._is_opt_op_on_pserver(
+ endpoint, op):
+ opt_op_on_pserver.append(op)
+ # step 3.3
+ # prepare if dc asgd is enabled
+ if self.config.enable_dc_asgd == True:
+ assert (self.sync_mode == False)
+ self.param_bak_list = []
+ # add param_bak for each trainer
+ for p in self.param_grad_ep_mapping[endpoint]["params"]:
+ # each parameter should have w_bak for each trainer id
+ for i in range(self.trainer_num):
+ param_bak_name = "%s.trainer_%d_bak" % (p.name, i)
+ tmpvar = pserver_program.global_block().create_var(
+ # NOTE: this var name format is used in `request_get_handler`
+ name=param_bak_name,
+ type=p.type,
+ shape=p.shape,
+ dtype=p.dtype)
+ self.param_bak_list.append((p, tmpvar))
+
+ # step 3.4
+ # Iterate through the ops, and if an op and the optimize ops
+ # which located on current pserver are in one set, then
+ # append it into the sub program.
+
+ global_ops = []
+
+ # sparse grad name to param name
+ sparse_grad_to_param = []
+
+ def __append_optimize_op__(op, block, grad_to_block_id, merged_var,
+ lr_ops):
+ if self._is_optimizer_op(op):
+ self._append_pserver_ops(block, op, endpoint, grad_to_block_id,
+ self.origin_program, merged_var,
+ sparse_grad_to_param)
+ elif op not in lr_ops:
+ self._append_pserver_non_opt_ops(block, op)
+
+ def __clone_lr_op_sub_block__(op, program, lr_block):
+ if not op.has_attr('sub_block'):
+ return
+
+ origin_block_desc = op.attr('sub_block')
+ origin_block = self.origin_program.block(origin_block_desc.id)
+ assert isinstance(origin_block, Block)
+ # we put the new sub block to new block to follow the block
+ # hierarchy of the original blocks
+ new_sub_block = program._create_block(lr_block.idx)
+
+ # clone vars
+ for var in origin_block.vars:
+ new_sub_block._clone_variable(var)
+
+ # clone ops
+ for origin_op in origin_block.ops:
+ cloned_op = self._clone_lr_op(program, new_sub_block, origin_op)
+ # clone sub_block of op
+ __clone_lr_op_sub_block__(cloned_op, program, new_sub_block)
+
+ # reset the block of op
+ op._set_attr('sub_block', new_sub_block)
+
+ # append lr decay ops to the child block if exists
+ lr_ops = self._get_lr_ops()
+ # record optimize blocks and we can run them on pserver parallel
+ optimize_blocks = []
+
+ lr_decay_block_id = -1
+ if len(lr_ops) > 0:
+ lr_decay_block = pserver_program._create_block(
+ pserver_program.num_blocks - 1)
+ optimize_blocks.append(lr_decay_block)
+ for _, op in enumerate(lr_ops):
+ cloned_op = self._append_pserver_non_opt_ops(lr_decay_block, op)
+ # append sub blocks to pserver_program in lr_decay_op
+ __clone_lr_op_sub_block__(cloned_op, pserver_program,
+ lr_decay_block)
+ lr_decay_block_id = lr_decay_block.idx
+
+ # append op to the current block
+ grad_to_block_id = []
+ pre_block_idx = pserver_program.num_blocks - 1
+ for idx, opt_op in enumerate(opt_op_on_pserver):
+ per_opt_block = pserver_program._create_block(pre_block_idx)
+ optimize_blocks.append(per_opt_block)
+ optimize_target_param_name = opt_op.attr(OP_ROLE_VAR_ATTR_NAME)[0]
+ # append grad merging ops before clip and weight decay
+ # e.g. merge grad -> L2Decay op -> clip op -> optimize
+ merged_var = None
+ for _, op in enumerate(self.optimize_ops):
+ # find the origin grad var before clipping/L2Decay,
+ # merged_var should be the input var name of L2Decay
+ grad_varname_for_block = op.attr(OP_ROLE_VAR_ATTR_NAME)[1]
+ if op.attr(
+ OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name:
+ merged_var = self._append_pserver_grad_merge_ops(
+ per_opt_block, grad_varname_for_block, endpoint,
+ grad_to_block_id, self.origin_program)
+ if merged_var:
+ break # append optimize op once then append other ops.
+ if merged_var:
+ for _, op in enumerate(self.optimize_ops):
+ # optimizer is connected to itself
+ if op.attr(OP_ROLE_VAR_ATTR_NAME)[0] == optimize_target_param_name and \
+ op not in global_ops:
+ log("append opt op: ", op.type, op.input_arg_names,
+ merged_var)
+ __append_optimize_op__(op, per_opt_block,
+ grad_to_block_id, merged_var,
+ lr_ops)
+
+ # dedup grad to ids list
+ grad_to_block_id = list(set(grad_to_block_id))
+ # append global ops
+ if global_ops:
+ opt_state_block = pserver_program._create_block(
+ pserver_program.num_blocks - 1)
+ optimize_blocks.append(opt_state_block)
+ for glb_op in global_ops:
+ __append_optimize_op__(glb_op, opt_state_block,
+ grad_to_block_id, None, lr_ops)
+
+ # process distributed lookup_table
+ prefetch_var_name_to_block_id = []
+ if self.has_distributed_lookup_table:
+ pserver_index = self.pserver_endpoints.index(endpoint)
+ table_opt_block = self._create_table_optimize_block(
+ pserver_index, pserver_program, pre_block_idx, grad_to_block_id)
+ optimize_blocks.append(table_opt_block)
+ lookup_table_var_name_to_block_id = self._create_prefetch_block(
+ pserver_index, pserver_program, table_opt_block)
+ checkpoint_block_id = self._create_checkpoint_save_block(
+ pserver_program, table_opt_block.idx)
+
+ pserver_program._distributed_lookup_table = self.table_name
+ prefetch_var_name_to_block_id.extend(
+ lookup_table_var_name_to_block_id)
+
+ if len(optimize_blocks) == 0:
+ logging.warn("pserver [" + str(endpoint) +
+ "] has no optimize block!!")
+ pre_block_idx = pserver_program.num_blocks - 1
+ empty_block = pserver_program._create_block(pre_block_idx)
+ optimize_blocks.append(empty_block)
+
+ # In some case, some parameter server will have no parameter to optimize
+ # So we give an empty optimize block to parameter server.
+ attrs = {
+ "optimize_blocks": optimize_blocks,
+ "endpoint": endpoint,
+ "pserver_id": self.pserver_endpoints.index(endpoint),
+ "Fanin": self.trainer_num,
+ "distributed_mode": self.distributed_mode,
+ "grad_to_block_id": grad_to_block_id,
+ "sparse_grad_to_param": sparse_grad_to_param,
+ "lr_decay_block_id": lr_decay_block_id,
+ "rpc_get_thread_num": self.server_config._rpc_get_thread_num,
+ "rpc_send_thread_num": self.server_config._rpc_send_thread_num,
+ "rpc_prefetch_thread_num":
+ self.server_config._rpc_prefetch_thread_num
+ }
+
+ if self.has_distributed_lookup_table:
+ attrs['checkpint_block_id'] = checkpoint_block_id
+ if self.config.enable_dc_asgd:
+ attrs['dc_asgd'] = True
+
+ if len(prefetch_var_name_to_block_id) > 0:
+ attrs[
+ 'prefetch_var_name_to_block_id'] = prefetch_var_name_to_block_id
+
+ # step5 append the listen_and_serv op
+ pserver_program.global_block().append_op(type="listen_and_serv",
+ inputs={'X': recv_inputs},
+ outputs={},
+ attrs=attrs)
+
+ pserver_program._sync_with_cpp()
+ # save pserver program to generate pserver side startup relatively.
+ self.pserver_program = pserver_program
+ return pserver_program
+
+ def get_pserver_programs(self, endpoint):
+ """
+ Get pserver side main program and startup program for distributed training.
+ The ``main_program`` returned by this function is consistent with the
+ return value of the function ``get_pserver_program`` .
+
+ Args:
+ endpoint (str): current pserver endpoint.
+
+ Returns:
+ tuple: (main_program, startup_program), of type "Program"
+
+ Examples:
+ .. code-block:: python
+
+ import paddle.fluid as fluid
+ #this is an example, find available endpoints in your case
+ pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ current_endpoint = "192.168.0.1:6174"
+ trainer_id = 0
+ trainers = 4
+ t = fluid.DistributeTranspiler()
+ t.transpile(
+ trainer_id, pservers=pserver_endpoints, trainers=trainers)
+ pserver_program, pserver_startup_program = t.get_pserver_programs(current_endpoint)
+ """
+ pserver_prog = self.get_pserver_program(endpoint)
+ pserver_startup = self.get_startup_program(endpoint,
+ pserver_program=pserver_prog)
+ return pserver_prog, pserver_startup
+
+ def get_startup_program(self,
+ endpoint,
+ pserver_program=None,
+ startup_program=None):
+ """
+ **Deprecated**
+
+ Get startup program for current parameter server.
+ Modify operator input variables if there are variables that
+ were split to several blocks.
+
+ Args:
+ endpoint (str): current pserver endpoint.
+ pserver_program (Program): deprecated, call get_pserver_program first.
+ startup_program (Program): deprecated, should pass startup_program
+ when initializing
+
+ Returns:
+ Program: parameter server side startup program.
+
+ Examples:
+ .. code-block:: python
+
+ pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
+ current_endpoint = "192.168.0.1:6174"
+ trainer_id = 0
+ trainers = 4
+
+ t = fluid.DistributeTranspiler()
+ t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers)
+ pserver_program = t.get_pserver_program(current_endpoint)
+ pserver_startup_program = t.get_startup_program(current_endpoint,
+ pserver_program)
+ """
+ s_prog = Program()
+ orig_s_prog = self.startup_program
+ s_prog.random_seed = orig_s_prog.random_seed
+ params = self.param_grad_ep_mapping[endpoint]["params"]
+
+ def _get_splited_name_and_shape(varname):
+ for idx, splited_param in enumerate(params):
+ pname = splited_param.name
+ if same_or_split_var(pname, varname) and varname != pname:
+ return pname, splited_param.shape
+ return "", []
+
+ # 1. create vars in pserver program to startup program
+ pserver_vars = pserver_program.global_block().vars
+ created_var_map = collections.OrderedDict()
+ for _, var in six.iteritems(pserver_vars):
+ tmpvar = s_prog.global_block()._clone_variable(var)
+ created_var_map[var.name] = tmpvar
+
+ # 2. rename op outputs
+ for op in orig_s_prog.global_block().ops:
+ new_outputs = collections.OrderedDict()
+ # do not append startup op if var is not on this pserver
+ op_on_pserver = False
+ # TODO(gongwb): remove this line.
+ if op.type not in ["recv", "fetch_barrier", "concat"]:
+ for key in op.output_names:
+ newname, _ = _get_splited_name_and_shape(op.output(key)[0])
+ if newname:
+ op_on_pserver = True
+ new_outputs[key] = created_var_map[newname]
+ elif op.output(key)[0] in pserver_vars:
+ op_on_pserver = True
+ new_outputs[key] = pserver_vars[op.output(key)[0]]
+
+ if op_on_pserver:
+ # most startup program ops have no inputs
+ new_inputs = self._get_input_map_from_op(pserver_vars, op)
+
+ if op.type in [
+ "gaussian_random", "fill_constant", "uniform_random",
+ "truncated_gaussian_random"
+ ]:
+ op._set_attr("shape", list(new_outputs["Out"].shape))
+ s_prog.global_block().append_op(type=op.type,
+ inputs=new_inputs,
+ outputs=new_outputs,
+ attrs=op.all_attrs())
+ if self.config.enable_dc_asgd:
+ for p, p_bak in self.param_bak_list:
+ startup_param_var = s_prog.global_block().vars[p.name]
+ startup_tmpvar = s_prog.global_block().vars[p_bak.name]
+ # copy init random value to param_bak
+ s_prog.global_block().append_op(type="assign",
+ inputs={"X": startup_param_var},
+ outputs={"Out": startup_tmpvar})
+
+ return s_prog
+
+ # ====================== private transpiler functions =====================
+ def _get_slice_var_info(self, slice_var):
+ block_suffix = "block"
+ block_idx = 0
+ offset = 0
+ is_slice = False
+
+ orig_var_name, block_name, _ = self._get_varname_parts(slice_var.name)
+
+ if not block_name:
+ return is_slice, block_idx, offset
+
+ block_idx = int(block_name.split(block_suffix)[1])
+ skip_dim0 = 0
+ slice_vars = self.param_var_mapping[orig_var_name]
+
+ orig_dim1_flatten = 1
+
+ if len(slice_vars[0].shape) >= 2:
+ orig_dim1_flatten = reduce(lambda x, y: x * y,
+ slice_vars[0].shape[1:])
+
+ for slice_var in slice_vars[:block_idx]:
+ skip_dim0 += slice_var.shape[0]
+
+ offset = skip_dim0 * orig_dim1_flatten
+ is_slice = True
+ return is_slice, block_idx, offset
+
+ def _get_distributed_optimizer_vars(self):
+
+ def _get_distributed_optimizer_var(endpoint):
+ opt_op_on_pserver = []
+ for _, op in enumerate(self.optimize_ops):
+ if self._is_optimizer_op(op) and self._is_opt_op_on_pserver(
+ endpoint, op):
+ opt_op_on_pserver.append(op)
+
+ for opt_op in opt_op_on_pserver:
+ dist_var = None
+ for key in opt_op.input_names:
+ if key == "Param":
+ param_name = opt_op.input(key)[0]
+ dist_var = self.vars_overview.get_distributed_var_by_origin_and_ep(
+ param_name, endpoint)
+ break
+ for key in opt_op.input_names:
+ if key in [
+ "Param", "Grad", "LearningRate", "Beta1Tensor",
+ "Beta2Tensor"
+ ]:
+ continue
+ origin_var = self.origin_program.global_block().vars[
+ opt_op.input(key)[0]]
+ # update accumulator variable shape
+ new_shape = self._get_optimizer_input_shape(
+ opt_op.type, key, origin_var.shape,
+ dist_var.slice.shape)
+
+ if new_shape == dist_var.slice.shape:
+ splited_var = VarStruct(
+ name=origin_var.name,
+ shape=new_shape,
+ dtype=origin_var.dtype,
+ type=origin_var.type,
+ lod_level=origin_var.lod_level,
+ persistable=origin_var.persistable)
+
+ self.vars_overview.add_distributed_var(
+ origin_var=origin_var,
+ slice_var=splited_var,
+ is_slice=dist_var.is_slice,
+ block_id=dist_var.block_id,
+ offset=dist_var.offset,
+ vtype="Optimizer",
+ endpoint=endpoint)
+ else:
+ self.vars_overview.add_distributed_var(
+ origin_var=origin_var,
+ slice_var=origin_var,
+ is_slice=False,
+ block_id=0,
+ offset=0,
+ vtype="Optimizer",
+ endpoint=endpoint)
+
+ for ep in self.pserver_endpoints:
+ _get_distributed_optimizer_var(ep)
+
+ def _update_dist_lookup_table_vars(self, param_list, grad_list,
+ params_grads):
+ # TODO(wuyi): put find a way to put dist lookup table stuff all together.
+ # update self.table_param_grad and self.trainer_side_table_grad_list
+ program = self.origin_program
+ if self.has_distributed_lookup_table:
+ param_list = [
+ param for param in param_list if param.name != self.table_name
+ ]
+ grad_list = [
+ grad for grad in grad_list
+ if grad.name != grad_var_name(self.table_name)
+ ]
+ self.table_param_grad = [
+ param_grad for param_grad in params_grads
+ if param_grad[0].name == self.table_name
+ ][0]
+ table_grad_var = self.table_param_grad[1]
+ if self.sync_mode:
+ self.trainer_side_table_grad_list = [
+ program.global_block().create_var(
+ name="%s.trainer_%d.pserver_%d" %
+ (table_grad_var.name, self.trainer_id, index),
+ type=table_grad_var.type,
+ shape=table_grad_var.shape,
+ dtype=table_grad_var.dtype)
+ for index in range(len(self.pserver_endpoints))
+ ]
+ else:
+ self.trainer_side_table_grad_list = [
+ program.global_block().create_var(
+ name="%s.pserver_%d" % (table_grad_var.name, index),
+ type=table_grad_var.type,
+ shape=table_grad_var.shape,
+ dtype=table_grad_var.dtype)
+ for index in range(len(self.pserver_endpoints))
+ ]
+ return param_list, grad_list
+
+ def _init_splited_vars(self):
+ # update these mappings for further transpile:
+ # 1. param_var_mapping: param var name -> [split params vars]
+ # 2. grad_var_mapping: grad var name -> [split grads vars]
+ # 3. grad_param_mapping: grad.blockx -> param.blockx
+ # 4. param_grad_ep_mapping: ep -> {"params": [], "grads": []}
+
+ param_list = []
+ grad_list = []
+ param_grad_set = set()
+ for p, g in self.params_grads:
+ # skip parameter marked not trainable
+ if type(p) == Parameter and p.trainable == False:
+ continue
+ if p.name not in param_grad_set:
+ param_list.append(p)
+ param_grad_set.add(p.name)
+ if g.name not in param_grad_set:
+ grad_list.append(g)
+ param_grad_set.add(g.name)
+
+ param_list, grad_list = self._update_dist_lookup_table_vars(
+ param_list, grad_list, self.params_grads)
+
+ if self.config.slice_var_up:
+ # when we slice var up into blocks, we will slice the var according to
+ # pserver services' count. A pserver may have two or more listening ports.
+ grad_blocks = slice_variable(grad_list, len(self.pserver_endpoints),
+ self.config.min_block_size)
+ param_blocks = slice_variable(param_list,
+ len(self.pserver_endpoints),
+ self.config.min_block_size)
+ else:
+ # when we do NOT slice var up into blocks, we will always slice params
+ # grads into one block.
+ grad_blocks = slice_variable(grad_list, 1,
+ self.config.min_block_size)
+ param_blocks = slice_variable(param_list, 1,
+ self.config.min_block_size)
+ assert (len(grad_blocks) == len(param_blocks))
+
+ # origin_param_name -> [splited_param_vars]
+ self.param_var_mapping = self._create_vars_from_blocklist(
+ self.origin_program, param_blocks)
+
+ for orig_name, splited_vars in self.param_var_mapping.items():
+ orig_var = self.origin_program.global_block().var(orig_name)
+
+ for splited_var in splited_vars:
+ is_slice, block_id, offset = self._get_slice_var_info(
+ splited_var)
+
+ self.vars_overview.add_distributed_var(origin_var=orig_var,
+ slice_var=splited_var,
+ block_id=block_id,
+ offset=offset,
+ is_slice=is_slice,
+ vtype="Param")
+
+ # origin_grad_name -> [splited_grad_vars]
+ self.grad_var_mapping = self._create_vars_from_blocklist(
+ self.origin_program,
+ grad_blocks,
+ add_trainer_suffix=self.trainer_num > 1)
+ # dict(grad_splited_var -> param_splited_var)
+ self.grad_param_mapping = collections.OrderedDict()
+ for g, p in zip(grad_blocks, param_blocks):
+ g_name, g_bid, _ = g.split(":")
+ p_name, p_bid, _ = p.split(":")
+ self.grad_param_mapping[self.grad_var_mapping[g_name][int(g_bid)]] = \
+ self.param_var_mapping[p_name][int(p_bid)]
+
+ # create mapping of endpoint -> split var to create pserver side program
+ self.param_grad_ep_mapping = collections.OrderedDict()
+ [
+ self.param_grad_ep_mapping.update({ep: {
+ "params": [],
+ "grads": []
+ }}) for ep in self.pserver_endpoints
+ ]
+
+ # transpiler function for dis lookup_table
+ def _replace_lookup_table_op_with_prefetch(self, program,
+ pserver_endpoints):
+ # 1. replace lookup_table_op with split_ids_op -> prefetch_op -> sum_op
+ self.all_in_ids_vars = []
+ self.all_prefetch_input_vars = []
+ self.all_prefetch_output_vars = []
+ self.all_out_emb_vars = []
+ lookup_table_op_index = -1
+
+ continue_search_lookup_table_op = True
+ while continue_search_lookup_table_op:
+ continue_search_lookup_table_op = False
+ all_ops = program.global_block().ops
+ for op in all_ops:
+ if op.type == LOOKUP_TABLE_TYPE and self.table_name == op.input(
+ "W")[0]:
+ if not op.attr('is_distributed'):
+ raise RuntimeError(
+ "lookup_table_op that lookup an distributed embedding table"
+ "should set is_distributed to true")
+ continue_search_lookup_table_op = True
+
+ lookup_table_op_index = lookup_table_op_index if lookup_table_op_index != -1 else list(
+ all_ops).index(op)
+ ids_name = op.input("Ids")
+ out_name = op.output("Out")
+
+ ids_var = program.global_block().vars[ids_name[0]]
+ self.all_in_ids_vars.append(ids_var)
+
+ out_var = program.global_block().vars[out_name[0]]
+ self.all_out_emb_vars.append(out_var)
+
+ # delete lookup_table_op
+ delete_ops(program.global_block(), [op])
+ # break for loop
+ break
+
+ for index in range(len(self.pserver_endpoints)):
+ in_var = program.global_block().create_var(
+ name=str("prefetch_compress_in_tmp_" + str(index)),
+ type=self.all_in_ids_vars[0].type,
+ shape=self.all_in_ids_vars[0].shape,
+ dtype=self.all_in_ids_vars[0].dtype)
+ self.all_prefetch_input_vars.append(in_var)
+
+ out_var = program.global_block().create_var(
+ name=str("prefetch_compress_out_tmp_" + str(index)),
+ type=self.all_out_emb_vars[0].type,
+ shape=self.all_out_emb_vars[0].shape,
+ dtype=self.all_out_emb_vars[0].dtype)
+ self.all_prefetch_output_vars.append(out_var)
+
+ # insert split_ids_op
+ program.global_block()._insert_op(
+ index=lookup_table_op_index,
+ type="split_ids",
+ inputs={'Ids': self.all_in_ids_vars},
+ outputs={"Out": self.all_prefetch_input_vars})
+
+ # insert prefetch_op
+ program.global_block()._insert_op(
+ index=lookup_table_op_index + 1,
+ type="prefetch",
+ inputs={'X': self.all_prefetch_input_vars},
+ outputs={"Out": self.all_prefetch_output_vars},
+ attrs={
+ "epmap": pserver_endpoints,
+ # FIXME(qiao) temporarily disable this config because prefetch
+ # is not act as other rpc op, it's more like a forward op
+ # RPC_OP_ROLE_ATTR_NAME: RPC_OP_ROLE_ATTR_VALUE
+ })
+
+ # insert concat_op
+ program.global_block()._insert_op(
+ index=lookup_table_op_index + 2,
+ type="merge_ids",
+ inputs={
+ 'Ids': self.all_in_ids_vars,
+ 'Rows': self.all_prefetch_input_vars,
+ 'X': self.all_prefetch_output_vars
+ },
+ outputs={"Out": self.all_out_emb_vars})
+
+ def _split_table_grad_and_add_send_vars(self, program, pserver_endpoints):
+ # 2. add split_ids_op and send_op to send gradient to pservers
+
+ # there should only be one table_name
+ all_ops = program.global_block().ops
+ table_grad_name = grad_var_name(self.table_name)
+ for op in all_ops:
+ if table_grad_name in op.output_arg_names:
+ op_index = list(all_ops).index(op)
+ # insert split_ids_op
+ program.global_block()._insert_op(
+ index=op_index + 1,
+ type="split_ids",
+ inputs={
+ 'Ids': [program.global_block().vars[table_grad_name]]
+ },
+ outputs={"Out": self.trainer_side_table_grad_list},
+ attrs={RPC_OP_ROLE_ATTR_NAME: DIST_OP_ROLE_ATTR_VALUE})
+ program.global_block()._insert_op(
+ index=op_index + 2,
+ type="send",
+ inputs={'X': self.trainer_side_table_grad_list},
+ outputs={
+ 'Out':
+ [self.grad_name_to_send_dummy_out[self.table_name]]
+ if self.sync_mode else []
+ },
+ attrs={
+ "epmap":
+ pserver_endpoints,
+ "trainer_id":
+ self.trainer_id,
+ RPC_OP_ROLE_ATTR_NAME:
+ RPC_OP_ROLE_ATTR_VALUE,
+ OP_ROLE_VAR_ATTR_NAME: [
+ self.grad_name_to_param_name[table_grad_name],
+ table_grad_name
+ ]
+ })
+ break
+
+ def _create_prefetch_block(self, pserver_index, pserver_program,
+ optimize_block):
+ # STEP: create prefetch block
+ table_var = pserver_program.global_block().vars[self.table_name]
+ prefetch_var_name_to_block_id = []
+ prefetch_block = pserver_program._create_block(optimize_block.idx)
+ trainer_ids = self.all_prefetch_input_vars[pserver_index]
+ pserver_ids = pserver_program.global_block().create_var(
+ name=trainer_ids.name,
+ type=trainer_ids.type,
+ shape=trainer_ids.shape,
+ dtype=trainer_ids.dtype)
+ trainer_out = self.all_prefetch_output_vars[pserver_index]
+ pserver_out = pserver_program.global_block().create_var(
+ name=trainer_out.name,
+ type=trainer_out.type,
+ shape=trainer_out.shape,
+ dtype=trainer_out.dtype)
+ prefetch_block.append_op(
+ type="lookup_sparse_table",
+ inputs={
+ 'Ids': pserver_ids,
+ "W": table_var
+ },
+ outputs={"Out": pserver_out},
+ attrs={
+ "is_sparse": True, # has no effect on lookup_table op
+ "is_distributed": True,
+ "padding_idx": -1
+ })
+ prefetch_var_name_to_block_id.append(trainer_ids.name + ":" +
+ str(prefetch_block.idx))
+ return prefetch_var_name_to_block_id
+
+ def _create_table_optimize_block(self, pserver_index, pserver_program,
+ pre_block_idx, grad_to_block_id):
+ # STEP: create table optimize block
+ table_opt_block = pserver_program._create_block(pre_block_idx)
+ # create table param and grad var in pserver program
+ # create table optimize block in pserver program
+ table_opt_op = [
+ op for op in self.optimize_ops if 'Param' in op.input_names
+ and op.input("Param")[0] == self.table_name
+ ][0]
+
+ origin_param_var = self.origin_program.global_block().vars[
+ self.table_name]
+
+ zero_dim = int(
+ math.ceil(origin_param_var.shape[0] /
+ float(len(self.pserver_endpoints))))
+ table_shape = list(origin_param_var.shape)
+ table_shape[0] = zero_dim
+
+ param_var = pserver_program.global_block().create_var(
+ name=origin_param_var.name,
+ shape=table_shape,
+ dtype=origin_param_var.dtype,
+ type=core.VarDesc.VarType.SELECTED_ROWS,
+ persistable=True)
+
+ # parameter must be selected rows
+ param_var.desc.set_type(core.VarDesc.VarType.SELECTED_ROWS)
+ grad_var = pserver_program.global_block()._clone_variable(
+ self.origin_program.global_block().vars[grad_var_name(
+ self.table_name)])
+
+ lr_var = pserver_program.global_block()._clone_variable(
+ self.origin_program.global_block().vars[table_opt_op.input(
+ "LearningRate")[0]])
+
+ if self.sync_mode:
+ # create grad vars in pserver program
+ table_grad_var = self.table_param_grad[1]
+ pserver_side_table_grad_list = [
+ pserver_program.global_block().create_var(
+ name="%s.trainer_%d.pserver_%d" %
+ (table_grad_var.name, index, pserver_index),
+ type=table_grad_var.type,
+ shape=table_grad_var.shape,
+ dtype=table_grad_var.dtype)
+ for index in range(self.trainer_num)
+ ]
+
+ # append sum op for pserver_side_table_grad_list
+ table_opt_block.append_op(
+ type="sum",
+ inputs={"X": pserver_side_table_grad_list},
+ outputs={"Out": [grad_var]},
+ attrs={"use_mkldnn": False})
+ else:
+ # in async_mode, for table gradient, it also need to be split to each parameter server
+ origin_grad_name = grad_var.name
+ splited_grad_name = self.trainer_side_table_grad_list[
+ pserver_index].name
+ if not splited_grad_name.startswith(origin_grad_name):
+ raise ValueError("origin_grad_var: " + splited_grad_name +
+ " grad_var:" + grad_var.name)
+ grad_var = pserver_program.global_block()._rename_var(
+ origin_grad_name, splited_grad_name)
+
+ inputs = {
+ "Param": [param_var],
+ "Grad": [grad_var],
+ "LearningRate": [lr_var]
+ }
+ outputs = {"ParamOut": [param_var]}
+ # only support sgd now
+ logging.warn(
+ "distribute lookup table only support sgd optimizer, change it's optimizer to sgd instead of "
+ + table_opt_op.type)
+ table_opt_block.append_op(type="sgd", inputs=inputs, outputs=outputs)
+
+ # add table parameter gradient and it's block id to grad_to_block_id
+ grad_to_block_id.append(grad_var.name + ":" + str(table_opt_block.idx))
+
+ return table_opt_block
+
+ def _create_checkpoint_save_block(self, pserver_program, pre_block_idx):
+ """
+ create a new block to handle save checkpoint.
+ """
+
+ pserver_program.global_block().create_var(name="kLookupTablePath",
+ persistable=True,
+ type=core.VarDesc.VarType.RAW)
+
+ checkpoint_save_block = pserver_program._create_block(pre_block_idx)
+ # this 'file_path' do not be used in save lookup table variable
+ checkpoint_save_block.append_op(type='save',
+ inputs={'X': [self.table_name]},
+ outputs={},
+ attrs={'file_path': "none"})
+
+ return checkpoint_save_block.idx
+
+ def _create_vars_from_blocklist(self,
+ program,
+ block_list,
+ add_trainer_suffix=False):
+ """
+ Create vars for each split.
+ NOTE: only grads need to be named for different trainers, use
+ add_trainer_suffix to rename the grad vars.
+ Args:
+ program (ProgramDesc): ProgramDesc which gradients blong.
+ block_list (list[(varname, block_id, block_size)]): List of gradient blocks.
+ add_trainer_suffix (Bool): Add trainer suffix to new variable's name if set True.
+ Returns:
+ var_mapping (collections.OrderedDict(varname->[new_varname_variable])):A dict mapping
+ from original var name to each var split.
+ """
+
+ # varname->[(block_id, current_block_size)]
+ block_map = collections.OrderedDict()
+
+ var_mapping = collections.OrderedDict()
+ for block_str in block_list:
+ varname, offset, size = block_str.split(":")
+ if varname not in block_map:
+ block_map[varname] = []
+ block_map[varname].append((int(offset), int(size)))
+
+ for varname, split in six.iteritems(block_map):
+ orig_var = program.global_block().var(varname)
+ if len(split) == 1:
+ if self.sync_mode and add_trainer_suffix:
+ new_var_name = "%s.trainer_%d" % \
+ (orig_var.name, self.trainer_id)
+ program.global_block()._rename_var(varname, new_var_name)
+ var_mapping[varname] = \
+ [program.global_block().var(new_var_name)]
+ else:
+ var_mapping[varname] = \
+ [program.global_block().var(orig_var.name)]
+ continue
+ var_mapping[varname] = []
+ orig_shape = orig_var.shape
+ orig_dim1_flatten = 1
+ if len(orig_shape) >= 2:
+ orig_dim1_flatten = reduce(lambda x, y: x * y, orig_shape[1:])
+
+ for i, block in enumerate(split):
+ size = block[1]
+ rows = size // orig_dim1_flatten
+ splited_shape = [rows]
+ if len(orig_shape) >= 2:
+ splited_shape.extend(orig_shape[1:])
+ new_var_name = ""
+ if self.sync_mode and add_trainer_suffix:
+ new_var_name = "%s.block%d.trainer_%d" % \
+ (varname, i, self.trainer_id)
+ else:
+ new_var_name = "%s.block%d" % \
+ (varname, i)
+ var = program.global_block().create_var(
+ name=new_var_name,
+ persistable=False,
+ dtype=orig_var.dtype,
+ type=orig_var.type,
+ shape=splited_shape) # flattend split var
+ var_mapping[varname].append(var)
+ program.global_block()._sync_with_cpp()
+ return var_mapping
+
+ def _clone_var(self, block, var, persistable=True):
+ return block.create_var(name=var.name,
+ shape=var.shape,
+ dtype=var.dtype,
+ type=var.type,
+ lod_level=var.lod_level,
+ persistable=persistable)
+
+ @staticmethod
+ def _get_splited_var_sections(splited_vars):
+ height_sections = []
+ for v in splited_vars:
+ height_sections.append(v.shape[0])
+ return height_sections
+
+ def _insert_split_op(self, program, orig_var, index, splited_vars):
+ height_sections = self._get_splited_var_sections(splited_vars)
+
+ if orig_var.type == core.VarDesc.VarType.SELECTED_ROWS:
+ sparse_param_name = self.grad_name_to_param_name[orig_var.name]
+ if self._is_input_of_remote_sparse_update_op(sparse_param_name):
+ self.sparse_param_to_height_sections[
+ sparse_param_name] = height_sections
+ program.global_block()._insert_op(index=index + 1,
+ type="split_selected_rows",
+ inputs={"X": orig_var},
+ outputs={"Out": splited_vars},
+ attrs={
+ "height_sections":
+ height_sections,
+ RPC_OP_ROLE_ATTR_NAME:
+ DIST_OP_ROLE_ATTR_VALUE
+ })
+ elif orig_var.type == core.VarDesc.VarType.LOD_TENSOR:
+ program.global_block()._insert_op(index=index + 1,
+ type="split_byref",
+ inputs={"X": orig_var},
+ outputs={"Out": splited_vars},
+ attrs={
+ "sections":
+ height_sections,
+ RPC_OP_ROLE_ATTR_NAME:
+ DIST_OP_ROLE_ATTR_VALUE
+ })
+ else:
+ AssertionError("Variable type should be in set "
+ "[LOD_TENSOR, SELECTED_ROWS]")
+
+ def _get_optimizer_input_shape(self, op_type, varkey, orig_shape,
+ param_shape):
+ """
+ Returns the shape for optimizer inputs that need to be reshaped when
+ Param and Grad is split to multiple servers.
+ """
+ # HACK(typhoonzero): Should use functions of corresponding optimizer in
+ # optimizer.py to get the shape, do not bind this in the transpiler.
+ if op_type == "adam":
+ if varkey in ["Moment1", "Moment2"]:
+ return param_shape
+ elif op_type == "adagrad":
+ if varkey == "Moment":
+ return param_shape
+ elif op_type == "adamax":
+ if varkey in ["Moment", "InfNorm"]:
+ return param_shape
+ elif op_type in ["momentum", "lars_momentum"]:
+ if varkey == "Velocity":
+ return param_shape
+ elif op_type == "rmsprop":
+ if varkey in ["Moment", "MeanSquare"]:
+ return param_shape
+ elif op_type == "decayed_adagrad":
+ if varkey == "Moment":
+ return param_shape
+ elif op_type == "ftrl":
+ if varkey in ["SquaredAccumulator", "LinearAccumulator"]:
+ return param_shape
+ elif op_type == "sgd":
+ pass
+ else:
+ raise ValueError(
+ "Not supported optimizer for distributed training: %s" %
+ op_type)
+ return orig_shape
+
+ def _get_varname_parts(self, varname):
+ # returns origin, blockid, trainerid
+ orig_var_name = ""
+ trainer_part = ""
+ block_part = ""
+ trainer_idx = varname.find(".trainer_")
+ if trainer_idx >= 0:
+ trainer_part = varname[trainer_idx + 1:]
+ else:
+ trainer_idx = len(varname)
+ block_index = varname.find(".block")
+ if block_index >= 0:
+ block_part = varname[block_index + 1:trainer_idx]
+ else:
+ block_index = len(varname)
+ orig_var_name = varname[0:min(block_index, trainer_idx)]
+ return orig_var_name, block_part, trainer_part
+
+ def _orig_varname(self, varname):
+ orig, _, _ = self._get_varname_parts(varname)
+ return orig
+
+ def _append_pserver_grad_merge_ops(self, optimize_block,
+ grad_varname_for_block, endpoint,
+ grad_to_block_id, origin_program):
+ program = optimize_block.program
+ pserver_block = program.global_block()
+ grad_block = None
+ for g in self.param_grad_ep_mapping[endpoint]["grads"]:
+ if self._orig_varname(g.name) == \
+ self._orig_varname(grad_varname_for_block):
+ grad_block = g
+ break
+ if not grad_block:
+ # do not append this op if current endpoint
+ # is not dealing with this grad block
+ return None
+ orig_varname, block_name, trainer_name = self._get_varname_parts(
+ grad_block.name)
+ if block_name:
+ merged_var_name = '.'.join([orig_varname, block_name])
+ else:
+ merged_var_name = orig_varname
+
+ merged_var = pserver_block.vars[merged_var_name]
+ grad_to_block_id.append(merged_var.name + ":" + str(optimize_block.idx))
+ if self.sync_mode or self.config.completely_not_async and self.trainer_num > 1:
+ vars2merge = []
+ for i in range(self.trainer_num):
+ per_trainer_name = "%s.trainer_%d" % \
+ (merged_var_name, i)
+ vars2merge.append(pserver_block.vars[per_trainer_name])
+ optimize_block.append_op(type="sum",
+ inputs={"X": vars2merge},
+ outputs={"Out": merged_var},
+ attrs={"use_mkldnn": False})
+ optimize_block.append_op(
+ type="scale",
+ inputs={"X": merged_var},
+ outputs={"Out": merged_var},
+ attrs={"scale": 1.0 / float(self.trainer_num)})
+ return merged_var
+
+ def _append_dc_asgd_ops(self, block, param_var, grad_var):
+ # NOTE: can not use grammar candy here, should put ops in specific block
+ local_param_bak = block.create_var(name="%s.local_bak" % param_var.name,
+ shape=param_var.shape,
+ type=param_var.type,
+ dtype=param_var.dtype,
+ persistable=False)
+ # trainer_id_var is block local
+ trainer_id_var = block.create_var(name="@TRAINER_ID@",
+ type=core.VarDesc.VarType.LOD_TENSOR,
+ dtype=core.VarDesc.VarType.INT64,
+ shape=[1],
+ persistable=False)
+
+ # ref_inputs = [x[1] for x in self.param_bak_list]
+ ref_inputs = []
+ for p, p_bak in self.param_bak_list:
+ if p.name == param_var.name:
+ ref_inputs.append(p_bak)
+ block.append_op(type="ref_by_trainer_id",
+ inputs={
+ "X": ref_inputs,
+ "TrainerId": trainer_id_var
+ },
+ outputs={"Out": local_param_bak})
+
+ def __create_temp_var__():
+ return block.create_var(name=unique_name.generate("tmp_dc_output"),
+ shape=param_var.shape,
+ type=param_var.type,
+ dtype=param_var.dtype,
+ persistable=False)
+
+ o1 = __create_temp_var__()
+ block.append_op(type="elementwise_sub",
+ inputs={
+ "X": param_var,
+ "Y": local_param_bak
+ },
+ outputs={"Out": o1})
+ o2 = __create_temp_var__()
+ block.append_op(type="elementwise_mul",
+ inputs={
+ "X": o1,
+ "Y": grad_var
+ },
+ outputs={"Out": o2})
+ o3 = __create_temp_var__()
+ block.append_op(type="elementwise_mul",
+ inputs={
+ "X": o2,
+ "Y": grad_var
+ },
+ outputs={"Out": o3})
+ # TODO(typhoonzero): append scale
+ o4 = __create_temp_var__()
+ block.append_op(type="elementwise_add",
+ inputs={
+ "X": grad_var,
+ "Y": o3
+ },
+ outputs={"Out": o4})
+ return o4
+
+ def _append_pserver_ops(self, optimize_block, opt_op, endpoint,
+ grad_to_block_id, origin_program, merged_var,
+ sparse_grad_to_param):
+ program = optimize_block.program
+ pserver_block = program.global_block()
+ new_inputs = collections.OrderedDict()
+
+ def _get_param_block(opt_op):
+ # param is already created on global program
+ param_block = None
+ for p in self.param_grad_ep_mapping[endpoint]["params"]:
+ if same_or_split_var(p.name, opt_op.input("Param")[0]):
+ param_block = p
+ break
+ return param_block
+
+ if self.config.enable_dc_asgd:
+ param_var = _get_param_block(opt_op)
+ dc = self._append_dc_asgd_ops(optimize_block, param_var, merged_var)
+
+ for key in opt_op.input_names:
+ if key == "Grad":
+ if self.config.enable_dc_asgd:
+ new_inputs[key] = dc
+ else:
+ # Note!! This is for l2decay on sparse gradient, because it will create a new tensor for
+ # decayed gradient but not inplace modify the origin one
+ origin_grad_name = opt_op.input(key)[0]
+ if core.kNewGradSuffix(
+ ) in origin_grad_name and pserver_block.has_var(
+ origin_grad_name):
+ new_grad = pserver_block.var(origin_grad_name)
+ new_inputs[key] = new_grad
+ else:
+ new_inputs[key] = merged_var
+ elif key == "Param":
+ param_block = _get_param_block(opt_op)
+ if not param_block:
+ return
+ tmpvar = pserver_block.create_var(name=param_block.name,
+ persistable=True,
+ dtype=param_block.dtype,
+ shape=param_block.shape)
+ new_inputs[key] = tmpvar
+ elif key == "LearningRate":
+ # learning rate variable has already be created by non-optimize op,
+ # don't create it once again.
+ lr_varname = opt_op.input(key)[0]
+ if lr_varname in pserver_block.vars:
+ new_inputs[key] = pserver_block.vars[opt_op.input(key)[0]]
+ else:
+ origin_var = origin_program.global_block().vars[lr_varname]
+ tmpvar = pserver_block.create_var(
+ name=origin_var.name,
+ persistable=origin_var.persistable,
+ dtype=origin_var.dtype,
+ shape=origin_var.shape)
+ new_inputs[key] = tmpvar
+
+ for key in opt_op.input_names:
+ new_shape = None
+ if key in [
+ "Param", "Grad", "LearningRate", "Beta1Tensor",
+ "Beta2Tensor"
+ ]:
+ continue
+ var = self.origin_program.global_block().vars[opt_op.input(key)[0]]
+ param_var = new_inputs["Param"]
+ # update accumulator variable shape
+ new_shape = self._get_optimizer_input_shape(opt_op.type, key,
+ var.shape,
+ param_var.shape)
+ tmpvar = pserver_block.create_var(name=var.name,
+ persistable=var.persistable,
+ dtype=var.dtype,
+ shape=new_shape)
+ new_inputs[key] = tmpvar
+
+ # change output's ParamOut variable
+ outputs = self._get_output_map_from_op(
+ self.origin_program.global_block().vars, opt_op)
+ outputs["ParamOut"] = new_inputs["Param"]
+ optimize_block.append_op(type=opt_op.type,
+ inputs=new_inputs,
+ outputs=outputs,
+ attrs=opt_op.all_attrs())
+
+ # record sparse grad to param name
+ if new_inputs["Grad"].type == core.VarDesc.VarType.SELECTED_ROWS:
+ sparse_grad_to_param.append(
+ str(new_inputs["Grad"].name) + ":" +
+ str(new_inputs["Param"].name))
+
+ def _get_pserver_grad_param_var(self, var, var_dict):
+ """
+ Return pserver side grad/param variable, return None
+ if the variable is not grad/param, e.g.
+
+ a@GRAD -> a@GRAD.block0
+ a@GRAD -> a@GRAD (a is not split)
+ fc_0.w_0 -> fc_0.w_0.block_0
+ fc_0.w_0 -> fc_0.w_0 (weight is not split)
+ _generated_var_123 -> None
+ """
+ grad_block = None
+ for _, g in six.iteritems(var_dict):
+ if self._orig_varname(g.name) == self._orig_varname(var.name):
+ # skip per trainer vars
+ if g.name.find(".trainer_") == -1:
+ # only param or grads have split blocks
+ if self._orig_varname(g.name) in self.grad_name_to_param_name or \
+ self._orig_varname(g.name) in self.param_name_to_grad_name:
+ grad_block = g
+ break
+ return grad_block
+
+ def _clone_lr_op(self, program, block, op):
+ inputs = self._get_input_map_from_op(
+ self.origin_program.global_block().vars, op)
+ for key, varlist in six.iteritems(inputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for var in varlist:
+ if var not in program.global_block().vars:
+ block._clone_variable(var)
+
+ outputs = self._get_output_map_from_op(
+ self.origin_program.global_block().vars, op)
+ for key, varlist in six.iteritems(outputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for var in varlist:
+ if var not in program.global_block().vars:
+ block._clone_variable(var)
+
+ return block.append_op(type=op.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=op.all_attrs())
+
+ def _append_pserver_non_opt_ops(self, optimize_block, opt_op):
+ program = optimize_block.program
+ # Append the ops for parameters that do not need to be optimized/updated
+ inputs = self._get_input_map_from_op(
+ self.origin_program.global_block().vars, opt_op)
+ for key, varlist in six.iteritems(inputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for i in range(len(varlist)):
+ var = varlist[i]
+ # for ops like clipping and weight decay, get the split var (xxx.block0)
+ # for inputs/outputs
+ grad_block = self._get_pserver_grad_param_var(
+ var,
+ program.global_block().vars)
+ if grad_block:
+ varlist[i] = grad_block
+ elif var.name not in program.global_block().vars:
+ tmpvar = program.global_block()._clone_variable(var)
+ varlist[i] = tmpvar
+ else:
+ varlist[i] = program.global_block().vars[var.name]
+ inputs[key] = varlist
+
+ outputs = self._get_output_map_from_op(
+ self.origin_program.global_block().vars, opt_op)
+ for key, varlist in six.iteritems(outputs):
+ if not isinstance(varlist, list):
+ varlist = [varlist]
+ for i in range(len(varlist)):
+ var = varlist[i]
+ grad_block = self._get_pserver_grad_param_var(
+ var,
+ program.global_block().vars)
+ if grad_block:
+ varlist[i] = grad_block
+ elif var.name not in program.global_block().vars:
+ tmpvar = program.global_block()._clone_variable(var)
+ varlist[i] = tmpvar
+ else:
+ varlist[i] = program.global_block().vars[var.name]
+ outputs[key] = varlist
+
+ return optimize_block.append_op(type=opt_op.type,
+ inputs=inputs,
+ outputs=outputs,
+ attrs=opt_op.all_attrs())
+
+ def _is_op_connected(self, op1, op2):
+ # If one op's input is another op's output or
+ # one op's output is another op's input, we say
+ # the two operator is connected.
+ if set(op1.desc.output_arg_names()) & set(op2.desc.input_arg_names()) or \
+ set(op1.desc.input_arg_names()) & set(op2.desc.output_arg_names()):
+ return True
+ return False
+
+ def _create_ufind(self, optimize_ops):
+ # Create a unit find data struct by optimize ops
+ ufind = UnionFind(optimize_ops)
+ for i in range(len(optimize_ops)):
+ for j in range(i, len(optimize_ops)):
+ op1 = optimize_ops[i]
+ op2 = optimize_ops[j]
+ if self._is_op_connected(op1, op2):
+ ufind.union(op1, op2)
+ return ufind
+
+ def _is_optimizer_op(self, op):
+ if "Param" in op.input_names and \
+ "LearningRate" in op.input_names:
+ return True
+ return False
+
+ def _is_opt_op_on_pserver(self, endpoint, op):
+ param_names = [
+ p.name for p in self.param_grad_ep_mapping[endpoint]["params"]
+ ]
+ if op.input("Param")[0] in param_names:
+ return True
+ else:
+ for n in param_names:
+ param = op.input("Param")[0]
+ if same_or_split_var(n, param) and n != param:
+ return True
+ return False
+
+ def _get_input_map_from_op(self, varmap, op):
+ """Returns a dict from op input name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.input_names:
+ vars = []
+ for varname in op.input(key):
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+ def _get_output_map_from_op(self, varmap, op):
+ """Returns a dict from op output name to the vars in varmap."""
+ iomap = collections.OrderedDict()
+ for key in op.output_names:
+ vars = []
+ for varname in op.output(key):
+ vars.append(varmap[varname])
+ if len(vars) == 1:
+ iomap[key] = vars[0]
+ else:
+ iomap[key] = vars
+ return iomap
+
+ def _get_lr_ops(self):
+ lr_ops = []
+ block = self.origin_program.global_block()
+ for index, op in enumerate(block.ops):
+ role_id = int(op.attr(RPC_OP_ROLE_ATTR_NAME))
+ if role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) or \
+ role_id == int(LR_SCHED_OP_ROLE_ATTR_VALUE) | \
+ int(OPT_OP_ROLE_ATTR_VALUE):
+ if self.sync_mode == False and op.type == 'increment':
+ inputs = self._get_input_map_from_op(
+ self.origin_program.global_block().vars, op)
+ outputs = self._get_output_map_from_op(
+ self.origin_program.global_block().vars, op)
+ for key in outputs:
+ counter_var = outputs[key]
+ all_trainer_counter_inputs = [
+ self.origin_program.global_block().create_var(
+ name="%s.trainer_%d" % (counter_var.name, id_),
+ type=counter_var.type,
+ shape=counter_var.shape,
+ dtype=counter_var.dtype,
+ persistable=counter_var.persistable)
+ for id_ in range(self.trainer_num)
+ ]
+ for i, op in enumerate(
+ self.startup_program.global_block().ops):
+ if op.type == 'fill_constant':
+ for key in op.output_names:
+ if len(op.output(key)) == 1 and op.output(
+ key)[0] == counter_var.name:
+ self.startup_program.global_block(
+ ).ops[i]._set_attr(
+ 'value', float(0.0 - self.trainer_num))
+ for var in all_trainer_counter_inputs:
+ if var.name == "%s.trainer_%d" % (counter_var.name,
+ self.trainer_id):
+ self.counter_var = var
+ self.startup_program.global_block().create_var(
+ name=var.name,
+ type=var.type,
+ dtype=var.dtype,
+ shape=var.shape,
+ persistable=var.persistable,
+ initializer=initializer.Constant(1))
+ op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName(
+ )
+ block._remove_op(index)
+ op = block._insert_op(
+ index,
+ type='sum',
+ inputs={'X': all_trainer_counter_inputs},
+ outputs=outputs,
+ attrs={op_role_attr_name: LR_SCHED_OP_ROLE_ATTR_VALUE})
+ lr_ops.append(op)
+ log("append lr op: ", op.type)
+ return lr_ops
+
+ def _get_lr_ops_deprecated(self):
+ lr_ops = []
+ # find learning rate variables by optimize op
+ lr_vars = set()
+ for op in self.optimize_ops:
+ if self._is_optimizer_op(op):
+ lr_vars.add(op.input("LearningRate")[0])
+
+ find_ops = []
+ # find ops which output is lr var
+ block = self.origin_program.global_block()
+ for op in block.ops:
+ if set(op.output_arg_names) & lr_vars:
+ find_ops.append(op)
+ # make a union find struct by the ops in default_main_program
+ ufind = UnionFind(block.ops)
+
+ for op1 in block.ops:
+ for op2 in block.ops:
+ # NOTE: we need to skip all optimize ops, since it is connected
+ # with forward/backward ops and lr ops, we only need the lr ops.
+ if op1 != op2 and self._is_op_connected(op1, op2) and \
+ not self._is_optimizer_op(op1) and not self._is_optimizer_op(op2):
+ ufind.union(op1, op2)
+ # find all ops which is related with lr var
+ for op1 in block.ops:
+ for op2 in find_ops:
+ if ufind.is_connected(op1, op2):
+ lr_ops.append(op1)
+ # we only need to append op for once
+ break
+ return lr_ops
+
+ def _is_opt_role_op(self, op):
+ # NOTE: depend on oprole to find out whether this op is for
+ # optimize
+ op_maker = core.op_proto_and_checker_maker
+ optimize_role = core.op_proto_and_checker_maker.OpRole.Optimize
+ if op_maker.kOpRoleAttrName() in op.attr_names and \
+ int(op.all_attrs()[op_maker.kOpRoleAttrName()]) == int(optimize_role):
+ return True
+ return False
+
+ def _get_optimize_pass(self):
+ """
+ Get optimizer operators, parameters and gradients from origin_program
+ Returns:
+ opt_ops (list): optimize operators.
+ params_grads (dict): parameter->gradient.
+ """
+ block = self.origin_program.global_block()
+ opt_ops = []
+ params_grads = []
+ # tmp set to dedup
+ optimize_params = set()
+ origin_var_dict = self.origin_program.global_block().vars
+ for op in block.ops:
+ if self._is_opt_role_op(op):
+ # Todo(chengmo): Whether clip related op belongs to Optimize guard should be discussed
+ # delete clip op from opt_ops when run in Parameter Server mode
+ if OP_NAME_SCOPE in op.all_attrs(
+ ) and CLIP_OP_NAME_SCOPE in op.attr(
+ OP_NAME_SCOPE
+ ) and self.config.mode != "nccl2" and self.config.mode != "collective":
+ op._set_attr(
+ "op_role",
+ int(core.op_proto_and_checker_maker.OpRole.Backward))
+ continue
+ opt_ops.append(op)
+ if op.attr(OP_ROLE_VAR_ATTR_NAME):
+ param_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[0]
+ grad_name = op.attr(OP_ROLE_VAR_ATTR_NAME)[1]
+ if not param_name in optimize_params:
+ optimize_params.add(param_name)
+ log("adding param_grad pair: ", param_name, grad_name)
+ params_grads.append([
+ origin_var_dict[param_name],
+ origin_var_dict[grad_name]
+ ])
+ else:
+ pass
+
+ # designed for special situation
+ special_distribute_update_vars = self._get_distribute_update_vars()
+ if special_distribute_update_vars:
+ params_grads = params_grads + special_distribute_update_vars
+
+ return opt_ops, params_grads
+
+ def _get_distribute_update_vars(self):
+ # TODO(chengmo): find more powerful and simple way to deal with these special situation
+ """
+ This Function is used for a special model, like PyramidDnn which has pyramid hash op.
+ Some Parameters don't use optimizing op to update its value, but updated in its BP process.
+ In these cases, Transpilse can't find these special vars by optimizing op information.
+ So we add this function and add attr "distribute_update_vars" to tell transpiler these Parameter
+ need to be updated in distribute training.
+ We assume these special var send and receive the same var_name.
+ """
+ block = self.origin_program.global_block()
+ origin_var_dict = self.origin_program.global_block().vars
+ params = []
+ for op in block.ops:
+ special_attr = "distribute_update_vars"
+ if special_attr in op.all_attrs():
+ if op.attr(special_attr):
+ for param_name in op.attr(special_attr).split(","):
+ params.append(origin_var_dict[param_name])
+ unique_params = list(set(params))
+ params_grads = []
+ for var in unique_params:
+ params_grads.append([var, var])
+ return params_grads
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/geo_sgd_transpiler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/geo_sgd_transpiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb86ffd36a2d49be92407dab913a028e8a47ec9a
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/geo_sgd_transpiler.py
@@ -0,0 +1,355 @@
+# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+"""
+Steps to transpile trainer:
+1. split variable to multiple blocks, aligned by product(dim[1:]) (width).
+2. create delta variable in global scope which used to send
+3. add send op to send sparse ids to communicator
+
+Steps to transpile pserver:
+1. create new program for parameter server.
+2. create params variables that assigned to current server instance.
+3. create a sub-block in the server side program
+4. append sum ops that should run on current server instance.
+5. add listen_and_serv op
+"""
+import sys
+import collections
+import six
+import numpy as np
+
+from .ps_dispatcher import RoundRobin, PSDispatcher
+from .. import core, framework
+from ..framework import Program, default_main_program, \
+ default_startup_program, Block, Parameter
+from .details import wait_server_ready, VarsDistributed
+from .details import delete_ops
+from ..distribute_lookup_table import find_distributed_lookup_table
+from .distribute_transpiler import DistributeTranspiler, DistributeTranspilerConfig, slice_variable, same_or_split_var, ServerRuntimeConfig
+from paddle.fluid.incubate.fleet.parameter_server.mode import DistributedMode
+
+RPC_OP_ROLE_ATTR_NAME = op_role_attr_name = core.op_proto_and_checker_maker.kOpRoleAttrName(
+)
+RPC_OP_ROLE_ATTR_VALUE = core.op_proto_and_checker_maker.OpRole.RPC
+
+
+class GeoSgdTranspiler(DistributeTranspiler):
+
+ def __init__(self, config=None):
+ if config is not None:
+ self.config = config
+ else:
+ self.config = DistributeTranspilerConfig()
+ self._set_server_config()
+
+ if self.config.split_method is None:
+ self.config.split_method = RoundRobin
+
+ assert (self.config.min_block_size >= 8192)
+ assert (self.config.split_method.__bases__[0] == PSDispatcher)
+
+ def transpile(self,
+ trainer_id,
+ program=None,
+ pservers="127.0.0.1:6174",
+ trainers=1,
+ sync_mode=False,
+ startup_program=None,
+ current_endpoint="127.0.0.1:6174"):
+ if program is None:
+ program = default_main_program()
+ if startup_program is None:
+ startup_program = default_startup_program()
+ self.origin_program = program
+ self.startup_program = startup_program
+ self.origin_startup_program = self.startup_program.clone()
+
+ self.trainer_num = trainers
+ # geo-sgd only supply async-mode
+ self.sync_mode = False
+ self.trainer_id = trainer_id
+ pserver_endpoints = pservers.split(",")
+ self.pserver_endpoints = pserver_endpoints
+ self.vars_overview = VarsDistributed()
+ self.optimize_ops, self.params_grads = self._get_optimize_pass()
+ ps_dispatcher = self.config.split_method(self.pserver_endpoints)
+ self.param_name_to_grad_name = dict()
+ self.grad_name_to_param_name = dict()
+ for param_var, grad_var in self.params_grads:
+ self.param_name_to_grad_name[param_var.name] = grad_var.name
+ self.grad_name_to_param_name[grad_var.name] = param_var.name
+
+ # distribute lookup table
+ self.table_name = find_distributed_lookup_table(self.origin_program)
+ self.has_distributed_lookup_table = self.table_name != None
+ self.origin_program._distributed_lookup_table = self.table_name if self.table_name else None
+
+ # add distributed attrs to program
+ self.origin_program._is_distributed = True
+ self.origin_program._endpoints = self.pserver_endpoints
+ self.origin_program._ps_endpoint = current_endpoint
+ self.origin_program._is_chief = self.trainer_id == 0
+
+ # program info send to geo-sgd communicator
+ self.vars_info = collections.OrderedDict()
+ self.split_to_origin_mapping = collections.OrderedDict()
+ self.delta_vars_list = []
+ self.sparse_var_list = []
+ self.sparse_var_splited_list = []
+
+ # split and create vars, then put split vars in dicts for later use.
+ # step 1. split and create vars, then put split vars in dicts for later use.
+ self._init_splited_vars()
+
+ # step 3. create send recv var (param after optimize)
+ send_vars = []
+ ps_dispatcher.reset()
+ param_var_mapping_items = list(six.iteritems(self.param_var_mapping))
+ # send_vars is the parameter which split by communicator and send to pserver,not the origin parameter
+ for _, splited_vars in param_var_mapping_items:
+ for _, var in enumerate(splited_vars):
+ send_vars.append(var)
+
+ recv_vars = send_vars
+
+ ps_dispatcher.reset()
+ eplist = ps_dispatcher.dispatch(recv_vars)
+ for i, ep in enumerate(eplist):
+ self.param_opt_ep_mapping[ep]["params"].append(recv_vars[i])
+ distributed_var = self.vars_overview.get_distributed_var_by_slice(
+ recv_vars[i].name)
+ distributed_var.endpoint = ep
+ origin_name = self.split_to_origin_mapping[recv_vars[i].name]
+ self.vars_info[origin_name]["epmap"].append(ep)
+ self.origin_program._parameters_on_pservers = self.vars_overview
+
+ # send sparse id to communicator
+ self.sparse_var = []
+ self.sparse_tables = []
+ unique_sparse_var = {}
+ for op in self.origin_program.global_block().ops:
+ if "is_sparse" in op.all_attrs():
+ if op.type == "lookup_table":
+ op._set_attr('remote_prefetch', False)
+ for input_var_name, sparse_var_name in zip(
+ op.input("Ids"), op.input("W")):
+ if sparse_var_name in self.sparse_var_list:
+ if input_var_name in unique_sparse_var:
+ if unique_sparse_var[
+ input_var_name] == sparse_var_name:
+ continue
+ input_var = program.global_block().var(input_var_name)
+ self.sparse_var.append(input_var)
+ self.sparse_tables.append(sparse_var_name)
+ unique_sparse_var[input_var_name] = sparse_var_name
+
+ # batch training loop end flag
+ dummy_output = program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ program.global_block().append_op(
+ type="send",
+ inputs={"X": self.sparse_var},
+ outputs={"Out": dummy_output},
+ attrs={"send_varnames": self.sparse_tables})
+
+ # add param_init flag in trainer startup program
+ self.trainer_startup_program = self._get_trainer_startup_program(
+ recv_vars=recv_vars, eplist=eplist)
+ for delta_var in self.delta_vars_list:
+ self.trainer_startup_program.global_block().create_var(
+ name=delta_var.name,
+ persistable=delta_var.persistable,
+ dtype=delta_var.dtype,
+ type=delta_var.type,
+ shape=delta_var.shape)
+ dummy_output = self.trainer_startup_program.global_block().create_var(
+ name=framework.generate_control_dev_var_name())
+ param_init = self.trainer_startup_program.global_block().create_var(
+ name="param_init")
+ self.trainer_startup_program.global_block().append_op(
+ type="send",
+ inputs={"X": [param_init]},
+ outputs={"Out": dummy_output},
+ attrs={"send_varnames": [param_init.name]})
+
+ def _get_vars_info(self):
+ return self.vars_info
+
+ def get_trainer_program(self, wait_port=True):
+ if wait_port:
+ wait_server_ready(self.pserver_endpoints)
+ return self.origin_program
+
+ def get_pserver_programs(self, endpoint):
+ pserver_prog = self.get_pserver_program(endpoint)
+ self.param_grad_ep_mapping = self.param_opt_ep_mapping
+ pserver_startup = self.get_startup_program(endpoint,
+ pserver_program=pserver_prog)
+ return pserver_prog, pserver_startup
+
+ def get_pserver_program(self, endpoint):
+ # step1
+ pserver_program = Program()
+ pserver_program.random_seed = self.origin_program.random_seed
+ pserver_program._copy_dist_param_info_from(self.origin_program)
+
+ # step2: Create vars to receive vars at parameter servers.
+ recv_inputs = []
+ for v in self.param_opt_ep_mapping[endpoint]["params"]:
+ self._clone_var(pserver_program.global_block(), v)
+
+ optimize_block = []
+ param_to_block_id = []
+ sparse_grad_to_param = []
+
+ # append op to the current block
+ pre_block_idx = pserver_program.num_blocks - 1
+ for var in self.param_opt_ep_mapping[endpoint]["params"]:
+ per_opt_block = pserver_program._create_block(pre_block_idx)
+ optimize_block.append(per_opt_block)
+ var_name = var.name
+ pserver_block = per_opt_block.program.global_block()
+ param = pserver_block.vars[var_name]
+
+ delta_var_name = "%s.delta" % (param.name)
+ if var.name in self.sparse_var_splited_list:
+ delta_type = core.VarDesc.VarType.SELECTED_ROWS
+ sparse_grad_to_param.append(":".join(
+ [delta_var_name, param.name]))
+ else:
+ delta_type = param.type
+ delta_var = pserver_block.create_var(name=delta_var_name,
+ persistable=False,
+ type=delta_type,
+ dtype=param.dtype,
+ shape=param.shape)
+
+ per_opt_block.append_op(type="sum",
+ inputs={"X": [param, delta_var]},
+ outputs={"Out": param})
+ param_to_block_id.append(delta_var_name + ":" +
+ str(per_opt_block.idx))
+
+ attrs = {
+ "optimize_blocks": optimize_block,
+ "endpoint": endpoint,
+ "Fanin": self.trainer_num,
+ "distributed_mode": DistributedMode.GEO,
+ "grad_to_block_id": param_to_block_id,
+ "sparse_grad_to_param": sparse_grad_to_param,
+ "rpc_get_thread_num": self.server_config._rpc_get_thread_num,
+ "rpc_send_thread_num": self.server_config._rpc_send_thread_num,
+ "rpc_prefetch_thread_num":
+ self.server_config._rpc_prefetch_thread_num
+ }
+
+ # step5 append the listen_and_serv op
+ pserver_program.global_block().append_op(type="listen_and_serv",
+ inputs={'X': recv_inputs},
+ outputs={},
+ attrs=attrs)
+
+ pserver_program._sync_with_cpp()
+ # save pserver program to generate pserver side startup relatively.
+ self.pserver_program = pserver_program
+ return pserver_program
+
+ def _init_splited_vars(self):
+ param_list = []
+ grad_list = []
+ param_grad_set = set()
+ # step 1. create param_list
+ for p, g in self.params_grads:
+ if type(p) == Parameter and p.trainable == False:
+ continue
+ if p.name not in param_grad_set:
+ param_list.append(p)
+ param_grad_set.add(p.name)
+ if g.name not in param_grad_set:
+ grad_list.append(g)
+ param_grad_set.add(g.name)
+ if g.type == core.VarDesc.VarType.SELECTED_ROWS:
+ self.sparse_var_list.append(p.name)
+
+ # step 2. Slice vars into numbers of piece with block_size
+ # when we slice var up into blocks, we will slice the var according to
+ # pserver services' count. A pserver may have two or more listening ports.
+ param_blocks = slice_variable(param_list, len(self.pserver_endpoints),
+ self.config.min_block_size)
+
+ # step 3. Create split param from split blocks
+ # origin_param_name -> [splited_param_vars]
+ # Todo: update _create_vars_from_blocklist
+ self.param_var_mapping = self._create_vars_from_blocklist(
+ self.origin_program, param_blocks)
+
+ # step 4. Create mapping of endpoint -> split var to create pserver side program
+ self.param_opt_ep_mapping = collections.OrderedDict()
+ [
+ self.param_opt_ep_mapping.update({ep: {
+ "params": [],
+ }}) for ep in self.pserver_endpoints
+ ]
+
+ # step 5. Create delta var of Geo-Sgd & record vars information
+ for origin_name, splited_vars in self.param_var_mapping.items():
+ origin_var = self.origin_program.global_block().var(origin_name)
+ self.vars_info[origin_name] = collections.OrderedDict()
+ self.vars_info[origin_name]["var_names"] = []
+ vars_section = self._get_splited_var_sections(splited_vars)
+ self.vars_info[origin_name]["sections"] = [
+ str(i) for i in vars_section
+ ]
+ self.vars_info[origin_name]["epmap"] = []
+ self.vars_info[origin_name]["is_sparse"] = []
+ # todo: add var shape(may be no need,because recv scope have)
+ if origin_name in self.sparse_var_list:
+ delta_type = core.VarDesc.VarType.SELECTED_ROWS
+ self.vars_info[origin_name]["is_sparse"].append("True")
+ else:
+ delta_type = origin_var.type
+ self.vars_info[origin_name]["is_sparse"].append("False")
+
+ delta_var = self.origin_program.global_block().create_var(
+ name=".".join([origin_name, "delta"]),
+ persistable=False,
+ dtype=origin_var.dtype,
+ type=delta_type,
+ shape=origin_var.shape)
+
+ self.delta_vars_list.append(delta_var)
+
+ for splited_var in splited_vars:
+ is_slice, block_id, offset = self._get_slice_var_info(
+ splited_var)
+ self.vars_overview.add_distributed_var(origin_var=origin_var,
+ slice_var=splited_var,
+ block_id=block_id,
+ offset=offset,
+ is_slice=is_slice,
+ vtype="Param")
+ self.split_to_origin_mapping[splited_var.name] = origin_name
+ if origin_name in self.sparse_var_list:
+ self.sparse_var_splited_list.append(splited_var.name)
+ self.vars_info[origin_name]["var_names"].append(
+ splited_var.name)
+ if len(splited_vars) != 1:
+ self.origin_program.global_block().create_var(
+ name=".".join([splited_var.name, "delta"]),
+ persistable=False,
+ dtype=splited_var.dtype,
+ type=delta_type,
+ shape=splited_var.shape)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/memory_optimization_transpiler.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/memory_optimization_transpiler.py
new file mode 100644
index 0000000000000000000000000000000000000000..e91f2043683c8d8d4021665214252fb85beb9940
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/memory_optimization_transpiler.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2018 PaddlePaddle 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 logging
+
+
+def memory_optimize(input_program,
+ skip_opt_set=None,
+ print_log=False,
+ level=0,
+ skip_grads=True):
+ """
+ :api_attr: Static Graph
+
+ This API is deprecated since 1.6. Please do not use it. The better
+ memory optimization strategies are enabled by default.
+ """
+ logging.warn(
+ 'Caution! paddle.fluid.memory_optimize() is deprecated '
+ 'and not maintained any more, since it is not stable!\n'
+ 'This API would not take any memory optimizations on your Program '
+ 'now, since we have provided default strategies for you.\n'
+ 'The newest and stable memory optimization strategies (they are all '
+ 'enabled by default) are as follows:\n'
+ ' 1. Garbage collection strategy, which is enabled by exporting '
+ 'environment variable FLAGS_eager_delete_tensor_gb=0 (0 is the '
+ 'default value).\n'
+ ' 2. Inplace strategy, which is enabled by setting '
+ 'build_strategy.enable_inplace=True (True is the default value) '
+ 'when using CompiledProgram or ParallelExecutor.\n')
+
+
+def release_memory(input_program, skip_opt_set=None):
+ """
+ :api_attr: Static Graph
+
+ This API is deprecated since 1.6. Please do not use it. The better
+ memory optimization strategies are enabled by default.
+ """
+ logging.warn('paddle.fluid.release_memory() is deprecated, it would not'
+ ' take any memory release on your program')
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ps_dispatcher.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ps_dispatcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bdd50c5523f40fe328592c554d2c18ee1f46100
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/transpiler/ps_dispatcher.py
@@ -0,0 +1,129 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+
+class PSDispatcher(object):
+ """
+ PSDispatcher is the base class for dispatching vars
+ into different pserver instance.
+ You need to implement the `dispatch` interface.
+ """
+
+ def __init__(self, pserver_endpoints):
+ self._eps = pserver_endpoints
+ self._step = 0
+
+ @property
+ def eps(self):
+ return self._eps
+
+ def reset(self):
+ """
+ reset the step counter, set it zero.
+ """
+ self._step = 0
+
+ def dispatch(self, varlist):
+ """
+ Args:
+ varlist(list): a list of Variables
+ Returns:
+ a map of pserver endpoint -> varname
+ """
+ AssertionError("Interface has not been implemented.")
+
+
+class HashName(PSDispatcher):
+ """
+ :api_attr: Static Graph
+
+ Hash variable names to several endpoints using python
+ "hash()" function.
+
+ Args:
+ pserver_endpoints (list): list of endpoint(ip:port).
+
+ Examples:
+ .. code-block:: python
+
+ pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"]
+ vars = ["var1","var2","var3","var4","var5"]
+
+ rr = RoundRobin(pserver_endpoints)
+ rr.dispatch(vars)
+
+ """
+
+ def __init__(self, pserver_endpoints):
+ super(self.__class__, self).__init__(pserver_endpoints)
+
+ def _hash_block(self, block_str, total):
+ return hash(block_str) % total
+
+ def dispatch(self, varlist):
+ """
+ use `HashName` method to dispatch variables with each parameter server.
+ Args:
+ varlist (list): a list of Variables
+
+ """
+ eplist = []
+ for var in varlist:
+ server_id = self._hash_block(var.name(), len(self._eps))
+ server_for_param = self._eps[server_id]
+ eplist.append(server_for_param)
+ return eplist
+
+
+class RoundRobin(PSDispatcher):
+ """
+ :api_attr: Static Graph
+
+ Distribute variables to several endpoints using
+ RondRobin method.
+
+ Args:
+ pserver_endpoints (list): list of endpoint(ip:port).
+
+ Examples:
+ .. code-block:: python
+
+ pserver_endpoints = ["127.0.0.1:6007", "127.0.0.1:6008"]
+ vars = ["var1","var2","var3","var4","var5"]
+
+ rr = RoundRobin(pserver_endpoints)
+ rr.dispatch(vars)
+
+ """
+
+ def __init__(self, pserver_endpoints):
+ super(RoundRobin, self).__init__(pserver_endpoints)
+
+ def dispatch(self, varlist):
+ """
+ use `RoundRobin` method to dispatch variables with each parameter server.
+ Args:
+ varlist (list): a list of Variables
+
+ """
+ eplist = []
+ for var in varlist:
+ server_for_param = self._eps[self._step]
+ eplist.append(server_for_param)
+ self._step += 1
+ if self._step >= len(self._eps):
+ self._step = 0
+ return eplist
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/unique_name.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/unique_name.py
new file mode 100644
index 0000000000000000000000000000000000000000..090d0e8dcbb87d259a7460a8ffab655b3ea425f9
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/unique_name.py
@@ -0,0 +1,228 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import collections
+from .wrapped_decorator import signature_safe_contextmanager
+import six
+import sys
+
+__all__ = ['generate', 'switch', 'guard']
+
+
+class UniqueNameGenerator(object):
+ """
+ Generate unique name with prefix.
+
+ Args:
+ prefix(str): The generated name prefix. All generated name will be
+ started with this prefix.
+ """
+
+ def __init__(self, prefix=None):
+ self.ids = collections.defaultdict(int)
+ if prefix is None:
+ prefix = ""
+ self.prefix = prefix
+
+ def __call__(self, key):
+ """
+ Generate unique names with prefix
+
+ Args:
+ key(str): The key of return string.
+
+ Returns(str): A unique string with the prefix
+ """
+ tmp = self.ids[key]
+ self.ids[key] += 1
+ return self.prefix + "_".join([key, str(tmp)])
+
+
+class DygraphParameterNameChecker(object):
+ """
+ Check whether the name of parameter is used.
+ """
+
+ def __init__(self):
+ self._name_set = set()
+
+ def __call__(self, name):
+ '''
+ Check whether the name is used. If not used, insert into the _name_set.
+
+ Args:
+ name(str): The name of parameter to check.
+
+ Returns(bool): If the name is in name_set, return True; Otherwise, return False.
+
+ '''
+ if name in self._name_set:
+ return True
+ else:
+ self._name_set.add(name)
+ return False
+
+
+dygraph_parameter_name_checker = DygraphParameterNameChecker()
+
+generator = UniqueNameGenerator()
+
+
+def generate(key):
+ """
+ Generate unique name with prefix key. Currently, Paddle distinguishes the
+ names of the same key by numbering it from zero. For example, when key=fc,
+ it continuously generates fc_0, fc_1, fc_2, etc.
+
+ Args:
+ key(str): The prefix of generated name.
+
+ Returns:
+ str: A unique string with the prefix key.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ name1 = paddle.utils.unique_name.generate('fc')
+ name2 = paddle.utils.unique_name.generate('fc')
+ print(name1, name2) # fc_0, fc_1
+ """
+ return generator(key)
+
+
+# FIXME(zjl): The previous naming rule in static graph would
+# cause memory leak in dygraph mode. It is because the previous
+# naming rule would use `conv_0.tmp` as the key, and in dygraph
+# mode, `conv_i` increases as batch increases. Thus, keys would
+# increase in a way like `conv_0.tmp`, `conv_1.tmp`, ....
+# Not find a better way to fix this bug in dygraph mode. In TF,
+# variable name is meaningless in eager execution mode, and in
+# PyTorch, there is no variable name at all. Maybe we should
+# discard variable name in dygraph mode.
+#
+# Another concern is that save/load interfaces. Usually, user
+# would save model in static graph mode, and load it in dygraph
+# mode. Therefore, we keep the variable name of Parameter currently.
+#
+# Please fix me if a better method is found.
+#
+# NOTE(zhiqiu): use c++ unique_name_generator in dygraph mode,
+# in order to keep name consistency.
+def generate_with_ignorable_key(key):
+ from .framework import _non_static_mode, _dygraph_tracer
+ if _non_static_mode():
+ return _dygraph_tracer()._generate_unique_name()
+
+ return generator(key)
+
+
+def switch(new_generator=None, new_para_name_checker=None):
+ """
+ Switch the namespace of in current context to a new namespace. Though
+ :code:`switch()` and :code:`guard()` can both change namespace,
+ :code:`guard()` is recommended since it can manage the context better
+ together with :code:`with` statement.
+
+ Args:
+ new_generator(UniqueNameGenerator, optional): A new UniqueNameGenerator, not
+ required normally. Default is None, which means switch to a new anonymous
+ namespace.
+ new_para_name_checker(DygraphParameterNameChecker, optional): A new DygraphParameterNameChecker,
+ not required normally. Default is None, which means switch to a new parameter name
+ checker.
+
+ Returns:
+ UniqueNameGenerator: The previous UniqueNameGenerator.
+ DygraphParameterNameChecker: The previous DygraphParameterNameChecker
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ name1 = paddle.utils.unique_name.generate('fc')
+ name2 = paddle.utils.unique_name.generate('fc')
+ print(name1, name2) # fc_0, fc_1
+
+ pre_generator, pre_dygraph_name_checker = paddle.utils.unique_name.switch() # switch to a new anonymous namespace.
+ name2 = paddle.utils.unique_name.generate('fc')
+ print(name2) # fc_0
+
+ paddle.utils.unique_name.switch(pre_generator, pre_dygraph_name_checker) # switch back to pre_generator.
+ name3 = paddle.utils.unique_name.generate('fc')
+ print(name3) # fc_2, since pre_generator has generated fc_0, fc_1.
+ """
+ global generator
+ old_generator = generator
+ global dygraph_parameter_name_checker
+ old_para_name_checker = dygraph_parameter_name_checker
+ if new_generator is None:
+ generator = UniqueNameGenerator()
+ else:
+ generator = new_generator
+
+ if new_para_name_checker is None:
+ dygraph_parameter_name_checker = DygraphParameterNameChecker()
+ else:
+ dygraph_parameter_name_checker = new_para_name_checker
+ return old_generator, old_para_name_checker
+
+
+@signature_safe_contextmanager
+def guard(new_generator=None):
+ """
+ Change the namespace of unique name with :code:`with` statement. After calling it,
+ a new namespace in the context of :code:`with` will be created, and it will number
+ names from zero again when calling :code:`generate()` with same key.
+
+ Args:
+ new_generator(str|bytes, optional): New name of global namespace. Note that str
+ in Python2 was spilted into str and bytes in Python3, so here are two
+ types. Default is None. If not None, new_generator will be added into
+ the prefix of unique name generated by :code:`generate()`.
+
+ Returns:
+ None.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ with paddle.utils.unique_name.guard():
+ name_1 = paddle.utils.unique_name.generate('fc')
+ with paddle.utils.unique_name.guard():
+ name_2 = paddle.utils.unique_name.generate('fc')
+ print(name_1, name_2) # fc_0, fc_0
+
+ with paddle.utils.unique_name.guard('A'):
+ name_1 = paddle.utils.unique_name.generate('fc')
+ with paddle.utils.unique_name.guard('B'):
+ name_2 = paddle.utils.unique_name.generate('fc')
+ print(name_1, name_2) # Afc_0, Bfc_0
+ """
+ if isinstance(new_generator, six.string_types):
+ new_generator = UniqueNameGenerator(new_generator)
+ elif isinstance(new_generator, six.binary_type):
+ new_generator = UniqueNameGenerator(new_generator.decode())
+
+ old_generator, old_para_name_checker = switch(new_generator)
+ try:
+ yield
+ finally:
+ switch(old_generator, old_para_name_checker)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/variable_index.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/variable_index.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a13e8304194c8e02d91c8695683533876d21f41
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/variable_index.py
@@ -0,0 +1,798 @@
+# Copyright (c) 2021 PaddlePaddle 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 sys
+import numpy as np
+from . import unique_name
+from . import core
+import paddle
+
+MAX_INTEGER = 2**31 - 1
+
+
+def is_list_tuple(index, contain_type):
+
+ def _is_list_tuple(item):
+ if not (isinstance(item, (list, tuple)) or type(item) == contain_type):
+ return False
+ if isinstance(item, (tuple, list)):
+ for s in item:
+ if not _is_list_tuple(s):
+ return False
+ return True
+
+ if not isinstance(index, (tuple, list)):
+ return False
+ for s in index:
+ if not _is_list_tuple(s):
+ return False
+ return True
+
+
+def is_one_dim_list(index, contain_type):
+ if isinstance(index, list):
+ for i in index:
+ if not isinstance(i, contain_type):
+ return False
+ else:
+ return False
+ return True
+
+
+def get_list_index_shape(var_dims, index_dims):
+ var_dims_size = len(var_dims)
+ index_dims_size = len(index_dims)
+
+ out_dims_size = var_dims_size - index_dims[0] + index_dims_size - 1
+
+ out_dims_shape = [1] * out_dims_size
+
+ out_dims_shape[:index_dims_size - 1] = index_dims[1:]
+
+ out_dims_shape[index_dims_size - 1:] = var_dims[index_dims[0]:]
+ return out_dims_shape
+
+
+class SliceInfo:
+
+ def __init__(self):
+ self.pre_shape = None
+ self.indexes = []
+ self.dtype = None
+
+ def update(self, index):
+ if is_list_tuple(index, int) or isinstance(
+ index, (paddle.fluid.Variable, np.ndarray)):
+ # convert index to Tensor
+ if not isinstance(index, paddle.fluid.Variable):
+ index = paddle.assign(index)
+
+ if self.dtype is None:
+ self.dtype = index.dtype
+ else:
+ if index.dtype != self.dtype:
+ raise IndexError(
+ "Data type of Tensor/List index should be same. The current data type is {}, but the previous data type is {}."
+ .format(index.dtype, self.dtype))
+
+ self.indexes.append(index)
+
+ if self.pre_shape is None:
+ self.pre_shape = index.shape
+ else:
+ if self.pre_shape != index.shape:
+ # broadcast
+ cur_shape = paddle.broadcast_shape(self.pre_shape,
+ index.shape)
+ for i in range(len(self.indexes)):
+ self.indexes[i] = paddle.broadcast_to(
+ self.indexes[i], cur_shape)
+ self.pre_shape = self.indexes[-1].shape
+ else:
+ raise ValueError(
+ "Index should be list/tuple of int or Tensor, but received {}.".
+ format(index))
+
+ def shape_stride(self, shape):
+ s = [1] * len(shape)
+ for i in range(len(shape) - 2, -1, -1):
+ s[i] = shape[i + 1] * s[i + 1]
+
+ return s
+
+ def numel(self, shape):
+ return reduce(lambda x, y: x * y, shape)
+
+ def get_offset_stride(self, tensor_shape):
+ for index in self.indexes:
+ if not isinstance(index, paddle.fluid.Variable):
+ raise ValueError(
+ "only support list/tensor index, but received {}.".format(
+ type(index)))
+
+ if len(self.indexes) <= len(tensor_shape) or len(self.indexes) == 1:
+ shape = paddle.stack(self.indexes)
+ axes = list(range(1,
+ len(self.pre_shape) + 1)) + [
+ 0,
+ ]
+
+ else:
+ raise ValueError(
+ "too many indices for tensor: tensor is {}-dimensional, but {} were indexed"
+ .format(len(tensor_shape), self.pre_shape[0]))
+
+ shape_transpose = paddle.transpose(shape, axes)
+ return shape_transpose
+
+ def get_item(self, tensor):
+ shape_transpose = self.get_offset_stride(tensor.shape)
+ index = paddle.assign(shape_transpose)
+ return paddle.gather_nd(tensor, index)
+
+ def set_item(self, tensor_origin, value):
+
+ if not isinstance(value, paddle.fluid.Variable):
+ value = paddle.assign(value)
+ tensor_type = None
+
+ if tensor_origin.dtype in [
+ core.VarDesc.VarType.FP32, core.VarDesc.VarType.FP64
+ ]:
+ tensor = tensor_origin
+ else:
+ tensor_type = tensor_origin.dtype
+ tensor = tensor_origin.astype(core.VarDesc.VarType.FP32)
+
+ if value.dtype != tensor.dtype:
+ value = value.astype(tensor.dtype)
+
+ shape_transpose = self.get_offset_stride(tensor_origin.shape)
+ index = paddle.assign(shape_transpose)
+
+ gather_tensor_shape = get_list_index_shape(tensor.shape, [
+ len(self.indexes),
+ ] + list(self.indexes[-1].shape))
+
+ value_dims_bd = [
+ 1,
+ ] * len(gather_tensor_shape)
+ value_dims_bd[-len(value.shape):] = list(value.shape)
+
+ for i in range(len(gather_tensor_shape)):
+ if not (value_dims_bd[i] == gather_tensor_shape[i]
+ or value_dims_bd[i] == 1):
+ raise ValueError("{} can not broadcast into {}".format(
+ value.shape, gather_tensor_shape))
+
+ value_broadcast = paddle.broadcast_to(value, gather_tensor_shape)
+
+ value_1d = value_broadcast.reshape(
+ [-1] + gather_tensor_shape[len(index.shape) - 1:])
+
+ index_1d = index.reshape([-1, index.shape[-1]])
+
+ tensor_stride = paddle.assign(
+ self.shape_stride(tensor.shape[:index.shape[-1]]))
+ inds = []
+ for i in range(index_1d.shape[0]):
+ temp = (index_1d[i] * tensor_stride).sum()
+ inds.append(temp)
+ index_1d = paddle.stack(inds).reshape([-1])
+ t_reshape = tensor.reshape([-1] + list(tensor.shape[index.shape[-1]:]))
+ out = paddle.scatter(t_reshape, index_1d, value_1d)
+ if tensor_type is not None:
+ out = out.astype(tensor_type)
+ tensor_origin[:] = out.reshape(tensor_origin.shape)
+
+ return tensor_origin
+
+
+def replace_ellipsis(var, item):
+ from .framework import Variable
+ # Use slice(None) to replace Ellipsis.
+ # For var, var.shape = [3,4,5,6]
+ #
+ # var[..., 1:2] -> var[:, :, :, 1:2]
+ # var[0, ...] -> var[0]
+ # var[0, ..., 1:2] -> var[0, :, :, 1:2]
+
+ item = list(item)
+
+ # Remove Variable to skip bug when counting Ellipsis
+ item_remove_var = [
+ ele for ele in item
+ if not isinstance(ele, (Variable, np.ndarray)) and ele is not None
+ ]
+ ell_count = item_remove_var.count(Ellipsis)
+ if ell_count == 0:
+ return item
+ elif ell_count > 1:
+ raise IndexError("An index can only have a single ellipsis ('...')")
+
+ ell_idx = item.index(Ellipsis)
+
+ if ell_idx == len(item) - 1:
+ return item[:-1]
+ else:
+ item[ell_idx:ell_idx +
+ 1] = [slice(None)
+ ] * (len(var.shape) - len(item) + item.count(None) + 1)
+
+ return item
+
+
+def replace_ndarray(item):
+ new_item = []
+ for slice_item in item:
+ if isinstance(slice_item, np.ndarray):
+ new_item.append(paddle.assign(slice_item))
+ else:
+ new_item.append(slice_item)
+ return new_item
+
+
+def replace_none(item):
+ new_item = []
+ none_axes = []
+ for i, slice_item in enumerate(item):
+ if slice_item is None:
+ none_axes.append(i)
+ else:
+ new_item.append(slice_item)
+ return new_item, none_axes
+
+
+def is_integer_or_scalar_tensor(ele):
+ from .framework import Variable
+ if isinstance(ele, int):
+ return True
+ elif isinstance(ele, Variable):
+ if len(ele.shape) == 1 and ele.shape[0] == 1:
+ return True
+ return False
+
+
+def is_bool_tensor(ele):
+ from .framework import Variable
+ if isinstance(ele, Variable) and ele.dtype == paddle.bool:
+ return True
+ return False
+
+
+def deal_attrs(attrs, attr, attr_name, tensor_attr_name, inputs, infer_flags):
+ from .framework import Variable
+ from .layers import utils
+
+ if utils._contain_var(attr):
+ inputs[tensor_attr_name] = utils._convert_to_tensor_list(attr,
+ dtype="int64")
+ for i, dim in enumerate(attr):
+ if isinstance(dim, Variable):
+ attrs[attr_name].append(-1)
+ infer_flags[i] = -1
+ else:
+ attrs[attr_name].append(dim)
+ else:
+ attrs[attr_name] = attr
+
+
+# the item is a tensor of bool
+def get_value_for_bool_tensor(var, item):
+ if len(item.shape) > len(var.shape):
+ raise IndexError("The dims of bool index doesn't match indexed array, "
+ "the dims of bool index except to be equal or less "
+ "than {}, but received {}.".format(
+ len(var.shape), len(item.shape)))
+ for i, dim_len in enumerate(item.shape):
+ if dim_len != var.shape[i]:
+ raise IndexError(
+ "The dimension of bool index doesn't match indexed array along "\
+ "dimension {}, the target dimension is {}, but received {}.".
+ format(i, var.shape[i], dim_len))
+
+ def idx_not_empty(var, item):
+ from .layers.nn import where
+ from ..tensor import gather_nd
+
+ bool_2_idx = where(item == True)
+ return gather_nd(var, bool_2_idx)
+
+ def idx_empty(var):
+ var_shape = list(var.shape)
+ var_shape[0] = 0
+ return paddle.empty(var_shape, dtype=var.dtype)
+
+ from .layers.control_flow import cond
+ return cond(item.any(), lambda: idx_not_empty(var, item),
+ lambda: idx_empty(var))
+
+
+def _getitem_impl_(var, item):
+ """
+ Slice the variable.
+
+ Args:
+ item(int/slice/tuple) : the index.
+
+ Returns:
+ Sliced variable
+ """
+ from .framework import default_main_program, Variable
+ if isinstance(item, list):
+ if not is_one_dim_list(item, int):
+ item = tuple(item)
+
+ if not isinstance(item, tuple):
+ item = (item, )
+
+ decrease_axes = []
+ axes = []
+ starts = []
+ ends = []
+ steps = []
+ reverse_axes = []
+
+ use_strided_slice = False
+ item = replace_ndarray(item)
+ item = replace_ellipsis(var, item)
+ item, none_axes = replace_none(item)
+ slice_info = SliceInfo()
+
+ for dim, slice_item in enumerate(item):
+ if is_integer_or_scalar_tensor(
+ slice_item) and not is_bool_tensor(slice_item):
+ if isinstance(slice_item,
+ int) and var.shape[dim] is not None and var.shape[
+ dim] >= 0 and slice_item >= var.shape[dim]:
+ # For python, if users write a, b = var, the __getitem__
+ # method will iterate through 0, 1, 2 ... until __getitem__
+ # throws an IndexError, then stop. The var[0], var[1] will
+ # be given to a, b respectively. If more values are given,
+ # the unpack size would cause error.
+ #
+ # We raises IndexError here to support grammar like `a, b = var`
+ raise IndexError(
+ "slice_item %d at dim %d should be >= 0 and < var.shape[%d]: %d"
+ % (slice_item, dim, dim, var.shape[dim]))
+ decrease_axes.append(dim)
+ start = slice_item
+ step = 1
+ end = slice_item + 1 if slice_item != -1 else MAX_INTEGER
+
+ elif isinstance(slice_item, slice):
+ start = slice_item.start
+ end = slice_item.stop
+ step = slice_item.step
+
+ if start is None and end is None and step is None:
+ continue
+
+ step = 1 if step is None else step
+
+ if start is None:
+ start = 0 if step > 0 else MAX_INTEGER
+ if end is None:
+ if var.shape[dim] != -1 and (
+ paddle.fluid.framework._non_static_mode()
+ or var.desc.type() !=
+ core.VarDesc.VarType.LOD_TENSOR_ARRAY):
+ end = var.shape[dim] if step > 0 else -1
+ else:
+ end = MAX_INTEGER if step > 0 else -1
+
+ elif isinstance(slice_item, list):
+ all_bool = True
+
+ if is_list_tuple(slice_item, int):
+ slice_info.update(slice_item)
+ continue
+
+ for i in slice_item:
+ if type(i) is int:
+ all_bool = False
+ elif not isinstance(i, bool):
+ raise TypeError("Only support int or bool in index list.")
+
+ if len(item) != 1:
+ raise IndexError(
+ "When index contains a list, its length must be 1, but received {}."
+ .format(len(item)))
+ new_slice_item = []
+ if all_bool:
+ if len(slice_item) != var.shape[0]:
+ raise IndexError(
+ "The dimension of bool index doesn't match indexed array along "\
+ "dimension 0, the target dimension is {}, but received {}.".
+ format(var.shape[0], len(slice_item)))
+ for idx, ele in enumerate(slice_item):
+ if ele is True:
+ new_slice_item.append(idx)
+ slice_item = new_slice_item
+ else:
+ for idx, ele in enumerate(slice_item):
+ if type(ele) is int:
+ new_slice_item.append(ele)
+ elif ele is True:
+ new_slice_item.append(1)
+ else:
+ new_slice_item.append(0)
+ slice_item = new_slice_item
+
+ from .layers import assign
+ from ..tensor import index_select
+
+ idx = assign(np.array(slice_item).astype("int32"))
+ return index_select(var, index=idx, axis=0)
+
+ elif isinstance(slice_item, (Variable, core.eager.Tensor)):
+ if len(item) == 1:
+
+ from ..tensor import index_select
+
+ if slice_item.dtype == paddle.bool:
+ return get_value_for_bool_tensor(var, slice_item)
+ else:
+ if len(slice_item.shape) == 1:
+ return index_select(var, index=slice_item, axis=0)
+ else:
+ slice_info.update(slice_item)
+ continue
+ else:
+ slice_info.update(slice_item)
+ continue
+
+ else:
+ raise IndexError(
+ "Valid index accept int or slice or ellipsis or list, but received {}."
+ .format(slice_item))
+
+ axes.append(dim)
+ starts.append(start)
+ ends.append(end)
+ steps.append(step)
+ use_strided_slice = True if step != 1 else use_strided_slice
+
+ if slice_info.indexes:
+ if len(slice_info.indexes) != len(item):
+ raise IndexError(
+ "Valid index accept int or slice or ellipsis or list, but received {}."
+ .format(item))
+ return slice_info.get_item(var)
+
+ inputs = {'Input': [var]}
+ attrs = {
+ 'axes': axes,
+ 'starts': [],
+ 'ends': [],
+ 'decrease_axis': decrease_axes
+ }
+ if use_strided_slice:
+ attrs['strides'] = []
+
+ infer_flags = [1] * len(axes)
+ deal_attrs(attrs, starts, "starts", "StartsTensorList", inputs, infer_flags)
+ deal_attrs(attrs, ends, "ends", "EndsTensorList", inputs, infer_flags)
+ deal_attrs(attrs, steps, "strides", "StridesTensorList", inputs,
+ infer_flags)
+ attrs['infer_flags'] = infer_flags
+
+ out = var
+ if len(axes) > 0:
+ op_type = "strided_slice" if use_strided_slice else "slice"
+ if paddle.fluid.framework.in_dygraph_mode() and op_type == "slice":
+ if "StartsTensorList" in inputs.keys():
+ st = inputs['StartsTensorList']
+ else:
+ st = attrs['starts']
+ if "EndsTensorList" in inputs.keys():
+ end = inputs['EndsTensorList']
+ else:
+ end = attrs['ends']
+ out = paddle._C_ops.slice(var, axes, st, end, attrs['infer_flags'],
+ attrs['decrease_axis'])
+ else:
+ target_block = default_main_program().current_block()
+
+ slice_out_var = target_block.create_var(
+ name=unique_name.generate_with_ignorable_key(var.name + "_" +
+ op_type),
+ dtype=var.dtype)
+ target_block.append_op(type=op_type,
+ inputs=inputs,
+ outputs={'Out': [slice_out_var]},
+ attrs=attrs)
+ out = slice_out_var
+
+ if len(reverse_axes) > 0:
+ from .layers.tensor import reverse
+ out = reverse(out, axis=reverse_axes)
+
+ # Deal with cases when all axes are decreased.
+ # After slice, the shape of out is [1], which should have been [], but Paddle doesn't support scalar.
+ # In order to ensure the correctness of the final shape of out, one dimension of out needs to be decreased.
+ # For example:
+ # # x.shape: (2,3,4)
+ # out = x[0, 1, 1, None] # out.shape : (1)
+ if len(decrease_axes) == len(var.shape):
+ none_axes = none_axes[1:]
+
+ if len(none_axes) > 0:
+ # Deal with cases that decrease_axes is not empty
+ # For example:
+ # # x.shape: (2,3,4)
+ # out = x[0, 0:2, None] # out.shape : (2, 1, 4)
+ for idx, axis in enumerate(none_axes):
+ l = len([i for i in decrease_axes if i < axis])
+ new_axis = axis - l
+ none_axes[idx] = new_axis
+
+ # Deal with cases when all axes are decreased.
+ # After slice, the shape of out is [1], which should have been [], but Paddle doesn't support scalar.
+ # In order to ensure the correctness of the final shape of out, one dimension of out needs to be decreased.
+ # For example:
+ # # x.shape: (2,3,4)
+ # out = x[0, 1, 1, None] # out.shape : (1)
+
+ from ..tensor import unsqueeze
+ out = unsqueeze(out, axis=none_axes)
+
+ return out
+
+
+def _setitem_for_tensor_array(var, item, value):
+ """ branches for tensor array setitem operation.
+ A item can be a:
+ (1) int/Variable, which is a simple number/variable such as [1], [-2]
+ (2) Slice, which is represented by bounds such as [2:-1]
+ (3) Tuple, which includes the above two cases such as [2:-1, 1]
+ If item is case (1), we perform paddle.tensor.array_write,
+ in other cases, we raise a NotImplementedError.
+ """
+ from ..framework import LayerHelper, core, _non_static_mode
+ from .framework import Variable
+ assert not _non_static_mode(
+ ), "setitem for tensor_array must be called in static graph mode."
+ if isinstance(item, (Variable, int)):
+ from paddle.fluid.dygraph.dygraph_to_static.variable_trans_func import to_static_variable
+ from paddle import cast
+ from paddle.tensor import array_write
+ item = paddle.cast(to_static_variable(item), dtype='int64')
+ value = to_static_variable(value)
+ array_write(x=value, i=item, array=var)
+ else:
+ raise NotImplementedError(
+ "Only support __setitem__ by Int/Variable in tensor_array, but gets {}"
+ .format(type(item)))
+
+
+def _setitem_impl_(var, item, value):
+ from .framework import default_main_program, Variable
+ from paddle.fluid import core
+ if var.type == core.VarDesc.VarType.LOD_TENSOR_ARRAY:
+ return _setitem_for_tensor_array(var, item, value)
+
+ inputs = {'Input': var}
+ if isinstance(item, list):
+ if not is_one_dim_list(item, int):
+ item = tuple(item)
+ # 1. Parse item
+ if not isinstance(item, tuple):
+ item = (item, )
+
+ decrease_axes = []
+ axes = []
+ starts = []
+ ends = []
+ steps = []
+
+ item = replace_ndarray(item)
+ item = replace_ellipsis(var, item)
+ item, none_axes = replace_none(item)
+ slice_info = SliceInfo()
+ dim = 0
+ for _, slice_item in enumerate(item):
+ if is_integer_or_scalar_tensor(
+ slice_item) and not is_bool_tensor(slice_item):
+ decrease_axes.append(dim)
+ start = slice_item
+ end = slice_item + 1 if slice_item != -1 else MAX_INTEGER
+ step = 1
+
+ elif isinstance(slice_item, slice):
+ start = slice_item.start
+ end = slice_item.stop
+ step = slice_item.step
+
+ if start is None and end is None and step is None:
+ dim += 1
+ continue
+
+ step = 1 if step is None else step
+
+ if not isinstance(step, Variable) and step == 0:
+ raise ValueError(
+ "When assign a value to a paddle.Tensor, step can not be 0, "
+ "but received step is {}.".format(step))
+
+ if isinstance(step, Variable) and (start is None or end is None):
+ raise ValueError(
+ "When assign a value to a paddle.Tensor, it's not supported that "
+ "the start or end is None when the type of step is paddle.Tensor."
+ )
+
+ if start is None:
+ start = 0 if step > 0 else MAX_INTEGER
+
+ if end is None:
+ end = MAX_INTEGER if step > 0 else (0 - MAX_INTEGER)
+ elif isinstance(slice_item, list):
+ if is_list_tuple(slice_item, int):
+ slice_info.update(slice_item)
+ continue
+
+ for i in slice_item:
+ if not isinstance(i, bool):
+ raise TypeError("Doesn't support {} in index list.".format(
+ type(i)))
+
+ if len(item) != 1:
+ raise IndexError(
+ "When index contains a bool list, its length must be 1, but received {}."
+ .format(len(item)))
+
+ from .layers import assign
+ idx_tensor = assign(slice_item)
+ return set_value_for_bool_tensor(var, idx_tensor, value)
+
+ elif isinstance(slice_item, Variable):
+ if slice_item.dtype == core.VarDesc.VarType.BOOL:
+ if len(item) != 1:
+ raise IndexError(
+ "When index contains a bool tensor, its length must be 1, but received {}."
+ .format(len(item)))
+ return set_value_for_bool_tensor(var, slice_item, value)
+ else:
+ slice_info.update(slice_item)
+ continue
+ else:
+ raise IndexError(
+ "Valid index accept int, slice, ellipsis, None, list of bool, Variable, "
+ "but received {}.".format(slice_item))
+
+ axes.append(dim)
+ starts.append(start)
+ ends.append(end)
+ steps.append(step)
+
+ dim += 1
+ if slice_info.indexes:
+ if len(slice_info.indexes) != len(item):
+ raise IndexError(
+ "Valid index accept int or slice or ellipsis or list, but received {}."
+ .format(item))
+ return slice_info.set_item(var, value)
+ attrs = {
+ 'axes': axes,
+ 'starts': starts,
+ 'ends': ends,
+ 'steps': steps,
+ 'decrease_axes': decrease_axes,
+ 'none_axes': none_axes
+ }
+
+ from .layers import utils
+ if utils._contain_var(starts):
+ inputs['StartsTensorList'] = utils._convert_to_tensor_list(starts)
+ del attrs['starts']
+ if utils._contain_var(ends):
+ inputs['EndsTensorList'] = utils._convert_to_tensor_list(ends)
+ del attrs['ends']
+ if utils._contain_var(steps):
+ inputs['StepsTensorList'] = utils._convert_to_tensor_list(steps)
+ del attrs['steps']
+
+ # 2. Parse value
+ dtype = var.dtype
+ attrs['dtype'] = dtype
+
+ from .data_feeder import convert_dtype
+ # 2.1 value is an integer of float
+ if isinstance(value, (int, float)):
+ value = np.array([value]).astype(convert_dtype(dtype))
+
+ # 2.2 value is a np.ndarray
+ if isinstance(value, np.ndarray):
+ shape = list(value.shape)
+ if dtype == core.VarDesc.VarType.BOOL:
+ value_name = "bool_values"
+ values = [int(v) for v in value.flat]
+ elif dtype == core.VarDesc.VarType.FP32:
+ value_name = "fp32_values"
+ values = [float(v) for v in value.flat]
+ elif dtype == core.VarDesc.VarType.FP64:
+ value_name = "fp64_values"
+ values = [float(v) for v in value.flat]
+ elif dtype == core.VarDesc.VarType.INT32:
+ value_name = "int32_values"
+ values = [int(v) for v in value.flat]
+ elif dtype == core.VarDesc.VarType.INT64:
+ value_name = "int64_values"
+ values = [int(v) for v in value.flat]
+ elif dtype == core.VarDesc.VarType.FP16:
+ value_name = "fp16_values"
+ values = [float(v) for v in value.flat]
+ else:
+ raise TypeError(
+ "When assign a numpy.ndarray, integer or float to a paddle.Tensor, "
+ "the data type of the paddle.Tensor must be bool, float32, int32, int64 or float16, but "
+ "received %s." % convert_dtype(dtype))
+ attrs[value_name] = values
+ attrs["shape"] = shape
+
+ elif isinstance(value, (Variable, core.eager.Tensor)):
+ inputs["ValueTensor"] = value
+ else:
+ raise TypeError(
+ "Only support to assign an integer, float, numpy.ndarray or "
+ "paddle.Tensor to a paddle.Tensor, but received {}".format(
+ type(value)))
+
+ if paddle.fluid.framework._non_static_mode():
+ var._bump_inplace_version()
+
+ cur_block = default_main_program().current_block()
+ cur_block.append_op(type="set_value",
+ inputs=inputs,
+ outputs={'Out': var},
+ attrs=attrs,
+ inplace_map={"Input": "Out"})
+
+ return var
+
+
+# the item is a tensor of bool
+def set_value_for_bool_tensor(var, item, value):
+ if len(item.shape) > len(var.shape):
+ raise IndexError("The dims of bool index doesn't match indexed array, "
+ "the dims of bool index except to be equal or less "
+ "than {}, but received {}.".format(
+ len(var.shape), len(item.shape)))
+ for i, dim_len in enumerate(item.shape):
+ if dim_len != var.shape[i]:
+ raise IndexError(
+ "The dimension of bool index doesn't match indexed array along "
+ "dimension {}, the target dimension is {}, but received {}.".
+ format(i, var.shape[i], dim_len))
+
+ def idx_not_empty(var, item, value):
+ from .framework import Variable
+ from .layers import assign
+ from .layers.nn import where
+ from ..tensor import gather_nd, scatter_nd_add
+
+ if not isinstance(value, Variable):
+ value = assign(value).cast(var.dtype)
+
+ idx = where(item)
+ gather_val = gather_nd(var, idx)
+ gather_val_new = value - gather_val
+ out = scatter_nd_add(var, idx, gather_val_new)
+ var[:] = out
+
+ from .layers.control_flow import cond
+ # If all the bool index is False, just do nothing
+ cond(item.any(), lambda: idx_not_empty(var, item, value))
+
+ return var
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/wrapped_decorator.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/wrapped_decorator.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f837b575637c561defc664f740bfc8e673c0aad
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/fluid/wrapped_decorator.py
@@ -0,0 +1,31 @@
+# Copyright (c) 2019 PaddlePaddle 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 decorator
+import contextlib
+
+__all__ = ['wrap_decorator', 'signature_safe_contextmanager']
+
+
+def wrap_decorator(decorator_func):
+
+ @decorator.decorator
+ def __impl__(func, *args, **kwargs):
+ wrapped_func = decorator_func(func)
+ return wrapped_func(*args, **kwargs)
+
+ return __impl__
+
+
+signature_safe_contextmanager = wrap_decorator(contextlib.contextmanager)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..34423e3f3ed6b5914dafc92232846b3580558545
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/__init__.py
@@ -0,0 +1,60 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+
+# TODO: import framework api under this directory
+
+from . import random # noqa: F401
+from .random import seed # noqa: F401
+from .framework import get_default_dtype # noqa: F401
+from .framework import set_default_dtype # noqa: F401
+from .framework import set_grad_enabled # noqa: F401
+from .framework import is_grad_enabled # noqa: F401
+
+from ..fluid.param_attr import ParamAttr # noqa: F401
+from ..fluid.layers.tensor import create_parameter # noqa: F401
+from ..fluid.core import CPUPlace # noqa: F401
+from ..fluid.core import IPUPlace # noqa: F401
+from ..fluid.core import CUDAPlace # noqa: F401
+from ..fluid.core import CUDAPinnedPlace # noqa: F401
+from ..fluid.core import NPUPlace # noqa: F401
+from ..fluid.core import MLUPlace # noqa: F401
+from ..fluid.core import CustomPlace # noqa: F401
+from ..fluid.core import VarBase # noqa: F401
+
+from ..fluid import core # noqa: F401
+from ..fluid.dygraph.base import no_grad_ as no_grad # noqa: F401
+from ..fluid.dygraph.base import grad # noqa: F401
+from .io import save # noqa: F401
+from .io import load # noqa: F401
+from ..fluid.dygraph.parallel import DataParallel # noqa: F401
+
+from ..fluid import monkey_patch_variable
+from ..fluid.dygraph import monkey_patch_math_varbase
+from ..fluid.framework import disable_signal_handler # noqa: F401
+from ..fluid.framework import get_flags # noqa: F401
+from ..fluid.framework import set_flags # noqa: F401
+from ..fluid.dygraph.base import enable_dygraph as disable_static # noqa: F401
+from ..fluid.dygraph.base import disable_dygraph as enable_static # noqa: F401
+from ..fluid.framework import _non_static_mode as in_dynamic_mode # noqa: F401
+from ..fluid.framework import _non_static_mode # noqa: F401; temporary used for hackson
+from ..fluid.framework import _current_expected_place, _get_paddle_place # noqa: F401
+from ..fluid.framework import dygraph_only # noqa: F401
+from ..fluid.framework import convert_np_dtype_to_dtype_, _varbase_creator, OpProtoHolder # noqa: F401
+from ..fluid.framework import _dygraph_tracer # noqa: F401
+
+from ..fluid.layer_helper import LayerHelper # noqa: F401
+from ..fluid.framework import in_dygraph_mode # noqa: F401
+from ..fluid.framework import _in_legacy_dygraph # noqa: F401
+
+__all__ = []
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/dtype.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/dtype.py
new file mode 100644
index 0000000000000000000000000000000000000000..6abc8e6e1aa9a7af641bb3a125e27b7a4943d688
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/dtype.py
@@ -0,0 +1,71 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from ..fluid.core import VarDesc
+from ..fluid.core import iinfo as core_iinfo
+
+dtype = VarDesc.VarType
+dtype.__qualname__ = "dtype"
+dtype.__module__ = "paddle"
+
+uint8 = VarDesc.VarType.UINT8
+int8 = VarDesc.VarType.INT8
+int16 = VarDesc.VarType.INT16
+int32 = VarDesc.VarType.INT32
+int64 = VarDesc.VarType.INT64
+
+float32 = VarDesc.VarType.FP32
+float64 = VarDesc.VarType.FP64
+float16 = VarDesc.VarType.FP16
+bfloat16 = VarDesc.VarType.BF16
+
+complex64 = VarDesc.VarType.COMPLEX64
+complex128 = VarDesc.VarType.COMPLEX128
+
+bool = VarDesc.VarType.BOOL
+
+
+def iinfo(dtype):
+ """
+
+ paddle.iinfo is a function that returns an object that represents the numerical properties of
+ an integer paddle.dtype.
+ This is similar to `numpy.iinfo `_.
+
+ Args:
+ dtype(paddle.dtype): One of paddle.uint8, paddle.int8, paddle.int16, paddle.int32, and paddle.int64.
+
+ Returns:
+ An iinfo object, which has the following 4 attributes:
+
+ - min: int, The smallest representable integer number.
+ - max: int, The largest representable integer number.
+ - bits: int, The number of bits occupied by the type.
+ - dtype: str, The string name of the argument dtype.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ iinfo_uint8 = paddle.iinfo(paddle.uint8)
+ print(iinfo_uint8)
+ # paddle.iinfo(min=0, max=255, bits=8, dtype=uint8)
+ print(iinfo_uint8.min) # 0
+ print(iinfo_uint8.max) # 255
+ print(iinfo_uint8.bits) # 8
+ print(iinfo_uint8.dtype) # uint8
+
+ """
+ return core_iinfo(dtype)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/framework.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/framework.py
new file mode 100644
index 0000000000000000000000000000000000000000..819c08a7f3ac97a23d417c42608409ba355d3ca5
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/framework.py
@@ -0,0 +1,149 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+
+# TODO: define framework api
+from paddle.fluid.layer_helper_base import LayerHelperBase
+from paddle.fluid.data_feeder import convert_dtype
+from paddle.fluid.framework import _dygraph_tracer
+import numpy as np
+from contextlib import contextmanager
+
+__all__ = []
+
+
+def set_default_dtype(d):
+ """
+ Set default dtype. The default dtype is initially float32.
+
+ Args:
+ d(string|np.dtype): the dtype to make the default. It only
+ supports float16, float32 and float64.
+
+ Returns:
+ None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.set_default_dtype("float32")
+
+ """
+ if isinstance(d, type):
+ if d in [np.float16, np.float32, np.float64]:
+ d = d.__name__
+ else:
+ raise TypeError(
+ "set_default_dtype only supports [float16, float32, float64] "
+ ", but received %s" % d.__name__
+ )
+ else:
+ if d in [
+ 'float16',
+ 'float32',
+ 'float64',
+ u'float16',
+ u'float32',
+ u'float64',
+ ]:
+ # this code is a little bit dangerous, since error could happen
+ # when casting no-ascii code to str in python2.
+ # but since the set itself is limited, so currently, it is good.
+ # however, jointly supporting python2 and python3, (as well as python4 maybe)
+ # may still be a long-lasting problem.
+ d = str(d)
+ else:
+ raise TypeError(
+ "set_default_dtype only supports [float16, float32, float64] "
+ ", but received %s" % str(d)
+ )
+
+ LayerHelperBase.set_default_dtype(d)
+
+
+def get_default_dtype():
+ """
+ Get the current default dtype. The default dtype is initially float32.
+
+ Args:
+ None.
+ Returns:
+ String, this global dtype only supports float16, float32, float64.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ paddle.get_default_dtype()
+ """
+ return LayerHelperBase.get_default_dtype()
+
+
+@contextmanager
+def set_grad_enabled(mode):
+ """
+ Create a context which enables or disables dygraph gradient calculation.
+
+ Args:
+ mode(bool): whether to enable (`True`), or disable (`False`) grad.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ x = paddle.ones([3, 2])
+ x.stop_gradient = False
+ with paddle.set_grad_enabled(False):
+ y = x * 2
+ with paddle.set_grad_enabled(True):
+ z = x * 2
+ print(y.stop_gradient) # True
+ print(z.stop_gradient) # False
+ """
+
+ tracer = _dygraph_tracer()
+ if tracer:
+ prev_mode = tracer._has_grad
+ tracer._has_grad = mode
+ try:
+ yield
+ finally:
+ tracer._has_grad = prev_mode
+ else:
+ yield
+
+
+def is_grad_enabled():
+ """
+ Returns whether current dygraph gradient calculation mode is enabled.
+
+ Returns:
+ bool: True if current dygraph gradient calculation mode is enabled, otherwise false.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ # Dygraph gradient calculation mode is enabled by default.
+ paddle.is_grad_enabled() # True
+
+ with paddle.set_grad_enabled(False):
+ paddle.is_grad_enabled() # False
+
+ paddle.enable_static()
+ paddle.is_grad_enabled() # False
+ """
+ tracer = _dygraph_tracer()
+ return tracer._has_grad if tracer else False
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/io.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/io.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa2375ca72fa60b22fccc5d8dd3b4ad73f9c91e6
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/io.py
@@ -0,0 +1,1152 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import os
+import collections
+import pickle
+import warnings
+import sys
+import numpy as np
+import copyreg
+import paddle
+
+# deprecated module import
+from paddle import fluid
+from paddle.fluid import core
+from paddle.fluid.io import (
+ _unpack_saved_dict,
+ _pack_loaded_dict,
+ _pickle_loads_mac,
+)
+from paddle.fluid.io import _legacy_save as _legacy_static_save
+from paddle.fluid.io import _open_file_buffer, _is_file_path, _is_memory_buffer
+
+from paddle.fluid.framework import (
+ Variable,
+ _varbase_creator,
+ _dygraph_tracer,
+ _non_static_mode,
+ ParamBase,
+ EagerParamBase,
+ _current_expected_place,
+ Program,
+)
+from paddle.fluid.dygraph.jit import _SaveLoadConfig
+from paddle.fluid.dygraph.io import (
+ _construct_program_holders,
+ _construct_params_and_buffers,
+)
+from paddle.fluid.dygraph.io import (
+ INFER_MODEL_SUFFIX,
+ INFER_PARAMS_SUFFIX,
+ INFER_PARAMS_INFO_SUFFIX,
+)
+
+try:
+ from collections.abc import Iterable
+except:
+ from collections import Iterable
+
+__all__ = []
+
+
+def _build_saved_state_dict(state_dict):
+ save_dict = {}
+ name_table = {}
+ for key, value in state_dict.items():
+ if isinstance(value, (Variable, core.VarBase, core.eager.Tensor)):
+ if value.type == core.VarDesc.VarType.VOCAB:
+ save_dict[key] = value.value().get_map_tensor()
+ else:
+ if not value.value().get_tensor()._is_initialized():
+ raise ValueError(
+ "The saved tensor is not initialized. If you used group sharded, please use save_group_sharded_model."
+ )
+ save_dict[key] = value.numpy()
+ name_table[key] = value.name
+ else:
+ save_dict[key] = value
+ save_dict["StructuredToParameterName@@"] = name_table
+
+ return save_dict
+
+
+def _load_state_dict_from_save_inference_model(model_path, config):
+ # 1. load program desc & construct _ProgramHolder
+ programs = _construct_program_holders(model_path, config.model_filename)
+
+ # 2. load layer parameters & buffers
+ with fluid.dygraph.guard():
+ persistable_var_dict = _construct_params_and_buffers(
+ model_path, programs, config.params_filename, append_suffix=False
+ )
+
+ # 3. construct state_dict
+ load_param_dict = dict()
+ for var_name in persistable_var_dict:
+ load_param_dict[var_name] = persistable_var_dict[var_name].numpy()
+
+ # if *.info exists, we can recover structured_name
+ var_info_filename = str(config.params_filename) + ".info"
+ var_info_path = os.path.join(model_path, var_info_filename)
+ if os.path.exists(var_info_path):
+ with open(var_info_path, 'rb') as f:
+ extra_var_info = pickle.load(f)
+ structured_para_dict = dict()
+ for var_name in load_param_dict:
+ structured_name = extra_var_info[var_name].get(
+ 'structured_name', None
+ )
+ assert structured_name is not None, (
+ "Cannot find saved variable (%s)'s structured name in saved model."
+ % var_name
+ )
+ structured_para_dict[structured_name] = load_param_dict[
+ var_name
+ ]
+ load_param_dict = structured_para_dict
+
+ return load_param_dict
+
+
+def _load_state_dict_from_save_params(model_path):
+ # Try to load all the files in the directory in VarBase format,
+ # the file name is used as the name of VarBase
+ load_var_list = []
+
+ # 1. load file names
+ var_name_list = []
+ for root, _, files in os.walk(model_path):
+ for filename in files:
+ file_path = os.path.join(root, filename)
+ tmp_var_name = os.path.relpath(file_path, model_path)
+ var_name = tmp_var_name.replace("\\", "/")
+ var_name_list.append(var_name)
+
+ # 2. create and load VarBase
+ with fluid.dygraph.guard():
+ for name in var_name_list:
+ new_var = _varbase_creator(name=name, persistable=True)
+ _dygraph_tracer().trace_op(
+ type='load',
+ inputs={},
+ outputs={'Out': new_var},
+ attrs={'file_path': os.path.join(model_path, name)},
+ )
+ load_var_list.append(new_var)
+
+ # 3. construct state_dict
+ load_param_dict = dict()
+ for var in load_var_list:
+ load_param_dict[var.name] = var.numpy()
+
+ return load_param_dict
+
+
+# NOTE(chenweihang): [ Handling of use cases of API paddle.load ]
+# `paddle.load` may be used to load saved results of:
+# 1. Expected cases:
+# - need [full filename] when loading
+# - paddle.save
+# - paddle.static.save
+# - paddle.fluid.save_dygraph
+# - need [prefix] when loading [compatible for paddle 2.x]
+# - paddle.jit.save
+# - paddle.static.save_inference_model
+# - need [directory] when loading [compatible for paddle 1.x]
+# - paddle.fluid.io.save_inference_model
+# - paddle.fluid.io.save_params/save_persistable
+# 2. Error cases:
+# - no error case
+def _build_load_path_and_config(path, config):
+ # NOTE(chenweihang): If both [prefix save format] and [directory save format] exist,
+ # raise error, avoid confusing behavior
+ prefix_format_path = path + INFER_MODEL_SUFFIX
+ prefix_format_exist = os.path.exists(prefix_format_path)
+ directory_format_exist = os.path.isdir(path)
+ if prefix_format_exist and directory_format_exist:
+ raise ValueError(
+ "The %s.pdmodel and %s directory exist at the same time, "
+ "don't know which one to load, please make sure that the specified target "
+ "of ``path`` is unique." % (path, path)
+ )
+ elif not prefix_format_exist and not directory_format_exist:
+ error_msg = "The ``path`` (%s) to load model not exists."
+ # if current path is a prefix, and the path.pdparams or path.pdopt
+ # is exist, users may want use `paddle.load` load the result of
+ # `fluid.save_dygraph`, we raise error here for users
+ params_file_path = path + ".pdparams"
+ opti_file_path = path + ".pdopt"
+ if os.path.exists(params_file_path) or os.path.exists(opti_file_path):
+ error_msg += (
+ " If you want to load the results saved by `fluid.save_dygraph`, "
+ "please specify the full file name, not just the file name prefix. For "
+ "example, it should be written as `paddle.load('model.pdparams')` instead of "
+ "`paddle.load('model')`."
+ )
+ raise ValueError(error_msg % path)
+ else:
+ if prefix_format_exist:
+ file_prefix = os.path.basename(path)
+ model_path = os.path.dirname(path)
+ if config.model_filename is not None:
+ warnings.warn(
+ "When loading the result saved with the "
+ "specified file prefix, the ``model_filename`` config does "
+ "not take effect."
+ )
+ config.model_filename = file_prefix + INFER_MODEL_SUFFIX
+ if config.params_filename is not None:
+ warnings.warn(
+ "When loading the result saved with the "
+ "specified file prefix, the ``params_filename`` config does "
+ "not take effect."
+ )
+ config.params_filename = file_prefix + INFER_PARAMS_SUFFIX
+ else:
+ # Compatible with the old save_inference_model format
+ model_path = path
+
+ return model_path, config
+
+
+def _parse_load_config(configs):
+ supported_configs = [
+ 'model_filename',
+ 'params_filename',
+ 'keep_name_table',
+ 'return_numpy',
+ ]
+
+ # input check
+ for key in configs:
+ if key not in supported_configs:
+ raise ValueError(
+ "The additional config (%s) of `paddle.load` is not supported."
+ % key
+ )
+
+ # construct inner config
+ inner_config = _SaveLoadConfig()
+ inner_config.model_filename = configs.get('model_filename', None)
+ inner_config.params_filename = configs.get('params_filename', None)
+ inner_config.keep_name_table = configs.get('keep_name_table', None)
+ inner_config.return_numpy = configs.get('return_numpy', False)
+
+ return inner_config
+
+
+def _parse_save_config(configs):
+ supported_configs = ['use_binary_format', 'pickle_protocol']
+
+ # input check
+ for key in configs:
+ if key not in supported_configs:
+ raise ValueError(
+ "The additional config (%s) of `paddle.save` is not supported."
+ % key
+ )
+
+ # construct inner config
+ inner_config = _SaveLoadConfig()
+ inner_config.use_binary_format = configs.get('use_binary_format', False)
+ inner_config.pickle_protocol = configs.get('pickle_protocol', None)
+
+ return inner_config
+
+
+def _pickle_save(obj, f, protocol):
+ # TODO(weixin):add support for BytesIO.
+ if not isinstance(protocol, int):
+ raise ValueError(
+ "The 'protocol' MUST be `int`, but received {}".format(
+ type(protocol)
+ )
+ )
+
+ if protocol < 2 or protocol > 4:
+ raise ValueError(
+ "Expected 1<'protocol'<5, but received protocol={}".format(protocol)
+ )
+
+ def reduce_varbase(self):
+ data = self.numpy()
+ name = self.name
+
+ return (tuple, ((name, data),))
+
+ def reduce_LoDTensor(self):
+ data = np.array(self)
+
+ return (eval, ('data', {'data': data}))
+
+ def reduce_Layer(self):
+ raise ValueError(
+ "paddle do not support saving `paddle.nn.Layer` object."
+ )
+
+ dispatch_table_layer = dict()
+
+ def create_layer_dispatch_table(layer):
+ dispatch_table_layer[layer.__class__] = reduce_Layer
+ return layer
+
+ _parse_every_object(
+ obj, lambda v: isinstance(v, fluid.Layer), create_layer_dispatch_table
+ )
+
+ def add_dispatch_table():
+ # This is not a good method, because the pickle module has been modified.
+ pickle.dispatch_table[core.VarBase] = reduce_varbase
+ pickle.dispatch_table[ParamBase] = reduce_varbase
+ pickle.dispatch_table[core.eager.Tensor] = reduce_varbase
+ pickle.dispatch_table[EagerParamBase] = reduce_varbase
+ pickle.dispatch_table[core.LoDTensor] = reduce_LoDTensor
+ pickle.dispatch_table.update(dispatch_table_layer)
+
+ def pop_dispatch_table():
+ pickle.dispatch_table.pop(core.VarBase)
+ pickle.dispatch_table.pop(core.LoDTensor)
+ pickle.dispatch_table.pop(ParamBase)
+ pickle.dispatch_table.pop(core.eager.Tensor)
+ pickle.dispatch_table.pop(EagerParamBase)
+ for k in dispatch_table_layer:
+ pickle.dispatch_table.pop(k)
+
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if sys.platform == 'darwin' and sys.version_info.major == 3:
+ add_dispatch_table()
+ pickle_bytes = pickle.dumps(obj)
+ pop_dispatch_table()
+
+ max_bytes = 2**30
+ for i in range(0, len(pickle_bytes), max_bytes):
+ f.write(pickle_bytes[i : i + max_bytes])
+ else:
+ pickler = pickle.Pickler(f, protocol)
+ pickler.dispatch_table = copyreg.dispatch_table.copy()
+
+ pickler.dispatch_table[core.VarBase] = reduce_varbase
+ pickler.dispatch_table[core.LoDTensor] = reduce_LoDTensor
+ pickler.dispatch_table[ParamBase] = reduce_varbase
+ pickler.dispatch_table[core.eager.Tensor] = reduce_varbase
+ pickler.dispatch_table[EagerParamBase] = reduce_varbase
+ pickler.dispatch_table.update(dispatch_table_layer)
+ pickler.dump(obj)
+
+
+def _contain_x(obj, condition_func):
+ if isinstance(obj, core.SelectedRows):
+ raise NotImplementedError(
+ "`paddle.save` do not support saving 'SelectedRows'."
+ )
+
+ if condition_func(obj):
+ return True
+ elif type(obj) in (dict, collections.OrderedDict, list, tuple):
+ if type(obj) in (dict, collections.OrderedDict):
+ keys = list(obj.keys())
+ else:
+ keys = range(len(obj))
+ flag = False
+ for key in keys:
+ flag |= _contain_x(obj[key], condition_func)
+ if flag:
+ return True
+ return flag
+ else:
+ return False
+
+
+def _is_state_dict(obj):
+ if isinstance(obj, dict):
+
+ def condition(obj):
+ return isinstance(
+ obj,
+ (
+ fluid.Layer,
+ Program,
+ core.VarBase,
+ core.eager.Tensor,
+ core.LoDTensor,
+ core.SelectedRows,
+ ),
+ )
+
+ # If the value of a dict is a core.VarBase/LoDTensor or a dict
+ # that does not contain a paddle type(Layer, Program, VarBase, LoDTensor, SelectedRows),
+ # the dict is considered to be a state_ dict.
+ for key, value in obj.items():
+ if isinstance(value, dict):
+ for k, v in value.items():
+ if _contain_x(v, condition):
+ return False
+ elif not isinstance(
+ value, (core.VarBase, core.eager.Tensor, core.LoDTensor)
+ ):
+ return False
+ return True
+
+ return False
+
+
+def _transformed_from_varbase(obj):
+ # In paddle2.1 version, VarBase is saved as tuple(tensor.name, tensor.numpy()).
+ # When executing paddle.load, use this function to determine whether to restore to VarBase/LoDTensor.
+ if isinstance(obj, tuple) and len(obj) == 2:
+ name_types = str
+ if isinstance(obj[0], name_types) and isinstance(obj[1], np.ndarray):
+ return True
+ return False
+
+
+def _transformed_from_lodtensor(obj):
+ # In paddle2.1 version, LoDTensor is saved as np.array(tensor).
+ # When executing paddle.load, use this function to determine whether to restore to VarBase/LoDTensor.
+ if isinstance(obj, np.ndarray):
+ return True
+ return False
+
+
+def _to_LodTensor(ndarray):
+ if not isinstance(ndarray, np.ndarray):
+ raise TypeError(
+ 'Type of `ndarray` should be numpy.ndarray, but received {}.'.format(
+ type(ndarray)
+ )
+ )
+ t = core.LoDTensor()
+ place = _current_expected_place()
+ t.set(ndarray, place)
+ return t
+
+
+def _tuple_to_tensor(obj, return_numpy):
+ if return_numpy:
+ return obj[1]
+ if _non_static_mode():
+ t = paddle.to_tensor(obj[1])
+ # This function does modify the name of return value.
+ # Loading the same variable multiple times may cause the same name.
+ t.name = obj[0]
+ return t
+ else:
+ return _to_LodTensor(obj[1])
+
+
+def _ndarray_to_tensor(obj, return_numpy):
+ if return_numpy:
+ return obj
+ if _non_static_mode():
+ return paddle.to_tensor(obj)
+ else:
+ return _to_LodTensor(obj)
+
+
+def _lod_tensor2varbase(tensor):
+ return_var = _varbase_creator()
+ return_var.value().get_tensor().set(tensor, _current_expected_place())
+ return return_var
+
+
+def _parse_every_object(obj, condition_func, convert_func):
+ if condition_func(obj):
+ return convert_func(obj)
+ elif type(obj) in (dict, collections.OrderedDict, list):
+ if type(obj) == list:
+ keys = range(len(obj))
+ else:
+ keys = list(obj.keys())
+ for key in keys:
+ if condition_func(obj[key]):
+ obj[key] = convert_func(obj[key])
+ else:
+ obj[key] = _parse_every_object(
+ obj[key], condition_func, convert_func
+ )
+ return obj
+ elif type(obj) == tuple:
+ return tuple(
+ _parse_every_object(list(obj), condition_func, convert_func)
+ )
+ elif type(obj) == set:
+ return set(_parse_every_object(list(obj), condition_func, convert_func))
+ else:
+ if isinstance(obj, Iterable) and not isinstance(
+ obj,
+ (str, np.ndarray, core.VarBase, core.eager.Tensor, core.LoDTensor),
+ ):
+ raise NotImplementedError(
+ "The iteratable objects supported are tuple, list, dict, OrderedDict, string. But received {}.".format(
+ type(obj)
+ )
+ )
+ return obj
+
+
+def _parse_load_result(obj, return_numpy):
+ def is_layer(obj):
+ return isinstance(obj, fluid.Layer)
+
+ def parse_layer(obj):
+ temp_dict = _parse_load_result(obj.__dict__, False)
+ obj.__dict__.update(temp_dict)
+ return obj
+
+ if _contain_x(obj, is_layer):
+ if not _non_static_mode():
+ raise ValueError(
+ "Layer can only be loaded in dynamic graph mode, but now in static graph mode."
+ )
+
+ _parse_every_object(obj, is_layer, parse_layer)
+
+ def tuple_to_tensor(obj):
+ return _tuple_to_tensor(obj, return_numpy=return_numpy)
+
+ def ndarray_to_tensor(obj):
+ return _ndarray_to_tensor(obj, return_numpy=return_numpy)
+
+ # tuple(name, ndarry) was converted from varbase of paddle2.1,
+ # and all tuple(name, ndarry) are converted to tensor.
+ if _contain_x(obj, _transformed_from_varbase):
+ return _parse_every_object(
+ obj, _transformed_from_varbase, tuple_to_tensor
+ )
+ # If there is no tuple(name, ndary), it is considered to be saved by paddle2.0
+ # or converted from LoDTensor, and all ndarrays are converted to tensor.
+ else:
+ return _parse_every_object(
+ obj, _transformed_from_lodtensor, ndarray_to_tensor
+ )
+
+
+def _save_lod_tensor(tensor, file_name):
+ if not tensor._is_initialized():
+ raise ValueError(
+ "The saved tensor is not initialized. If you used group sharded, please use save_group_sharded_model firstly."
+ )
+ if _is_file_path(file_name):
+ _seek = core.save_lod_tensor(tensor, file_name)
+ # '_seek' is the end position of this tensor in the file.
+
+ elif _is_memory_buffer(file_name):
+ tensor_bytes = core.save_lod_tensor_to_memory(tensor)
+
+ with _open_file_buffer(file_name, 'wb') as f:
+ f.write(tensor_bytes)
+ _seek = f.tell()
+
+ else:
+ raise NotImplementedError(
+ 'Only supports saving objects to file or BytesIO, but received {}'.format(
+ type(file_name)
+ )
+ )
+ return _seek
+
+
+def _load_lod_tensor(file_name):
+ temp_t = paddle.fluid.core.LoDTensor()
+ if _is_file_path(file_name):
+ # '_seek' is the end position of this tensor in the file.
+ _seek = paddle.fluid.core.load_lod_tensor(temp_t, file_name)
+
+ elif _is_memory_buffer(file_name):
+ with _open_file_buffer(file_name, 'rb') as f:
+ tensor_bytes = f.read()
+ paddle.fluid.core.load_lod_tensor_from_memory(temp_t, tensor_bytes)
+ _seek = f.tell()
+
+ else:
+ raise NotImplementedError(
+ 'Only supports load objects from file or BytesIO, but received {}'.format(
+ type(file_name)
+ )
+ )
+
+ return temp_t, _seek
+
+
+def _save_selected_rows(selected_rows, file_name):
+ if not selected_rows.get_tensor()._is_initialized():
+ raise ValueError("The saved tensor is not initialized.")
+ if _is_file_path(file_name):
+ # '_seek' is the end position of this SelectedRows in the file.
+ _seek = core.save_selected_rows(selected_rows, file_name)
+
+ elif _is_memory_buffer(file_name):
+ selected_rows_bytes = core.save_selected_rows_to_memory(selected_rows)
+ with _open_file_buffer(file_name, 'wb') as f:
+ f.write(selected_rows_bytes)
+ _seek = f.tell()
+ else:
+ raise NotImplementedError(
+ 'Only supports saving objects to file or BytesIO, but received {}'.format(
+ type(file_name)
+ )
+ )
+ return _seek
+
+
+def _load_selected_rows(file_name):
+ temp_sr = core.SelectedRows()
+ if _is_file_path(file_name):
+ # '_seek' is the end position of this SelectedRows in the file.
+ _seek = core.load_selected_rows(temp_sr, file_name)
+
+ elif _is_memory_buffer(file_name):
+ with _open_file_buffer(file_name, 'rb') as f:
+ selected_rows_bytes = f.read()
+ paddle.fluid.core.load_selected_rows_from_memory(
+ temp_sr, selected_rows_bytes
+ )
+ _seek = f.tell()
+
+ else:
+ raise NotImplementedError(
+ 'Only supports load objects from file or BytesIO, but received {}'.format(
+ type(file_name)
+ )
+ )
+
+ return temp_sr, _seek
+
+
+def _save_binary_var(obj, path):
+ if isinstance(obj, core.LoDTensor):
+ _save_lod_tensor(obj, path)
+ elif isinstance(obj, core.SelectedRows):
+ _save_selected_rows(obj, path)
+ elif isinstance(obj, (core.VarBase, core.eager.Tensor)):
+ _save_lod_tensor(obj.value().get_tensor(), path)
+ else:
+ # Since the concept of 'Tensor' is only exposed to users, the error message can only contain tensor instead of 'LoDTensor' or 'SelectedRows'
+ raise NotImplementedError(
+ "When use_binary_format = True, `paddle.save` expected Tensor, but received {}.".format(
+ type(obj)
+ )
+ )
+
+
+def save(obj, path, protocol=4, **configs):
+ '''
+ Save an object to the specified path.
+
+ Note:
+ Now supports saving ``state_dict`` of Layer/Optimizer, Tensor and nested structure containing Tensor, Program.
+
+ Note:
+ Different from ``paddle.jit.save``, since the save result of ``paddle.save`` is a single file,
+ there is no need to distinguish multiple saved files by adding a suffix. The argument ``path``
+ of ``paddle.save`` will be directly used as the saved file name instead of a prefix.
+ In order to unify the saved file name format, we recommend using the paddle standard suffix:
+ 1. for ``Layer.state_dict`` , recommend to use ``.pdparams`` ;
+ 2. for ``Optimizer.state_dict`` , recommend to use ``.pdopt`` .
+ For specific examples, please refer to API code examples.
+
+ Args:
+ obj(Object) : The object to be saved.
+ path(str|BytesIO) : The path/buffer of the object to be saved.
+ If saved in the current directory, the input path string will be used as the file name.
+ protocol(int, optional): The protocol version of pickle module must be greater than 1 and less than 5.
+ Default: 4
+ **configs(dict, optional): optional keyword arguments. The following options are currently supported:
+ use_binary_format(bool): When the saved object is static graph variable, you can specify ``use_binary_for_var``.
+ If True, save the file in the c++ binary format when saving a single static graph variable; otherwise, save it in pickle format.
+ Default: False
+
+ Returns:
+ None
+
+ Examples:
+ .. code-block:: python
+
+ # example 1: dynamic graph
+ import paddle
+ emb = paddle.nn.Embedding(10, 10)
+ layer_state_dict = emb.state_dict()
+
+ # save state_dict of emb
+ paddle.save(layer_state_dict, "emb.pdparams")
+
+ scheduler = paddle.optimizer.lr.NoamDecay(
+ d_model=0.01, warmup_steps=100, verbose=True)
+ adam = paddle.optimizer.Adam(
+ learning_rate=scheduler,
+ parameters=emb.parameters())
+ opt_state_dict = adam.state_dict()
+
+ # save state_dict of optimizer
+ paddle.save(opt_state_dict, "adam.pdopt")
+ # save weight of emb
+ paddle.save(emb.weight, "emb.weight.pdtensor")
+
+ # example 2: Save multiple state_dict at the same time
+ from paddle import nn
+ from paddle.optimizer import Adam
+
+ layer = paddle.nn.Linear(3, 4)
+ adam = Adam(learning_rate=0.001, parameters=layer.parameters())
+ obj = {'model': layer.state_dict(), 'opt': adam.state_dict(), 'epoch': 100}
+ path = 'example/model.pdparams'
+ paddle.save(obj, path)
+
+
+ # example 3: static graph
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ # create network
+ x = paddle.static.data(name="x", shape=[None, 224], dtype='float32')
+ z = paddle.static.nn.fc(x, 10)
+
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(paddle.static.default_startup_program())
+ prog = paddle.static.default_main_program()
+ for var in prog.list_vars():
+ if list(var.shape) == [224, 10]:
+ tensor = var.get_value()
+ break
+
+ # save/load tensor
+ path_tensor = 'temp/tensor.pdtensor'
+ paddle.save(tensor, path_tensor)
+
+ # save/load state_dict
+ path_state_dict = 'temp/model.pdparams'
+ paddle.save(prog.state_dict("param"), path_tensor)
+
+ # example 4: save program
+ import paddle
+
+ paddle.enable_static()
+
+ data = paddle.static.data(
+ name='x_static_save', shape=(None, 224), dtype='float32')
+ y_static = z = paddle.static.nn.fc(data, 10)
+ main_program = paddle.static.default_main_program()
+ path = "example/main_program.pdmodel"
+ paddle.save(main_program, path)
+
+
+ # example 5: save object to memory
+ from io import BytesIO
+ import paddle
+ from paddle.nn import Linear
+ paddle.disable_static()
+
+ linear = Linear(5, 10)
+ state_dict = linear.state_dict()
+ byio = BytesIO()
+ paddle.save(state_dict, byio)
+ tensor = paddle.randn([2, 3], dtype='float32')
+ paddle.save(tensor, byio)
+
+ '''
+ if _is_file_path(path):
+ # 1. input check
+ filename = os.path.basename(path)
+ if filename == "":
+ raise ValueError(
+ "The input path MUST be format of dirname/filename "
+ "[dirname\\filename in Windows system], but received "
+ "filename is empty string."
+ )
+
+ # 2. save object
+ dirname = os.path.dirname(path)
+ if dirname and not os.path.exists(dirname):
+ os.makedirs(dirname)
+ elif not _is_memory_buffer(path):
+ raise ValueError(
+ "only supports saving objects to file and `BytesIO`, but got {}".format(
+ type(path)
+ )
+ )
+
+ config = _parse_save_config(configs)
+
+ if not isinstance(config.use_binary_format, bool):
+ raise TypeError(
+ "Type of `use_binary_format` should be bool, but received {}.".format(
+ type(config.use_binary_format)
+ )
+ )
+
+ if config.use_binary_format:
+ _save_binary_var(obj, path)
+ else:
+ # `protocol` need to be used, `pickle_protocol` is a deprecated arg.
+ if config.pickle_protocol is not None:
+ protocol = config.pickle_protocol
+ warnings.warn(
+ "'pickle_protocol' is a deprecated argument. Please use 'protocol' instead."
+ )
+
+ if isinstance(obj, Program):
+ obj.desc.flush()
+ with _open_file_buffer(path, "wb") as f:
+ f.write(obj.desc.serialize_to_string())
+
+ elif _is_state_dict(obj):
+ if _non_static_mode():
+ _legacy_save(obj, path, protocol)
+ else:
+ _legacy_static_save(obj, path, protocol)
+ else:
+ with _open_file_buffer(path, 'wb') as f:
+ _pickle_save(obj, f, protocol)
+
+
+def _legacy_save(obj, path, protocol=2):
+ # 1. input check
+ if not isinstance(obj, dict):
+ raise NotImplementedError(
+ "Now only supports save state_dict of Layer or Optimizer, "
+ "expect dict, but received %s." % type(obj)
+ )
+
+ if len(obj) == 0:
+ warnings.warn("The input state dict is empty, no need to save.")
+
+ if not isinstance(protocol, int):
+ raise ValueError(
+ "The 'protocol' MUST be `int`, but received {}".format(
+ type(protocol)
+ )
+ )
+
+ if protocol < 2 or protocol > 4:
+ raise ValueError(
+ "Expected 1<'protocol'<5, but received protocol={}".format(protocol)
+ )
+
+ if _is_file_path(path):
+ filename = os.path.basename(path)
+ if filename == "":
+ raise ValueError(
+ "The input path MUST be format of dirname/filename "
+ "[dirname\\filename in Windows system], but received "
+ "filename is empty string."
+ )
+ # 2. save object
+ dirname = os.path.dirname(path)
+ if dirname and not os.path.exists(dirname):
+ os.makedirs(dirname)
+
+ if isinstance(obj, dict):
+ saved_obj = _build_saved_state_dict(obj)
+
+ saved_obj = _unpack_saved_dict(saved_obj, protocol)
+
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if (
+ _is_file_path(path)
+ and sys.platform == 'darwin'
+ and sys.version_info.major == 3
+ ):
+ pickle_bytes = pickle.dumps(saved_obj, protocol=protocol)
+ with open(path, 'wb') as f:
+ max_bytes = 2**30
+ for i in range(0, len(pickle_bytes), max_bytes):
+ f.write(pickle_bytes[i : i + max_bytes])
+ else:
+ with _open_file_buffer(path, 'wb') as f:
+ pickle.dump(saved_obj, f, protocol=protocol)
+
+
+def load(path, **configs):
+ '''
+ Load an object can be used in paddle from specified path.
+
+ Note:
+ Now supports loading ``state_dict`` of Layer/Optimizer, Tensor and nested structure containing Tensor, Program.
+
+ Note:
+ In order to use the model parameters saved by paddle more efficiently,
+ ``paddle.load`` supports loading ``state_dict`` of Layer from the result of
+ other save APIs except ``paddle.save`` , but the argument ``path`` format is
+ different:
+ 1. loading from ``paddle.static.save`` or ``paddle.Model().save(training=True)`` ,
+ ``path`` needs to be a complete file name, such as ``model.pdparams`` or
+ ``model.pdopt`` ;
+ 2. loading from ``paddle.jit.save`` or ``paddle.static.save_inference_model``
+ or ``paddle.Model().save(training=False)`` , ``path`` need to be a file prefix,
+ such as ``model/mnist``, and ``paddle.load`` will get information from
+ ``mnist.pdmodel`` and ``mnist.pdiparams`` ;
+ 3. loading from paddle 1.x APIs ``paddle.fluid.io.save_inference_model`` or
+ ``paddle.fluid.io.save_params/save_persistables`` , ``path`` need to be a
+ directory, such as ``model`` and model is a directory.
+
+ Note:
+ If you load ``state_dict`` from the saved result of static mode API such as
+ ``paddle.static.save`` or ``paddle.static.save_inference_model`` ,
+ the structured variable name in dynamic mode will cannot be restored.
+ You need to set the argument ``use_structured_name=False`` when using
+ ``Layer.set_state_dict`` later.
+
+ Args:
+ path(str|BytesIO) : The path/buffer to load the target object. Generally, the path is the target
+ file path. When loading state_dict from the saved result of the API used to save
+ the inference model, the path may be a file prefix or directory.
+ **configs (dict, optional): other load configuration options for compatibility. We do not
+ recommend using these configurations, they may be removed in the future. If not necessary,
+ DO NOT use them. Default None.
+ The following options are currently supported:
+ (1) model_filename (str): The inference model file name of the paddle 1.x
+ ``save_inference_model`` save format. Default file name is :code:`__model__` .
+ (2) params_filename (str): The persistable variables file name of the paddle 1.x
+ ``save_inference_model`` save format. No default file name, save variables separately
+ by default.
+ (3) return_numpy(bool): If specified as True, return tensor as numpy.ndarray, otherwise return tensor as paddle.Tensor.
+ Default False.
+
+ Returns:
+ Object(Object): a target object can be used in paddle
+
+ Examples:
+ .. code-block:: python
+
+ # example 1: dynamic graph
+ import paddle
+ emb = paddle.nn.Embedding(10, 10)
+ layer_state_dict = emb.state_dict()
+
+ # save state_dict of emb
+ paddle.save(layer_state_dict, "emb.pdparams")
+
+ scheduler = paddle.optimizer.lr.NoamDecay(
+ d_model=0.01, warmup_steps=100, verbose=True)
+ adam = paddle.optimizer.Adam(
+ learning_rate=scheduler,
+ parameters=emb.parameters())
+ opt_state_dict = adam.state_dict()
+
+ # save state_dict of optimizer
+ paddle.save(opt_state_dict, "adam.pdopt")
+ # save weight of emb
+ paddle.save(emb.weight, "emb.weight.pdtensor")
+
+ # load state_dict of emb
+ load_layer_state_dict = paddle.load("emb.pdparams")
+ # load state_dict of optimizer
+ load_opt_state_dict = paddle.load("adam.pdopt")
+ # load weight of emb
+ load_weight = paddle.load("emb.weight.pdtensor")
+
+
+ # example 2: Load multiple state_dict at the same time
+ from paddle import nn
+ from paddle.optimizer import Adam
+
+ layer = paddle.nn.Linear(3, 4)
+ adam = Adam(learning_rate=0.001, parameters=layer.parameters())
+ obj = {'model': layer.state_dict(), 'opt': adam.state_dict(), 'epoch': 100}
+ path = 'example/model.pdparams'
+ paddle.save(obj, path)
+ obj_load = paddle.load(path)
+
+
+ # example 3: static graph
+ import paddle
+ import paddle.static as static
+
+ paddle.enable_static()
+
+ # create network
+ x = paddle.static.data(name="x", shape=[None, 224], dtype='float32')
+ z = paddle.static.nn.fc(x, 10)
+
+ place = paddle.CPUPlace()
+ exe = paddle.static.Executor(place)
+ exe.run(paddle.static.default_startup_program())
+ prog = paddle.static.default_main_program()
+ for var in prog.list_vars():
+ if list(var.shape) == [224, 10]:
+ tensor = var.get_value()
+ break
+
+ # save/load tensor
+ path_tensor = 'temp/tensor.pdtensor'
+ paddle.save(tensor, path_tensor)
+ load_tensor = paddle.load(path_tensor)
+
+ # save/load state_dict
+ path_state_dict = 'temp/model.pdparams'
+ paddle.save(prog.state_dict("param"), path_tensor)
+ load_state_dict = paddle.load(path_tensor)
+
+
+ # example 4: load program
+ import paddle
+
+ paddle.enable_static()
+
+ data = paddle.static.data(
+ name='x_static_save', shape=(None, 224), dtype='float32')
+ y_static = z = paddle.static.nn.fc(data, 10)
+ main_program = paddle.static.default_main_program()
+ path = "example/main_program.pdmodel"
+ paddle.save(main_program, path)
+ load_main = paddle.load(path)
+ print(load_main)
+
+
+ # example 5: save object to memory
+ from io import BytesIO
+ import paddle
+ from paddle.nn import Linear
+ paddle.disable_static()
+
+ linear = Linear(5, 10)
+ state_dict = linear.state_dict()
+ byio = BytesIO()
+ paddle.save(state_dict, byio)
+ tensor = paddle.randn([2, 3], dtype='float32')
+ paddle.save(tensor, byio)
+ byio.seek(0)
+ # load state_dict
+ dict_load = paddle.load(byio)
+
+ '''
+
+ if _is_memory_buffer(path) or os.path.isfile(path):
+ config = _parse_load_config(configs)
+ exception_type = pickle.UnpicklingError
+ try:
+ with _open_file_buffer(path, 'rb') as f:
+ # When value of dict is lager than 4GB ,there is a Bug on 'MAC python3'
+ if (
+ _is_file_path(path)
+ and sys.platform == 'darwin'
+ and sys.version_info.major == 3
+ ):
+ load_result = _pickle_loads_mac(path, f)
+ else:
+ load_result = pickle.load(f, encoding='latin1')
+
+ # TODO(weixin):If `obj` is any object, the judgment condition should be more precise.
+ if isinstance(load_result, dict):
+ load_result = _pack_loaded_dict(load_result)
+ # paddle2.0: paddle.save/load
+ if "StructuredToParameterName@@" in load_result:
+
+ for key in load_result["StructuredToParameterName@@"]:
+ if isinstance(load_result[key], np.ndarray):
+ load_result[key] = _ndarray_to_tensor(
+ load_result[key], config.return_numpy
+ )
+
+ if (
+ not config.keep_name_table
+ and "StructuredToParameterName@@" in load_result
+ ):
+ del load_result["StructuredToParameterName@@"]
+ else:
+ # paddle2.1 static.save/load
+ load_result = _parse_load_result(
+ load_result, config.return_numpy
+ )
+
+ else:
+ load_result = _parse_load_result(
+ load_result, config.return_numpy
+ )
+
+ except exception_type as msg_pickle:
+ try:
+ tensor, _ = _load_selected_rows(path)
+ return tensor
+ except:
+ try:
+ tensor, _ = _load_lod_tensor(path)
+ if config.return_numpy:
+ return np.array(tensor)
+ else:
+ if _non_static_mode():
+ return _lod_tensor2varbase(tensor)
+ return tensor
+ except:
+ try:
+ with _open_file_buffer(path, "rb") as f:
+ program_desc_str = f.read()
+ program = Program.parse_from_string(
+ program_desc_str
+ )
+ return program
+ except:
+ raise ValueError(
+ "`paddle.load` can not parse the file:{}.".format(
+ path
+ )
+ )
+
+ else:
+ load_result = _legacy_load(path, **configs)
+
+ return load_result
+
+
+def _legacy_load(path, **configs):
+ load_result = None
+ config = _parse_load_config(configs)
+
+ if os.path.isfile(path) or _is_memory_buffer(path):
+ # we think path is file means this file is created by paddle.save
+ with _open_file_buffer(path, 'rb') as f:
+ load_result = pickle.load(f, encoding='latin1')
+ load_result = _pack_loaded_dict(load_result)
+ if (
+ not config.keep_name_table
+ and "StructuredToParameterName@@" in load_result
+ ):
+ del load_result["StructuredToParameterName@@"]
+ else:
+ # file prefix and directory are compatible cases
+ model_path, config = _build_load_path_and_config(path, config)
+ # check whether model file exists
+ if config.model_filename is None:
+ model_filename = '__model__'
+ else:
+ model_filename = config.model_filename
+ model_file_path = os.path.join(model_path, model_filename)
+
+ if os.path.exists(model_file_path):
+ # Load state dict by `jit.save/io.save_inference_model` save format
+ # NOTE(chenweihang): [ Compatibility of save_inference_model save format ]
+ # The model saved by `save_inference_model` does not completely correspond to
+ # the information required by the `state_dict` under the dygraph.
+ # `save_inference_model` not save structured name, we need to remind
+ # the user to configure the `use_structured_name` argument when `set_state_dict`
+ # NOTE(chenweihang): `jit.save` doesn't save optimizer state
+ load_result = _load_state_dict_from_save_inference_model(
+ model_path, config
+ )
+ else:
+ # load state dict by `io.save_params/persistables` save format
+ # TODO(chenweihang): [ Now only supports loading parameters separately ]
+ # If users save all parameters as one file, the [ variable.name -> variable ]
+ # mapping info will lost, so users need to give variable list, but users build
+ # variable list in dygraph mode is difficult, we recommend users to use
+ # paddle.static.load_program_state in this case
+ load_result = _load_state_dict_from_save_params(model_path)
+
+ return load_result
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/random.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/random.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c5ff2c8efba9c5618a1e1fd3d7acace71331c13
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/framework/random.py
@@ -0,0 +1,130 @@
+# Copyright (c) 2020 PaddlePaddle 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.
+
+# TODO: define random api
+import paddle.fluid as fluid
+from paddle.fluid import core
+
+__all__ = []
+
+
+def seed(seed):
+ """
+
+ Sets the seed for global default generator, which manages the random number generation.
+
+ Args:
+ seed(int): The random seed to set. It is recommend to set a large int number.
+
+ Returns:
+ Generator: The global default generator object.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ gen = paddle.seed(102)
+
+ """
+ #TODO(zhiqiu): 1. remove program.random_seed when all random-related op upgrade
+ # 2. support gpu generator by global device
+
+ seed = int(seed)
+
+ if core.is_compiled_with_cuda():
+ for i in range(core.get_cuda_device_count()):
+ core.default_cuda_generator(i).manual_seed(seed)
+
+ return core.default_cpu_generator().manual_seed(seed)
+
+
+def get_cuda_rng_state():
+ """
+
+ Get random state of cuda generators.
+
+ Args:
+ None.
+
+ Returns:
+ GeneratorState: object.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ sts = paddle.get_cuda_rng_state()
+
+ """
+ state_list = []
+ if core.is_compiled_with_cuda():
+ for i in range(core.get_cuda_device_count()):
+ state_list.append(core.default_cuda_generator(i).get_state())
+
+ return state_list
+
+
+def set_cuda_rng_state(state_list):
+ """
+
+ Sets generator state for all cuda generators.
+
+ Args:
+ state_list(list|tuple): The cuda states to set back to cuda generators. state_list is obtained from get_cuda_rng_state().
+
+ Returns:
+ None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ sts = paddle.get_cuda_rng_state()
+ paddle.set_cuda_rng_state(sts)
+
+ """
+ if core.is_compiled_with_cuda():
+ if not len(state_list) == core.get_cuda_device_count():
+ raise ValueError(
+ "Length of cuda state list shoule be equal to the cuda device count"
+ )
+ for i in range(core.get_cuda_device_count()):
+ core.default_cuda_generator(i).set_state(state_list[i])
+
+
+def _manual_program_seed(seed):
+ """
+ Sets global seed for generating random numbers.
+
+ NOTE(zhiqiu): This is the original implemention of seed. Keeps it temporally
+ since CUDA generator is not developed, so we need it in the unittest.
+
+ Args:
+ seed(int): The random seed to set. It is recommend to set a large int number.
+
+ Returns:
+ None
+ """
+ fluid.default_main_program().random_seed = seed
+ fluid.default_startup_program().random_seed = seed
+ program = fluid.Program()
+ program.global_seed(seed)
+
+
+def set_random_seed_generator(name, seed):
+ core.set_random_seed_generator(name, seed)
+
+
+def get_random_seed_generator(name):
+ return core.get_random_seed_generator(name)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9618bc57a203ea4c724b9ee6c406ac41c7f2ab65
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/__init__.py
@@ -0,0 +1,37 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .message_passing import send_u_recv # noqa: F401
+from .message_passing import send_ue_recv # noqa: F401
+from .message_passing import send_uv # noqa: F401
+from .math import segment_sum # noqa: F401
+from .math import segment_mean # noqa: F401
+from .math import segment_min # noqa: F401
+from .math import segment_max # noqa: F401
+from .reindex import reindex_graph # noqa: F401
+from .reindex import reindex_heter_graph # noqa: F401
+from .sampling import sample_neighbors # noqa: F401
+
+__all__ = [
+ 'send_u_recv',
+ 'send_ue_recv',
+ 'send_uv',
+ 'segment_sum',
+ 'segment_mean',
+ 'segment_min',
+ 'segment_max',
+ 'reindex_graph',
+ 'reindex_heter_graph',
+ 'sample_neighbors',
+]
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/math.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/math.py
new file mode 100644
index 0000000000000000000000000000000000000000..22b0f32114a2213cb4e5768fe5db26cecac7fed1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/math.py
@@ -0,0 +1,264 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from paddle.fluid.layer_helper import LayerHelper, _non_static_mode
+from paddle.fluid.data_feeder import check_variable_and_dtype
+from paddle import _C_ops, _legacy_C_ops
+from paddle.fluid.framework import _in_legacy_dygraph, in_dygraph_mode
+
+__all__ = []
+
+
+def segment_sum(data, segment_ids, name=None):
+ r"""
+ Segment Sum Operator.
+
+ This operator sums the elements of input `data` which with
+ the same index in `segment_ids`.
+ It computes a tensor such that $out_i = \\sum_{j} data_{j}$
+ where sum is over j such that `segment_ids[j] == i`.
+
+ Args:
+ data (Tensor): A tensor, available data type float32, float64, int32, int64, float16.
+ segment_ids (Tensor): A 1-D tensor, which have the same size
+ with the first dimension of input data.
+ Available data type is int32, int64.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - output (Tensor), the reduced result.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.to_tensor([[1, 2, 3], [3, 2, 1], [4, 5, 6]], dtype='float32')
+ segment_ids = paddle.to_tensor([0, 0, 1], dtype='int32')
+ out = paddle.geometric.segment_sum(data, segment_ids)
+ #Outputs: [[4., 4., 4.], [4., 5., 6.]]
+
+ """
+ if in_dygraph_mode():
+ return _C_ops.segment_pool(data, segment_ids, "SUM")[0]
+ if _in_legacy_dygraph():
+ out, tmp = _legacy_C_ops.segment_pool(
+ data, segment_ids, 'pooltype', "SUM"
+ )
+ return out
+
+ check_variable_and_dtype(
+ data,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "segment_pool",
+ )
+ check_variable_and_dtype(
+ segment_ids, "SegmentIds", ("int32", "int64"), "segment_pool"
+ )
+
+ helper = LayerHelper("segment_sum", **locals())
+ out = helper.create_variable_for_type_inference(dtype=data.dtype)
+ summed_ids = helper.create_variable_for_type_inference(dtype=data.dtype)
+ helper.append_op(
+ type="segment_pool",
+ inputs={"X": data, "SegmentIds": segment_ids},
+ outputs={"Out": out, "SummedIds": summed_ids},
+ attrs={"pooltype": "SUM"},
+ )
+ return out
+
+
+def segment_mean(data, segment_ids, name=None):
+ r"""
+ Segment mean Operator.
+
+ This operator calculate the mean value of input `data` which
+ with the same index in `segment_ids`.
+ It computes a tensor such that $out_i = \\frac{1}{n_i} \\sum_{j} data[j]$
+ where sum is over j such that 'segment_ids[j] == i' and $n_i$ is the number
+ of all index 'segment_ids[j] == i'.
+
+ Args:
+ data (tensor): a tensor, available data type float32, float64, int32, int64, float16.
+ segment_ids (tensor): a 1-d tensor, which have the same size
+ with the first dimension of input data.
+ available data type is int32, int64.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - output (Tensor), the reduced result.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.to_tensor([[1, 2, 3], [3, 2, 1], [4, 5, 6]], dtype='float32')
+ segment_ids = paddle.to_tensor([0, 0, 1], dtype='int32')
+ out = paddle.geometric.segment_mean(data, segment_ids)
+ #Outputs: [[2., 2., 2.], [4., 5., 6.]]
+
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.segment_pool(data, segment_ids, "MEAN")[0]
+ if _in_legacy_dygraph():
+ out, tmp = _legacy_C_ops.segment_pool(
+ data, segment_ids, 'pooltype', "MEAN"
+ )
+ return out
+
+ check_variable_and_dtype(
+ data,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "segment_pool",
+ )
+ check_variable_and_dtype(
+ segment_ids, "SegmentIds", ("int32", "int64"), "segment_pool"
+ )
+
+ helper = LayerHelper("segment_mean", **locals())
+ out = helper.create_variable_for_type_inference(dtype=data.dtype)
+ summed_ids = helper.create_variable_for_type_inference(dtype=data.dtype)
+ helper.append_op(
+ type="segment_pool",
+ inputs={"X": data, "SegmentIds": segment_ids},
+ outputs={"Out": out, "SummedIds": summed_ids},
+ attrs={"pooltype": "MEAN"},
+ )
+ return out
+
+
+def segment_min(data, segment_ids, name=None):
+ r"""
+ Segment min operator.
+
+ This operator calculate the minimum elements of input `data` which with
+ the same index in `segment_ids`.
+ It computes a tensor such that $out_i = \\min_{j} data_{j}$
+ where min is over j such that `segment_ids[j] == i`.
+
+ Args:
+ data (tensor): a tensor, available data type float32, float64, int32, int64, float16.
+ segment_ids (tensor): a 1-d tensor, which have the same size
+ with the first dimension of input data.
+ available data type is int32, int64.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - output (Tensor), the reduced result.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.to_tensor([[1, 2, 3], [3, 2, 1], [4, 5, 6]], dtype='float32')
+ segment_ids = paddle.to_tensor([0, 0, 1], dtype='int32')
+ out = paddle.geometric.segment_min(data, segment_ids)
+ #Outputs: [[1., 2., 1.], [4., 5., 6.]]
+
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.segment_pool(data, segment_ids, "MIN")[0]
+ if _in_legacy_dygraph():
+ out, tmp = _legacy_C_ops.segment_pool(
+ data, segment_ids, 'pooltype', "MIN"
+ )
+ return out
+
+ check_variable_and_dtype(
+ data,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "segment_pool",
+ )
+ check_variable_and_dtype(
+ segment_ids, "SegmentIds", ("int32", "int64"), "segment_pool"
+ )
+
+ helper = LayerHelper("segment_min", **locals())
+ out = helper.create_variable_for_type_inference(dtype=data.dtype)
+ summed_ids = helper.create_variable_for_type_inference(dtype=data.dtype)
+ helper.append_op(
+ type="segment_pool",
+ inputs={"X": data, "SegmentIds": segment_ids},
+ outputs={"Out": out, "SummedIds": summed_ids},
+ attrs={"pooltype": "MIN"},
+ )
+ return out
+
+
+def segment_max(data, segment_ids, name=None):
+ r"""
+ Segment max operator.
+
+ This operator calculate the maximum elements of input `data` which with
+ the same index in `segment_ids`.
+ It computes a tensor such that $out_i = \\max_{j} data_{j}$
+ where max is over j such that `segment_ids[j] == i`.
+
+ Args:
+ data (tensor): a tensor, available data type float32, float64, int32, int64, float16.
+ segment_ids (tensor): a 1-d tensor, which have the same size
+ with the first dimension of input data.
+ available data type is int32, int64.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - output (Tensor), the reduced result.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ data = paddle.to_tensor([[1, 2, 3], [3, 2, 1], [4, 5, 6]], dtype='float32')
+ segment_ids = paddle.to_tensor([0, 0, 1], dtype='int32')
+ out = paddle.geometric.segment_max(data, segment_ids)
+ #Outputs: [[3., 2., 3.], [4., 5., 6.]]
+
+ """
+
+ if in_dygraph_mode():
+ return _C_ops.segment_pool(data, segment_ids, "MAX")[0]
+ if _in_legacy_dygraph():
+ out, tmp = _legacy_C_ops.segment_pool(
+ data, segment_ids, 'pooltype', "MAX"
+ )
+ return out
+
+ check_variable_and_dtype(
+ data,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "segment_pool",
+ )
+ check_variable_and_dtype(
+ segment_ids, "SegmentIds", ("int32", "int64"), "segment_pool"
+ )
+
+ helper = LayerHelper("segment_max", **locals())
+ out = helper.create_variable_for_type_inference(dtype=data.dtype)
+ summed_ids = helper.create_variable_for_type_inference(dtype=data.dtype)
+ helper.append_op(
+ type="segment_pool",
+ inputs={"X": data, "SegmentIds": segment_ids},
+ outputs={"Out": out, "SummedIds": summed_ids},
+ attrs={"pooltype": "MAX"},
+ )
+ return out
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c07f9bc40c6b39967ed168afb11928eb2ba1d635
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/__init__.py
@@ -0,0 +1,19 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .send_recv import send_u_recv # noqa: F401
+from .send_recv import send_ue_recv # noqa: F401
+from .send_recv import send_uv # noqa: F401
+
+__all__ = []
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/send_recv.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/send_recv.py
new file mode 100644
index 0000000000000000000000000000000000000000..839b6e93e80a27043af3b99a4c44fe544238d5e2
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/send_recv.py
@@ -0,0 +1,515 @@
+# Copyright (c) 2022 PaddlePaddle 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 numpy as np
+from paddle.fluid.layer_helper import LayerHelper
+from paddle.fluid.framework import (
+ _non_static_mode,
+ _in_legacy_dygraph,
+ in_dygraph_mode,
+)
+from paddle.fluid.framework import Variable
+from paddle.fluid.data_feeder import (
+ check_variable_and_dtype,
+ check_type,
+ check_dtype,
+ convert_dtype,
+)
+from paddle import _C_ops, _legacy_C_ops
+
+from .utils import (
+ convert_out_size_to_list,
+ get_out_size_tensor_inputs,
+ reshape_lhs_rhs,
+)
+
+__all__ = []
+
+
+def send_u_recv(
+ x, src_index, dst_index, reduce_op="sum", out_size=None, name=None
+):
+ """
+ Graph Learning message passing api.
+
+ This api is mainly used in Graph Learning domain, and the main purpose is to reduce intermediate memory
+ consumption in the process of message passing. Take `x` as the input tensor, we first use `src_index`
+ to gather the corresponding data, and then use `dst_index` to update the corresponding position of output tensor
+ in different reduce ops, like sum, mean, max, or min. Besides, we can use `out_size` to set necessary output shape.
+
+ .. code-block:: text
+
+ Given:
+
+ x = [[0, 2, 3],
+ [1, 4, 5],
+ [2, 6, 7]]
+
+ src_index = [0, 1, 2, 0]
+
+ dst_index = [1, 2, 1, 0]
+
+ reduce_op = "sum"
+
+ out_size = None
+
+ Then:
+
+ out = [[0, 2, 3],
+ [2, 8, 10],
+ [1, 4, 5]]
+
+ Args:
+ x (Tensor): The input tensor, and the available data type is float32, float64, int32, int64.
+ And we support float16 in gpu version.
+ src_index (Tensor): An 1-D tensor, and the available data type is int32, int64.
+ dst_index (Tensor): An 1-D tensor, and should have the same shape as `src_index`.
+ The available data type is int32, int64.
+ reduce_op (str): Different reduce ops, including `sum`, `mean`, `max`, `min`.
+ Default value is `sum`.
+ out_size (int|Tensor|None): We can set `out_size` to get necessary output shape. If not set or
+ out_size is smaller or equal to 0, then this input will not be used.
+ Otherwise, `out_size` should be equal with or larger than
+ max(dst_index) + 1.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - out (Tensor), the output tensor, should have the same shape and same dtype as input tensor `x`.
+ If `out_size` is set correctly, then it should have the same shape as `x` except the 0th dimension.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [1, 2], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out = paddle.geometric.send_u_recv(x, src_index, dst_index, reduce_op="sum")
+ # Outputs: [[0., 2., 3.], [2., 8., 10.], [1., 4., 5.]]
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out_size = paddle.max(dst_index) + 1
+ out = paddle.geometric.send_u_recv(x, src_index, dst_index, reduce_op="sum", out_size=out_size)
+ # Outputs: [[0., 2., 3.], [[2., 8., 10.]]]
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out = paddle.geometric.send_u_recv(x, src_index, dst_index, reduce_op="sum")
+ # Outputs: [[0., 2., 3.], [2., 8., 10.], [0., 0., 0.]]
+
+ """
+
+ if reduce_op not in ["sum", "mean", "max", "min"]:
+ raise ValueError(
+ "reduce_op should be `sum`, `mean`, `max` or `min`, but received %s"
+ % reduce_op
+ )
+
+ # TODO(daisiming): Should we add judgement for out_size: max(dst_index) + 1.
+
+ if _in_legacy_dygraph():
+ out_size = convert_out_size_to_list(out_size)
+ out, tmp = _legacy_C_ops.graph_send_recv(
+ x,
+ src_index,
+ dst_index,
+ None,
+ 'reduce_op',
+ reduce_op.upper(),
+ 'out_size',
+ out_size,
+ )
+ return out
+ if in_dygraph_mode():
+ out_size = convert_out_size_to_list(out_size)
+ return _C_ops.graph_send_recv(
+ x, src_index, dst_index, reduce_op.upper(), out_size
+ )
+
+ check_variable_and_dtype(
+ x,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "graph_send_recv",
+ )
+ check_variable_and_dtype(
+ src_index, "Src_index", ("int32", "int64"), "graph_send_recv"
+ )
+ check_variable_and_dtype(
+ dst_index, "Dst_index", ("int32", "int64"), "graph_send_recv"
+ )
+ if out_size:
+ check_type(
+ out_size,
+ 'out_size',
+ (int, np.int32, np.int64, Variable),
+ 'graph_send_recv',
+ )
+ if isinstance(out_size, Variable):
+ check_dtype(
+ out_size.dtype, 'out_size', ['int32', 'int64'], 'graph_send_recv'
+ )
+
+ helper = LayerHelper("send_u_recv", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ dst_count = helper.create_variable_for_type_inference(
+ dtype="int32", stop_gradient=True
+ )
+
+ inputs = {"X": x, "Src_index": src_index, "Dst_index": dst_index}
+ attrs = {"reduce_op": reduce_op.upper()}
+ get_out_size_tensor_inputs(
+ inputs=inputs, attrs=attrs, out_size=out_size, op_type='graph_send_recv'
+ )
+
+ helper.append_op(
+ type="graph_send_recv",
+ inputs=inputs,
+ outputs={"Out": out, "Dst_count": dst_count},
+ attrs=attrs,
+ )
+ return out
+
+
+def send_ue_recv(
+ x,
+ y,
+ src_index,
+ dst_index,
+ message_op="add",
+ reduce_op="sum",
+ out_size=None,
+ name=None,
+):
+ """
+
+ Graph Learning message passing api.
+
+ This api is mainly used in Graph Learning domain, and the main purpose is to reduce intermediate memory
+ consumption in the process of message passing. Take `x` as the input tensor, we first use `src_index`
+ to gather the corresponding data, after computing with `y` in different message ops like add/sub/mul/div, then use `dst_index` to
+ update the corresponding position of output tensor in different reduce ops, like sum, mean, max, or min.
+ Besides, we can use `out_size` to set necessary output shape.
+
+ .. code-block:: text
+
+ Given:
+
+ x = [[0, 2, 3],
+ [1, 4, 5],
+ [2, 6, 7]]
+
+ y = [1, 1, 1]
+
+ src_index = [0, 1, 2, 0]
+
+ dst_index = [1, 2, 1, 0]
+
+ message_op = "add"
+
+ reduce_op = "sum"
+
+ out_size = None
+
+ Then:
+
+ out = [[1, 3, 4],
+ [4, 10, 12],
+ [2, 5, 6]]
+
+ Args:
+ x (Tensor): The input node feature tensor, and the available data type is float32, float64, int32, int64.
+ And we support float16 in gpu version.
+ y (Tensor): The input edge feature tensor, and the available data type is float32, float64, int32, int64.
+ And we support float16 in gpu version.
+ src_index (Tensor): An 1-D tensor, and the available data type is int32, int64.
+ dst_index (Tensor): An 1-D tensor, and should have the same shape as `src_index`.
+ The available data type is int32, int64.
+ message_op (str, optional): Different message ops for x and e, including `add`, `sub`, `mul`, `div`.
+ reduce_op (str, optional): Different reduce ops, including `sum`, `mean`, `max`, `min`.
+ Default value is `sum`.
+ out_size (int|Tensor, optional): We can set `out_size` to get necessary output shape. If not set or
+ out_size is smaller or equal to 0, then this input will not be used.
+ Otherwise, `out_size` should be equal with or larger than
+ max(dst_index) + 1. Default value is `None`.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - out (Tensor), the output tensor, should have the same shape and same dtype as input tensor `x`.
+ If `out_size` is set correctly, then it should have the same shape as `x` except the 0th dimension.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ y = paddle.to_tensor([1, 1, 1, 1], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [1, 2], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out = paddle.geometric.send_ue_recv(x, y, src_index, dst_index, message_op="add", reduce_op="sum")
+ # Outputs: [[1., 3., 4.], [4., 10., 12.], [2., 5., 6.]]
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ y = paddle.to_tensor([1, 1, 1], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out_size = paddle.max(dst_index) + 1
+ out = paddle.geometric.send_ue_recv(x, y, src_index, dst_index, message_op="add", reduce_op="sum", out_size=out_size)
+ # Outputs: [[1., 3., 4.], [[4., 10., 12.]]]
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ y = paddle.to_tensor([1, 1, 1], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [2, 1], [0, 0]], dtype="int32")
+ src_index, dst_index = indexes[:, 0], indexes[:, 1]
+ out = paddle.geometric.send_ue_recv(x, y, src_index, dst_index, message_op="add", reduce_op="sum")
+ # Outputs: [[1., 3., 4.], [4., 10., 12.], [0., 0., 0.]]
+
+ """
+
+ if message_op not in ["add", "sub", "mul", "div"]:
+ raise ValueError(
+ "message_op should be `add`, `sub`, `mul`, `div`, but received %s"
+ % message_op
+ )
+
+ if reduce_op not in ["sum", "mean", "max", "min"]:
+ raise ValueError(
+ "reduce_op should be `sum`, `mean`, `max` or `min`, but received %s"
+ % reduce_op
+ )
+
+ x, y = reshape_lhs_rhs(x, y)
+
+ if message_op == 'sub':
+ message_op = 'add'
+ y = -y
+ if message_op == "div":
+ message_op = 'mul'
+ y = 1.0 / (y + 1e-12)
+
+ # TODO(daisiming): Should we add judgement for out_size: max(dst_index) + 1.
+
+ if _in_legacy_dygraph():
+ out_size = convert_out_size_to_list(out_size)
+ out, tmp = _legacy_C_ops.graph_send_ue_recv(
+ x,
+ y,
+ src_index,
+ dst_index,
+ None,
+ 'message_op',
+ message_op.upper(),
+ 'reduce_op',
+ reduce_op.upper(),
+ 'out_size',
+ out_size,
+ )
+ return out
+ if in_dygraph_mode():
+ out_size = convert_out_size_to_list(out_size)
+ return _C_ops.graph_send_ue_recv(
+ x,
+ y,
+ src_index,
+ dst_index,
+ message_op.upper(),
+ reduce_op.upper(),
+ out_size,
+ )
+
+ check_variable_and_dtype(
+ x,
+ "X",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "graph_send_ue_recv",
+ )
+ check_variable_and_dtype(
+ y,
+ "Y",
+ ("float32", "float64", "int32", "int64", "float16"),
+ "graph_send_ue_recv",
+ )
+ check_variable_and_dtype(
+ src_index, "Src_index", ("int32", "int64"), "graph_send_ue_recv"
+ )
+ check_variable_and_dtype(
+ dst_index, "Dst_index", ("int32", "int64"), "graph_send_ue_recv"
+ )
+ if out_size:
+ check_type(
+ out_size,
+ 'out_size',
+ (int, np.int32, np.int64, Variable),
+ 'graph_send_ue_recv',
+ )
+ if isinstance(out_size, Variable):
+ check_dtype(
+ out_size.dtype, 'out_size', ['int32', 'int64'], 'graph_send_ue_recv'
+ )
+
+ helper = LayerHelper("send_ue_recv", **locals())
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+ dst_count = helper.create_variable_for_type_inference(
+ dtype="int32", stop_gradient=True
+ )
+
+ inputs = {"X": x, "Y": y, "Src_index": src_index, "Dst_index": dst_index}
+ attrs = {"message_op": message_op.upper(), "reduce_op": reduce_op.upper()}
+ get_out_size_tensor_inputs(
+ inputs=inputs,
+ attrs=attrs,
+ out_size=out_size,
+ op_type='graph_send_ue_recv',
+ )
+
+ helper.append_op(
+ type="graph_send_ue_recv",
+ inputs=inputs,
+ outputs={"Out": out, "Dst_count": dst_count},
+ attrs=attrs,
+ )
+ return out
+
+
+def send_uv(x, y, src_index, dst_index, message_op="add", name=None):
+ """
+
+ Graph Learning message passing api.
+
+ This api is mainly used in Graph Learning domain, and the main purpose is to reduce intermediate memory
+ consumption in the process of message passing. Take `x` as the source node feature tensor, take `y` as
+ the destination node feature tensor. Then we use `src_index` and `dst_index` to gather the corresponding data,
+ and then compute the edge features in different message_ops like `add`, `sub`, `mul`, `div`.
+
+ .. code-block:: text
+
+ Given:
+
+ x = [[0, 2, 3],
+ [1, 4, 5],
+ [2, 6, 7]]
+
+ y = [[0, 1, 2],
+ [2, 3, 4],
+ [4, 5, 6]]
+
+ src_index = [0, 1, 2, 0]
+
+ dst_index = [1, 2, 1, 0]
+
+ message_op = "add"
+
+ Then:
+
+ out = [[2, 5, 7],
+ [5, 9, 11],
+ [4, 9, 11],
+ [0, 3, 5]]
+
+ Args:
+ x (Tensor): The source node feature tensor, and the available data type is float32, float64, int32, int64. And we support float16 in gpu version.
+ y (Tensor): The destination node feature tensor, and the available data type is float32, float64, int32, int64. And we support float16 in gpu version.
+ src_index (Tensor): An 1-D tensor, and the available data type is int32, int64.
+ dst_index (Tensor): An 1-D tensor, and should have the same shape as `src_index`.
+ The available data type is int32, int64.
+ message_op (str): Different message ops for x and y, including `add`, `sub`, `mul` and `div`.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - out (Tensor), the output tensor.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ x = paddle.to_tensor([[0, 2, 3], [1, 4, 5], [2, 6, 7]], dtype="float32")
+ y = paddle.to_tensor([[0, 1, 2], [2, 3, 4], [4, 5, 6]], dtype="float32")
+ indexes = paddle.to_tensor([[0, 1], [1, 2], [2, 1], [0, 0]], dtype="int32")
+ src_index = indexes[:, 0]
+ dst_index = indexes[:, 1]
+ out = paddle.geometric.send_uv(x, y, src_index, dst_index, message_op="add")
+ # Outputs: [[2., 5., 7.], [5., 9., 11.], [4., 9., 11.], [0., 3., 5.]]
+
+ """
+
+ if message_op not in ['add', 'sub', 'mul', 'div']:
+ raise ValueError(
+ "message_op should be `add`, `sub`, `mul`, `div`, but received %s"
+ % message_op
+ )
+
+ x, y = reshape_lhs_rhs(x, y)
+
+ if message_op == 'sub':
+ message_op = 'add'
+ y = -y
+ if message_op == 'div':
+ message_op = 'mul'
+ y = 1.0 / (y + 1e-12)
+
+ if in_dygraph_mode():
+ return _C_ops.graph_send_uv(
+ x, y, src_index, dst_index, message_op.upper()
+ )
+ else:
+ if _in_legacy_dygraph():
+ return _legacy_C_ops.graph_send_uv(
+ x, y, src_index, dst_index, "message_op", message_op.upper()
+ )
+ else:
+ helper = LayerHelper("send_uv", **locals())
+ check_variable_and_dtype(
+ x,
+ 'x',
+ ['int32', 'int64', 'float32', 'float64', 'float16'],
+ 'graph_send_uv',
+ )
+ check_variable_and_dtype(
+ y,
+ 'y',
+ ['int32', 'int64', 'float32', 'float64', 'float16'],
+ 'graph_send_uv',
+ )
+ check_variable_and_dtype(
+ src_index, 'src_index', ['int32', 'int64'], 'graph_send_uv'
+ )
+ check_variable_and_dtype(
+ dst_index, 'dst_index', ['int32', 'int64'], 'graph_send_uv'
+ )
+ out = helper.create_variable_for_type_inference(dtype=x.dtype)
+
+ inputs = {
+ 'x': x,
+ 'y': y,
+ 'src_index': src_index,
+ 'dst_index': dst_index,
+ }
+ attrs = {'message_op': message_op.upper()}
+ helper.append_op(
+ type="graph_send_uv",
+ inputs=inputs,
+ attrs=attrs,
+ outputs={"out": out},
+ )
+ return out
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/utils.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..51c088522983b79dd9edbe4b90c866ea25eeaca1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/message_passing/utils.py
@@ -0,0 +1,85 @@
+# Copyright (c) 2022 PaddlePaddle 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 numpy as np
+import paddle
+from paddle.fluid.framework import Variable
+from paddle.fluid.data_feeder import check_dtype, convert_dtype
+from paddle.fluid.layers.tensor import cast
+
+
+def convert_out_size_to_list(out_size):
+ """
+ Convert out_size(int, np.int32, np.int64, Variable) to list
+ in imperative mode.
+ """
+ if out_size is None:
+ out_size = [0]
+ elif isinstance(out_size, (int, np.int32, np.int64)):
+ out_size = [out_size]
+ else:
+ out_size = [out_size.numpy().astype(int)[0]]
+ return out_size
+
+
+def get_out_size_tensor_inputs(inputs, attrs, out_size, op_type):
+ """
+ Convert out_size(int, np.int32, np.int64, Variable) to inputs
+ and attrs in static mode.
+ """
+ if out_size is None:
+ attrs['out_size'] = [0]
+ elif isinstance(out_size, (int, np.int32, np.int64)):
+ attrs['out_size'] = [out_size]
+ elif isinstance(out_size, Variable):
+ out_size.stop_gradient = True
+ check_dtype(out_size.dtype, 'out_size', ['int32', 'int64'], 'op_type',
+ '(When type of out_size in' + op_type + ' is Variable.)')
+ if (convert_dtype(out_size.dtype) == 'int64'):
+ out_size = cast(out_size, 'int32')
+ inputs["Out_size"] = out_size
+ else:
+ raise TypeError("Out_size only supports Variable or int.")
+
+
+def reshape_lhs_rhs(x, y):
+ """
+ Expand dims to ensure there will be no broadcasting issues with different
+ number of dimensions.
+ """
+ if len(x.shape) == 1:
+ x = paddle.reshape(x, [-1, 1])
+ if len(y.shape) == 1:
+ y = paddle.reshape(y, [-1, 1])
+
+ x_shape = paddle.shape(x)
+ y_shape = paddle.shape(y)
+ if len(x.shape) != len(y.shape):
+ max_ndims = max(len(x.shape), len(y.shape))
+ x_pad_ndims = max_ndims - len(x.shape)
+ y_pad_ndims = max_ndims - len(y.shape)
+ new_x_shape = [
+ x_shape[0],
+ ] + [
+ 1,
+ ] * x_pad_ndims + list(x_shape[1:])
+ new_y_shape = [
+ y_shape[0],
+ ] + [
+ 1,
+ ] * y_pad_ndims + list(y_shape[1:])
+ x = paddle.reshape(x, new_x_shape)
+ y = paddle.reshape(y, new_y_shape)
+
+ return x, y
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/reindex.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/reindex.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b68931dfb99e7a08a9586844ab65d5eb78f51f4
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/reindex.py
@@ -0,0 +1,270 @@
+# Copyright (c) 2022 PaddlePaddle 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 paddle
+from paddle.fluid.layer_helper import LayerHelper
+from paddle.fluid.framework import _non_static_mode, Variable
+from paddle.fluid.data_feeder import check_variable_and_dtype
+from paddle.fluid import core
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = []
+
+
+def reindex_graph(
+ x, neighbors, count, value_buffer=None, index_buffer=None, name=None
+):
+ """
+
+ Reindex Graph API.
+
+ This API is mainly used in Graph Learning domain, which should be used
+ in conjunction with `paddle.geometric.sample_neighbors` API. And the main purpose
+ is to reindex the ids information of the input nodes, and return the
+ corresponding graph edges after reindex.
+
+ Take input nodes x = [0, 1, 2] as an example. If we have neighbors = [8, 9, 0, 4, 7, 6, 7], and count = [2, 3, 2],
+ then we know that the neighbors of 0 is [8, 9], the neighbors of 1 is [0, 4, 7], and the neighbors of 2 is [6, 7].
+ Then after graph_reindex, we will have 3 different outputs: reindex_src: [3, 4, 0, 5, 6, 7, 6], reindex_dst: [0, 0, 1, 1, 1, 2, 2]
+ and out_nodes: [0, 1, 2, 8, 9, 4, 7, 6]. We can see that the numbers in `reindex_src` and `reindex_dst` is the corresponding index
+ of nodes in `out_nodes`.
+
+ Note:
+ The number in x should be unique, otherwise it would cause potential errors. We will reindex all the nodes from 0.
+
+ Args:
+ x (Tensor): The input nodes which we sample neighbors for. The available
+ data type is int32, int64.
+ neighbors (Tensor): The neighbors of the input nodes `x`. The data type
+ should be the same with `x`.
+ count (Tensor): The neighbor count of the input nodes `x`. And the
+ data type should be int32.
+ value_buffer (Tensor, optional): Value buffer for hashtable. The data type should be int32,
+ and should be filled with -1. Only useful for gpu version. Default is None.
+ index_buffer (Tensor, optional): Index buffer for hashtable. The data type should be int32,
+ and should be filled with -1. Only useful for gpu version.
+ `value_buffer` and `index_buffer` should be both not None
+ if you want to speed up by using hashtable buffer. Default is None.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - reindex_src (Tensor), the source node index of graph edges after reindex.
+
+ - reindex_dst (Tensor), the destination node index of graph edges after reindex.
+
+ - out_nodes (Tensor), the index of unique input nodes and neighbors before reindex, where we put the input nodes `x` in the front, and put neighbor nodes in the back.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = [0, 1, 2]
+ neighbors = [8, 9, 0, 4, 7, 6, 7]
+ count = [2, 3, 2]
+ x = paddle.to_tensor(x, dtype="int64")
+ neighbors = paddle.to_tensor(neighbors, dtype="int64")
+ count = paddle.to_tensor(count, dtype="int32")
+ reindex_src, reindex_dst, out_nodes = paddle.geometric.reindex_graph(x, neighbors, count)
+ # reindex_src: [3, 4, 0, 5, 6, 7, 6]
+ # reindex_dst: [0, 0, 1, 1, 1, 2, 2]
+ # out_nodes: [0, 1, 2, 8, 9, 4, 7, 6]
+
+ """
+ use_buffer_hashtable = (
+ True if value_buffer is not None and index_buffer is not None else False
+ )
+
+ if _non_static_mode():
+ reindex_src, reindex_dst, out_nodes = _legacy_C_ops.graph_reindex(
+ x,
+ neighbors,
+ count,
+ value_buffer,
+ index_buffer,
+ "flag_buffer_hashtable",
+ use_buffer_hashtable,
+ )
+ return reindex_src, reindex_dst, out_nodes
+
+ check_variable_and_dtype(x, "X", ("int32", "int64"), "graph_reindex")
+ check_variable_and_dtype(
+ neighbors, "Neighbors", ("int32", "int64"), "graph_reindex"
+ )
+ check_variable_and_dtype(count, "Count", ("int32"), "graph_reindex")
+
+ if use_buffer_hashtable:
+ check_variable_and_dtype(
+ value_buffer, "HashTable_Value", ("int32"), "graph_reindex"
+ )
+ check_variable_and_dtype(
+ index_buffer, "HashTable_Index", ("int32"), "graph_reindex"
+ )
+
+ helper = LayerHelper("reindex_graph", **locals())
+ reindex_src = helper.create_variable_for_type_inference(dtype=x.dtype)
+ reindex_dst = helper.create_variable_for_type_inference(dtype=x.dtype)
+ out_nodes = helper.create_variable_for_type_inference(dtype=x.dtype)
+ helper.append_op(
+ type="graph_reindex",
+ inputs={
+ "X": x,
+ "Neighbors": neighbors,
+ "Count": count,
+ "HashTable_Value": value_buffer if use_buffer_hashtable else None,
+ "HashTable_Index": index_buffer if use_buffer_hashtable else None,
+ },
+ outputs={
+ "Reindex_Src": reindex_src,
+ "Reindex_Dst": reindex_dst,
+ "Out_Nodes": out_nodes,
+ },
+ attrs={"flag_buffer_hashtable": use_buffer_hashtable},
+ )
+ return reindex_src, reindex_dst, out_nodes
+
+
+def reindex_heter_graph(
+ x, neighbors, count, value_buffer=None, index_buffer=None, name=None
+):
+ """
+
+ Reindex HeterGraph API.
+
+ This API is mainly used in Graph Learning domain, which should be used
+ in conjunction with `paddle.geometric.sample_neighbors` API. And the main purpose
+ is to reindex the ids information of the input nodes, and return the
+ corresponding graph edges after reindex.
+
+ Take input nodes x = [0, 1, 2] as an example. For graph A, suppose we have neighbors = [8, 9, 0, 4, 7, 6, 7], and count = [2, 3, 2],
+ then we know that the neighbors of 0 is [8, 9], the neighbors of 1 is [0, 4, 7], and the neighbors of 2 is [6, 7]. For graph B,
+ suppose we have neighbors = [0, 2, 3, 5, 1], and count = [1, 3, 1], then we know that the neighbors of 0 is [0], the neighbors of 1 is [2, 3, 5],
+ and the neighbors of 3 is [1]. We will get following outputs: reindex_src: [3, 4, 0, 5, 6, 7, 6, 0, 2, 8, 9, 1], reindex_dst: [0, 0, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2]
+ and out_nodes: [0, 1, 2, 8, 9, 4, 7, 6, 3, 5].
+
+ Note:
+ The number in x should be unique, otherwise it would cause potential errors. We support multi-edge-types neighbors reindexing in reindex_heter_graph api. We will reindex all the nodes from 0.
+
+ Args:
+ x (Tensor): The input nodes which we sample neighbors for. The available
+ data type is int32, int64.
+ neighbors (list|tuple): The neighbors of the input nodes `x` from different graphs.
+ The data type should be the same with `x`.
+ count (list|tuple): The neighbor counts of the input nodes `x` from different graphs.
+ And the data type should be int32.
+ value_buffer (Tensor, optional): Value buffer for hashtable. The data type should be int32,
+ and should be filled with -1. Only useful for gpu version. Default is None.
+ index_buffer (Tensor, optional): Index buffer for hashtable. The data type should be int32,
+ and should be filled with -1. Only useful for gpu version.
+ `value_buffer` and `index_buffer` should be both not None
+ if you want to speed up by using hashtable buffer. Default is None.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - reindex_src (Tensor), the source node index of graph edges after reindex.
+
+ - reindex_dst (Tensor), the destination node index of graph edges after reindex.
+
+ - out_nodes (Tensor), the index of unique input nodes and neighbors before reindex,
+ where we put the input nodes `x` in the front, and put neighbor
+ nodes in the back.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ x = [0, 1, 2]
+ neighbors_a = [8, 9, 0, 4, 7, 6, 7]
+ count_a = [2, 3, 2]
+ x = paddle.to_tensor(x, dtype="int64")
+ neighbors_a = paddle.to_tensor(neighbors_a, dtype="int64")
+ count_a = paddle.to_tensor(count_a, dtype="int32")
+ neighbors_b = [0, 2, 3, 5, 1]
+ count_b = [1, 3, 1]
+ neighbors_b = paddle.to_tensor(neighbors_b, dtype="int64")
+ count_b = paddle.to_tensor(count_b, dtype="int32")
+ neighbors = [neighbors_a, neighbors_b]
+ count = [count_a, count_b]
+ reindex_src, reindex_dst, out_nodes = paddle.geometric.reindex_heter_graph(x, neighbors, count)
+ # reindex_src: [3, 4, 0, 5, 6, 7, 6, 0, 2, 8, 9, 1]
+ # reindex_dst: [0, 0, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2]
+ # out_nodes: [0, 1, 2, 8, 9, 4, 7, 6, 3, 5]
+
+ """
+ use_buffer_hashtable = (
+ True if value_buffer is not None and index_buffer is not None else False
+ )
+
+ if _non_static_mode():
+ neighbors = paddle.concat(neighbors, axis=0)
+ count = paddle.concat(count, axis=0)
+ reindex_src, reindex_dst, out_nodes = _legacy_C_ops.graph_reindex(
+ x,
+ neighbors,
+ count,
+ value_buffer,
+ index_buffer,
+ "flag_buffer_hashtable",
+ use_buffer_hashtable,
+ )
+ return reindex_src, reindex_dst, out_nodes
+
+ if isinstance(neighbors, Variable):
+ neighbors = [neighbors]
+ if isinstance(count, Variable):
+ count = [count]
+
+ neighbors = paddle.concat(neighbors, axis=0)
+ count = paddle.concat(count, axis=0)
+
+ check_variable_and_dtype(x, "X", ("int32", "int64"), "heter_graph_reindex")
+ check_variable_and_dtype(
+ neighbors, "Neighbors", ("int32", "int64"), "graph_reindex"
+ )
+ check_variable_and_dtype(count, "Count", ("int32"), "graph_reindex")
+
+ if use_buffer_hashtable:
+ check_variable_and_dtype(
+ value_buffer, "HashTable_Value", ("int32"), "graph_reindex"
+ )
+ check_variable_and_dtype(
+ index_buffer, "HashTable_Index", ("int32"), "graph_reindex"
+ )
+
+ helper = LayerHelper("reindex_heter_graph", **locals())
+ reindex_src = helper.create_variable_for_type_inference(dtype=x.dtype)
+ reindex_dst = helper.create_variable_for_type_inference(dtype=x.dtype)
+ out_nodes = helper.create_variable_for_type_inference(dtype=x.dtype)
+ neighbors = paddle.concat(neighbors, axis=0)
+ count = paddle.concat(count, axis=0)
+ helper.append_op(
+ type="graph_reindex",
+ inputs={
+ "X": x,
+ "Neighbors": neighbors,
+ "Count": count,
+ "HashTable_Value": value_buffer if use_buffer_hashtable else None,
+ "HashTable_Index": index_buffer if use_buffer_hashtable else None,
+ },
+ outputs={
+ "Reindex_Src": reindex_src,
+ "Reindex_Dst": reindex_dst,
+ "Out_Nodes": out_nodes,
+ },
+ attrs={"flag_buffer_hashtable": use_buffer_hashtable},
+ )
+ return reindex_src, reindex_dst, out_nodes
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e5b24fdd60b7fbc366f23a048b0645e2df9284c
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/__init__.py
@@ -0,0 +1,17 @@
+# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .neighbors import sample_neighbors # noqa: F401
+
+__all__ = []
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/neighbors.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/neighbors.py
new file mode 100644
index 0000000000000000000000000000000000000000..a52570576b04c64f5e67ed0f8a540ff316bde245
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/geometric/sampling/neighbors.py
@@ -0,0 +1,173 @@
+# Copyright (c) 2022 PaddlePaddle 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 paddle
+from paddle.fluid.layer_helper import LayerHelper
+from paddle.fluid.framework import _non_static_mode
+from paddle.fluid.data_feeder import check_variable_and_dtype
+from paddle import _C_ops, _legacy_C_ops
+
+__all__ = []
+
+
+def sample_neighbors(
+ row,
+ colptr,
+ input_nodes,
+ sample_size=-1,
+ eids=None,
+ return_eids=False,
+ perm_buffer=None,
+ name=None,
+):
+ """
+
+ Graph Sample Neighbors API.
+
+ This API is mainly used in Graph Learning domain, and the main purpose is to
+ provide high performance of graph sampling method. For example, we get the
+ CSC(Compressed Sparse Column) format of the input graph edges as `row` and
+ `colptr`, so as to convert graph data into a suitable format for sampling.
+ `input_nodes` means the nodes we need to sample neighbors, and `sample_sizes`
+ means the number of neighbors and number of layers we want to sample.
+
+ Besides, we support fisher-yates sampling in GPU version.
+
+ Args:
+ row (Tensor): One of the components of the CSC format of the input graph, and
+ the shape should be [num_edges, 1] or [num_edges]. The available
+ data type is int32, int64.
+ colptr (Tensor): One of the components of the CSC format of the input graph,
+ and the shape should be [num_nodes + 1, 1] or [num_nodes + 1].
+ The data type should be the same with `row`.
+ input_nodes (Tensor): The input nodes we need to sample neighbors for, and the
+ data type should be the same with `row`.
+ sample_size (int, optional): The number of neighbors we need to sample. Default value is -1,
+ which means returning all the neighbors of the input nodes.
+ eids (Tensor, optional): The eid information of the input graph. If return_eids is True,
+ then `eids` should not be None. The data type should be the
+ same with `row`. Default is None.
+ return_eids (bool, optional): Whether to return eid information of sample edges. Default is False.
+ perm_buffer (Tensor, optional): Permutation buffer for fisher-yates sampling. If `use_perm_buffer`
+ is True, then `perm_buffer` should not be None. The data type should
+ be the same with `row`. If not None, we will use fiser-yates sampling
+ to speed up. Only useful for gpu version. Default is None.
+ name (str, optional): Name for the operation (optional, default is None).
+ For more information, please refer to :ref:`api_guide_Name`.
+
+ Returns:
+ - out_neighbors (Tensor), the sample neighbors of the input nodes.
+
+ - out_count (Tensor), the number of sampling neighbors of each input node, and the shape
+ should be the same with `input_nodes`.
+
+ - out_eids (Tensor), if `return_eids` is True, we will return the eid information of the
+ sample edges.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+
+ # edges: (3, 0), (7, 0), (0, 1), (9, 1), (1, 2), (4, 3), (2, 4),
+ # (9, 5), (3, 5), (9, 6), (1, 6), (9, 8), (7, 8)
+ row = [3, 7, 0, 9, 1, 4, 2, 9, 3, 9, 1, 9, 7]
+ colptr = [0, 2, 4, 5, 6, 7, 9, 11, 11, 13, 13]
+ nodes = [0, 8, 1, 2]
+ sample_size = 2
+ row = paddle.to_tensor(row, dtype="int64")
+ colptr = paddle.to_tensor(colptr, dtype="int64")
+ nodes = paddle.to_tensor(nodes, dtype="int64")
+ out_neighbors, out_count = paddle.geometric.sample_neighbors(row, colptr, nodes, sample_size=sample_size)
+
+ """
+
+ if return_eids:
+ if eids is None:
+ raise ValueError(
+ f"`eids` should not be None if `return_eids` is True."
+ )
+
+ use_perm_buffer = True if perm_buffer is not None else False
+
+ if _non_static_mode():
+ (
+ out_neighbors,
+ out_count,
+ out_eids,
+ ) = _legacy_C_ops.graph_sample_neighbors(
+ row,
+ colptr,
+ input_nodes,
+ eids,
+ perm_buffer,
+ "sample_size",
+ sample_size,
+ "return_eids",
+ return_eids,
+ "flag_perm_buffer",
+ use_perm_buffer,
+ )
+ if return_eids:
+ return out_neighbors, out_count, out_eids
+ return out_neighbors, out_count
+
+ check_variable_and_dtype(
+ row, "Row", ("int32", "int64"), "graph_sample_neighbors"
+ )
+ check_variable_and_dtype(
+ colptr, "Col_Ptr", ("int32", "int64"), "graph_sample_neighbors"
+ )
+ check_variable_and_dtype(
+ input_nodes, "X", ("int32", "int64"), "graph_sample_neighbors"
+ )
+ if return_eids:
+ check_variable_and_dtype(
+ eids, "Eids", ("int32", "int64"), "graph_sample_neighbors"
+ )
+ if use_perm_buffer:
+ check_variable_and_dtype(
+ perm_buffer,
+ "Perm_Buffer",
+ ("int32", "int64"),
+ "graph_sample_neighbors",
+ )
+
+ helper = LayerHelper("sample_neighbors", **locals())
+ out_neighbors = helper.create_variable_for_type_inference(dtype=row.dtype)
+ out_count = helper.create_variable_for_type_inference(dtype=row.dtype)
+ out_eids = helper.create_variable_for_type_inference(dtype=row.dtype)
+ helper.append_op(
+ type="graph_sample_neighbors",
+ inputs={
+ "Row": row,
+ "Col_Ptr": colptr,
+ "X": input_nodes,
+ "Eids": eids if return_eids else None,
+ "Perm_Buffer": perm_buffer if use_perm_buffer else None,
+ },
+ outputs={
+ "Out": out_neighbors,
+ "Out_Count": out_count,
+ "Out_Eids": out_eids,
+ },
+ attrs={
+ "sample_size": sample_size,
+ "return_eids": return_eids,
+ "flag_perm_buffer": use_perm_buffer,
+ },
+ )
+ if return_eids:
+ return out_neighbors, out_count, out_eids
+ return out_neighbors, out_count
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/__init__.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2829bbe94708981f30ffcfdeeff89fd85899e33b
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/__init__.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import logger # noqa: F401
+from . import callbacks # noqa: F401
+from . import hub # noqa: F401
+from . import progressbar # noqa: F401
+from . import static_flops # noqa: F401
+
+from .model import Model # noqa: F401
+from .model_summary import summary # noqa: F401
+from .dynamic_flops import flops # noqa: F401
+
+logger.setup_logger()
+
+__all__ = []
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/callbacks.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdd79b35a499abd017e57786a8dcc4f93bff32b4
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/callbacks.py
@@ -0,0 +1,1125 @@
+# Copyright (c) 2020 PaddlePaddle 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 os
+import time
+import numbers
+import warnings
+
+import numpy as np
+
+import paddle
+from paddle.fluid.dygraph.parallel import ParallelEnv
+from paddle.utils import try_import
+
+from .progressbar import ProgressBar
+
+__all__ = []
+
+
+def config_callbacks(callbacks=None,
+ model=None,
+ batch_size=None,
+ epochs=None,
+ steps=None,
+ log_freq=2,
+ verbose=2,
+ save_freq=1,
+ save_dir=None,
+ metrics=None,
+ mode='train'):
+ cbks = callbacks or []
+ cbks = cbks if isinstance(cbks, (list, tuple)) else [cbks]
+ if not any(isinstance(k, ProgBarLogger) for k in cbks) and verbose:
+ cbks = [ProgBarLogger(log_freq, verbose=verbose)] + cbks
+
+ if not any(isinstance(k, ModelCheckpoint) for k in cbks):
+ cbks = cbks + [ModelCheckpoint(save_freq, save_dir)]
+
+ for k in cbks:
+ if isinstance(k, EarlyStopping):
+ k.save_dir = save_dir
+ if not any(isinstance(k, LRScheduler) for k in cbks):
+ cbks = cbks + [LRScheduler()]
+
+ cbk_list = CallbackList(cbks)
+ cbk_list.set_model(model)
+ metrics = metrics or [] if mode != 'test' else []
+ params = {
+ 'batch_size': batch_size,
+ 'epochs': epochs,
+ 'steps': steps,
+ 'verbose': verbose,
+ 'metrics': metrics,
+ }
+ cbk_list.set_params(params)
+ return cbk_list
+
+
+class CallbackList(object):
+
+ def __init__(self, callbacks=None):
+ # copy
+ self.callbacks = [c for c in callbacks]
+ self.params = {}
+ self.model = None
+
+ def append(self, callback):
+ self.callbacks.append(callback)
+
+ def __iter__(self):
+ return iter(self.callbacks)
+
+ def set_params(self, params):
+ for c in self.callbacks:
+ c.set_params(params)
+
+ def set_model(self, model):
+ for c in self.callbacks:
+ c.set_model(model)
+
+ def _call(self, name, *args):
+ for c in self.callbacks:
+ func = getattr(c, name)
+ func(*args)
+
+ def _check_mode(self, mode):
+ assert mode in ['train', 'eval', 'predict'], \
+ 'mode should be train, eval or predict'
+
+ def on_begin(self, mode, logs=None):
+ self._check_mode(mode)
+ name = 'on_{}_begin'.format(mode)
+ self._call(name, logs)
+
+ def on_end(self, mode, logs=None):
+ self._check_mode(mode)
+ name = 'on_{}_end'.format(mode)
+ self._call(name, logs)
+
+ def on_epoch_begin(self, epoch=None, logs=None):
+ self._call('on_epoch_begin', epoch, logs)
+
+ def on_epoch_end(self, epoch=None, logs=None):
+ self._call('on_epoch_end', epoch, logs)
+
+ def on_batch_begin(self, mode, step=None, logs=None):
+ self._check_mode(mode)
+ name = 'on_{}_batch_begin'.format(mode)
+ self._call(name, step, logs)
+
+ def on_batch_end(self, mode, step=None, logs=None):
+ self._check_mode(mode)
+ name = 'on_{}_batch_end'.format(mode)
+ self._call(name, step, logs)
+
+
+class Callback(object):
+ """
+ Base class used to build new callbacks. And new callbacks could also
+ terminate training by setting `model.stop_training=True`.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+
+ # build a simple model checkpoint callback
+ class ModelCheckpoint(paddle.callbacks.Callback):
+ def __init__(self, save_freq=1, save_dir=None):
+ self.save_freq = save_freq
+ self.save_dir = save_dir
+
+ def on_epoch_end(self, epoch, logs=None):
+ if self.model is not None and epoch % self.save_freq == 0:
+ path = '{}/{}'.format(self.save_dir, epoch)
+ print('save checkpoint at {}'.format(path))
+ self.model.save(path)
+
+ """
+
+ def __init__(self):
+ self.model = None
+ self.params = {}
+
+ def set_params(self, params):
+ """
+ Set parameters, which is dict. The keys contain:
+
+ - 'batch_size': an integer. Number of samples per batch.
+ - 'epochs': an integer. Number of epochs.
+ - 'steps': an integer. Number of steps of one epoch.
+ - 'verbose': an integer. Verbose mode is 0, 1 or 2. 0 = silent, 1 = progress bar, 2 = one line per epoch.
+ - 'metrics': a list of str. Names of metrics, including 'loss' and the names of paddle.metric.Metric.
+ """
+ self.params = params
+
+ def set_model(self, model):
+ """model is instance of paddle.Model.
+ """
+ self.model = model
+
+ def on_train_begin(self, logs=None):
+ """Called at the start of training.
+
+ Args:
+ logs (dict): The logs is a dict or None.
+ """
+
+ def on_train_end(self, logs=None):
+ """Called at the end of training.
+
+ Args:
+ logs (dict): The logs is a dict or None. The keys of logs
+ passed by paddle.Model contains 'loss', metric names and
+ `batch_size`.
+ """
+
+ def on_eval_begin(self, logs=None):
+ """Called at the start of evaluation.
+
+ Args:
+ logs (dict): The logs is a dict or None. The keys of logs
+ passed by paddle.Model contains 'steps' and 'metrics',
+ The `steps` is number of total steps of validation dataset.
+ The `metrics` is a list of str including 'loss' and the names
+ of paddle.metric.Metric.
+ """
+
+ def on_eval_end(self, logs=None):
+ """Called at the end of evaluation.
+
+ Args:
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is a dict contains 'loss', metrics and 'batch_size'
+ of last batch of validation dataset.
+ """
+
+ def on_predict_begin(self, logs=None):
+ """Called at the beginning of predict.
+
+ Args:
+ logs (dict): The logs is a dict or None.
+ """
+
+ def on_predict_end(self, logs=None):
+ """Called at the end of predict.
+
+ Args:
+ logs (dict): The logs is a dict or None.
+ """
+
+ def on_epoch_begin(self, epoch, logs=None):
+ """Called at the beginning of each epoch.
+
+ Args:
+ epoch (int): The index of epoch.
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is None.
+ """
+
+ def on_epoch_end(self, epoch, logs=None):
+ """Called at the end of each epoch.
+
+ Args:
+ epoch (int): The index of epoch.
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is a dict, contains 'loss', metrics and 'batch_size'
+ of last batch.
+ """
+
+ def on_train_batch_begin(self, step, logs=None):
+ """Called at the beginning of each batch in training.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is empty.
+ """
+
+ def on_train_batch_end(self, step, logs=None):
+ """Called at the end of each batch in training.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is a dict, contains 'loss', metrics and 'batch_size'
+ of current batch.
+ """
+
+ def on_eval_batch_begin(self, step, logs=None):
+ """Called at the beginning of each batch in evaluation.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is empty.
+ """
+
+ def on_eval_batch_end(self, step, logs=None):
+ """Called at the end of each batch in evaluation.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None. The `logs` passed by
+ paddle.Model is a dict, contains 'loss', metrics and 'batch_size'
+ of current batch.
+ """
+
+ def on_predict_batch_begin(self, step, logs=None):
+ """Called at the beginning of each batch in predict.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None.
+ """
+
+ def on_predict_batch_end(self, step, logs=None):
+ """Called at the end of each batch in predict.
+
+ Args:
+ step (int): The index of step (or iteration).
+ logs (dict): The logs is a dict or None.
+ """
+
+
+class ProgBarLogger(Callback):
+ """
+ Logger callback function to print loss and metrics to stdout. It supports
+ silent mode (not print), progress bar or one line per each printing,
+ see arguments for more detailed.
+
+ Args:
+ log_freq (int): The frequency, in number of steps,
+ the logs such as loss, metrics are printed. Default: 1.
+ verbose (int): The verbosity mode, should be 0, 1, or 2.
+ 0 = silent, 1 = progress bar, 2 = one line each printing, 3 = 2 +
+ time counter, such as average reader cost, samples per second.
+ Default: 2.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.vision.datasets import MNIST
+ from paddle.static import InputSpec
+
+ inputs = [InputSpec([-1, 1, 28, 28], 'float32', 'image')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = MNIST(mode='train', transform=transform)
+
+ lenet = paddle.vision.models.LeNet()
+ model = paddle.Model(lenet,
+ inputs, labels)
+
+ optim = paddle.optimizer.Adam(0.001, parameters=lenet.parameters())
+ model.prepare(optimizer=optim,
+ loss=paddle.nn.CrossEntropyLoss(),
+ metrics=paddle.metric.Accuracy())
+
+ callback = paddle.callbacks.ProgBarLogger(log_freq=10)
+ model.fit(train_dataset, batch_size=64, callbacks=callback)
+ """
+
+ def __init__(self, log_freq=1, verbose=2):
+ self.epochs = None
+ self.steps = None
+ self.progbar = None
+ self.verbose = verbose
+ self.log_freq = log_freq
+
+ def _is_print(self):
+ return self.verbose and ParallelEnv().local_rank == 0
+
+ def on_train_begin(self, logs=None):
+ self.epochs = self.params['epochs']
+ assert self.epochs
+ self.train_metrics = self.params['metrics']
+ assert self.train_metrics
+
+ self._train_timer = {
+ 'data_time': 0,
+ 'batch_time': 0,
+ 'count': 0,
+ 'samples': 0,
+ }
+ if self._is_print():
+ print(
+ "The loss value printed in the log is the current step, and the metric is the average value of previous steps."
+ )
+
+ def on_epoch_begin(self, epoch=None, logs=None):
+ self.steps = self.params['steps']
+ self.epoch = epoch
+ self.train_step = 0
+ if self.epochs and self._is_print():
+ print('Epoch %d/%d' % (epoch + 1, self.epochs))
+ self.train_progbar = ProgressBar(num=self.steps, verbose=self.verbose)
+
+ self._train_timer['batch_start_time'] = time.time()
+
+ def _updates(self, logs, mode):
+ values = []
+ metrics = getattr(self, '%s_metrics' % (mode))
+ progbar = getattr(self, '%s_progbar' % (mode))
+ steps = getattr(self, '%s_step' % (mode))
+
+ for k in metrics:
+ if k in logs:
+ values.append((k, logs[k]))
+
+ if self.verbose == 3 and hasattr(self, '_%s_timer' % (mode)):
+ timer = getattr(self, '_%s_timer' % (mode))
+ cnt = timer['count'] if timer['count'] > 0 else 1.0
+ samples = timer['samples'] if timer['samples'] > 0 else 1.0
+ values.append(
+ ('avg_reader_cost', "%.5f sec" % (timer['data_time'] / cnt)))
+ values.append(
+ ('avg_batch_cost', "%.5f sec" % (timer['batch_time'] / cnt)))
+ values.append(
+ ('ips', "%.5f samples/sec" %
+ (samples / (timer['data_time'] + timer['batch_time']))))
+ timer['count'] = 0
+ timer['samples'] = 0
+ timer['data_time'] = 0.
+ timer['batch_time'] = 0.
+
+ progbar.update(steps, values)
+
+ def on_train_batch_begin(self, step, logs=None):
+ self._train_timer['batch_data_end_time'] = time.time()
+ self._train_timer['data_time'] += (
+ self._train_timer['batch_data_end_time'] -
+ self._train_timer['batch_start_time'])
+
+ def on_train_batch_end(self, step, logs=None):
+ logs = logs or {}
+ self.train_step += 1
+
+ self._train_timer['batch_time'] += (
+ time.time() - self._train_timer['batch_data_end_time'])
+ self._train_timer['count'] += 1
+ samples = logs.get('batch_size', 1)
+ self._train_timer['samples'] += samples
+ if self._is_print() and self.train_step % self.log_freq == 0:
+ if self.steps is None or self.train_step < self.steps:
+ self._updates(logs, 'train')
+ self._train_timer['batch_start_time'] = time.time()
+
+ def on_epoch_end(self, epoch, logs=None):
+ logs = logs or {}
+ if self._is_print() and (self.steps is not None):
+ self._updates(logs, 'train')
+
+ def on_eval_begin(self, logs=None):
+ self.eval_steps = logs.get('steps', None)
+ self.eval_metrics = logs.get('metrics', [])
+ self.eval_step = 0
+ self.evaled_samples = 0
+
+ self._eval_timer = {
+ 'data_time': 0,
+ 'batch_time': 0,
+ 'count': 0,
+ 'samples': 0,
+ }
+
+ self.eval_progbar = ProgressBar(num=self.eval_steps,
+ verbose=self.verbose)
+ if self._is_print():
+ print('Eval begin...')
+
+ self._eval_timer['batch_start_time'] = time.time()
+
+ def on_eval_batch_begin(self, step, logs=None):
+ self._eval_timer['batch_data_end_time'] = time.time()
+ self._eval_timer['data_time'] += (
+ self._eval_timer['batch_data_end_time'] -
+ self._eval_timer['batch_start_time'])
+
+ def on_eval_batch_end(self, step, logs=None):
+ logs = logs or {}
+ self.eval_step += 1
+ samples = logs.get('batch_size', 1)
+ self.evaled_samples += samples
+
+ self._eval_timer['batch_time'] += (
+ time.time() - self._eval_timer['batch_data_end_time'])
+ self._eval_timer['count'] += 1
+ samples = logs.get('batch_size', 1)
+ self._eval_timer['samples'] += samples
+
+ if self._is_print() and self.eval_step % self.log_freq == 0:
+ if self.eval_steps is None or self.eval_step < self.eval_steps:
+ self._updates(logs, 'eval')
+
+ self._eval_timer['batch_start_time'] = time.time()
+
+ def on_predict_begin(self, logs=None):
+ self.test_steps = logs.get('steps', None)
+ self.test_metrics = logs.get('metrics', [])
+ self.test_step = 0
+ self.tested_samples = 0
+
+ self._test_timer = {
+ 'data_time': 0,
+ 'batch_time': 0,
+ 'count': 0,
+ 'samples': 0,
+ }
+
+ self.test_progbar = ProgressBar(num=self.test_steps,
+ verbose=self.verbose)
+ if self._is_print():
+ print('Predict begin...')
+
+ self._test_timer['batch_start_time'] = time.time()
+
+ def on_predict_batch_begin(self, step, logs=None):
+ self._test_timer['batch_data_end_time'] = time.time()
+ self._test_timer['data_time'] += (
+ self._test_timer['batch_data_end_time'] -
+ self._test_timer['batch_start_time'])
+
+ def on_predict_batch_end(self, step, logs=None):
+ logs = logs or {}
+ self.test_step += 1
+ samples = logs.get('batch_size', 1)
+ self.tested_samples += samples
+
+ self._test_timer['batch_time'] += (
+ time.time() - self._test_timer['batch_data_end_time'])
+ self._test_timer['count'] += 1
+ samples = logs.get('batch_size', 1)
+ self._test_timer['samples'] += samples
+
+ if self.test_step % self.log_freq == 0 and self._is_print():
+ if self.test_steps is None or self.test_step < self.test_steps:
+ self._updates(logs, 'test')
+
+ self._test_timer['batch_start_time'] = time.time()
+
+ def on_eval_end(self, logs=None):
+ logs = logs or {}
+ if self._is_print() and (self.eval_steps is not None):
+ self._updates(logs, 'eval')
+ print('Eval samples: %d' % (self.evaled_samples))
+
+ def on_predict_end(self, logs=None):
+ logs = logs or {}
+ if self._is_print():
+ if self.test_step % self.log_freq != 0 or self.verbose == 1:
+ self._updates(logs, 'test')
+ print('Predict samples: %d' % (self.tested_samples))
+
+
+class ModelCheckpoint(Callback):
+ """
+ Model checkpoint callback function to save model weights and optimizer
+ state during training in conjunction with model.fit(). Currently,
+ ModelCheckpoint only supports saving after a fixed number of epochs.
+
+ Args:
+ save_freq(int): The frequency, in number of epochs, the model checkpoint
+ are saved. Default: 1.
+ save_dir(str|None): The directory to save checkpoint during training.
+ If None, will not save checkpoint. Default: None.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.vision.datasets import MNIST
+ from paddle.static import InputSpec
+
+ inputs = [InputSpec([-1, 1, 28, 28], 'float32', 'image')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = MNIST(mode='train', transform=transform)
+
+ lenet = paddle.vision.models.LeNet()
+ model = paddle.Model(lenet,
+ inputs, labels)
+
+ optim = paddle.optimizer.Adam(0.001, parameters=lenet.parameters())
+ model.prepare(optimizer=optim,
+ loss=paddle.nn.CrossEntropyLoss(),
+ metrics=paddle.metric.Accuracy())
+
+ callback = paddle.callbacks.ModelCheckpoint(save_dir='./temp')
+ model.fit(train_dataset, batch_size=64, callbacks=callback)
+ """
+
+ def __init__(self, save_freq=1, save_dir=None):
+ self.save_freq = save_freq
+ self.save_dir = save_dir
+
+ def on_epoch_begin(self, epoch=None, logs=None):
+ self.epoch = epoch
+
+ def _is_save(self):
+ return self.model and self.save_dir and ParallelEnv().local_rank == 0
+
+ def on_epoch_end(self, epoch, logs=None):
+ if self._is_save() and self.epoch % self.save_freq == 0:
+ path = '{}/{}'.format(self.save_dir, epoch)
+ print('save checkpoint at {}'.format(os.path.abspath(path)))
+ self.model.save(path)
+
+ def on_train_end(self, logs=None):
+ if self._is_save():
+ path = '{}/final'.format(self.save_dir)
+ print('save checkpoint at {}'.format(os.path.abspath(path)))
+ self.model.save(path)
+
+
+class LRScheduler(Callback):
+ """Lr scheduler callback function
+
+ Args:
+ by_step(bool, optional): whether to update learning rate scheduler
+ by step. Default: True.
+ by_epoch(bool, optional): whether to update learning rate scheduler
+ by epoch. Default: False.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.static import InputSpec
+
+ inputs = [InputSpec([-1, 1, 28, 28], 'float32', 'image')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform)
+
+ lenet = paddle.vision.models.LeNet()
+ model = paddle.Model(lenet,
+ inputs, labels)
+
+ base_lr = 1e-3
+ boundaries = [5, 8]
+ wamup_steps = 4
+
+ def make_optimizer(parameters=None):
+ momentum = 0.9
+ weight_decay = 5e-4
+ values = [base_lr * (0.1**i) for i in range(len(boundaries) + 1)]
+ learning_rate = paddle.optimizer.lr.PiecewiseDecay(
+ boundaries=boundaries, values=values)
+ learning_rate = paddle.optimizer.lr.LinearWarmup(
+ learning_rate=learning_rate,
+ warmup_steps=wamup_steps,
+ start_lr=base_lr / 5.,
+ end_lr=base_lr,
+ verbose=True)
+ optimizer = paddle.optimizer.Momentum(
+ learning_rate=learning_rate,
+ weight_decay=weight_decay,
+ momentum=momentum,
+ parameters=parameters)
+ return optimizer
+
+ optim = make_optimizer(parameters=lenet.parameters())
+ model.prepare(optimizer=optim,
+ loss=paddle.nn.CrossEntropyLoss(),
+ metrics=paddle.metric.Accuracy())
+
+ # if LRScheduler callback not set, an instance LRScheduler update by step
+ # will be created auto.
+ model.fit(train_dataset, batch_size=64)
+
+ # create a learning rate scheduler update by epoch
+ callback = paddle.callbacks.LRScheduler(by_step=False, by_epoch=True)
+ model.fit(train_dataset, batch_size=64, callbacks=callback)
+ """
+
+ def __init__(self, by_step=True, by_epoch=False):
+ if by_step and by_epoch:
+ raise ValueError(
+ "by_step option is mutually exclusive with by_epoch")
+
+ self.by_step = by_step
+ self.by_epoch = by_epoch
+
+ def on_epoch_end(self, epoch, logs=None):
+ if self.by_epoch:
+ if self.model._optimizer and \
+ hasattr(self.model._optimizer, '_learning_rate') and \
+ isinstance(self.model._optimizer._learning_rate,
+ paddle.optimizer.lr.LRScheduler):
+ self.model._optimizer._learning_rate.step()
+
+ def on_train_batch_end(self, step, logs=None):
+ if self.by_step:
+ if self.model._optimizer and \
+ hasattr(self.model._optimizer, '_learning_rate') and \
+ isinstance(self.model._optimizer._learning_rate,
+ paddle.optimizer.lr.LRScheduler):
+ self.model._optimizer._learning_rate.step()
+
+
+class EarlyStopping(Callback):
+ """Stop training when the given monitor stopped improving during evaluation
+ by setting `model.stop_training=True`.
+
+ Args:
+ monitor(str): Quantity to be monitored. Default: 'loss'.
+ mode(str|None): Mode should be one of 'auto', 'min' or 'max'. In 'min'
+ mode, training will stop until monitored quantity stops decreasing.
+ In 'max' mode, training will stop until monitored quantity stops
+ increasing. In 'auto' mode, exact mode can be inferred by the name
+ of monitor. If 'acc' in monitor, the mode will be considered as
+ 'max', otherwise the mode will be set to 'min'. Default: 'auto'.
+ patience(int): Number of epochs with no improvement after which
+ training will be stopped. Default: 0.
+ verbose(int): The verbosity mode, should be 0 or 1. When verbose=0,
+ logs will not be printed. When verbose=1, logs will be printed.
+ Default: 1.
+ min_delta(int|float): The minimum change of monitored quantity. If
+ the change is less than min_delta, model could be considered as no
+ improvement. Default: 0.
+ baseline(int|float|None): Baseline value for the monitored quantity.
+ Training will stop if the model doesn't show improvement over the
+ baseline. Default: None.
+ save_best_model(bool): Whether to save best model. Default: True.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ from paddle import Model
+ from paddle.static import InputSpec
+ from paddle.vision.models import LeNet
+ from paddle.vision.datasets import MNIST
+ from paddle.metric import Accuracy
+ from paddle.nn import CrossEntropyLoss
+ import paddle.vision.transforms as T
+
+ device = paddle.set_device('cpu')
+ sample_num = 200
+ save_dir = './best_model_checkpoint'
+ transform = T.Compose(
+ [T.Transpose(), T.Normalize([127.5], [127.5])])
+ train_dataset = MNIST(mode='train', transform=transform)
+ val_dataset = MNIST(mode='test', transform=transform)
+ net = LeNet()
+ optim = paddle.optimizer.Adam(
+ learning_rate=0.001, parameters=net.parameters())
+
+ inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+
+ model = Model(net, inputs=inputs, labels=labels)
+ model.prepare(
+ optim,
+ loss=CrossEntropyLoss(reduction="sum"),
+ metrics=[Accuracy()])
+ callbacks = paddle.callbacks.EarlyStopping(
+ 'loss',
+ mode='min',
+ patience=1,
+ verbose=1,
+ min_delta=0,
+ baseline=None,
+ save_best_model=True)
+ model.fit(train_dataset,
+ val_dataset,
+ batch_size=64,
+ log_freq=200,
+ save_freq=10,
+ save_dir=save_dir,
+ epochs=20,
+ callbacks=[callbacks])
+ """
+
+ def __init__(self,
+ monitor='loss',
+ mode='auto',
+ patience=0,
+ verbose=1,
+ min_delta=0,
+ baseline=None,
+ save_best_model=True):
+ super(EarlyStopping, self).__init__()
+ self.monitor = monitor
+ self.patience = patience
+ self.verbose = verbose
+ self.baseline = baseline
+ self.min_delta = abs(min_delta)
+ self.wait_epoch = 0
+ self.best_weights = None
+ self.stopped_epoch = 0
+ self.save_best_model = save_best_model
+ # The value of `save_dir` is set in function `config_callbacks`
+ self.save_dir = None
+ if mode not in ['auto', 'min', 'max']:
+ warnings.warn('EarlyStopping mode %s is unknown, '
+ 'fallback to auto mode.' % mode)
+ mode = 'auto'
+ if mode == 'min':
+ self.monitor_op = np.less
+ elif mode == 'max':
+ self.monitor_op = np.greater
+ # When mode == 'auto', the mode should be inferred by `self.monitor`
+ else:
+ if 'acc' in self.monitor:
+ self.monitor_op = np.greater
+ else:
+ self.monitor_op = np.less
+
+ if self.monitor_op == np.greater:
+ self.min_delta *= 1
+ else:
+ self.min_delta *= -1
+
+ def on_train_begin(self, logs=None):
+ self.wait_epoch = 0
+ if self.baseline is not None:
+ self.best_value = self.baseline
+ else:
+ self.best_value = np.inf if self.monitor_op == np.less else -np.inf
+ self.best_weights = None
+
+ def on_eval_end(self, logs=None):
+ if logs is None or self.monitor not in logs:
+ warnings.warn(
+ 'Monitor of EarlyStopping should be loss or metric name.')
+ return
+ current = logs[self.monitor]
+ if isinstance(current, (list, tuple)):
+ current = current[0]
+ elif isinstance(current, numbers.Number):
+ current = current
+ else:
+ return
+
+ if self.monitor_op(current - self.min_delta, self.best_value):
+ self.best_value = current
+ self.wait_epoch = 0
+ if self.save_best_model and self.save_dir is not None:
+ path = os.path.join(self.save_dir, 'best_model')
+ self.model.save(path)
+ else:
+ self.wait_epoch += 1
+ if self.wait_epoch >= self.patience:
+ self.model.stop_training = True
+ if self.verbose > 0:
+ print('Epoch %d: Early stopping.' % (self.stopped_epoch + 1))
+ if self.save_best_model and self.save_dir is not None:
+ print('Best checkpoint has been saved at %s' %
+ (os.path.abspath(
+ os.path.join(self.save_dir, 'best_model'))))
+ self.stopped_epoch += 1
+
+
+class VisualDL(Callback):
+ """
+ VisualDL callback function.
+
+ Args:
+ log_dir (str): The directory to save visualdl log file.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.static import InputSpec
+
+ inputs = [InputSpec([-1, 1, 28, 28], 'float32', 'image')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=transform)
+ eval_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)
+
+ net = paddle.vision.models.LeNet()
+ model = paddle.Model(net, inputs, labels)
+
+ optim = paddle.optimizer.Adam(0.001, parameters=net.parameters())
+ model.prepare(optimizer=optim,
+ loss=paddle.nn.CrossEntropyLoss(),
+ metrics=paddle.metric.Accuracy())
+
+ ## uncomment following lines to fit model with visualdl callback function
+ # callback = paddle.callbacks.VisualDL(log_dir='visualdl_log_dir')
+ # model.fit(train_dataset, eval_dataset, batch_size=64, callbacks=callback)
+
+ """
+
+ def __init__(self, log_dir):
+ self.log_dir = log_dir
+ self.epochs = None
+ self.steps = None
+ self.epoch = 0
+
+ def _is_write(self):
+ return ParallelEnv().local_rank == 0
+
+ def on_train_begin(self, logs=None):
+ self.epochs = self.params['epochs']
+ assert self.epochs
+ self.train_metrics = self.params['metrics']
+ assert self.train_metrics
+ self._is_fit = True
+ self.train_step = 0
+
+ def on_epoch_begin(self, epoch=None, logs=None):
+ self.steps = self.params['steps']
+ self.epoch = epoch
+
+ def _updates(self, logs, mode):
+ if not self._is_write():
+ return
+ if not hasattr(self, 'writer'):
+ visualdl = try_import('visualdl')
+ self.writer = visualdl.LogWriter(self.log_dir)
+
+ metrics = getattr(self, '%s_metrics' % (mode))
+ current_step = getattr(self, '%s_step' % (mode))
+
+ if mode == 'train':
+ total_step = current_step
+ else:
+ total_step = self.epoch
+
+ for k in metrics:
+ if k in logs:
+ temp_tag = mode + '/' + k
+
+ if isinstance(logs[k], (list, tuple)):
+ temp_value = logs[k][0]
+ elif isinstance(logs[k], numbers.Number):
+ temp_value = logs[k]
+ else:
+ continue
+
+ self.writer.add_scalar(tag=temp_tag,
+ step=total_step,
+ value=temp_value)
+
+ def on_train_batch_end(self, step, logs=None):
+ logs = logs or {}
+ self.train_step += 1
+
+ if self._is_write():
+ self._updates(logs, 'train')
+
+ def on_eval_begin(self, logs=None):
+ self.eval_steps = logs.get('steps', None)
+ self.eval_metrics = logs.get('metrics', [])
+ self.eval_step = 0
+ self.evaled_samples = 0
+
+ def on_train_end(self, logs=None):
+ if hasattr(self, 'writer'):
+ self.writer.close()
+ delattr(self, 'writer')
+
+ def on_eval_end(self, logs=None):
+ if self._is_write():
+ self._updates(logs, 'eval')
+
+ if (not hasattr(self, '_is_fit')) and hasattr(self, 'writer'):
+ self.writer.close()
+ delattr(self, 'writer')
+
+
+class ReduceLROnPlateau(Callback):
+ """Reduce learning rate when a metric of evaluation has stopped improving.
+ Models often benefit from reducing the learning rate by a factor
+ of 2-10 once learning stagnates. This callback monitors a
+ quantity and if no improvement is seen for a 'patience' number
+ of epochs, the learning rate is reduced.
+
+ Args:
+ monitor(str, optional): Quantity to be monitored. Default: 'loss'.
+ factor(float, optional): factor by which the learning rate will be reduced.
+ `new_lr = lr * factor`. Default: 0.1.
+ patience(int, optional): Number of epochs with no improvement after which
+ learning rate will be reduced. Default: 10.
+ verbose(int, optional): The verbosity mode. 0: quiet, 1: update messages.
+ Default: 1.
+ mode(str, optional): one of `{'auto', 'min', 'max'}`. In `'min'` mode,
+ the learning rate will be reduced when the quantity monitored has
+ stopped decreasing. In 'max' mode, learning rate will reduce until
+ monitored quantity stops increasing. In 'auto' mode, exact mode
+ can be inferred by the name of monitor. If 'acc' in monitor, the
+ mode will be considered as 'max', otherwise the mode will be set
+ to 'min'. Default: 'auto'.
+ min_delta(int|float, optional): threshold for measuring the new optimum,
+ to only focus on significant changes. Default: 0.
+ cooldown(int, optional): number of epochs to wait before resuming normal operation after
+ lr has been reduced. Default: 0.
+ min_lr(float, optional): lower bound on the learning rate. Default: 0.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ from paddle import Model
+ from paddle.static import InputSpec
+ from paddle.vision.models import LeNet
+ from paddle.vision.datasets import MNIST
+ from paddle.metric import Accuracy
+ from paddle.nn.layer.loss import CrossEntropyLoss
+ import paddle.vision.transforms as T
+ sample_num = 200
+ transform = T.Compose(
+ [T.Transpose(), T.Normalize([127.5], [127.5])])
+ train_dataset = MNIST(mode='train', transform=transform)
+ val_dataset = MNIST(mode='test', transform=transform)
+ net = LeNet()
+ optim = paddle.optimizer.Adam(
+ learning_rate=0.001, parameters=net.parameters())
+ inputs = [InputSpec([None, 1, 28, 28], 'float32', 'x')]
+ labels = [InputSpec([None, 1], 'int64', 'label')]
+ model = Model(net, inputs=inputs, labels=labels)
+ model.prepare(
+ optim,
+ loss=CrossEntropyLoss(),
+ metrics=[Accuracy()])
+ callbacks = paddle.callbacks.ReduceLROnPlateau(patience=3, verbose=1)
+ model.fit(train_dataset,
+ val_dataset,
+ batch_size=64,
+ log_freq=200,
+ save_freq=10,
+ epochs=20,
+ callbacks=[callbacks])
+
+ """
+
+ def __init__(self,
+ monitor='loss',
+ factor=0.1,
+ patience=10,
+ verbose=1,
+ mode='auto',
+ min_delta=1e-4,
+ cooldown=0,
+ min_lr=0):
+ super(ReduceLROnPlateau, self).__init__()
+
+ self.monitor = monitor
+ if factor >= 1.0:
+ raise ValueError('ReduceLROnPlateau '
+ 'does not support a factor >= 1.0.')
+
+ self.factor = factor
+ self.min_lr = min_lr
+ self.min_delta = min_delta
+ self.patience = patience
+ self.verbose = verbose
+ self.cooldown = cooldown
+ self.cooldown_counter = 0 # Cooldown counter.
+ self.wait = 0
+ self.best = 0
+ self.mode = mode
+ self.monitor_op = None
+ self.epoch = 0
+ self._reset()
+
+ def _reset(self):
+ """Resets wait counter and cooldown counter.
+ """
+ if self.mode not in ['auto', 'min', 'max']:
+ warnings.warn('Learning rate reduction mode %s is unknown, '
+ 'fallback to auto mode.' % self.mode)
+ self.mode = 'auto'
+ if (self.mode == 'min'
+ or (self.mode == 'auto' and 'acc' not in self.monitor)):
+ self.monitor_op = lambda a, b: np.less(a, b - self.min_delta)
+ self.best = np.Inf
+ else:
+ self.monitor_op = lambda a, b: np.greater(a, b + self.min_delta)
+ self.best = -np.Inf
+ self.cooldown_counter = 0
+ self.wait = 0
+
+ def on_train_begin(self, logs=None):
+ self._reset()
+
+ def on_eval_end(self, logs=None):
+ if logs is None or self.monitor not in logs:
+ warnings.warn(
+ 'Monitor of ReduceLROnPlateau should be loss or metric name.')
+ return
+ else:
+ try:
+ lr = self.model._optimizer._learning_rate
+ if not isinstance(lr, float):
+ warnings.warn(
+ 'Expected learning_rate be float, bug got {}.'.format(
+ type(lr)))
+ return
+ except Exception as e:
+ warnings.warn(
+ 'There are something wrong when get learning_rate from optimizer: {}.'
+ .format(e))
+ return
+
+ current = logs[self.monitor]
+ if isinstance(current, (list, tuple)):
+ current = current[0]
+ elif isinstance(current, numbers.Number):
+ current = current
+ else:
+ return
+
+ if self.in_cooldown():
+ self.cooldown_counter -= 1
+ self.wait = 0
+
+ if self.monitor_op(current, self.best):
+ self.best = current
+ self.wait = 0
+ elif not self.in_cooldown():
+ self.wait += 1
+ if self.wait >= self.patience:
+ old_lr = self.model._optimizer.get_lr()
+ if old_lr > np.float32(self.min_lr):
+ new_lr = old_lr * self.factor
+ new_lr = max(new_lr, self.min_lr)
+ self.model._optimizer._learning_rate = new_lr
+ if self.verbose > 0 and ParallelEnv().local_rank == 0:
+ print('\nEpoch %d: ReduceLROnPlateau reducing learning '
+ 'rate to %s.' % (self.epoch + 1, new_lr))
+ self.cooldown_counter = self.cooldown
+ self.wait = 0
+ self.epoch += 1
+
+ def in_cooldown(self):
+ return self.cooldown_counter > 0
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/dynamic_flops.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/dynamic_flops.py
new file mode 100644
index 0000000000000000000000000000000000000000..214af9f2f5986edcc085716243c19a8d160cc388
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/dynamic_flops.py
@@ -0,0 +1,296 @@
+# Copyright (c) 2020 PaddlePaddle 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 paddle
+import warnings
+import paddle.nn as nn
+import numpy as np
+from .static_flops import static_flops, Table
+from paddle.fluid.dygraph.dygraph_to_static.program_translator import unwrap_decorators
+
+__all__ = []
+
+
+def flops(net, input_size, custom_ops=None, print_detail=False):
+ """Print a table about the FLOPs of network.
+
+ Args:
+ net (paddle.nn.Layer||paddle.static.Program): The network which could be a instance of paddle.nn.Layer in
+ dygraph or paddle.static.Program in static graph.
+ input_size (list): size of input tensor. Note that the batch_size in argument ``input_size`` only support 1.
+ custom_ops (A dict of function, optional): A dictionary which key is the class of specific operation such as
+ paddle.nn.Conv2D and the value is the function used to count the FLOPs of this operation. This
+ argument only work when argument ``net`` is an instance of paddle.nn.Layer. The details could be found
+ in following example code. Default is None.
+ print_detail (bool, optional): Whether to print the detail information, like FLOPs per layer, about the net FLOPs.
+ Default is False.
+
+ Returns:
+ Int: A number about the FLOPs of total network.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+
+ class LeNet(nn.Layer):
+ def __init__(self, num_classes=10):
+ super(LeNet, self).__init__()
+ self.num_classes = num_classes
+ self.features = nn.Sequential(
+ nn.Conv2D(
+ 1, 6, 3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.MaxPool2D(2, 2),
+ nn.Conv2D(
+ 6, 16, 5, stride=1, padding=0),
+ nn.ReLU(),
+ nn.MaxPool2D(2, 2))
+
+ if num_classes > 0:
+ self.fc = nn.Sequential(
+ nn.Linear(400, 120),
+ nn.Linear(120, 84),
+ nn.Linear(
+ 84, 10))
+
+ def forward(self, inputs):
+ x = self.features(inputs)
+
+ if self.num_classes > 0:
+ x = paddle.flatten(x, 1)
+ x = self.fc(x)
+ return x
+
+ lenet = LeNet()
+ # m is the instance of nn.Layer, x is the intput of layer, y is the output of layer.
+ def count_leaky_relu(m, x, y):
+ x = x[0]
+ nelements = x.numel()
+ m.total_ops += int(nelements)
+
+ FLOPs = paddle.flops(lenet, [1, 1, 28, 28], custom_ops= {nn.LeakyReLU: count_leaky_relu},
+ print_detail=True)
+ print(FLOPs)
+
+ #+--------------+-----------------+-----------------+--------+--------+
+ #| Layer Name | Input Shape | Output Shape | Params | Flops |
+ #+--------------+-----------------+-----------------+--------+--------+
+ #| conv2d_2 | [1, 1, 28, 28] | [1, 6, 28, 28] | 60 | 47040 |
+ #| re_lu_2 | [1, 6, 28, 28] | [1, 6, 28, 28] | 0 | 0 |
+ #| max_pool2d_2 | [1, 6, 28, 28] | [1, 6, 14, 14] | 0 | 0 |
+ #| conv2d_3 | [1, 6, 14, 14] | [1, 16, 10, 10] | 2416 | 241600 |
+ #| re_lu_3 | [1, 16, 10, 10] | [1, 16, 10, 10] | 0 | 0 |
+ #| max_pool2d_3 | [1, 16, 10, 10] | [1, 16, 5, 5] | 0 | 0 |
+ #| linear_0 | [1, 400] | [1, 120] | 48120 | 48000 |
+ #| linear_1 | [1, 120] | [1, 84] | 10164 | 10080 |
+ #| linear_2 | [1, 84] | [1, 10] | 850 | 840 |
+ #+--------------+-----------------+-----------------+--------+--------+
+ #Total Flops: 347560 Total Params: 61610
+ """
+ if isinstance(net, nn.Layer):
+ # If net is a dy2stat model, net.forward is StaticFunction instance,
+ # we set net.forward to original forward function.
+ _, net.forward = unwrap_decorators(net.forward)
+
+ inputs = paddle.randn(input_size)
+ return dynamic_flops(net,
+ inputs=inputs,
+ custom_ops=custom_ops,
+ print_detail=print_detail)
+ elif isinstance(net, paddle.static.Program):
+ return static_flops(net, print_detail=print_detail)
+ else:
+ warnings.warn(
+ "Your model must be an instance of paddle.nn.Layer or paddle.static.Program."
+ )
+ return -1
+
+
+def count_convNd(m, x, y):
+ x = x[0]
+ kernel_ops = np.product(m.weight.shape[2:])
+ bias_ops = 1 if m.bias is not None else 0
+ total_ops = int(
+ y.numel()) * (x.shape[1] / m._groups * kernel_ops + bias_ops)
+ m.total_ops += abs(int(total_ops))
+
+
+def count_leaky_relu(m, x, y):
+ x = x[0]
+ nelements = x.numel()
+ m.total_ops += int(nelements)
+
+
+def count_bn(m, x, y):
+ x = x[0]
+ nelements = x.numel()
+ if not m.training:
+ total_ops = 2 * nelements
+ m.total_ops += abs(int(total_ops))
+
+
+def count_linear(m, x, y):
+ total_mul = m.weight.shape[0]
+ num_elements = y.numel()
+ total_ops = total_mul * num_elements
+ m.total_ops += abs(int(total_ops))
+
+
+def count_avgpool(m, x, y):
+ kernel_ops = 1
+ num_elements = y.numel()
+ total_ops = kernel_ops * num_elements
+
+ m.total_ops += int(total_ops)
+
+
+def count_adap_avgpool(m, x, y):
+ kernel = np.array(x[0].shape[2:]) // np.array(y.shape[2:])
+ total_add = np.product(kernel)
+ total_div = 1
+ kernel_ops = total_add + total_div
+ num_elements = y.numel()
+ total_ops = kernel_ops * num_elements
+ m.total_ops += abs(int(total_ops))
+
+
+def count_zero_ops(m, x, y):
+ m.total_ops += int(0)
+
+
+def count_parameters(m, x, y):
+ total_params = 0
+ for p in m.parameters():
+ total_params += p.numel()
+ m.total_params[0] = abs(int(total_params))
+
+
+def count_io_info(m, x, y):
+ m.register_buffer('input_shape', paddle.to_tensor(x[0].shape))
+ if isinstance(y, (list, tuple)):
+ m.register_buffer('output_shape', paddle.to_tensor(y[0].shape))
+ else:
+ m.register_buffer('output_shape', paddle.to_tensor(y.shape))
+
+
+register_hooks = {
+ nn.Conv1D: count_convNd,
+ nn.Conv2D: count_convNd,
+ nn.Conv3D: count_convNd,
+ nn.Conv1DTranspose: count_convNd,
+ nn.Conv2DTranspose: count_convNd,
+ nn.Conv3DTranspose: count_convNd,
+ nn.layer.norm.BatchNorm2D: count_bn,
+ nn.BatchNorm: count_bn,
+ nn.ReLU: count_zero_ops,
+ nn.ReLU6: count_zero_ops,
+ nn.LeakyReLU: count_leaky_relu,
+ nn.Linear: count_linear,
+ nn.Dropout: count_zero_ops,
+ nn.AvgPool1D: count_avgpool,
+ nn.AvgPool2D: count_avgpool,
+ nn.AvgPool3D: count_avgpool,
+ nn.AdaptiveAvgPool1D: count_adap_avgpool,
+ nn.AdaptiveAvgPool2D: count_adap_avgpool,
+ nn.AdaptiveAvgPool3D: count_adap_avgpool
+}
+
+
+def dynamic_flops(model, inputs, custom_ops=None, print_detail=False):
+ handler_collection = []
+ types_collection = set()
+ if custom_ops is None:
+ custom_ops = {}
+
+ def add_hooks(m):
+ if len(list(m.children())) > 0:
+ return
+ m.register_buffer('total_ops', paddle.zeros([1], dtype='int64'))
+ m.register_buffer('total_params', paddle.zeros([1], dtype='int64'))
+ m_type = type(m)
+
+ flops_fn = None
+ if m_type in custom_ops:
+ flops_fn = custom_ops[m_type]
+ if m_type not in types_collection:
+ print(
+ "Customize Function has been applied to {}".format(m_type))
+ elif m_type in register_hooks:
+ flops_fn = register_hooks[m_type]
+ if m_type not in types_collection:
+ print("{}'s flops has been counted".format(m_type))
+ else:
+ if m_type not in types_collection:
+ print(
+ "Cannot find suitable count function for {}. Treat it as zero FLOPs."
+ .format(m_type))
+
+ if flops_fn is not None:
+ flops_handler = m.register_forward_post_hook(flops_fn)
+ handler_collection.append(flops_handler)
+ params_handler = m.register_forward_post_hook(count_parameters)
+ io_handler = m.register_forward_post_hook(count_io_info)
+ handler_collection.append(params_handler)
+ handler_collection.append(io_handler)
+ types_collection.add(m_type)
+
+ training = model.training
+
+ model.eval()
+ model.apply(add_hooks)
+
+ with paddle.framework.no_grad():
+ model(inputs)
+
+ total_ops = 0
+ total_params = 0
+ for m in model.sublayers():
+ if len(list(m.children())) > 0:
+ continue
+ if {'total_ops', 'total_params', 'input_shape',
+ 'output_shape'}.issubset(set(list(m._buffers.keys()))):
+ total_ops += m.total_ops
+ total_params += m.total_params
+
+ if training:
+ model.train()
+ for handler in handler_collection:
+ handler.remove()
+
+ table = Table(
+ ["Layer Name", "Input Shape", "Output Shape", "Params", "Flops"])
+
+ for n, m in model.named_sublayers():
+ if len(list(m.children())) > 0:
+ continue
+ if {'total_ops', 'total_params', 'input_shape',
+ 'output_shape'}.issubset(set(list(m._buffers.keys()))):
+ table.add_row([
+ m.full_name(),
+ list(m.input_shape.numpy()),
+ list(m.output_shape.numpy()),
+ int(m.total_params),
+ int(m.total_ops)
+ ])
+ m._buffers.pop("total_ops")
+ m._buffers.pop("total_params")
+ m._buffers.pop('input_shape')
+ m._buffers.pop('output_shape')
+ if print_detail:
+ table.print_table()
+ print('Total Flops: {} Total Params: {}'.format(int(total_ops),
+ int(total_params)))
+ return int(total_ops)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/hub.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/hub.py
new file mode 100644
index 0000000000000000000000000000000000000000..3217059c647d05826bbe4a91a5be70278bff3099
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/hub.py
@@ -0,0 +1,302 @@
+# Copyright (c) 2021 PaddlePaddle 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 os
+import re
+import sys
+import shutil
+import zipfile
+from paddle.utils.download import get_path_from_url
+
+__all__ = []
+
+DEFAULT_CACHE_DIR = '~/.cache'
+VAR_DEPENDENCY = 'dependencies'
+MODULE_HUBCONF = 'hubconf.py'
+HUB_DIR = os.path.expanduser(os.path.join('~', '.cache', 'paddle', 'hub'))
+
+
+def _remove_if_exists(path):
+ if os.path.exists(path):
+ if os.path.isfile(path):
+ os.remove(path)
+ else:
+ shutil.rmtree(path)
+
+
+def _import_module(name, repo_dir):
+ sys.path.insert(0, repo_dir)
+ try:
+ hub_module = __import__(name)
+ sys.modules.pop(name)
+ except ImportError:
+ sys.path.remove(repo_dir)
+ raise RuntimeError(
+ 'Please make sure config exists or repo error messages above fixed when importing'
+ )
+
+ sys.path.remove(repo_dir)
+
+ return hub_module
+
+
+def _git_archive_link(repo_owner, repo_name, branch, source):
+ if source == 'github':
+ return 'https://github.com/{}/{}/archive/{}.zip'.format(
+ repo_owner, repo_name, branch)
+ elif source == 'gitee':
+ return 'https://gitee.com/{}/{}/repository/archive/{}.zip'.format(
+ repo_owner, repo_name, branch)
+
+
+def _parse_repo_info(repo, source):
+ branch = 'main' if source == 'github' else 'master'
+ if ':' in repo:
+ repo_info, branch = repo.split(':')
+ else:
+ repo_info = repo
+ repo_owner, repo_name = repo_info.split('/')
+ return repo_owner, repo_name, branch
+
+
+def _make_dirs(dirname):
+ try:
+ from pathlib import Path
+ except ImportError:
+ from pathlib2 import Path
+ Path(dirname).mkdir(exist_ok=True)
+
+
+def _get_cache_or_reload(repo, force_reload, verbose=True, source='github'):
+ # Setup hub_dir to save downloaded files
+ hub_dir = HUB_DIR
+
+ _make_dirs(hub_dir)
+
+ # Parse github/gitee repo information
+ repo_owner, repo_name, branch = _parse_repo_info(repo, source)
+ # Github allows branch name with slash '/',
+ # this causes confusion with path on both Linux and Windows.
+ # Backslash is not allowed in Github branch name so no need to
+ # to worry about it.
+ normalized_br = branch.replace('/', '_')
+ # Github renames folder repo/v1.x.x to repo-1.x.x
+ # We don't know the repo name before downloading the zip file
+ # and inspect name from it.
+ # To check if cached repo exists, we need to normalize folder names.
+ repo_dir = os.path.join(hub_dir,
+ '_'.join([repo_owner, repo_name, normalized_br]))
+
+ use_cache = (not force_reload) and os.path.exists(repo_dir)
+
+ if use_cache:
+ if verbose:
+ sys.stderr.write('Using cache found in {}\n'.format(repo_dir))
+ else:
+ cached_file = os.path.join(hub_dir, normalized_br + '.zip')
+ _remove_if_exists(cached_file)
+
+ url = _git_archive_link(repo_owner, repo_name, branch, source=source)
+
+ fpath = get_path_from_url(
+ url,
+ hub_dir,
+ check_exist=not force_reload,
+ decompress=False,
+ method=('wget' if source == 'gitee' else 'get'))
+ shutil.move(fpath, cached_file)
+
+ with zipfile.ZipFile(cached_file) as cached_zipfile:
+ extraced_repo_name = cached_zipfile.infolist()[0].filename
+ extracted_repo = os.path.join(hub_dir, extraced_repo_name)
+ _remove_if_exists(extracted_repo)
+ # Unzip the code and rename the base folder
+ cached_zipfile.extractall(hub_dir)
+
+ _remove_if_exists(cached_file)
+ _remove_if_exists(repo_dir)
+ # rename the repo
+ shutil.move(extracted_repo, repo_dir)
+
+ return repo_dir
+
+
+def _load_entry_from_hubconf(m, name):
+ '''load entry from hubconf
+ '''
+ if not isinstance(name, str):
+ raise ValueError(
+ 'Invalid input: model should be a str of function name')
+
+ func = getattr(m, name, None)
+
+ if func is None or not callable(func):
+ raise RuntimeError('Cannot find callable {} in hubconf'.format(name))
+
+ return func
+
+
+def _check_module_exists(name):
+ try:
+ __import__(name)
+ return True
+ except ImportError:
+ return False
+
+
+def _check_dependencies(m):
+ dependencies = getattr(m, VAR_DEPENDENCY, None)
+
+ if dependencies is not None:
+ missing_deps = [
+ pkg for pkg in dependencies if not _check_module_exists(pkg)
+ ]
+ if len(missing_deps):
+ raise RuntimeError('Missing dependencies: {}'.format(
+ ', '.join(missing_deps)))
+
+
+def list(repo_dir, source='github', force_reload=False):
+ r"""
+ List all entrypoints available in `github` hubconf.
+
+ Args:
+ repo_dir(str): github or local path.
+
+ github path (str): a str with format "repo_owner/repo_name[:tag_name]" with an optional
+ tag/branch. The default branch is `main` if not specified.
+
+ local path (str): local repo path
+
+ source (str): `github` | `gitee` | `local`, default is `github`.
+ force_reload (bool, optional): whether to discard the existing cache and force a fresh download, default is `False`.
+ Returns:
+ entrypoints: a list of available entrypoint names
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.hub.list('lyuwenyu/paddlehub_demo:main', source='github', force_reload=False)
+
+ """
+ if source not in ('github', 'gitee', 'local'):
+ raise ValueError(
+ 'Unknown source: "{}". Allowed values: "github" | "gitee" | "local".'
+ .format(source))
+
+ if source in ('github', 'gitee'):
+ repo_dir = _get_cache_or_reload(repo_dir,
+ force_reload,
+ True,
+ source=source)
+
+ hub_module = _import_module(MODULE_HUBCONF.split('.')[0], repo_dir)
+
+ entrypoints = [
+ f for f in dir(hub_module)
+ if callable(getattr(hub_module, f)) and not f.startswith('_')
+ ]
+
+ return entrypoints
+
+
+def help(repo_dir, model, source='github', force_reload=False):
+ """
+ Show help information of model
+
+ Args:
+ repo_dir(str): github or local path.
+
+ github path (str): a str with format "repo_owner/repo_name[:tag_name]" with an optional
+ tag/branch. The default branch is `main` if not specified.
+
+ local path (str): local repo path.
+
+ model (str): model name.
+ source (str): `github` | `gitee` | `local`, default is `github`.
+ force_reload (bool, optional): default is `False`.
+ Return:
+ docs
+
+ Example:
+ .. code-block:: python
+
+ import paddle
+
+ paddle.hub.help('lyuwenyu/paddlehub_demo:main', model='MM', source='github')
+
+ """
+ if source not in ('github', 'gitee', 'local'):
+ raise ValueError(
+ 'Unknown source: "{}". Allowed values: "github" | "gitee" | "local".'
+ .format(source))
+
+ if source in ('github', 'gitee'):
+ repo_dir = _get_cache_or_reload(repo_dir,
+ force_reload,
+ True,
+ source=source)
+
+ hub_module = _import_module(MODULE_HUBCONF.split('.')[0], repo_dir)
+
+ entry = _load_entry_from_hubconf(hub_module, model)
+
+ return entry.__doc__
+
+
+def load(repo_dir, model, source='github', force_reload=False, **kwargs):
+ """
+ Load model
+
+ Args:
+ repo_dir(str): github or local path.
+
+ github path (str): a str with format "repo_owner/repo_name[:tag_name]" with an optional
+ tag/branch. The default branch is `main` if not specified.
+
+ local path (str): local repo path.
+
+ model (str): model name.
+ source (str): `github` | `gitee` | `local`, default is `github`.
+ force_reload (bool, optional): default is `False`.
+ **kwargs: parameters using for model
+ Return:
+ paddle model
+ Example:
+ .. code-block:: python
+
+ import paddle
+ paddle.hub.load('lyuwenyu/paddlehub_demo:main', model='MM', source='github')
+
+ """
+ if source not in ('github', 'gitee', 'local'):
+ raise ValueError(
+ 'Unknown source: "{}". Allowed values: "github" | "gitee" | "local".'
+ .format(source))
+
+ if source in ('github', 'gitee'):
+ repo_dir = _get_cache_or_reload(repo_dir,
+ force_reload,
+ True,
+ source=source)
+
+ hub_module = _import_module(MODULE_HUBCONF.split('.')[0], repo_dir)
+
+ _check_dependencies(hub_module)
+
+ entry = _load_entry_from_hubconf(hub_module, model)
+
+ return entry(**kwargs)
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/logger.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea515d95324675b071f810c813fcf0849490d007
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/logger.py
@@ -0,0 +1,73 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+import logging
+
+from paddle.fluid.dygraph.parallel import ParallelEnv
+
+__all__ = []
+
+
+def setup_logger(output=None, name="hapi", log_level=logging.INFO):
+ """
+ Initialize logger of hapi and set its verbosity level to "INFO".
+
+ Args:
+ output (str): a file name or a directory to save log. If None, will not save log file.
+ If ends with ".txt" or ".log", assumed to be a file name.
+ Otherwise, logs will be saved to `output/log.txt`.
+ name (str): the root module name of this logger. Default: 'hapi'.
+ log_level (enum): log level. eg.'INFO', 'DEBUG', 'ERROR'. Default: logging.INFO.
+ Returns:
+ logging.Logger: a logger
+ """
+ logger = logging.getLogger(name)
+ logger.propagate = False
+ logger.setLevel(log_level)
+
+ format_str = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+ # stdout logging: only local rank==0
+ local_rank = ParallelEnv().local_rank
+ if local_rank == 0 and len(logger.handlers) == 0:
+ ch = logging.StreamHandler(stream=sys.stdout)
+ ch.setLevel(log_level)
+
+ ch.setFormatter(logging.Formatter(format_str))
+ logger.addHandler(ch)
+
+ # file logging if output is not None: all workers
+ if output is not None:
+ if output.endswith(".txt") or output.endswith(".log"):
+ filename = output
+ else:
+ filename = os.path.join(output, "log.txt")
+
+ if local_rank > 0:
+ filename = filename + ".rank{}".format(local_rank)
+
+ if not os.path.exists(os.path.dirname(filename)):
+ os.makedirs(os.path.dirname(filename))
+
+ fh = logging.StreamHandler(filename)
+ fh.setLevel(log_level)
+ fh.setFormatter(logging.Formatter(format_str))
+ logger.addHandler(fh)
+
+ return logger
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model.py
new file mode 100644
index 0000000000000000000000000000000000000000..cea4951d8ef68373d304a4acdd3dd8f712b0d2f1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model.py
@@ -0,0 +1,2443 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import inspect
+import os
+import pickle
+import numpy as np
+import six
+import warnings
+import time
+import socket
+import contextlib
+
+import paddle
+from paddle import fluid
+from paddle.fluid import core
+from paddle.fluid.framework import _non_static_mode, in_dygraph_mode
+from paddle.fluid.framework import Variable
+from paddle.fluid.framework import _get_paddle_place
+from paddle.fluid.framework import _current_expected_place as _get_device
+from paddle.fluid.executor import global_scope
+from paddle.fluid.io import is_belong_to_optimizer
+from paddle.fluid.dygraph.base import to_variable
+from paddle.fluid.dygraph.parallel import ParallelEnv
+from paddle.fluid.dygraph.io import INFER_MODEL_SUFFIX
+from paddle.fluid.dygraph.io import INFER_PARAMS_SUFFIX
+from paddle.fluid.layers.utils import flatten
+from paddle.fluid.layers import collective
+
+from paddle.io import DataLoader
+from paddle.io import Dataset
+from paddle.io import DistributedBatchSampler
+from paddle.metric import Metric
+from paddle.static import InputSpec as Input
+from paddle.distributed.fleet.base import role_maker
+from paddle.autograd import no_grad
+from paddle.distributed import fleet
+from paddle.distributed.parallel import init_parallel_env
+
+from .callbacks import config_callbacks, EarlyStopping
+from .model_summary import summary
+
+__all__ = []
+
+_parallel_context_initialized = False
+
+
+def to_list(value):
+ if value is None:
+ return value
+ if isinstance(value, (list, tuple)):
+ return list(value)
+ return [value]
+
+
+def to_numpy(var):
+ assert isinstance(
+ var, (Variable, fluid.core.VarBase, fluid.core.eager.Tensor)
+ ), "not a variable"
+ if isinstance(var, (fluid.core.VarBase, fluid.core.eager.Tensor)):
+ return var.numpy()
+ t = global_scope().find_var(var.name).get_tensor()
+ return np.array(t)
+
+
+def flatten_list(l):
+ assert isinstance(l, list), "not a list"
+ outl = []
+ splits = []
+ for sl in l:
+ assert isinstance(sl, list), "sub content not a list"
+ splits.append(len(sl))
+ outl += sl
+ return outl, splits
+
+
+def restore_flatten_list(l, splits):
+ outl = []
+ for split in splits:
+ assert len(l) >= split, "list length invalid"
+ sl, l = l[:split], l[split:]
+ outl.append(sl)
+ return outl
+
+
+def extract_args(func):
+ if hasattr(inspect, 'getfullargspec'):
+ return inspect.getfullargspec(func)[0]
+ else:
+ return inspect.getargspec(func)[0]
+
+
+def _all_gather(x, nranks, ring_id=0, use_calc_stream=True):
+ return collective._c_allgather(
+ x, nranks, ring_id=ring_id, use_calc_stream=use_calc_stream
+ )
+
+
+def wait_server_ready(endpoints):
+ assert not isinstance(endpoints, six.string_types)
+ while True:
+ all_ok = True
+ not_ready_endpoints = []
+ for ep in endpoints:
+ ip_port = ep.split(":")
+ with contextlib.closing(
+ socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ ) as sock:
+ sock.settimeout(2)
+ result = sock.connect_ex((ip_port[0], int(ip_port[1])))
+ if result != 0:
+ all_ok = False
+ not_ready_endpoints.append(ep)
+ if not all_ok:
+ time.sleep(3)
+ else:
+ break
+
+
+def init_communicator(
+ program, rank, nranks, wait_port, current_endpoint, endpoints
+):
+ if nranks < 2:
+ return
+ other_endpoints = endpoints[:]
+ other_endpoints.remove(current_endpoint)
+ block = program.global_block()
+ if rank == 0 and wait_port:
+ wait_server_ready(other_endpoints)
+ if core.is_compiled_with_cuda():
+ nccl_id_var = block.create_var(
+ name=fluid.unique_name.generate('nccl_id'),
+ persistable=True,
+ type=fluid.core.VarDesc.VarType.RAW,
+ )
+
+ block.append_op(
+ type='c_gen_nccl_id',
+ inputs={},
+ outputs={'Out': nccl_id_var},
+ attrs={
+ 'rank': rank,
+ 'endpoint': current_endpoint,
+ 'other_endpoints': other_endpoints,
+ },
+ )
+
+ block.append_op(
+ type='c_comm_init',
+ inputs={'X': nccl_id_var},
+ outputs={},
+ attrs={
+ 'nranks': nranks,
+ 'rank': rank,
+ 'ring_id': 0,
+ },
+ )
+ elif core.is_compiled_with_npu():
+ hccl_id_var = block.create_var(
+ name=fluid.unique_name.generate('hccl_id'),
+ persistable=True,
+ type=core.VarDesc.VarType.RAW,
+ )
+ block.append_op(
+ type='c_gen_hccl_id',
+ inputs={},
+ outputs={'Out': hccl_id_var},
+ attrs={
+ 'rank': rank,
+ 'endpoint': current_endpoint,
+ 'other_endpoints': other_endpoints,
+ },
+ )
+ block.append_op(
+ type='c_comm_init_hccl',
+ inputs={'X': hccl_id_var},
+ outputs={},
+ attrs={
+ 'rank': rank,
+ 'ring_id': 0,
+ 'device_id': int(os.getenv("FLAGS_selected_npus")),
+ 'rank_ids': nranks,
+ },
+ )
+
+
+def prepare_distributed_context(place=None):
+ if place is None:
+ place = (
+ fluid.CUDAPlace(ParallelEnv().dev_id)
+ if ParallelEnv().nranks > 1
+ else fluid.CUDAPlace(0)
+ )
+
+ place = _get_paddle_place(place)
+ strategy = fluid.dygraph.parallel.ParallelStrategy()
+ strategy.nranks = ParallelEnv().nranks
+ strategy.local_rank = ParallelEnv().local_rank
+ strategy.trainer_endpoints = ParallelEnv().trainer_endpoints
+ strategy.current_endpoint = ParallelEnv().current_endpoint
+
+ if strategy.nranks < 2:
+ return
+
+ global _parallel_context_initialized
+
+ if not _parallel_context_initialized and isinstance(place, fluid.CUDAPlace):
+
+ def _init_context():
+ communicator_prog = fluid.Program()
+ init_communicator(
+ communicator_prog,
+ strategy.local_rank,
+ strategy.nranks,
+ True,
+ strategy.current_endpoint,
+ strategy.trainer_endpoints,
+ )
+ exe = fluid.Executor(place)
+ exe.run(communicator_prog)
+
+ if fluid._non_static_mode():
+ fluid.disable_dygraph()
+ _init_context()
+ fluid.enable_dygraph(place)
+
+ else:
+ assert "Only support CUDAPlace for now."
+
+ _parallel_context_initialized = True
+ return strategy
+
+
+def _update_input_info(inputs):
+ "Get input shape list by given inputs in Model initialization."
+ shapes = None
+ dtypes = None
+ if isinstance(inputs, Input):
+ shapes = [list(inputs.shape)]
+ dtypes = [inputs.dtype]
+ elif isinstance(inputs, (list, tuple)):
+ shapes = [list(input.shape) for input in inputs]
+ dtypes = [input.dtype for input in inputs]
+ elif isinstance(inputs, dict):
+ shapes = [list(inputs[name].shape) for name in inputs]
+ dtypes = [inputs[name].dtype for name in inputs]
+ else:
+ return None
+ return shapes, dtypes
+
+
+class StaticGraphAdapter(object):
+ """
+
+ Model traning/inference with a static graph.
+
+ """
+
+ def __init__(self, model):
+ super(StaticGraphAdapter, self).__init__()
+ self.model = model
+ # with `_build_once` gone, parameters are now created in `__init__`
+ # so we need to keep track of the parameters already created
+ self._startup_prog = fluid.default_startup_program()
+ self._orig_prog = fluid.default_main_program()
+
+ self._label_vars = {} # label variables
+ self._input_vars = {} # label variables
+ self._endpoints = {}
+ self._loss_endpoint = None
+ self._executor = None
+ self._progs = {}
+ self._compiled_progs = {}
+
+ self._merge_count = {
+ 'eval_total': 0,
+ 'test_total': 0,
+ 'eval_batch': 0,
+ 'test_batch': 0,
+ }
+
+ self._nranks = ParallelEnv().nranks
+ self._local_rank = ParallelEnv().local_rank
+
+ self._amp_level = "O0"
+ self._amp_configs = {}
+ self._amp_custom_lists = {}
+ self._use_fp16_guard = None
+
+ @property
+ def mode(self):
+ return self.model.mode
+
+ @mode.setter
+ def mode(self, value):
+ self.model.mode = value
+
+ def train_batch(self, inputs, labels=None, update=True):
+ assert (
+ self.model._optimizer
+ ), "model not ready, please call `model.prepare()` first"
+ self.mode = 'train'
+ assert (
+ update is True
+ ), "Does not support `update == False` in static mode by now."
+ return self._run(inputs, labels)
+
+ def eval_batch(self, inputs, labels=None):
+ self.mode = 'eval'
+ return self._run(inputs, labels)
+
+ def predict_batch(self, inputs):
+ self.mode = 'test'
+ return self._run(inputs, None)
+
+ def parameters(self, *args, **kwargs):
+ return self.model.network.parameters(*args, **kwargs)
+
+ def save(self, path):
+ def _save(state, path):
+ if not state:
+ return
+ state = {
+ k: to_numpy(v) if isinstance(v, Variable) else v
+ for k, v in state.items()
+ }
+ with open(path, 'wb') as f:
+ pickle.dump(state, f)
+
+ base = os.path.basename(path)
+ assert base != "", "path should be of 'dirname/filename' format"
+ dir_name = os.path.dirname(path)
+ if dir_name and not os.path.exists(dir_name):
+ os.makedirs(dir_name)
+ param_path = path + ".pdparams"
+ _save(self.model.network.state_dict(), param_path)
+ prog = self._progs.get('train', None)
+ if prog is None or self.model._optimizer is None:
+ return
+ # XXX `optimizer.state_dict()` only work in dygraph mode
+ optim_path = path + ".pdopt"
+ optim = {
+ p.name: p for p in filter(is_belong_to_optimizer, prog.list_vars())
+ }
+ if not optim:
+ return
+
+ _save(optim, optim_path)
+
+ # TODO: support save/load scaler state in static graph
+ def load(self, param_state_pairs, optim_state):
+ if self._executor is None:
+ executor = fluid.Executor(fluid.CPUPlace())._default_executor
+ else:
+ executor = self._executor._default_executor
+
+ # restore parameter states
+ fluid.core._create_loaded_parameter(
+ [param for param, state in param_state_pairs],
+ global_scope(),
+ executor,
+ )
+ for param, state in param_state_pairs:
+ self._set_var(param, state)
+
+ # restore optimizer states
+ # FIXME what if a different optimizer is used?
+ if not self.model._optimizer or not optim_state:
+ return
+ self._load_optimizer(optim_state, executor)
+
+ def _load_optimizer(self, state, executor):
+ prog = self._progs.get('train', None)
+ optim = list(filter(is_belong_to_optimizer, prog.list_vars()))
+ if not optim:
+ return
+
+ fluid.core._create_loaded_parameter(optim, global_scope(), executor)
+
+ converted_state = dict(state)
+ for var in optim:
+ if var.name in ["@LR_DECAY_COUNTER@", "global_step"]:
+ # When using learning rate scheduler, dygraph would name the
+ # global step var as "global_step" to save, while static-graph
+ # would has a state var named as "@LR_DECAY_COUNTER@".
+ # NOTE: dygraph saved global_step is 1 larger than that in
+ # static-graph, since the time of global_step to increase is
+ # different.
+ state_val = (
+ (np.array(converted_state.pop("global_step")) - 1)
+ if "global_step" in converted_state
+ else converted_state.pop("@LR_DECAY_COUNTER@", None)
+ )
+ if state_val is not None:
+ converted_state[var.name] = state_val
+ elif var.name.startswith("learning_rate_"):
+ # When using static learning rate, static-graph would make it
+ # a persistable var named 'unique_name.generate("learning_rate")',
+ # However, dygraph wouldn't save it.
+ if var.name not in state:
+ continue
+ else:
+ # moment and other accumulators
+ if var.name not in converted_state:
+ # try to convert from dygraph name
+ opt_name = self.model._optimizer._name
+ opt_cls_name = self.model._optimizer.__class__.__name__
+ opt_unq_name = None
+ for name in self.model._optimizer._accumulators.keys():
+ accum_name = (
+ name
+ if opt_name is None
+ else name[len(opt_name) + 1 :]
+ )
+ for (
+ param_name,
+ state_var,
+ ) in self.model._optimizer._accumulators[name].items():
+ if opt_unq_name is None:
+ # can not infer out the exact unique(opt_name),
+ # thus try to extract rather than generate
+ for state_key in sorted(
+ state.keys(),
+ key=lambda x: len(x),
+ reverse=True,
+ ):
+ prefix = (
+ param_name
+ + "_"
+ + (
+ opt_cls_name
+ if opt_name is None
+ else opt_name
+ )
+ + "_"
+ )
+ if state_key.startswith(prefix):
+ prefix_offset = state_key[
+ len(prefix) :
+ ].find("_") + len(prefix)
+ opt_unq_name = state_key[
+ len(
+ param_name + "_"
+ ) : prefix_offset
+ ]
+ # TODO: assert
+ # assert opt_unq_name is None
+ # gen(param.name + "_" + gen(opt_name) + "_" + accum_name)
+ # always end with "_0" since the unique optimizer._name
+ dy_state_name = (
+ param_name
+ + "_"
+ + opt_unq_name
+ + "_"
+ + accum_name
+ + "_0"
+ )
+ converted_state[
+ state_var.name
+ ] = converted_state.pop(dy_state_name)
+
+ assert (
+ var.name in converted_state
+ ), "variable [{}] is not in optimizer state file".format(var.name)
+ self._set_var(var, converted_state[var.name])
+
+ def _set_var(self, var, ndarray):
+ t = global_scope().find_var(var.name).get_tensor()
+ p = t._place()
+ if p.is_cpu_place():
+ place = fluid.CPUPlace()
+ elif p.is_cuda_pinned_place():
+ place = fluid.CUDAPinnedPlace()
+ else:
+ p = fluid.core.Place()
+ p.set_place(t._place())
+ place = fluid.CUDAPlace(p.gpu_device_id())
+
+ t.set(ndarray, place)
+
+ def _run(self, inputs, labels=None):
+ compiled_prog = self._compiled_progs.get(self.mode, None)
+ assert (
+ compiled_prog
+ ), "Model is not ready, please call `model.prepare()` first"
+
+ inputs = to_list(inputs)
+ if labels is not None:
+ labels = to_list(labels)
+ assert len(inputs) == len(self._input_vars[self.mode]), (
+ "number of inputs"
+ + " does not match number of arguments of `forward` method"
+ )
+
+ feed = {}
+ input_names = [v.name for v in self._input_vars[self.mode]]
+ input_dtypes = [v.dtype for v in self._input_vars[self.mode]]
+
+ for idx, n in enumerate(input_names):
+ # train and test may take different arguments
+ if inputs[idx] is not None:
+ feed[n] = inputs[idx]
+ if (
+ self._amp_level == 'O2'
+ and input_dtypes[idx] == core.VarDesc.VarType.FP16
+ ):
+ if isinstance(feed[n], core.LoDTensor):
+ feed[n] = feed[n]._as_type(core.VarDesc.VarType.FP16)
+ elif isinstance(feed[n], np.array):
+ feed[n] = feed[n].astype('float16')
+
+ if labels is not None:
+ for idx, v in enumerate(self._label_vars[self.mode]):
+ feed[v.name] = labels[idx]
+
+ endpoints = self._endpoints[self.mode]
+ if self.mode == 'test':
+ fetch_list = endpoints['output']
+ else:
+ metric_list, metric_splits = flatten_list(endpoints['metric'])
+ fetch_list = endpoints['loss'] + metric_list
+ num_loss = len(endpoints['loss'])
+
+ # if fetch Variable is same as input Variable, do not fetch
+ # from program, get it from input directly
+ pruned_fetch_list = []
+ pruned_fetch_idx_name_map = [""] * len(fetch_list)
+ for i, fetch_var in enumerate(fetch_list):
+ if fetch_var.name in feed.keys():
+ pruned_fetch_idx_name_map[i] = fetch_var.name
+ else:
+ pruned_fetch_list.append(fetch_var)
+
+ rets = self._executor.run(
+ compiled_prog,
+ feed=feed,
+ fetch_list=pruned_fetch_list,
+ return_numpy=False,
+ )
+
+ # restore pruned fetch_list Variable from feeds
+ for i, name in enumerate(pruned_fetch_idx_name_map):
+ if len(name) > 0:
+ rets.insert(i, feed[name])
+
+ # LoDTensor cannot be fetch as numpy directly
+ rets = [np.array(v) for v in rets]
+ if self.mode == 'test':
+ return rets[:]
+
+ metric_states = restore_flatten_list(rets[num_loss:], metric_splits)
+ metrics = []
+ for metric, state in zip(self.model._metrics, metric_states):
+ # cut off padding size
+ if (
+ self.mode != 'train'
+ and self.model._test_dataloader is not None
+ and isinstance(self.model._test_dataloader, DataLoader)
+ and self._nranks > 1
+ ):
+ total_size = len(self.model._test_dataloader.dataset)
+ # TODO: fixme if have better way to get batch size
+ samples = state[0].shape[0]
+ current_count = self._merge_count.get(self.mode + '_total', 0)
+ if current_count + samples >= total_size:
+ state = [
+ s[: int(total_size - current_count), ...] for s in state
+ ]
+ self._merge_count[self.mode + '_total'] = 0
+ self._merge_count[self.mode + '_batch'] = int(
+ total_size - current_count
+ )
+ else:
+ self._merge_count[self.mode + '_total'] += samples
+ self._merge_count[self.mode + '_batch'] = samples
+
+ metrics.append(metric.update(*state))
+
+ if num_loss and len(metrics):
+ return rets[:num_loss], metrics
+ else:
+ return rets[:num_loss] if num_loss else metrics
+
+ def prepare(self):
+ modes = ['train', 'eval', 'test']
+ for mode in modes:
+ self._make_program(mode)
+ self._compile_and_initialize(self._progs[mode], mode)
+
+ def _make_program(self, mode):
+ prog = self._progs.get(mode, None)
+ if prog is not None:
+ return
+
+ prog = self._orig_prog.clone()
+ # NOTE: When defining learning rate scheduling in static-graph, ops to
+ # increase the global step var and calculate learning rate would be
+ # prepended into _orig_prog. test program maked by `_orig_prog.clone`
+ # also would include these ops. Thus must prune these ops in test
+ # program, otherwise the global step would be changed in test.
+ if mode != 'train':
+ for op in list(prog.global_block().ops):
+ prog.global_block()._remove_op(0)
+ if (
+ mode == 'train'
+ and self.model._optimizer
+ and self.model._optimizer._learning_rate_map
+ ):
+ # HACK workaround learning rate map issue
+ lr_var = self.model._optimizer._learning_rate_map[self._orig_prog]
+ new_lr_var = prog.global_block().vars[lr_var.name]
+ self.model._optimizer._learning_rate_map[prog] = new_lr_var
+
+ losses = []
+ metrics = []
+ with fluid.program_guard(prog, self._startup_prog):
+ inputs = self.model._inputs
+ labels = self.model._labels if self.model._labels else []
+ inputs = [k._create_feed_layer() for k in to_list(inputs)]
+ labels = [k._create_feed_layer() for k in to_list(labels)]
+ self._label_vars[mode] = labels
+ outputs = to_list(self.model.network.forward(*inputs))
+
+ if mode != 'test' and self.model._loss:
+ losses = self.model._loss(*(outputs + labels))
+
+ if self._nranks > 1 and mode != 'train':
+ outputs = [_all_gather(o, self._nranks) for o in outputs]
+ if mode != 'test':
+ labels = [_all_gather(l, self._nranks) for l in labels]
+
+ if mode != 'test':
+ for metric in self.model._metrics:
+ metrics.append(to_list(metric.compute(*(outputs + labels))))
+
+ if mode == 'train' and self.model._optimizer:
+ self._loss_endpoint = fluid.layers.sum(losses)
+ if self._nranks > 1:
+ role = role_maker.PaddleCloudRoleMaker(is_collective=True)
+ fleet.init(role)
+ dist_strategy = fleet.DistributedStrategy()
+ if self._amp_level != 'O0':
+ dist_strategy.amp = True
+ dist_strategy.amp_configs = self._amp_configs.copy()
+ dist_strategy.amp_configs.update(self._amp_custom_lists)
+ dist_strategy.amp_configs['use_pure_fp16'] = (
+ self._amp_level == 'O2'
+ )
+ self.model._optimizer = fleet.distributed_optimizer(
+ self.model._optimizer, strategy=dist_strategy
+ )
+ elif self._amp_level != "O0" and core.is_compiled_with_cuda:
+ amp_lists = (
+ paddle.static.amp.AutoMixedPrecisionLists(
+ **self._amp_custom_lists
+ )
+ if self._amp_custom_lists
+ else None
+ )
+ self.model._optimizer = paddle.static.amp.decorate(
+ self.model._optimizer,
+ amp_lists=amp_lists,
+ use_pure_fp16=self._amp_level == "O2",
+ use_fp16_guard=self._use_fp16_guard,
+ **self._amp_configs
+ )
+
+ self.model._optimizer.minimize(self._loss_endpoint)
+
+ if mode != 'train': # clone again to put it in test mode
+ prog = prog.clone(for_test=True)
+
+ self._input_vars[mode] = inputs
+
+ self._progs[mode] = prog
+ self._endpoints[mode] = {
+ "output": outputs,
+ "loss": to_list(losses),
+ "metric": metrics,
+ }
+
+ def _compile_and_initialize(self, prog, mode):
+ compiled_prog = self._compiled_progs.get(mode, None)
+ if compiled_prog is not None:
+ return compiled_prog
+
+ assert (
+ self.model._place is not None
+ ), "device is not set, please call `model.prepare()` first"
+
+ place = self.model._place
+
+ # XXX *ALL WEIGHTS* should be initialized upon model construction
+ # even if `forward()` may run different code path for different mode
+ # therefore startup program only needs to run once
+ if self._executor is None:
+ self._executor = fluid.Executor(place)
+ # XXX incremental initialization
+ uninitialized = []
+ for var_py in self._startup_prog.list_vars():
+ var = fluid.global_scope().find_var(var_py.name)
+ if (
+ not var_py.name.startswith('nccl_id')
+ and var
+ and var.get_tensor()._is_initialized()
+ ):
+ continue
+
+ uninitialized.append(var_py)
+ if uninitialized:
+ startup_prog = self._startup_prog._prune(uninitialized)
+ self._executor.run(startup_prog)
+
+ if (
+ self._amp_level == "O2"
+ and mode == 'train'
+ and core.is_compiled_with_cuda()
+ ):
+ self.model._optimizer.amp_init(place)
+
+ if self._nranks < 2:
+ compiled_prog = fluid.CompiledProgram(prog)
+ else:
+ compiled_prog = prog
+
+ self._compiled_progs[mode] = compiled_prog
+
+
+class DynamicGraphAdapter(object):
+ def __init__(self, model):
+ super(DynamicGraphAdapter, self).__init__()
+ self.model = model
+ self._nranks = ParallelEnv().nranks
+ self._local_rank = ParallelEnv().local_rank
+ self._merge_count = {
+ 'eval_total': 0,
+ 'test_total': 0,
+ 'eval_batch': 0,
+ 'test_batch': 0,
+ }
+
+ self._input_info = None
+ self._amp_level = "O0"
+ self._amp_configs = {}
+ self._amp_custom_lists = {}
+ self._use_fp16_guard = True
+
+ if self._nranks > 1:
+ init_parallel_env()
+ stradegy = fluid.dygraph.parallel.ParallelStrategy()
+ stradegy.nranks = ParallelEnv().nranks
+ stradegy.local_rank = ParallelEnv().local_rank
+ stradegy.trainer_endpoints = ParallelEnv().trainer_endpoints
+ stradegy.current_endpoint = ParallelEnv().current_endpoint
+ self.ddp_model = fluid.dygraph.parallel.DataParallel(
+ self.model.network, stradegy
+ )
+
+ @property
+ def mode(self):
+ return self.model.mode
+
+ @mode.setter
+ def mode(self, value):
+ self.model.mode = value
+
+ # TODO multi device in dygraph mode not implemented at present time
+ def train_batch(self, inputs, labels=None, update=True):
+ assert (
+ self.model._optimizer
+ ), "model not ready, please call `model.prepare()` first"
+ self.model.network.train()
+ self.mode = 'train'
+ inputs = to_list(inputs)
+ self._input_info = _update_input_info(inputs)
+ labels = labels or []
+ labels = [to_variable(l) for l in to_list(labels)]
+
+ # scaler should be initialized only once
+ if self._amp_level != "O0" and self.model._scaler is None:
+ self.model._scaler = paddle.amp.GradScaler(**self._amp_configs)
+
+ with paddle.amp.auto_cast(
+ enable=self._amp_level != 'O0',
+ **self._amp_custom_lists,
+ level=self._amp_level
+ ):
+ if self._nranks > 1:
+ outputs = self.ddp_model(*[to_variable(x) for x in inputs])
+ else:
+ outputs = self.model.network(*[to_variable(x) for x in inputs])
+
+ losses = self.model._loss(*(to_list(outputs) + labels))
+ losses = to_list(losses)
+ final_loss = fluid.layers.sum(losses)
+
+ if self._amp_level != "O0":
+ scaled = self.model._scaler.scale(final_loss)
+ scaled.backward()
+ if update:
+ self.model._scaler.minimize(self.model._optimizer, scaled)
+ self.model.network.clear_gradients()
+ else:
+ final_loss.backward()
+ if update:
+ self.model._optimizer.minimize(final_loss)
+ self.model.network.clear_gradients()
+
+ metrics = []
+ for metric in self.model._metrics:
+ metric_outs = metric.compute(*(to_list(outputs) + labels))
+ m = metric.update(*[to_numpy(m) for m in to_list(metric_outs)])
+ metrics.append(m)
+
+ return (
+ ([to_numpy(l) for l in losses], metrics)
+ if len(metrics) > 0
+ else [to_numpy(l) for l in losses]
+ )
+
+ def eval_batch(self, inputs, labels=None):
+ self.model.network.eval()
+ self.mode = 'eval'
+ inputs = to_list(inputs)
+ self._input_info = _update_input_info(inputs)
+ labels = labels or []
+ labels = [to_variable(l) for l in to_list(labels)]
+
+ outputs = self.model.network(*[to_variable(x) for x in inputs])
+
+ # Transfrom data to expected device
+ expected_device = paddle.device.get_device()
+ for o in to_list(outputs):
+ o._to(device=expected_device)
+
+ for l in labels:
+ l._to(device=expected_device)
+
+ if self.model._loss:
+ losses = self.model._loss(*(to_list(outputs) + labels))
+ losses = to_list(losses)
+
+ if self._nranks > 1:
+ outputs = [_all_gather(o, self._nranks) for o in to_list(outputs)]
+ labels = [_all_gather(l, self._nranks) for l in labels]
+ metrics = []
+ for metric in self.model._metrics:
+ # cut off padding value.
+ if (
+ self.model._test_dataloader is not None
+ and self._nranks > 1
+ and isinstance(self.model._test_dataloader, DataLoader)
+ ):
+ total_size = len(self.model._test_dataloader.dataset)
+ samples = outputs[0].shape[0]
+ current_count = self._merge_count.get(self.mode + '_total', 0)
+ if current_count + samples >= total_size:
+ outputs = [
+ o[: int(total_size - current_count)] for o in outputs
+ ]
+ labels = [
+ l[: int(total_size - current_count)] for l in labels
+ ]
+ self._merge_count[self.mode + '_total'] = 0
+ self._merge_count[self.mode + '_batch'] = int(
+ total_size - current_count
+ )
+ else:
+ self._merge_count[self.mode + '_total'] += samples
+ self._merge_count[self.mode + '_batch'] = samples
+
+ metric_outs = metric.compute(*(to_list(outputs) + labels))
+ m = metric.update(*[to_numpy(m) for m in to_list(metric_outs)])
+ metrics.append(m)
+
+ if self.model._loss and len(metrics):
+ return [to_numpy(l) for l in losses], metrics
+ elif self.model._loss:
+ return [to_numpy(l) for l in losses]
+ else:
+ return metrics
+
+ def predict_batch(self, inputs):
+ self.model.network.eval()
+ self.mode = 'test'
+ inputs = [to_variable(x) for x in to_list(inputs)]
+ self._input_info = _update_input_info(inputs)
+ outputs = self.model.network(*inputs)
+ if self._nranks > 1 and isinstance(self.model._place, fluid.CUDAPlace):
+ outputs = [_all_gather(o, self._nranks) for o in to_list(outputs)]
+
+ return [to_numpy(o) for o in to_list(outputs)]
+
+ def parameters(self, *args, **kwargs):
+ return self.model.network.parameters(*args, **kwargs)
+
+ def save(self, path):
+ params = self.model.network.state_dict()
+ fluid.save_dygraph(params, path)
+ if self.model._optimizer is not None:
+ if self.model._optimizer.state_dict():
+ optim = self.model._optimizer.state_dict()
+ fluid.save_dygraph(optim, path)
+ if hasattr(self.model, '_scaler') and self.model._scaler is not None:
+ if self.model._scaler.state_dict():
+ scaler = self.model._scaler.state_dict()
+ paddle.save(scaler, path + '.pdscaler')
+
+ def load(self, param_state_pairs, optim_state, scaler_state=None):
+ # restore parameter states
+ for param, state in param_state_pairs:
+ param.set_value(state)
+
+ if hasattr(self.model, '_scaler') and self.model._scaler is not None:
+ if scaler_state:
+ self.model._scaler.load_state_dict(scaler_state)
+
+ # resotre optimizer states
+ if not self.model._optimizer or not optim_state:
+ return
+
+ # If optimizer performs set_state_dict when state vars haven't been created,
+ # which would happen when set_state_dict before minimize, the state would be
+ # stored in optimizer._accumulators_holder and loaded lazily.
+ # To contrive this when loading from static-graph saved states, extend
+ # state dict to include keys named accoring to dygraph naming rules.
+ # TODO: if len(self.model._optimizer._accumulators) > 0
+ converted_state = dict(optim_state)
+ opt_unq_name = self.model._optimizer._name
+ if opt_unq_name is None:
+ opt_unq_name = ''
+
+ opt_cls_name = self.model._optimizer.__class__.__name__
+ opt_name = opt_unq_name[: opt_unq_name.rfind("_")] # remove suffix idx
+ param_names = [param.name for param in self.model.network.parameters()]
+ for var_name, state_var in sorted(
+ optim_state.items(), key=lambda x: len(x[0]), reverse=True
+ ):
+ if var_name in ["@LR_DECAY_COUNTER@", "global_step"]:
+ # NOTE: dygraph saved global_step is 1 larger than that in
+ # static-graph, since the time of global_step to increase is
+ # different.
+ if var_name == "@LR_DECAY_COUNTER@":
+ converted_state["global_step"] = (
+ np.array(converted_state.pop("@LR_DECAY_COUNTER@")) + 1
+ )
+ else:
+ # moment and other accumulators
+ # extend state dict to include promising dygraph names
+ for param_name in param_names:
+ if var_name.startswith(param_name + "_" + opt_name):
+ # when init optimizer with name
+ accum_name = var_name[
+ len(param_name + "_" + opt_name + "_") :
+ ]
+ elif (
+ var_name.startswith(param_name + "_")
+ and opt_name == opt_cls_name
+ ):
+ # when init optimizer without name
+ accum_name = var_name[len(param_name + "_") :]
+ else:
+ continue
+ # remove suffix idx
+ accum_name = accum_name[: accum_name.rfind("_")]
+ # state names always end with "_0" in dygraph because of the
+ # unique optimizer._name
+ dy_state_name = (
+ param_name
+ + "_"
+ + opt_unq_name
+ + "_"
+ + accum_name
+ + "_0"
+ )
+ converted_state[dy_state_name] = state_var
+
+ if not hasattr(self.model._optimizer, 'set_state_dict'):
+ warnings.warn(
+ "paddle.fluid.optimizer is deprecated in API 2.0, please use paddle.optimizer instead."
+ )
+ self.model._optimizer.set_dict(converted_state)
+ else:
+ self.model._optimizer.set_state_dict(converted_state)
+
+ def prepare(self):
+ if (
+ self._amp_level == "O2"
+ and self.model.mode == 'train'
+ and core.is_compiled_with_cuda()
+ ):
+ self.model.network, self.model._optimizer = paddle.amp.decorate(
+ models=self.model.network,
+ optimizers=self.model._optimizer,
+ level='O2',
+ )
+ if self._amp_level != "O0":
+ self.model._scaler = None
+
+
+class Model(object):
+ """
+
+ An Model object is network with training and inference features.
+ Dynamic graph and static graph are supported at the same time,
+ switched by `paddle.enable_static()`. The usage is as follows.
+ But note, the switching between dynamic and static should be before
+ instantiating a Model. The input description, i.e, paddle.static.InputSpec,
+ must be required for static graph.
+
+ When training on GPU, auto mixed precision (AMP O1) and pure float16
+ (AMP O2) training are both supported in static mode and dynamic mode.
+ In static graph mode, before training with pure float16 (AMP O2),
+ `multi_precision` could be set to True when creating optimizer, which can
+ avoid poor accuracy or slow convergence in a way, and inputs of dtype float
+ should be cast to float16 by users. `paddle.static.amp.fp16_guard` API
+ should be also used to limit the range of pure float16 training, otherwise,
+ 'use_fp16_guard' should be set to False by users. However, limiting the
+ range of is not supported during training using AMP.
+
+ Args:
+ network (paddle.nn.Layer): The network is an instance of
+ paddle.nn.Layer.
+ inputs (InputSpec|list|tuple|dict|None, optional): `inputs`, entry points of network,
+ could be a InputSpec instance, or list/tuple of InputSpec instances,
+ or dict ({name: InputSpec}), and it couldn't be None in static
+ graph. Default: None.
+ labels (InputSpec|list|tuple|None, optional): `labels`, entry points of network,
+ could be a InputSpec instnace or list/tuple of InputSpec instances,
+ or None. For static graph, if labels is required in loss,
+ labels must be set. Otherwise, it could be None. Default: None.
+
+
+ Examples:
+ 1. A common example
+
+ .. code-block:: python
+ :name: code-example1
+
+ import paddle
+ import paddle.nn as nn
+ import paddle.vision.transforms as T
+ from paddle.static import InputSpec
+
+ device = paddle.set_device('cpu') # or 'gpu'
+
+ net = nn.Sequential(
+ nn.Flatten(1),
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10))
+
+ # inputs and labels are not required for dynamic graph.
+ input = InputSpec([None, 784], 'float32', 'x')
+ label = InputSpec([None, 1], 'int64', 'label')
+
+ model = paddle.Model(net, input, label)
+ optim = paddle.optimizer.SGD(learning_rate=1e-3,
+ parameters=model.parameters())
+
+ model.prepare(optim,
+ paddle.nn.CrossEntropyLoss(),
+ paddle.metric.Accuracy())
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ data = paddle.vision.datasets.MNIST(mode='train', transform=transform)
+ model.fit(data, epochs=2, batch_size=32, verbose=1)
+
+
+ 2. An example using mixed precision training.
+
+ .. code-block:: python
+ :name: code-example2
+
+ # required: gpu
+ import paddle
+ import paddle.nn as nn
+ import paddle.vision.transforms as T
+
+ def run_example_code():
+ device = paddle.set_device('gpu')
+
+ net = nn.Sequential(nn.Flatten(1), nn.Linear(784, 200), nn.Tanh(),
+ nn.Linear(200, 10))
+
+ model = paddle.Model(net)
+ optim = paddle.optimizer.SGD(learning_rate=1e-3, parameters=model.parameters())
+
+ amp_configs = {
+ "level": "O1",
+ "custom_white_list": {'conv2d'},
+ "use_dynamic_loss_scaling": True
+ }
+ model.prepare(optim,
+ paddle.nn.CrossEntropyLoss(),
+ paddle.metric.Accuracy(),
+ amp_configs=amp_configs)
+
+ transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])])
+ data = paddle.vision.datasets.MNIST(mode='train', transform=transform)
+ model.fit(data, epochs=2, batch_size=32, verbose=1)
+
+ # mixed precision training is only supported on GPU now.
+ if paddle.is_compiled_with_cuda():
+ run_example_code()
+
+ """
+
+ def __init__(self, network, inputs=None, labels=None):
+ self.mode = 'train'
+ self.network = network
+ self._inputs = None
+ self._labels = None
+ self._loss = None
+ self._loss_weights = None
+ self._optimizer = None
+ self._input_info = None
+ self._is_shape_inferred = False
+ self._test_dataloader = None
+ self.stop_training = False
+
+ if not _non_static_mode():
+ if not isinstance(inputs, (list, tuple, dict, Input)):
+ raise TypeError(
+ "'inputs' must be list or tuple or dict, and couldn't be None."
+ )
+ elif inputs:
+ self._input_info = _update_input_info(inputs)
+
+ self._inputs = self._verify_spec(inputs, is_input=True)
+ self._labels = self._verify_spec(labels)
+
+ # init backend
+ if fluid._non_static_mode():
+ self._adapter = DynamicGraphAdapter(self)
+ else:
+ self._adapter = StaticGraphAdapter(self)
+
+ def train_batch(self, inputs, labels=None, update=True):
+ """
+
+ Run one training step on one batch of data. And using `update` indicates
+ whether optimizer update gradients computing by this batch.
+
+ Args:
+ inputs (numpy.ndarray|Tensor|list): Batch of input data. It could
+ be a numpy array or paddle.Tensor, or a list of arrays or
+ tensors (in case the model has multiple inputs).
+ labels (numpy.ndarray|Tensor|list, optional): Batch of labels. It could be
+ a numpy array or paddle.Tensor, or a list of arrays or tensors
+ (in case the model has multiple labels). If has no labels,
+ set None. Default: None.
+ update (bool, optional): Whether update parameters after loss.backward() computing.
+ Set it to False to accumulate gradients. Default: True.
+
+ Returns:
+ A list of scalar training loss if the model has no metrics,
+ or a tuple (list of scalar loss, list of metrics) if the model
+ set metrics.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.static import InputSpec
+
+ device = paddle.set_device('cpu') # or 'gpu'
+
+ net = nn.Sequential(
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10))
+
+ input = InputSpec([None, 784], 'float32', 'x')
+ label = InputSpec([None, 1], 'int64', 'label')
+ model = paddle.Model(net, input, label)
+ optim = paddle.optimizer.SGD(learning_rate=1e-3,
+ parameters=model.parameters())
+ model.prepare(optim, paddle.nn.CrossEntropyLoss())
+ data = paddle.rand((4, 784), dtype="float32")
+ label = paddle.randint(0, 10, (4, 1), dtype="int64")
+ loss = model.train_batch([data], [label])
+ print(loss)
+ # [array([2.192784], dtype=float32)]
+
+ """
+ loss = self._adapter.train_batch(inputs, labels, update)
+ if fluid._non_static_mode() and self._input_info is None:
+ self._update_inputs()
+ return loss
+
+ @no_grad()
+ def eval_batch(self, inputs, labels=None):
+ """
+
+ Run one evaluating step on a batch of data.
+
+ Args:
+ inputs (numpy.ndarray|Tensor|list): Batch of input data. It could
+ be a numpy array or paddle.Tensor, or a list of arrays or
+ tensors (in case the model has multiple inputs).
+ labels (numpy.ndarray|Tensor|list, optional): Batch of labels. It could be
+ a numpy array or paddle.Tensor, or a list of arrays or tensors
+ (in case the model has multiple labels). If has no labels,
+ set None. Default: None.
+
+ Returns:
+ A list of scalar testing loss if the model has no metrics,
+ or a tuple (list of scalar loss, list of metrics) if the model
+ set metrics.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.static import InputSpec
+
+ device = paddle.set_device('cpu') # or 'gpu'
+
+ net = nn.Sequential(
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10))
+
+ input = InputSpec([None, 784], 'float32', 'x')
+ label = InputSpec([None, 1], 'int64', 'label')
+ model = paddle.Model(net, input, label)
+ optim = paddle.optimizer.SGD(learning_rate=1e-3,
+ parameters=model.parameters())
+ model.prepare(optim,
+ paddle.nn.CrossEntropyLoss(), metrics=paddle.metric.Accuracy())
+ data = paddle.rand((4, 784), dtype="float32")
+ label = paddle.randint(0, 10, (4, 1), dtype="int64")
+ loss, acc = model.eval_batch([data], [label])
+ print(loss, acc)
+ # [array([2.8825705], dtype=float32)] [0.0]
+
+ """
+ loss = self._adapter.eval_batch(inputs, labels)
+ if fluid._non_static_mode() and self._input_info is None:
+ self._update_inputs()
+ return loss
+
+ @no_grad()
+ def predict_batch(self, inputs):
+ """
+
+ Run one predicting step on a batch of data.
+
+ Args:
+ inputs (numpy.ndarray|Tensor|list): Batch of input data. It could
+ be a numpy array or paddle.Tensor, or a list of arrays or
+ tensors (in case the model has multiple inputs).
+
+ Returns:
+ A list of numpy.ndarray of predictions, that is the outputs
+ of Model forward.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.static import InputSpec
+
+ device = paddle.set_device('cpu') # or 'gpu'
+
+ input = InputSpec([None, 784], 'float32', 'x')
+ label = InputSpec([None, 1], 'int64', 'label')
+
+ net = nn.Sequential(
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10),
+ nn.Softmax())
+
+ model = paddle.Model(net, input, label)
+ model.prepare()
+ data = paddle.rand((1, 784), dtype="float32")
+ out = model.predict_batch([data])
+ print(out)
+ # [array([[0.08189095, 0.16740078, 0.06889386, 0.05085445, 0.10729759,
+ # 0.02217775, 0.14518553, 0.1591538 , 0.01808308, 0.17906217]],
+ # dtype=float32)]
+
+ """
+ loss = self._adapter.predict_batch(inputs)
+ if fluid._non_static_mode() and self._input_info is None:
+ self._update_inputs()
+ return loss
+
+ def save(self, path, training=True):
+ """
+
+ This function saves parameters, optimizer information or model and
+ paramters only for inference to path. It depends on the parameter
+ `training`.
+
+ If `training` is set to True, the parameters saved contain all
+ the trainable Variable, will save to a file with suffix ".pdparams".
+ The optimizer information contains all the variable used by optimizer.
+ For Adam optimizer, contains beta1, beta2, momentum etc. All the
+ information will save to a file with suffix ".pdopt". (If the optimizer
+ have no variable need to save (like SGD), the fill will not generated).
+ This function will silently overwrite existing file at the target location.
+
+ If `training` is set to False, only inference model will be saved.
+
+ Args:
+ path (str): The file prefix to save model. The format
+ is 'dirname/file_prefix' or 'file_prefix'. if empty str.
+ A exception will be raised.
+ training (bool, optional): Whether to save for training. If not, save
+ for inference only. Default: True.
+
+ Returns:
+ None
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ import paddle.vision.transforms as T
+ from paddle.static import InputSpec
+
+ class Mnist(nn.Layer):
+ def __init__(self):
+ super(Mnist, self).__init__()
+ self.net = nn.Sequential(
+ nn.Flatten(1),
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10),
+ nn.Softmax())
+
+ def forward(self, x):
+ return self.net(x)
+
+ dynamic = True # False
+ # if use static graph, do not set
+ if not dynamic:
+ paddle.enable_static()
+
+ input = InputSpec([None, 784], 'float32', 'x')
+ label = InputSpec([None, 1], 'int64', 'label')
+ model = paddle.Model(Mnist(), input, label)
+ optim = paddle.optimizer.SGD(learning_rate=1e-3,
+ parameters=model.parameters())
+ model.prepare(optim, paddle.nn.CrossEntropyLoss())
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ data = paddle.vision.datasets.MNIST(mode='train', transform=transform)
+
+ model.fit(data, epochs=1, batch_size=32, verbose=0)
+ model.save('checkpoint/test') # save for training
+ model.save('inference_model', False) # save for inference
+
+ """
+
+ if ParallelEnv().local_rank == 0:
+ if not training:
+ self._save_inference_model(path)
+ else:
+ self._adapter.save(path)
+
+ def load(self, path, skip_mismatch=False, reset_optimizer=False):
+ """
+
+ Load from files storing the model states and optimizer states. The file
+ for optimizer states is not necessary if no need to restore the optimizer.
+
+ NOTE: parameters are retrieved out from the file storing model states
+ accoring to their structured names.
+
+ For fine-tuning or transfer-learning models where some of the layers have
+ changed, keep parameters needed to restore have same structured names in
+ the pre-trained model and fine-tuning model.
+
+ Args:
+ path (str): The prefix of files storing the model states and
+ optimizer states. The files would be `path.pdparams` and
+ `path.pdopt` separately, and the latter is not necessary
+ when no need to restore.
+ skip_mismatch (bool, optional): Whether to skip the loading of mismatch
+ parameter or raise an error when mismatch happens (not found
+ the parameter in file storing model states of or receives a
+ mismatch shape). Default: False.
+ reset_optimizer (bool, optional): If True, ignore the providing file storing
+ optimizer states and initialize optimizer states from scratch.
+ Otherwise, restore optimizer states from `path.pdopt` if
+ a optimizer has been set to the model. Default: False.
+
+ Returns:
+ None
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.static import InputSpec
+
+ device = paddle.set_device('cpu')
+
+ input = InputSpec([None, 784], 'float32', 'x')
+
+ model = paddle.Model(nn.Sequential(
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10),
+ nn.Softmax()), input)
+
+ model.save('checkpoint/test')
+ model.load('checkpoint/test')
+
+ """
+
+ def _load_state_from_path(path):
+ if not os.path.exists(path):
+ return
+ with open(path, 'rb') as f:
+ return pickle.load(f, encoding='latin1')
+
+ def _check_match(key, param):
+ state = param_state.get(key, None)
+ if state is None:
+ raise ValueError(
+ "{} is not found in the providing file.".format(key)
+ )
+ if list(state.shape) != list(param.shape):
+ raise ValueError(
+ "{} receives a shape {}, but the expected shape is {}.".format(
+ key, list(state.shape), list(param.shape)
+ )
+ )
+ return param, state
+
+ def _strip_postfix(path):
+ path, ext = os.path.splitext(path)
+ assert ext in [
+ '',
+ '.pdparams',
+ '.pdopt',
+ '.pdmodel',
+ ], "Unknown postfix {} from weights".format(ext)
+ return path
+
+ path = _strip_postfix(path)
+ param_state = _load_state_from_path(path + ".pdparams")
+ assert param_state, "Failed to load parameters, please check path."
+
+ matched_param_state = []
+ for key, param in self.network.state_dict().items():
+ try:
+ match_res = _check_match(key, param)
+ except ValueError as err:
+ if skip_mismatch:
+ warnings.warn(
+ ("Skip loading for {}. ".format(key) + str(err))
+ )
+ # reset optimizer when mismatch happens
+ reset_optimizer = True
+ else:
+ raise err
+ matched_param_state.append(match_res)
+
+ optim_state = (
+ None if reset_optimizer else _load_state_from_path(path + ".pdopt")
+ )
+
+ # TODO: support save/load scaler state in static graph
+ if _non_static_mode():
+ scaler_state = None
+ if hasattr(self, '_scaler') and self._scaler is not None:
+ if os.path.exists(path + '.pdscaler'):
+ scaler_state = paddle.load(path + '.pdscaler')
+
+ return self._adapter.load(
+ matched_param_state, optim_state, scaler_state
+ )
+ else:
+ return self._adapter.load(matched_param_state, optim_state)
+
+ def parameters(self, *args, **kwargs):
+ """
+
+ Returns a list of parameters of the model.
+
+ Returns:
+ A list of Parameter in static graph.
+ A list of ParamBase in dynamic graph.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+ from paddle.static import InputSpec
+
+ input = InputSpec([None, 784], 'float32', 'x')
+
+ model = paddle.Model(nn.Sequential(
+ nn.Linear(784, 200),
+ nn.Tanh(),
+ nn.Linear(200, 10)), input)
+
+ params = model.parameters()
+
+ """
+ return self._adapter.parameters()
+
+ def _prepare_amp(self, amp_configs):
+ def _check_pure_fp16_configs():
+ # pure float16 training has some restricts now
+ if self._adapter._amp_level == "O2" and self._optimizer._grad_clip:
+ # clip by value is not supported
+ assert isinstance(
+ self._optimizer._grad_clip,
+ (paddle.nn.ClipGradByGlobalNorm, paddle.nn.ClipGradByNorm),
+ ), "Only GradientClipByNorm and GradientClipByGlobalNorm are supported in amp training with level=O2 currently."
+
+ self._adapter._amp_custom_lists = {}
+ self._adapter._amp_configs = {}
+
+ # check and get level of mixed precision training
+ if not amp_configs:
+ self._adapter._amp_level = 'O0'
+ return
+ elif isinstance(amp_configs, str):
+ if amp_configs not in ('O0', 'O1', 'O2'):
+ raise ValueError(
+ "The level of amp_configs should be 'O0', 'O1' or 'O2'."
+ )
+ self._adapter._amp_level = amp_configs
+ _check_pure_fp16_configs()
+ return
+ else:
+ if 'level' not in amp_configs:
+ self._adapter._amp_level = 'O1'
+ elif amp_configs['level'] not in ('O0', 'O1', 'O2'):
+ raise ValueError(
+ "amp_configs['level'] should be 'O0', 'O1' or 'O2'."
+ )
+ else:
+ self._adapter._amp_level = amp_configs['level']
+ amp_config_key_set = set(amp_configs.keys()) - {'level'}
+ if not amp_config_key_set or self._adapter._amp_level == 'O0':
+ return
+
+ if 'use_pure_fp16' in amp_configs:
+ raise ValueError(
+ "'use_pure_fp16' is an invalid parameter, the level of mixed precision training only depends on 'O1' or 'O2'."
+ )
+
+ _check_pure_fp16_configs()
+
+ # construct amp_custom_lists
+ if self._adapter._amp_level != 'O0' and amp_config_key_set:
+ for param_name in [
+ 'custom_white_list',
+ 'custom_black_list',
+ 'custom_black_varnames',
+ ]:
+ if param_name in amp_config_key_set:
+ self._adapter._amp_custom_lists[param_name] = amp_configs[
+ param_name
+ ]
+ amp_config_key_set -= {param_name}
+
+ def _check_amp_configs(amp_config_key_set):
+ accepted_param_set = {
+ 'init_loss_scaling',
+ 'incr_ratio',
+ 'decr_ratio',
+ 'incr_every_n_steps',
+ 'decr_every_n_nan_or_inf',
+ 'use_dynamic_loss_scaling',
+ 'use_fp16_guard',
+ }
+ if amp_config_key_set - accepted_param_set:
+ raise ValueError(
+ "Except for 'level', the keys of 'amp_configs' must be accepted by mixed precision APIs, but {} could not be recognized.".format(
+ tuple(amp_config_key_set - accepted_param_set)
+ )
+ )
+
+ if 'use_fp16_guard' in amp_config_key_set:
+ if _non_static_mode():
+ raise ValueError(
+ "'use_fp16_guard' is supported in static mode only."
+ )
+ self._adapter._use_fp16_guard = amp_configs['use_fp16_guard']
+ amp_config_key_set.remove('use_fp16_guard')
+
+ return amp_config_key_set
+
+ amp_configs_set = _check_amp_configs(amp_config_key_set)
+ for key in amp_configs_set:
+ self._adapter._amp_configs[key] = amp_configs[key]
+
+ def prepare(
+ self, optimizer=None, loss=None, metrics=None, amp_configs=None
+ ):
+ """
+
+ Configures the model before runing.
+
+ Args:
+ optimizer (Optimizer|None, optional): Optimizer must be set in training
+ and should be a Optimizer instance. It can be None in eval
+ and test mode. Default: None.
+ loss (Loss|Callable|None, optional): Loss function can
+ be a `paddle.nn.Layer` instance or any callable function
+ taken the predicted values and ground truth values as input.
+ It can be None when there is no loss. Default: None.
+ metrics (Metric|list[Metric]|None, optional): If metrics is set, all
+ metrics will be calculated and output in train/eval mode. Default: None.
+ amp_configs (str|dict|None, optional): AMP configurations. If AMP or pure
+ float16 training is used, the key 'level' of 'amp_configs'
+ should be set to 'O1' or 'O2' respectively. Otherwise, the
+ value of 'level' defaults to 'O0', which means float32
+ training. In addition to 'level', parameters consistent with
+ mixed precision API could also be passed in. The supported
+ keys are: 'init_loss_scaling', 'incr_ratio', 'decr_ratio',
+ 'incr_every_n_steps', 'decr_every_n_nan_or_inf',
+ 'use_dynamic_loss_scaling', 'custom_white_list',
+ 'custom_black_list', and 'custom_black_varnames'or
+ 'use_fp16_guard' is only supported in static mode. Mixed
+ precision API documentations :ref:`api_paddle_amp_auto_cast`
+ and :ref:`api_paddle_amp_GradScaler` could be referenced
+ for details. For convenience, 'amp_configs' could be set to
+ 'O1' or 'O2' if no more parameters are needed. 'amp_configs'
+ could be None in float32 training. Default: None.
+
+ Returns:
+ None
+
+ """
+ self._place = _get_device()
+ if isinstance(self._place, fluid.CUDAPlace):
+ global _parallel_context_initialized
+ if ParallelEnv().nranks > 1 and not _parallel_context_initialized:
+ if fluid._non_static_mode():
+ main_prog_seed = fluid.default_main_program().random_seed
+ startup_prog_seed = (
+ fluid.default_startup_program().random_seed
+ )
+ fluid.disable_dygraph()
+ paddle.disable_static(self._place)
+ # enable_dygraph would create and switch to a new program,
+ # thus also copy seed to the new program
+ fluid.default_main_program().random_seed = main_prog_seed
+ fluid.default_startup_program().random_seed = (
+ startup_prog_seed
+ )
+ else:
+ prepare_distributed_context(self._place)
+ _parallel_context_initialized = True
+
+ self._optimizer = optimizer
+ if loss is not None:
+ if not isinstance(loss, paddle.nn.Layer) and not callable(loss):
+ raise TypeError(
+ "'loss' must be sub classes of `paddle.nn.Layer` or any callable function."
+ )
+ self._loss = loss
+
+ metrics = metrics or []
+ for metric in to_list(metrics):
+ assert isinstance(
+ metric, Metric
+ ), "{} is not sub class of Metric".format(metric.__class__.__name__)
+ self._metrics = to_list(metrics)
+ self._prepare_amp(amp_configs)
+
+ self._adapter.prepare()
+
+ def fit(
+ self,
+ train_data=None,
+ eval_data=None,
+ batch_size=1,
+ epochs=1,
+ eval_freq=1,
+ log_freq=10,
+ save_dir=None,
+ save_freq=1,
+ verbose=2,
+ drop_last=False,
+ shuffle=True,
+ num_workers=0,
+ callbacks=None,
+ accumulate_grad_batches=1,
+ num_iters=None,
+ ):
+ """
+
+ Trains the model for a fixed number of epochs. If `eval_data` is set,
+ evaluation will be done at the end of each epoch.
+
+ Args:
+ train_data (Dataset|DataLoader, optional): An iterable data loader is used for
+ train. An instance of paddle paddle.io.Dataset or
+ paddle.io.Dataloader is recomended. Default: None.
+ eval_data (Dataset|DataLoader, optional): An iterable data loader is used for
+ evaluation at the end of epoch. If None, will not do evaluation.
+ An instance of paddle.io.Dataset or paddle.io.Dataloader
+ is recomended. Default: None.
+ batch_size (int, optional): The batch size of train_data and eval_data. When
+ train_data and eval_data are both the instance of Dataloader, this
+ parameter will be ignored. Default: 1.
+ epochs (int, optional): The number of epochs to train the model. Default: 1.
+ eval_freq (int, optional): The frequency, in number of epochs, an evalutation
+ is performed. Default: 1.
+ log_freq (int, optional): The frequency, in number of steps, the training logs
+ are printed. Default: 10.
+ save_dir(str|None, optional): The directory to save checkpoint during training.
+ If None, will not save checkpoint. Default: None.
+ save_freq (int, optional): The frequency, in number of epochs, to save
+ checkpoint. Default: 1.
+ verbose (int, optional): The verbosity mode, should be 0, 1, or 2. 0 = silent,
+ 1 = progress bar, 2 = one line per epoch. Default: 2.
+ drop_last (bool, optional): Whether drop the last incomplete batch of
+ train_data when dataset size is not divisible by the batch size.
+ When train_data is an instance of Dataloader, this parameter
+ will be ignored. Default: False.
+ shuffle (bool, optional): Whther to shuffle train_data. When train_data is
+ an instance of Dataloader, this parameter will be ignored.
+ Default: True.
+ num_workers (int, optional): The number of subprocess to load data, 0 for no
+ subprocess used and loading data in main process.
+ When train_data and eval_data are both the instance of
+ Dataloader, this parameter will be ignored. Default: 0.
+ callbacks (Callback|None, optional): A list of `Callback` instances to apply
+ during training. If None, :ref:`api_paddle_callbacks_ProgBarLogger` and
+ :ref:`api_paddle_callbacks_ModelCheckpoint` are automatically inserted. Default: None.
+ accumulate_grad_batches (int, optional): The number of batches to accumulate gradident
+ during training process before optimizer updates. It can mimic large batch
+ size. Default: 1.
+ num_iters (int|None, optional): The number of iterations to evaluate the model.
+ If None, evaluate on whole input dataset, otherwise, evaluate `num_iters` times.
+ Default: None.
+
+ Returns:
+ None
+
+ Examples:
+ 1. An example use Dataset and set batch size, shuffle in fit.
+ How to make a batch is done internally.
+
+ .. code-block:: python
+ :name: code-example3
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.vision.datasets import MNIST
+ from paddle.static import InputSpec
+
+ dynamic = True
+ if not dynamic:
+ paddle.enable_static()
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = MNIST(mode='train', transform=transform)
+ val_dataset = MNIST(mode='test', transform=transform)
+
+ input = InputSpec([None, 1, 28, 28], 'float32', 'image')
+ label = InputSpec([None, 1], 'int64', 'label')
+
+ model = paddle.Model(
+ paddle.vision.models.LeNet(),
+ input, label)
+ optim = paddle.optimizer.Adam(
+ learning_rate=0.001, parameters=model.parameters())
+ model.prepare(
+ optim,
+ paddle.nn.CrossEntropyLoss(),
+ paddle.metric.Accuracy(topk=(1, 2)))
+ model.fit(train_dataset,
+ val_dataset,
+ epochs=2,
+ batch_size=64,
+ save_dir='mnist_checkpoint')
+
+ 2. An example use DataLoader, batch size and shuffle is set in
+ DataLoader.
+
+ .. code-block:: python
+ :name: code-example4
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.vision.datasets import MNIST
+ from paddle.static import InputSpec
+
+ dynamic = True
+ if not dynamic:
+ paddle.enable_static()
+
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ train_dataset = MNIST(mode='train', transform=transform)
+ train_loader = paddle.io.DataLoader(train_dataset,
+ batch_size=64)
+ val_dataset = MNIST(mode='test', transform=transform)
+ val_loader = paddle.io.DataLoader(val_dataset,
+ batch_size=64)
+
+ input = InputSpec([None, 1, 28, 28], 'float32', 'image')
+ label = InputSpec([None, 1], 'int64', 'label')
+
+ model = paddle.Model(
+ paddle.vision.models.LeNet(), input, label)
+ optim = paddle.optimizer.Adam(
+ learning_rate=0.001, parameters=model.parameters())
+ model.prepare(
+ optim,
+ paddle.nn.CrossEntropyLoss(),
+ paddle.metric.Accuracy(topk=(1, 2)))
+ model.fit(train_loader,
+ val_loader,
+ epochs=2,
+ save_dir='mnist_checkpoint')
+
+ """
+ assert train_data is not None, "train_data must be given!"
+
+ if isinstance(train_data, Dataset):
+ train_sampler = DistributedBatchSampler(
+ train_data,
+ batch_size=batch_size,
+ shuffle=shuffle,
+ drop_last=drop_last,
+ )
+ train_loader = DataLoader(
+ train_data,
+ batch_sampler=train_sampler,
+ places=self._place,
+ num_workers=num_workers,
+ return_list=True,
+ )
+ else:
+ train_loader = train_data
+
+ if eval_data is not None and isinstance(eval_data, Dataset):
+ eval_sampler = DistributedBatchSampler(
+ eval_data, batch_size=batch_size
+ )
+ eval_loader = DataLoader(
+ eval_data,
+ batch_sampler=eval_sampler,
+ places=self._place,
+ num_workers=num_workers,
+ return_list=True,
+ )
+ elif eval_data is not None:
+ eval_loader = eval_data
+ else:
+ eval_loader = None
+
+ do_eval = eval_loader is not None
+ self._test_dataloader = eval_loader
+
+ self._accumulate = accumulate_grad_batches
+
+ steps = self._len_data_loader(train_loader)
+ self.num_iters = num_iters
+ if (
+ num_iters is not None
+ and isinstance(num_iters, int)
+ and isinstance(steps, int)
+ ):
+ assert num_iters > 0, "num_iters must be greater than 0!"
+ epochs = (num_iters // steps) + 1
+ steps = min(num_iters, steps)
+ cbks = config_callbacks(
+ callbacks,
+ model=self,
+ epochs=epochs,
+ steps=steps,
+ log_freq=log_freq,
+ save_freq=save_freq,
+ save_dir=save_dir,
+ verbose=verbose,
+ metrics=self._metrics_name(),
+ )
+
+ if any(isinstance(k, EarlyStopping) for k in cbks) and not do_eval:
+ warnings.warn("EarlyStopping needs validation data.")
+
+ cbks.on_begin('train')
+ for epoch in range(epochs):
+ cbks.on_epoch_begin(epoch)
+ logs = self._run_one_epoch(train_loader, cbks, 'train')
+ cbks.on_epoch_end(epoch, logs)
+
+ if do_eval and epoch % eval_freq == 0:
+
+ eval_steps = self._len_data_loader(eval_loader)
+ cbks.on_begin(
+ 'eval',
+ {'steps': eval_steps, 'metrics': self._metrics_name()},
+ )
+
+ eval_logs = self._run_one_epoch(eval_loader, cbks, 'eval')
+
+ cbks.on_end('eval', eval_logs)
+ if self.stop_training:
+ break
+
+ cbks.on_end('train', logs)
+ self._test_dataloader = None
+
+ def evaluate(
+ self,
+ eval_data,
+ batch_size=1,
+ log_freq=10,
+ verbose=2,
+ num_workers=0,
+ callbacks=None,
+ num_iters=None,
+ ):
+ """
+ Evaluate the loss and metrics of the model on input dataset.
+
+ Args:
+ eval_data (Dataset|DataLoader): An iterable data loader is used for
+ evaluation. An instance of paddle.io.Dataset or
+ paddle.io.Dataloader is recomended.
+ batch_size (int, optional): The batch size of train_data and eval_data.
+ When eval_data is the instance of Dataloader, this argument will be
+ ignored. Default: 1.
+ log_freq (int, optional): The frequency, in number of steps, the eval logs
+ are printed. Default: 10.
+ verbose (int, optional): The verbosity mode, should be 0, 1, or 2. 0 = silent,
+ 1 = progress bar, 2 = one line per epoch. Default: 2.
+ num_workers (int, optional): The number of subprocess to load data,
+ 0 for no subprocess used and loading data in main process. When
+ train_data and eval_data are both the instance of Dataloader,
+ this parameter will be ignored. Default: 0.
+ callbacks (Callback|None, optional): A list of `Callback` instances to apply
+ during training. If None, `ProgBarLogger` and `ModelCheckpoint`
+ are automatically inserted. Default: None.
+ num_iters (int|None, optional): The number of iterations to evaluate the model.
+ If None, evaluate on whole input dataset, otherwise, evaluate `num_iters` times.
+ Default: None.
+ Returns:
+ dict: Result of metric. The key is the names of Metric,
+ value is a scalar or numpy.array.
+
+ Examples:
+
+ .. code-block:: python
+
+ import paddle
+ import paddle.vision.transforms as T
+ from paddle.static import InputSpec
+
+ # declarative mode
+ transform = T.Compose([
+ T.Transpose(),
+ T.Normalize([127.5], [127.5])
+ ])
+ val_dataset = paddle.vision.datasets.MNIST(mode='test', transform=transform)
+
+ input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
+ label = InputSpec([None, 1], 'int64', 'label')
+ model = paddle.Model(paddle.vision.models.LeNet(), input, label)
+ model.prepare(metrics=paddle.metric.Accuracy())
+ result = model.evaluate(val_dataset, batch_size=64)
+ print(result)
+ # {'acc': 0.0699}
+ """
+
+ if eval_data is not None and isinstance(eval_data, Dataset):
+ eval_sampler = DistributedBatchSampler(
+ eval_data, batch_size=batch_size
+ )
+ eval_loader = DataLoader(
+ eval_data,
+ batch_sampler=eval_sampler,
+ places=self._place,
+ num_workers=num_workers,
+ return_list=True,
+ )
+ else:
+ eval_loader = eval_data
+
+ self._test_dataloader = eval_loader
+
+ cbks = config_callbacks(
+ callbacks,
+ model=self,
+ log_freq=log_freq,
+ verbose=verbose,
+ metrics=self._metrics_name(),
+ )
+
+ eval_steps = self._len_data_loader(eval_loader)
+ self.num_iters = num_iters
+ if (
+ num_iters is not None
+ and isinstance(num_iters, int)
+ and isinstance(eval_steps, int)
+ ):
+ assert num_iters > 0, "num_iters must be greater than 0!"
+ eval_steps = min(num_iters, eval_steps)
+ self.num_iters = eval_steps
+ cbks.on_begin(
+ 'eval', {'steps': eval_steps, 'metrics': self._metrics_name()}
+ )
+
+ logs = self._run_one_epoch(eval_loader, cbks, 'eval')
+
+ cbks.on_end('eval', logs)
+
+ self._test_dataloader = None
+
+ eval_result = {}
+ for k in self._metrics_name():
+ eval_result[k] = logs[k]
+
+ return eval_result
+
+ def predict(
+ self,
+ test_data,
+ batch_size=1,
+ num_workers=0,
+ stack_outputs=False,
+ verbose=1,
+ callbacks=None,
+ ):
+ """
+ Compute the output predictions on testing data.
+
+ Args:
+ test_data (Dataset|DataLoader): An iterable data loader is used for
+ predict. An instance of paddle.io.Dataset or paddle.io.Dataloader
+ is recomended.
+ batch_size (int, optional): The batch size of test_data. When test_data is the
+ instance of Dataloader, this argument will be ignored. Default: 1.
+ num_workers (int, optional): The number of subprocess to load data, 0 for no subprocess
+ used and loading data in main process. When test_data is the instance of Dataloader,
+ this argument will be ignored. Default: 0.
+ stack_outputs (bool, optional): Whether stack output field like a batch, as for an output
+ field of a sample is in shape [X, Y], test_data contains N samples, predict
+ output field will be in shape [N, X, Y] if stack_output is True, and will
+ be a length N list in shape [[X, Y], [X, Y], ..., [X, Y]] if stack_outputs
+ is False. stack_outputs as False is used for LoDTensor output situation,
+ it is recommended set as True if outputs contains no LoDTensor. Default: False.
+ verbose (int, optional): The verbosity mode, should be 0, 1, or 2. 0 = silent,
+ 1 = progress bar, 2 = one line per batch. Default: 1.
+ callbacks(Callback, optional): A Callback instance, Default: None.
+
+ Returns:
+ list: output of models.
+
+ Examples:
+
+ .. code-block:: python
+
+ import numpy as np
+ import paddle
+ from paddle.static import InputSpec
+
+ class MnistDataset(paddle.vision.datasets.MNIST):
+ def __init__(self, mode, return_label=True):
+ super(MnistDataset, self).__init__(mode=mode)
+ self.return_label = return_label
+
+ def __getitem__(self, idx):
+ img = np.reshape(self.images[idx], [1, 28, 28])
+ if self.return_label:
+ return img, np.array(self.labels[idx]).astype('int64')
+ return img,
+
+ def __len__(self):
+ return len(self.images)
+
+ test_dataset = MnistDataset(mode='test', return_label=False)
+
+ # imperative mode
+ input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
+ model = paddle.Model(paddle.vision.models.LeNet(), input)
+ model.prepare()
+ result = model.predict(test_dataset, batch_size=64)
+ print(len(result[0]), result[0][0].shape)
+ # 157 (64, 10)
+
+ # declarative mode
+ device = paddle.set_device('cpu')
+ paddle.enable_static()
+ input = InputSpec([-1, 1, 28, 28], 'float32', 'image')
+ model = paddle.Model(paddle.vision.models.LeNet(), input)
+ model.prepare()
+
+ result = model.predict(test_dataset, batch_size=64)
+ print(len(result[0]), result[0][0].shape)
+ # 157 (64, 10)
+ """
+
+ if test_data is not None and isinstance(test_data, Dataset):
+ test_sampler = DistributedBatchSampler(
+ test_data, batch_size=batch_size
+ )
+ test_loader = DataLoader(
+ test_data,
+ batch_sampler=test_sampler,
+ places=self._place,
+ num_workers=num_workers,
+ return_list=True,
+ )
+ else:
+ test_loader = test_data
+
+ self._test_dataloader = test_loader
+
+ cbks = config_callbacks(callbacks, model=self, verbose=verbose)
+
+ test_steps = self._len_data_loader(test_loader)
+ logs = {'steps': test_steps}
+
+ cbks.on_begin('predict', logs)
+
+ outputs = []
+
+ logs, outputs = self._run_one_epoch(test_loader, cbks, 'predict')
+
+ outputs = list(zip(*outputs))
+
+ # NOTE: for lod tensor output, we should not stack outputs
+ # for stacking may lose its detail info
+ if stack_outputs:
+ outputs = [np.vstack(outs) for outs in outputs]
+
+ self._test_dataloader = None
+
+ cbks.on_end('predict', logs)
+ return outputs
+
+ def _save_inference_model(self, path):
+ """
+ Save inference model can be used in static or dynamic mode.
+
+ Args:
+ path (str): The path prefix to save model. The format is
+ ``dirname/file_prefix`` or ``file_prefix``.
+ Returns:
+ None
+ """
+
+ if fluid._non_static_mode():
+ with fluid.framework._dygraph_guard(None):
+ layer = self.network
+ if self._input_info is None: # No provided or inferred
+ raise RuntimeError(
+ "Saving inference model needs 'inputs' or running before saving. Please specify 'inputs' in Model initialization or input training data and perform a training for shape derivation."
+ )
+ if self._is_shape_inferred:
+ warnings.warn(
+ "'inputs' was not specified when Model initialization, so the input shape to be saved will be the shape derived from the user's actual inputs. The input shape to be saved is %s. For saving correct input shapes, please provide 'inputs' for Model initialization."
+ % self._input_info[0]
+ )
+
+ paddle.jit.save(layer, path, input_spec=self._inputs)
+
+ else:
+ # path check
+ file_prefix = os.path.basename(path)
+ if file_prefix == "":
+ raise ValueError(
+ "The input path MUST be format of dirname/file_prefix "
+ "[dirname\\file_prefix in Windows system], but received "
+ "file_prefix is empty string."
+ )
+
+ dirname = os.path.dirname(path)
+ if dirname and not os.path.exists(dirname):
+ os.makedirs(dirname)
+
+ model_path = dirname
+ model_filename = file_prefix + INFER_MODEL_SUFFIX
+ params_filename = file_prefix + INFER_PARAMS_SUFFIX
+
+ prog = self._adapter._progs.get('test', None)
+ assert (
+ prog
+ ), "Model is not ready, please call `model.prepare()` first"
+
+ infer_prog = prog.clone(for_test=True)
+
+ input_names = [v.name for v in self._adapter._input_vars['test']]
+ endpoints = self._adapter._endpoints['test']['output']
+
+ fluid.io.save_inference_model(
+ model_path,
+ input_names,
+ endpoints,
+ self._adapter._executor,
+ main_program=infer_prog,
+ model_filename=model_filename,
+ params_filename=params_filename,
+ )
+
+ def _run_one_epoch(
+ self,
+ data_loader,
+ callbacks,
+ mode,
+ logs={},
+ ):
+ outputs = []
+ for step, data in enumerate(data_loader):
+ # data might come from different types of data_loader and have
+ # different format, as following:
+ # 1. DataLoader in static graph:
+ # [[input1, input2, ..., label1, lable2, ...]]
+ # 2. DataLoader in dygraph
+ # [input1, input2, ..., label1, lable2, ...]
+ # 3. custumed iterator yield concated inputs and labels:
+ # [input1, input2, ..., label1, lable2, ...]
+ # 4. custumed iterator yield separated inputs and labels:
+ # ([input1, input2, ...], [label1, lable2, ...])
+ # To handle all of these, flatten (nested) list to list.
+ data = flatten(data)
+ # LoDTensor.shape is callable, where LoDTensor comes from
+ # DataLoader in static graph
+
+ batch_size = (
+ data[0].shape()[0]
+ if callable(data[0].shape)
+ else data[0].shape[0]
+ )
+
+ callbacks.on_batch_begin(mode, step, logs)
+
+ if mode != 'predict':
+ _inputs = [data[: len(self._inputs)], data[len(self._inputs) :]]
+ if mode == 'train':
+ _inputs.append(
+ (step + 1) % self._accumulate == 0
+ or step + 1 == len(data_loader)
+ )
+
+ outs = getattr(self, mode + '_batch')(*_inputs)
+
+ if self._metrics and self._loss:
+ metrics = [[l[0] for l in outs[0]]]
+ elif self._loss:
+ metrics = [[l[0] for l in outs]]
+ else:
+ metrics = []
+
+ # metrics
+ for metric in self._metrics:
+ res = metric.accumulate()
+ metrics.extend(to_list(res))
+
+ assert len(self._metrics_name()) == len(metrics)
+ for k, v in zip(self._metrics_name(), metrics):
+ logs[k] = v
+ else:
+ if self._inputs is not None:
+ outs = self.predict_batch(data[: len(self._inputs)])
+ else:
+ outs = self.predict_batch(data)
+
+ outputs.append(outs)
+
+ logs['step'] = step
+ if (
+ mode == 'train'
+ or self._adapter._merge_count.get(mode + '_batch', 0) <= 0
+ ):
+ logs['batch_size'] = batch_size * ParallelEnv().nranks
+ else:
+ logs['batch_size'] = self._adapter._merge_count[mode + '_batch']
+
+ callbacks.on_batch_end(mode, step, logs)
+ if hasattr(self, 'num_iters') and self.num_iters is not None:
+ self.num_iters -= 1
+ if self.num_iters <= 0:
+ self.stop_training = True
+ del self.num_iters
+ break
+ self._reset_metrics()
+
+ if mode == 'predict':
+ return logs, outputs
+ return logs
+
+ def summary(self, input_size=None, dtype=None):
+ """Prints a string summary of the network.
+
+ Args:
+ input_size (tuple|InputSpec|list[tuple|InputSpec], optional): size of input tensor.
+ if not set, input_size will get from ``self._inputs`` if network only have
+ one input, input_size can be tuple or InputSpec. if model have multiple
+ input, input_size must be a list which contain every input's shape.
+ Default: None.
+ dtype (str, optional): if dtype is None, 'float32' will be used, Default: None.
+
+ Returns:
+ Dict: a summary of the network including total params and total trainable params.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ from paddle.static import InputSpec
+
+ input = InputSpec([None, 1, 28, 28], 'float32', 'image')
+ label = InputSpec([None, 1], 'int64', 'label')
+
+ model = paddle.Model(paddle.vision.models.LeNet(),
+ input, label)
+ optim = paddle.optimizer.Adam(
+ learning_rate=0.001, parameters=model.parameters())
+ model.prepare(
+ optim,
+ paddle.nn.CrossEntropyLoss())
+
+ params_info = model.summary()
+ print(params_info)
+ # {'total_params': 61610, 'trainable_params': 61610}
+
+ """
+ assert (
+ input_size is not None or self._inputs is not None
+ ), "'input_size' or 'self._input' must be set"
+ if input_size is not None:
+ _input_size = input_size
+ else:
+ _input_size = self._inputs
+ return summary(self.network, _input_size, dtypes=dtype)
+
+ def _verify_spec(self, specs, shapes=None, dtypes=None, is_input=False):
+ out_specs = []
+
+ if specs is None:
+ # Note(Aurelius84): If not specific specs of `Input`, using argument names of `forward` function
+ # to generate `Input`. But how can we know the actual shape of each input tensor?
+
+ if is_input:
+ arg_names = extract_args(self.network.forward)[1:]
+ # While Saving inference model in dygraph, and providing inputs only in running.
+ if (
+ shapes is not None
+ and dtypes is not None
+ and fluid._non_static_mode()
+ ):
+ out_specs = [
+ Input(name=n, dtype=dtypes[i], shape=shapes[i])
+ for i, n in enumerate(arg_names)
+ ]
+ else:
+ out_specs = [Input(name=n, shape=[None]) for n in arg_names]
+ else:
+ out_specs = to_list(specs)
+ elif isinstance(specs, dict):
+ assert is_input is False
+ out_specs = [
+ specs[n]
+ for n in extract_args(self.network.forward)
+ if n != 'self'
+ ]
+ else:
+ out_specs = to_list(specs)
+ # Note: checks each element has specificed `name`.
+ if out_specs is not None:
+ for i, spec in enumerate(out_specs):
+ assert isinstance(spec, Input)
+ if spec.name is None:
+ raise ValueError(
+ "Requires Input[{}].name != None, but receive `None` with {}.".format(
+ i, spec
+ )
+ )
+
+ return out_specs
+
+ def _reset_metrics(self):
+ for metric in self._metrics:
+ metric.reset()
+
+ def _metrics_name(self):
+ metrics_name = ['loss'] if self._loss else []
+ for m in self._metrics:
+ metrics_name.extend(to_list(m.name()))
+ return metrics_name
+
+ def _len_data_loader(self, data_loader):
+ try:
+ steps = len(data_loader)
+ except Exception:
+ steps = None
+ return steps
+
+ def _update_inputs(self):
+ "Update self._inputs according to given inputs."
+ self._input_info = self._adapter._input_info
+ if self._input_info is not None and len(self._input_info) == 2:
+ self._inputs = self._verify_spec(
+ None, self._input_info[0], self._input_info[1], True
+ )
+ self._is_shape_inferred = True
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model_summary.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model_summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..26bf28ed10afdfa364a17c4cd722a188e9e19989
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/model_summary.py
@@ -0,0 +1,467 @@
+# Copyright (c) 2020 PaddlePaddle 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 warnings
+import numpy as np
+import numbers
+
+import paddle
+import paddle.nn as nn
+from paddle.static import InputSpec
+from paddle.autograd import no_grad
+from collections import OrderedDict
+
+__all__ = []
+
+
+def summary(net, input_size=None, dtypes=None, input=None):
+ """Prints a string summary of the network.
+
+ Args:
+ net (Layer): the network which must be a subinstance of Layer.
+ input_size (tuple|InputSpec|list[tuple|InputSpec], optional): size of input tensor. if model only
+ have one input, input_size can be tuple or InputSpec. if model
+ have multiple input, input_size must be a list which contain
+ every input's shape. Note that input_size only dim of
+ batch_size can be None or -1. Default: None. Note that
+ input_size and input cannot be None at the same time.
+ dtypes (str, optional): if dtypes is None, 'float32' will be used, Default: None.
+ input: the input tensor. if input is given, input_size and dtype will be ignored, Default: None.
+
+ Returns:
+ Dict: a summary of the network including total params and total trainable params.
+
+ Examples:
+ .. code-block:: python
+
+ import paddle
+ import paddle.nn as nn
+
+ class LeNet(nn.Layer):
+ def __init__(self, num_classes=10):
+ super(LeNet, self).__init__()
+ self.num_classes = num_classes
+ self.features = nn.Sequential(
+ nn.Conv2D(
+ 1, 6, 3, stride=1, padding=1),
+ nn.ReLU(),
+ nn.MaxPool2D(2, 2),
+ nn.Conv2D(
+ 6, 16, 5, stride=1, padding=0),
+ nn.ReLU(),
+ nn.MaxPool2D(2, 2))
+
+ if num_classes > 0:
+ self.fc = nn.Sequential(
+ nn.Linear(400, 120),
+ nn.Linear(120, 84),
+ nn.Linear(
+ 84, 10))
+
+ def forward(self, inputs):
+ x = self.features(inputs)
+
+ if self.num_classes > 0:
+ x = paddle.flatten(x, 1)
+ x = self.fc(x)
+ return x
+
+ lenet = LeNet()
+
+ params_info = paddle.summary(lenet, (1, 1, 28, 28))
+ print(params_info)
+
+ # multi input demo
+ class LeNetMultiInput(LeNet):
+
+ def forward(self, inputs, y):
+ x = self.features(inputs)
+
+ if self.num_classes > 0:
+ x = paddle.flatten(x, 1)
+ x = self.fc(x + y)
+ return x
+
+ lenet_multi_input = LeNetMultiInput()
+
+ params_info = paddle.summary(lenet_multi_input, [(1, 1, 28, 28), (1, 400)],
+ dtypes=['float32', 'float32'])
+ print(params_info)
+
+ # list input demo
+ class LeNetListInput(LeNet):
+
+ def forward(self, inputs):
+ x = self.features(inputs[0])
+
+ if self.num_classes > 0:
+ x = paddle.flatten(x, 1)
+ x = self.fc(x + inputs[1])
+ return x
+
+ lenet_list_input = LeNetListInput()
+ input_data = [paddle.rand([1, 1, 28, 28]), paddle.rand([1, 400])]
+ params_info = paddle.summary(lenet_list_input, input=input_data)
+ print(params_info)
+
+ # dict input demo
+ class LeNetDictInput(LeNet):
+
+ def forward(self, inputs):
+ x = self.features(inputs['x1'])
+
+ if self.num_classes > 0:
+ x = paddle.flatten(x, 1)
+ x = self.fc(x + inputs['x2'])
+ return x
+
+ lenet_dict_input = LeNetDictInput()
+ input_data = {'x1': paddle.rand([1, 1, 28, 28]),
+ 'x2': paddle.rand([1, 400])}
+ params_info = paddle.summary(lenet_dict_input, input=input_data)
+ print(params_info)
+
+ """
+ if input_size is None and input is None:
+ raise ValueError("input_size and input cannot be None at the same time")
+
+ if input_size is None and input is not None:
+ if paddle.is_tensor(input):
+ input_size = tuple(input.shape)
+ elif isinstance(input, (list, tuple)):
+ input_size = []
+ for x in input:
+ input_size.append(tuple(x.shape))
+ elif isinstance(input, dict):
+ input_size = []
+ for key in input.keys():
+ input_size.append(tuple(input[key].shape))
+ elif isinstance(input, paddle.fluid.framework.Variable):
+ input_size = tuple(input.shape)
+ else:
+ raise ValueError(
+ "Input is not tensor, list, tuple and dict, unable to determine input_size, please input input_size."
+ )
+
+ if isinstance(input_size, InputSpec):
+ _input_size = tuple(input_size.shape)
+ elif isinstance(input_size, list):
+ _input_size = []
+ for item in input_size:
+ if isinstance(item, int):
+ item = (item, )
+ assert isinstance(item,
+ (tuple, InputSpec)), 'When input_size is list, \
+ expect item in input_size is a tuple or InputSpec, but got {}'.format(
+ type(item))
+
+ if isinstance(item, InputSpec):
+ _input_size.append(tuple(item.shape))
+ else:
+ _input_size.append(item)
+ elif isinstance(input_size, int):
+ _input_size = (input_size, )
+ else:
+ _input_size = input_size
+
+ if not paddle.in_dynamic_mode():
+ warnings.warn(
+ "Your model was created in static mode, this may not get correct summary information!"
+ )
+ in_train_mode = False
+ else:
+ in_train_mode = net.training
+
+ if in_train_mode:
+ net.eval()
+
+ def _is_shape(shape):
+ for item in shape:
+ if isinstance(item, (list, tuple)):
+ return False
+ return True
+
+ def _check_shape(shape):
+ num_unknown = 0
+ new_shape = []
+ for i in range(len(shape)):
+ item = shape[i]
+ if item is None or item == -1:
+ num_unknown += 1
+ if num_unknown > 1:
+ raise ValueError(
+ 'Option input_size only the dim of batch_size can be None or -1.'
+ )
+ item = 1
+ elif isinstance(item, numbers.Number):
+ if item <= 0:
+ raise ValueError(
+ "Expected element in input size greater than zero, but got {}"
+ .format(item))
+ new_shape.append(item)
+ return tuple(new_shape)
+
+ def _check_input(input_size):
+ if isinstance(input_size, (list, tuple)) and _is_shape(input_size):
+ return _check_shape(input_size)
+ else:
+ return [_check_input(i) for i in input_size]
+
+ _input_size = _check_input(_input_size)
+
+ result, params_info = summary_string(net, _input_size, dtypes, input)
+ print(result)
+
+ if in_train_mode:
+ net.train()
+
+ return params_info
+
+
+@no_grad()
+def summary_string(model, input_size=None, dtypes=None, input=None):
+
+ def _all_is_numper(items):
+ for item in items:
+ if not isinstance(item, numbers.Number):
+ return False
+ return True
+
+ def _build_dtypes(input_size, dtype):
+ if dtype is None:
+ dtype = 'float32'
+
+ if isinstance(input_size, (list, tuple)) and _all_is_numper(input_size):
+ return [dtype]
+ else:
+ return [_build_dtypes(i, dtype) for i in input_size]
+
+ if not isinstance(dtypes, (list, tuple)):
+ dtypes = _build_dtypes(input_size, dtypes)
+
+ batch_size = 1
+
+ summary_str = ''
+
+ depth = len(list(model.sublayers()))
+
+ def _get_shape_from_tensor(x):
+ if isinstance(x, (paddle.fluid.Variable, paddle.fluid.core.VarBase)):
+ return list(x.shape)
+ elif isinstance(x, (list, tuple)):
+ return [_get_shape_from_tensor(xx) for xx in x]
+
+ def _get_output_shape(output):
+ if isinstance(output, (list, tuple)):
+ output_shape = [_get_output_shape(o) for o in output]
+ elif hasattr(output, 'shape'):
+ output_shape = list(output.shape)
+ else:
+ output_shape = []
+ return output_shape
+
+ def register_hook(layer):
+
+ def hook(layer, input, output):
+ class_name = str(layer.__class__).split(".")[-1].split("'")[0]
+
+ try:
+ layer_idx = int(layer._full_name.split('_')[-1])
+ except:
+ layer_idx = len(summary)
+
+ m_key = "%s-%i" % (class_name, layer_idx + 1)
+ summary[m_key] = OrderedDict()
+
+ try:
+ summary[m_key]["input_shape"] = _get_shape_from_tensor(input)
+ except:
+ warnings.warn('Get layer {} input shape failed!')
+ summary[m_key]["input_shape"] = []
+
+ try:
+ summary[m_key]["output_shape"] = _get_output_shape(output)
+ except:
+ warnings.warn('Get layer {} output shape failed!')
+ summary[m_key]["output_shape"]
+
+ params = 0
+
+ if paddle.in_dynamic_mode():
+ layer_state_dict = layer._parameters
+ else:
+ layer_state_dict = layer.state_dict()
+
+ summary[m_key]["trainable_params"] = 0
+ trainable_flag = False
+ for k, v in layer_state_dict.items():
+ params += np.prod(v.shape)
+
+ try:
+ if (getattr(getattr(layer, k), 'trainable')) and (
+ not getattr(getattr(layer, k), 'stop_gradient')):
+ summary[m_key]["trainable_params"] += np.prod(v.shape)
+ summary[m_key]["trainable"] = True
+ trainable_flag = True
+ elif not trainable_flag:
+ summary[m_key]["trainable"] = False
+ except:
+ summary[m_key]["trainable"] = True
+
+ summary[m_key]["nb_params"] = params
+
+ if (not isinstance(layer, nn.Sequential)
+ and not isinstance(layer, nn.LayerList)
+ and (not (layer == model) or depth < 1)):
+
+ hooks.append(layer.register_forward_post_hook(hook))
+ # For rnn, gru and lstm layer
+ elif hasattr(layer, 'could_use_cudnn') and layer.could_use_cudnn:
+ hooks.append(layer.register_forward_post_hook(hook))
+
+ if isinstance(input_size, tuple):
+ input_size = [input_size]
+
+ def build_input(input_size, dtypes):
+ if isinstance(input_size, (list, tuple)) and _all_is_numper(input_size):
+ if isinstance(dtypes, (list, tuple)):
+ dtype = dtypes[0]
+ else:
+ dtype = dtypes
+ return paddle.cast(paddle.rand(list(input_size)), dtype)
+ else:
+ return [
+ build_input(i, dtype) for i, dtype in zip(input_size, dtypes)
+ ]
+
+ # create properties
+ summary = OrderedDict()
+ hooks = []
+ # register hook
+ model.apply(register_hook)
+ if input is not None:
+ x = input
+ model(x)
+ else:
+ x = build_input(input_size, dtypes)
+ # make a forward pass
+ model(*x)
+
+ # remove these hooks
+ for h in hooks:
+ h.remove()
+
+ def _get_str_length(summary):
+ head_length = {
+ 'layer_width': 15,
+ 'input_shape_width': 20,
+ 'output_shape_width': 20,
+ 'params_width': 15,
+ 'table_width': 75
+ }
+
+ for layer in summary:
+ if head_length['output_shape_width'] < len(
+ str(summary[layer]["output_shape"])):
+ head_length['output_shape_width'] = len(
+ str(summary[layer]["output_shape"]))
+ if head_length['input_shape_width'] < len(
+ str(summary[layer]["input_shape"])):
+ head_length['input_shape_width'] = len(
+ str(summary[layer]["input_shape"]))
+ if head_length['layer_width'] < len(str(layer)):
+ head_length['layer_width'] = len(str(layer))
+ if head_length['params_width'] < len(
+ str(summary[layer]["nb_params"])):
+ head_length['params_width'] = len(
+ str(summary[layer]["nb_params"]))
+
+ _temp_width = 0
+ for k, v in head_length.items():
+ if k != 'table_width':
+ _temp_width += v
+
+ if head_length['table_width'] < _temp_width + 5:
+ head_length['table_width'] = _temp_width + 5
+
+ return head_length
+
+ table_width = _get_str_length(summary)
+
+ summary_str += "-" * table_width['table_width'] + "\n"
+ line_new = "{:^{}} {:^{}} {:^{}} {:^{}}".format(
+ "Layer (type)", table_width['layer_width'], "Input Shape",
+ table_width['input_shape_width'], "Output Shape",
+ table_width['output_shape_width'], "Param #",
+ table_width['params_width'])
+ summary_str += line_new + "\n"
+ summary_str += "=" * table_width['table_width'] + "\n"
+ total_params = 0
+ total_output = 0
+ trainable_params = 0
+ max_length = 0
+ for layer in summary:
+ # input_shape, output_shape, trainable, nb_params
+ line_new = "{:^{}} {:^{}} {:^{}} {:^{}}".format(
+ layer, table_width['layer_width'],
+ str(summary[layer]["input_shape"]),
+ table_width['input_shape_width'],
+ str(summary[layer]["output_shape"]),
+ table_width['output_shape_width'], "{0:,}".format(
+ summary[layer]["nb_params"]), table_width['params_width'])
+ total_params += summary[layer]["nb_params"]
+
+ try:
+ total_output += np.sum(
+ np.prod(summary[layer]["output_shape"], axis=-1))
+ except:
+ for output_shape in summary[layer]["output_shape"]:
+ total_output += np.sum(np.prod(output_shape, axis=-1))
+
+ if "trainable" in summary[layer]:
+ if summary[layer]["trainable"] == True:
+ trainable_params += summary[layer]["trainable_params"]
+ summary_str += line_new + "\n"
+
+ def _get_input_size(input_size, size):
+ if isinstance(input_size, (list, tuple)) and _all_is_numper(input_size):
+ size = abs(np.prod(input_size) * 4. / (1024**2.))
+ else:
+ size = sum([_get_input_size(i, size) for i in input_size])
+ return size
+
+ total_input_size = _get_input_size(input_size, 0)
+
+ total_output_size = abs(2. * total_output * 4. /
+ (1024**2.)) # x2 for gradients
+ total_params_size = abs(total_params * 4. / (1024**2.))
+ total_size = total_params_size + total_output_size + total_input_size
+
+ summary_str += "=" * table_width['table_width'] + "\n"
+ summary_str += "Total params: {0:,}".format(total_params) + "\n"
+ summary_str += "Trainable params: {0:,}".format(trainable_params) + "\n"
+ summary_str += "Non-trainable params: {0:,}".format(total_params -
+ trainable_params) + "\n"
+ summary_str += "-" * table_width['table_width'] + "\n"
+ summary_str += "Input size (MB): %0.2f" % total_input_size + "\n"
+ summary_str += "Forward/backward pass size (MB): %0.2f" % total_output_size + "\n"
+ summary_str += "Params size (MB): %0.2f" % total_params_size + "\n"
+ summary_str += "Estimated Total Size (MB): %0.2f" % total_size + "\n"
+ summary_str += "-" * table_width['table_width'] + "\n"
+
+ # return summary
+ return summary_str, {
+ 'total_params': total_params,
+ 'trainable_params': trainable_params
+ }
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/progressbar.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/progressbar.py
new file mode 100644
index 0000000000000000000000000000000000000000..58dfdef604e7c54f019a393098bdee9098f7225d
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/progressbar.py
@@ -0,0 +1,211 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import sys
+import time
+import numpy as np
+import struct
+from collections import namedtuple
+
+__all__ = []
+
+
+class ProgressBar(object):
+ """progress bar """
+
+ def __init__(self,
+ num=None,
+ width=30,
+ verbose=1,
+ start=True,
+ file=sys.stdout,
+ name='step'):
+ self._num = num
+ if isinstance(num, int) and num <= 0:
+ raise TypeError('num should be None or integer (> 0)')
+ max_width = self._get_max_width()
+ self._width = width if width <= max_width else max_width
+ self._total_width = 0
+ self._verbose = verbose
+ self.file = file
+ self._values = {}
+ self._values_order = []
+ if start:
+ self._start = time.time()
+ self._last_update = 0
+ self.name = name
+
+ self._dynamic_display = ((hasattr(self.file, 'isatty')
+ and self.file.isatty())
+ or 'ipykernel' in sys.modules
+ or 'posix' in sys.modules
+ or 'PYCHARM_HOSTED' in os.environ)
+
+ def _get_max_width(self):
+ if sys.version_info > (3, 3):
+ from shutil import get_terminal_size
+ else:
+ try:
+ from backports.shutil_get_terminal_size import get_terminal_size
+ except:
+
+ def get_terminal_size():
+ terminal_size = namedtuple("terminal_size", "columns lines")
+ return terminal_size(80, 24)
+
+ terminal_width, _ = get_terminal_size()
+ terminal_width = terminal_width if terminal_width > 0 else 80
+ max_width = min(int(terminal_width * 0.6), terminal_width - 50)
+ return max_width
+
+ def start(self):
+ self.file.flush()
+ self._start = time.time()
+
+ def update(self, current_num, values={}):
+ now = time.time()
+
+ def convert_uint16_to_float(in_list):
+ in_list = np.asarray(in_list)
+ out = np.vectorize(
+ lambda x: struct.unpack('= 1 or time_per_unit == 0:
+ fps = ' - %.0fs/%s' % (time_per_unit, self.name)
+ elif time_per_unit >= 1e-3:
+ fps = ' - %.0fms/%s' % (time_per_unit * 1e3, self.name)
+ else:
+ fps = ' - %.0fus/%s' % (time_per_unit * 1e6, self.name)
+
+ info = ''
+ if self._verbose == 1:
+ prev_total_width = self._total_width
+
+ if self._dynamic_display:
+ sys.stdout.write('\b' * prev_total_width)
+ sys.stdout.write('\r')
+ else:
+ sys.stdout.write('\n')
+
+ if self._num is not None:
+ numdigits = int(np.log10(self._num)) + 1
+
+ bar_chars = (self.name + ' %' + str(numdigits) +
+ 'd/%d [') % (current_num, self._num)
+ prog = float(current_num) / self._num
+ prog_width = int(self._width * prog)
+
+ if prog_width > 0:
+ bar_chars += ('=' * (prog_width - 1))
+ if current_num < self._num:
+ bar_chars += '>'
+ else:
+ bar_chars += '='
+ bar_chars += ('.' * (self._width - prog_width))
+ bar_chars += ']'
+ else:
+ bar_chars = self.name + ' %3d' % current_num
+
+ self._total_width = len(bar_chars)
+ sys.stdout.write(bar_chars)
+
+ for k, val in values:
+ info += ' - %s:' % k
+ val = val if isinstance(val, list) else [val]
+ for i, v in enumerate(val):
+ if isinstance(v, (float, np.float32, np.float64)):
+ if abs(v) > 1e-3:
+ info += ' %.4f' % v
+ else:
+ info += ' %.4e' % v
+ else:
+ info += ' %s' % v
+
+ if self._num is not None and current_num < self._num:
+ eta = time_per_unit * (self._num - current_num)
+ if eta > 3600:
+ eta_format = '%d:%02d:%02d' % (eta // 3600,
+ (eta % 3600) // 60, eta % 60)
+ elif eta > 60:
+ eta_format = '%d:%02d' % (eta // 60, eta % 60)
+ else:
+ eta_format = '%ds' % eta
+
+ info += ' - ETA: %s' % eta_format
+
+ info += fps
+ self._total_width += len(info)
+ if prev_total_width > self._total_width:
+ info += (' ' * (prev_total_width - self._total_width))
+
+ # newline for another epoch
+ if self._num is not None and current_num >= self._num:
+ info += '\n'
+ if self._num is None:
+ info += '\n'
+
+ sys.stdout.write(info)
+ sys.stdout.flush()
+ self._last_update = now
+ elif self._verbose == 2 or self._verbose == 3:
+ if self._num:
+ numdigits = int(np.log10(self._num)) + 1
+ count = (self.name + ' %' + str(numdigits) +
+ 'd/%d') % (current_num, self._num)
+ else:
+ count = self.name + ' %3d' % current_num
+ info = count + info
+
+ for k, val in values:
+ info += ' - %s:' % k
+ val = val if isinstance(val, list) else [val]
+ for v in val:
+ if isinstance(v, (float, np.float32, np.float64)):
+ if abs(v) > 1e-3:
+ info += ' %.4f' % v
+ else:
+ info += ' %.4e' % v
+ elif isinstance(v, np.ndarray) and \
+ v.size == 1 and \
+ v.dtype in [np.float32, np.float64]:
+ if abs(v[0]) > 1e-3:
+ info += ' %.4f' % v[0]
+ else:
+ info += ' %.4e' % v[0]
+ else:
+ info += ' %s' % v
+
+ info += fps
+ info += '\n'
+ sys.stdout.write(info)
+ sys.stdout.flush()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/static_flops.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/static_flops.py
new file mode 100644
index 0000000000000000000000000000000000000000..297199b7326a9b11ad8cd2b5e42cb2bc41b6022f
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hapi/static_flops.py
@@ -0,0 +1,259 @@
+# Copyright (c) 2020 PaddlePaddle 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 copy
+import numpy as np
+import paddle
+from collections import OrderedDict
+from paddle.static import Program, program_guard, Variable
+
+__all__ = []
+
+
+class VarWrapper(object):
+
+ def __init__(self, var, graph):
+ assert isinstance(var, Variable)
+ assert isinstance(graph, GraphWrapper)
+ self._var = var
+ self._graph = graph
+
+ def name(self):
+ """
+ Get the name of the variable.
+ """
+ return self._var.name
+
+ def shape(self):
+ """
+ Get the shape of the varibale.
+ """
+ return self._var.shape
+
+
+class OpWrapper(object):
+
+ def __init__(self, op, graph):
+ assert isinstance(graph, GraphWrapper)
+ self._op = op
+ self._graph = graph
+
+ def type(self):
+ """
+ Get the type of this operator.
+ """
+ return self._op.type
+
+ def inputs(self, name):
+ """
+ Get all the varibales by the input name.
+ """
+ if name in self._op.input_names:
+ return [
+ self._graph.var(var_name) for var_name in self._op.input(name)
+ ]
+ else:
+ return []
+
+ def outputs(self, name):
+ """
+ Get all the varibales by the output name.
+ """
+ return [self._graph.var(var_name) for var_name in self._op.output(name)]
+
+
+class GraphWrapper(object):
+ """
+ It is a wrapper of paddle.fluid.framework.IrGraph with some special functions
+ for paddle slim framework.
+
+ Args:
+ program(framework.Program): A program with
+ in_nodes(dict): A dict to indicate the input nodes of the graph.
+ The key is user-defined and human-readable name.
+ The value is the name of Variable.
+ out_nodes(dict): A dict to indicate the input nodes of the graph.
+ The key is user-defined and human-readable name.
+ The value is the name of Variable.
+ """
+
+ def __init__(self, program=None, in_nodes=[], out_nodes=[]):
+ """
+ """
+ super(GraphWrapper, self).__init__()
+ self.program = Program() if program is None else program
+ self.persistables = {}
+ self.teacher_persistables = {}
+ for var in self.program.list_vars():
+ if var.persistable:
+ self.persistables[var.name] = var
+ self.compiled_graph = None
+ in_nodes = [] if in_nodes is None else in_nodes
+ out_nodes = [] if out_nodes is None else out_nodes
+ self.in_nodes = OrderedDict(in_nodes)
+ self.out_nodes = OrderedDict(out_nodes)
+ self._attrs = OrderedDict()
+
+ def ops(self):
+ """
+ Return all operator nodes included in the graph as a set.
+ """
+ ops = []
+ for block in self.program.blocks:
+ for op in block.ops:
+ ops.append(OpWrapper(op, self))
+ return ops
+
+ def var(self, name):
+ """
+ Get the variable by variable name.
+ """
+ for block in self.program.blocks:
+ if block.has_var(name):
+ return VarWrapper(block.var(name), self)
+ return None
+
+
+def count_convNd(op):
+ filter_shape = op.inputs("Filter")[0].shape()
+ filter_ops = np.product(filter_shape[1:])
+ bias_ops = 1 if len(op.inputs("Bias")) > 0 else 0
+ output_numel = np.product(op.outputs("Output")[0].shape()[1:])
+ total_ops = output_numel * (filter_ops + bias_ops)
+ total_ops = abs(total_ops)
+ return total_ops
+
+
+def count_leaky_relu(op):
+ total_ops = np.product(op.outputs("Output")[0].shape()[1:])
+ return total_ops
+
+
+def count_bn(op):
+ output_numel = np.product(op.outputs("Y")[0].shape()[1:])
+ total_ops = 2 * output_numel
+ total_ops = abs(total_ops)
+ return total_ops
+
+
+def count_linear(op):
+ total_mul = op.inputs("Y")[0].shape()[0]
+ numel = np.product(op.outputs("Out")[0].shape()[1:])
+ total_ops = total_mul * numel
+ total_ops = abs(total_ops)
+ return total_ops
+
+
+def count_pool2d(op):
+ input_shape = op.inputs("X")[0].shape()
+ output_shape = op.outputs('Out')[0].shape()
+ kernel = np.array(input_shape[2:]) // np.array(output_shape[2:])
+ total_add = np.product(kernel)
+ total_div = 1
+ kernel_ops = total_add + total_div
+ num_elements = np.product(output_shape[1:])
+ total_ops = kernel_ops * num_elements
+ total_ops = abs(total_ops)
+ return total_ops
+
+
+def count_element_op(op):
+ input_shape = op.inputs("X")[0].shape()
+ total_ops = np.product(input_shape[1:])
+ total_ops = abs(total_ops)
+ return total_ops
+
+
+def _graph_flops(graph, detail=False):
+ assert isinstance(graph, GraphWrapper)
+ flops = 0
+ op_flops = 0
+ table = Table(["OP Type", 'Param name', "Flops"])
+ for op in graph.ops():
+ param_name = ''
+ if op.type() in ['conv2d', 'depthwise_conv2d']:
+ op_flops = count_convNd(op)
+ flops += op_flops
+ param_name = op.inputs("Filter")[0].name()
+ elif op.type() == 'pool2d':
+ op_flops = count_pool2d(op)
+ flops += op_flops
+
+ elif op.type() in ['mul', 'matmul']:
+ op_flops = count_linear(op)
+ flops += op_flops
+ param_name = op.inputs("Y")[0].name()
+ elif op.type() == 'batch_norm':
+ op_flops = count_bn(op)
+ flops += op_flops
+ elif op.type().startswith('element'):
+ op_flops = count_element_op(op)
+ flops += op_flops
+ if op_flops != 0:
+ table.add_row([op.type(), param_name, op_flops])
+ op_flops = 0
+ if detail:
+ table.print_table()
+ return flops
+
+
+def static_flops(program, print_detail=False):
+ graph = GraphWrapper(program)
+ return _graph_flops(graph, detail=print_detail)
+
+
+class Table(object):
+
+ def __init__(self, table_heads):
+ self.table_heads = table_heads
+ self.table_len = []
+ self.data = []
+ self.col_num = len(table_heads)
+ for head in table_heads:
+ self.table_len.append(len(head))
+
+ def add_row(self, row_str):
+ if not isinstance(row_str, list):
+ print('The row_str should be a list')
+ if len(row_str) != self.col_num:
+ print(
+ 'The length of row data should be equal the length of table heads, but the data: {} is not equal table heads {}'
+ .format(len(row_str), self.col_num))
+ for i in range(self.col_num):
+ if len(str(row_str[i])) > self.table_len[i]:
+ self.table_len[i] = len(str(row_str[i]))
+ self.data.append(row_str)
+
+ def print_row(self, row):
+ string = ''
+ for i in range(self.col_num):
+ string += '|' + str(row[i]).center(self.table_len[i] + 2)
+ string += '|'
+ print(string)
+
+ def print_shelf(self):
+ string = ''
+ for length in self.table_len:
+ string += '+'
+ string += '-' * (length + 2)
+ string += '+'
+ print(string)
+
+ def print_table(self):
+ self.print_shelf()
+ self.print_row(self.table_heads)
+ self.print_shelf()
+ for data in self.data:
+ self.print_row(data)
+ self.print_shelf()
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hub.py b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hub.py
new file mode 100644
index 0000000000000000000000000000000000000000..acdb28cb6f08dfd51e9770c40283eb3f8d98a010
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/hub.py
@@ -0,0 +1,21 @@
+# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .hapi.hub import list # noqa: F401
+from .hapi.hub import help # noqa: F401
+from .hapi.hub import load # noqa: F401
+
+__all__ = [ #noqa
+ 'list', 'help', 'load'
+]
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/extension.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/extension.h
new file mode 100644
index 0000000000000000000000000000000000000000..1c2d546fbf039e5286832702c1df59faac3d35e1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/extension.h
@@ -0,0 +1,18 @@
+/* Copyright (c) 2021 PaddlePaddle 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. */
+
+#pragma once
+
+// All paddle apis in C++ frontend
+#include "paddle/phi/api/all.h"
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/all.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/all.h
new file mode 100644
index 0000000000000000000000000000000000000000..233d1dc981fb229f0cb034aa8f8df1c891ec5d0a
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/all.h
@@ -0,0 +1,20 @@
+// Copyright (c) 2022 PaddlePaddle 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.
+
+#pragma once
+
+#include "function.h" //NOLINT
+#include "layer.h" // NOLINT
+#include "serializer.h" // NOLINT
+#include "serializer_utils.h" // NOLINT
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/function.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/function.h
new file mode 100644
index 0000000000000000000000000000000000000000..a80d46d63994606a147cdb864bcfe491ffcc4f26
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/function.h
@@ -0,0 +1,47 @@
+// Copyright (c) 2022 PaddlePaddle 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.
+
+#pragma once
+
+#include
+#include
+
+#include "paddle/phi/api/include/tensor.h"
+
+namespace paddle {
+namespace jit {
+class BaseEngine;
+using DenseTensor = phi::DenseTensor;
+using Tensor = paddle::experimental::Tensor;
+
+class Function {
+ public:
+ Function() : engine_(nullptr) {}
+ explicit Function(BaseEngine* engine);
+
+ std::vector operator()(const std::vector& inputs) const;
+
+ std::vector operator()(
+ const std::vector& inputs) const;
+
+ bool IsValid() const { return engine_ != nullptr; }
+
+ ~Function() = default;
+
+ private:
+ BaseEngine* engine_;
+};
+
+} // namespace jit
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/layer.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/layer.h
new file mode 100644
index 0000000000000000000000000000000000000000..dd5ff5d9f91cd9fa27bd03ae220b201b7982c407
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/layer.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2022 PaddlePaddle 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.
+
+#pragma once
+
+#include
+#include
+#include
+#include
+
+#include "paddle/phi/api/include/tensor.h"
+#include "paddle/phi/common/place.h"
+
+#include "function.h" //NOLINT
+
+namespace paddle {
+
+namespace framework {
+class Variable;
+} // namespace framework
+
+namespace jit {
+class CompilationUnit;
+class FunctionInfo;
+
+using DenseTensor = phi::DenseTensor;
+using Tensor = paddle::experimental::Tensor;
+using Variable = paddle::framework::Variable;
+using VariableMap = std::unordered_map>;
+using FunctionInfoMap =
+ std::unordered_map>;
+
+class Layer {
+ public:
+ Layer(const VariableMap& params_map,
+ const VariableMap& attrs_map_,
+ const FunctionInfoMap& info_map,
+ const phi::Place& place);
+
+ jit::Function Function(const std::string& name) const;
+
+ template
+ T Attribute(const std::string& name) const;
+
+ std::vector forward(const std::vector& inputs);
+
+ std::vector forward(const std::vector& inputs);
+
+ void to(const phi::Place& place);
+
+ void SetEngine(const std::string& name,
+ const std::shared_ptr& engine);
+
+ const std::shared_ptr& FunctionInfo(
+ const std::string& name) const;
+
+ std::vector FunctionNames() const;
+
+ private:
+ VariableMap params_map_;
+ VariableMap attrs_map_;
+ FunctionInfoMap info_map_;
+ std::shared_ptr unit_;
+};
+
+} // namespace jit
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b93eaa44fe63268b13bfd86b66e998ac77da3392
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer.h
@@ -0,0 +1,77 @@
+// Copyright (c) 2022 PaddlePaddle 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.
+
+#pragma once
+
+#include
+#include
+#include
+#include
+
+#include "paddle/phi/common/place.h"
+
+namespace paddle {
+
+namespace framework {
+class Variable;
+class ProgramDesc;
+} // namespace framework
+
+namespace jit {
+class Layer;
+using Variable = paddle::framework::Variable;
+using VariableMap = std::unordered_map>;
+
+// Export Layer into local disk
+class Serializer {
+ public:
+ void operator()(const Layer& layer, const std::string& file_dir);
+
+ // private:
+ // void WriteTensorData(const Layer& layer, const std::string& file_name)
+ // const;
+ // void WriteExtraInfo(const Layer& layer, const std::string& file_name)
+ // const;
+ // void WriteByteCode(const Layer& layer, const std::string& file_name)
+ // const;
+};
+
+class Deserializer {
+ public:
+ Layer operator()(const std::string& dir_path, const phi::Place& place);
+
+ private:
+ void ReadTensorData(const std::string& file_name,
+ const std::set& var_name,
+ const phi::Place& place,
+ VariableMap* params_dict) const;
+
+ // property pb
+ void ReadAttributeData(const std::string& file_path,
+ VariableMap* attrs_dict) const;
+
+ // void ReadExtraInfo(const std::string& file_name) const;
+
+ // void ReadByteCode(const std::string& file_name) const;
+
+ framework::ProgramDesc LoadProgram(const std::string& file_name);
+};
+
+void Export(const Layer& layer, const std::string& file_path);
+
+// path should be like 'dirname/file_prefix'
+Layer Load(const std::string& path, const phi::Place& place);
+
+} // namespace jit
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer_utils.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer_utils.h
new file mode 100644
index 0000000000000000000000000000000000000000..0afe6be3fe2cba3521405235ac16d76c22f8e405
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/jit/serializer_utils.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2022 PaddlePaddle 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.
+
+#pragma once
+
+#include
+#include
+
+namespace paddle {
+
+namespace framework {
+class VarDesc;
+} // namespace framework
+
+namespace jit {
+static const char PDMODEL_SUFFIX[] = ".pdmodel";
+static const char PDPARAMS_SUFFIX[] = ".pdiparams";
+static const char PROPERTY_SUFFIX[] = ".meta";
+
+namespace utils {
+bool IsPersistable(framework::VarDesc* desc_ptr);
+
+bool StartsWith(const std::string& str, const std::string& suffix);
+
+bool EndsWith(const std::string& str, const std::string& suffix);
+
+void ReplaceAll(std::string* str,
+ const std::string& old_value,
+ const std::string& new_value);
+
+bool FileExists(const std::string& file_path);
+
+const std::vector> PdmodelFilePaths(
+ const std::string& path);
+
+void InitKernelSignatureMap();
+
+} // namespace utils
+} // namespace jit
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/all.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/all.h
new file mode 100644
index 0000000000000000000000000000000000000000..5838e7b2eaab7107db9897eabaf824f9b5da0994
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/all.h
@@ -0,0 +1,44 @@
+/* Copyright (c) 2021 PaddlePaddle 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. */
+
+#pragma once
+
+#if !defined(_MSC_VER) && __cplusplus < 201402L
+#error C++14 or later compatible compiler is required to use Paddle.
+#endif
+
+#ifdef _WIN32
+#ifndef NOMINMAX
+#define NOMINMAX // msvc max/min macro conflict with std::min/max
+#endif
+#endif
+
+// new phi apis
+#include "paddle/phi/api/include/api.h"
+#include "paddle/phi/api/include/context_pool.h"
+#include "paddle/phi/api/include/sparse_api.h"
+#include "paddle/phi/api/include/tensor.h"
+
+// phi common headers
+#include "paddle/phi/common/backend.h"
+#include "paddle/phi/common/data_type.h"
+#include "paddle/phi/common/int_array.h"
+#include "paddle/phi/common/layout.h"
+#include "paddle/phi/common/scalar.h"
+
+// original custom op headers
+#include "paddle/phi/api/ext/dispatch.h"
+#include "paddle/phi/api/ext/exception.h"
+#include "paddle/phi/api/ext/op_meta_info.h"
+#include "paddle/phi/api/ext/tensor_compat.h"
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/dispatch.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/dispatch.h
new file mode 100644
index 0000000000000000000000000000000000000000..aa9cd0f53a4c642b97292f77567f2b6706857f00
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/dispatch.h
@@ -0,0 +1,70 @@
+/* Copyright (c) 2021 PaddlePaddle 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. */
+
+#pragma once
+
+#include "paddle/phi/core/visit_type.h"
+
+namespace paddle {
+
+// Note: Keep this file only for compatibility with custom operators
+
+///////// Floating Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_TYPES(TYPE, NAME, __VA_ARGS__)
+
+#define PD_DISPATCH_FLOATING_AND_HALF_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_HALF_TYPES(TYPE, NAME, __VA_ARGS__)
+
+///////// Integral Dispatch Marco ///////////
+
+#define PD_DISPATCH_INTEGRAL_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_INTEGRAL_TYPES(TYPE, NAME, __VA_ARGS__)
+
+///////// Complex Dispatch Marco ///////////
+
+#define PD_DISPATCH_COMPLEX_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_COMPLEX_TYPES(TYPE, NAME, __VA_ARGS__)
+
+///////// Floating and Integral Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_AND_INTEGRAL_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_INTEGRAL_TYPES(TYPE, NAME, __VA_ARGS__)
+
+///////// Floating and Complex Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_AND_COMPLEX_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_COMPLEX_TYPES(TYPE, NAME, __VA_ARGS__)
+
+///////// Floating and Complex and other type Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_AND_COMPLEX_AND_1_TYPE( \
+ SPECIFIED_TYPE, TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_COMPLEX_AND_1_TYPE( \
+ SPECIFIED_TYPE, TYPE, NAME, __VA_ARGS__)
+
+///////// Floating and Complex and 2 other type Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_AND_COMPLEX_AND_2_TYPES( \
+ SPECIFIED_TYPE1, SPECIFIED_TYPE2, TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_COMPLEX_AND_2_TYPES( \
+ SPECIFIED_TYPE1, SPECIFIED_TYPE2, TYPE, NAME, __VA_ARGS__)
+
+///////// Floating, Integral and Complex Dispatch Marco ///////////
+
+#define PD_DISPATCH_FLOATING_AND_INTEGRAL_AND_COMPLEX_TYPES(TYPE, NAME, ...) \
+ PD_VISIT_FLOATING_AND_INTEGRAL_AND_COMPLEX_TYPES(TYPE, NAME, __VA_ARGS__)
+
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/exception.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/exception.h
new file mode 100644
index 0000000000000000000000000000000000000000..92b17b4898d3f7f9af26a0ba7172fc1a1ad36fe1
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/exception.h
@@ -0,0 +1,99 @@
+/* Copyright (c) 2021 PaddlePaddle 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. */
+
+#pragma once
+
+#include
+#include
+#include
+
+namespace paddle {
+
+//////////////// Exception handling and Error Message /////////////////
+#if !defined(_WIN32)
+#define PD_UNLIKELY(expr) (__builtin_expect(static_cast(expr), 0))
+#define PD_LIKELY(expr) (__builtin_expect(static_cast(expr), 1))
+#else
+#define PD_UNLIKELY(expr) (expr)
+#define PD_LIKELY(expr) (expr)
+#endif
+
+struct PD_Exception : public std::exception {
+ public:
+ template
+ explicit PD_Exception(const std::string& msg,
+ const char* file,
+ int line,
+ const char* default_msg) {
+ std::ostringstream sout;
+ if (msg.empty()) {
+ sout << default_msg << "\n [" << file << ":" << line << "]";
+ } else {
+ sout << msg << "\n [" << file << ":" << line << "]";
+ }
+ err_msg_ = sout.str();
+ }
+
+ const char* what() const noexcept override { return err_msg_.c_str(); }
+
+ private:
+ std::string err_msg_;
+};
+
+class ErrorMessage {
+ public:
+ template
+ explicit ErrorMessage(const Args&... args) {
+ build_string(args...);
+ }
+
+ void build_string() { oss << ""; }
+
+ template
+ void build_string(const T& t) {
+ oss << t;
+ }
+
+ template
+ void build_string(const T& t, const Args&... args) {
+ build_string(t);
+ build_string(args...);
+ }
+
+ std::string to_string() { return oss.str(); }
+
+ private:
+ std::ostringstream oss;
+};
+
+#define PD_CHECK(COND, ...) \
+ do { \
+ if (PD_UNLIKELY(!(COND))) { \
+ auto __message__ = ::paddle::ErrorMessage(__VA_ARGS__).to_string(); \
+ throw ::paddle::PD_Exception(__message__, \
+ __FILE__, \
+ __LINE__, \
+ "Expected " #COND \
+ ", but it's not satisfied."); \
+ } \
+ } while (0)
+
+#define PD_THROW(...) \
+ do { \
+ auto __message__ = ::paddle::ErrorMessage(__VA_ARGS__).to_string(); \
+ throw ::paddle::PD_Exception( \
+ __message__, __FILE__, __LINE__, "An error occurred."); \
+ } while (0)
+
+} // namespace paddle
diff --git a/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/op_meta_info.h b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/op_meta_info.h
new file mode 100644
index 0000000000000000000000000000000000000000..546b0accf8ba7e41b71f672807257ffa783de0c2
--- /dev/null
+++ b/PaddleOCR_ali1k_det_rec_300epoch_standalone/paddle/include/paddle/phi/api/ext/op_meta_info.h
@@ -0,0 +1,672 @@
+/* Copyright (c) 2021 PaddlePaddle 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. */
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+
+#include "paddle/phi/api/ext/exception.h"
+#include "paddle/phi/api/include/dll_decl.h"
+#include "paddle/phi/api/include/tensor.h"
+#include "paddle/utils/any.h"
+
+/**
+ * Op Meta Info Related Define.
+ *
+ * Used to maintain operator core information.
+ *
+ */
+
+namespace paddle {
+namespace framework {
+class PADDLE_API OpMetaInfoHelper;
+} // namespace framework
+
+using Tensor = paddle::experimental::Tensor;
+
+///////////////// Util Marco Define ////////////////
+
+#define PD_DISABLE_COPY_AND_ASSIGN(classname) \
+ private: \
+ classname(const classname&) = delete; \
+ classname(classname&&) = delete; \
+ classname& operator=(const classname&) = delete; \
+ classname& operator=(classname&&) = delete
+
+#define STATIC_ASSERT_GLOBAL_NAMESPACE(uniq_name, msg) \
+ struct __test_global_namespace_##uniq_name##__ {}; \
+ static_assert(std::is_same<::__test_global_namespace_##uniq_name##__, \
+ __test_global_namespace_##uniq_name##__>::value, \
+ msg)
+
+///////////////// Util Define and Function ////////////////
+
+constexpr char kGradTensorSuffix[] = "@GRAD";
+constexpr char kTensorVectorSuffix[] = "@VECTOR";
+constexpr char kDoubleGradNewOutSuffix[] = "@NEW";
+
+// Used for Construct Grad Tensor name
+inline std::string Grad(const std::string& t_name) {
+ std::string result;
+ result.reserve(t_name.size() + 5U);
+ result += t_name;
+ result += kGradTensorSuffix;
+ return result;
+}
+
+// Used for Construct std::vector name
+inline std::string Vec(const std::string& t_name) {
+ std::string result;
+ result.reserve(t_name.size() + 7U);
+ result += t_name;
+ result += kTensorVectorSuffix;
+ return result;
+}
+
+// Used for Construct double grad output name
+inline std::string New(const std::string& t_name) {
+ std::string result;
+ result.reserve(t_name.size() + 4U);
+ result += t_name;
+ result += kDoubleGradNewOutSuffix;
+ return result;
+}
+
+PADDLE_API void AssignTensorImpl(const Tensor& src, Tensor* dst);
+
+////////////////////// Kernel Context ////////////////////////
+
+class PADDLE_API CustomOpKernelContext {
+ public:
+ CustomOpKernelContext() = default;
+
+ void EmplaceBackInput(Tensor&& input);
+ void EmplaceBackInputs(const std::vector& inputs);
+ void EmplaceBackOutput(Tensor&& output);
+ void EmplaceBackOutputs(const std::vector& outputs);
+ void EmplaceBackAttr(paddle::any attr);
+ void EmplaceBackAttrs(const std::vector& attrs) {
+ attrs_ = std::move(attrs);
+ }
+ const std::pair& InputRangeAt(size_t idx) const;
+ const std::pair& OutputRangeAt(size_t idx) const;
+
+ const Tensor& InputAt(size_t idx) const;
+ std::vector InputsBetween(size_t start, size_t end) const;
+ const std::vector& Attrs() const { return attrs_; }
+ const std::vector>& InputRange() {
+ return input_range_;
+ }
+ const std::vector>& OutputRange() {
+ return output_range_;
+ }
+ Tensor* MutableOutputAt(size_t idx);
+ std::vector MutableOutputBetweeen(size_t start, size_t end);
+ std::vector OutputsBetweeen(size_t start, size_t end);
+ std::vector
+
+ 
+ 
+ 
+
+
+
+
+ 
+ 
+
+ 
+
+ 
+
+
+
+
+
+
+
+