# Copyright 2024 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""Silent Check."""
import os
from mindspore.common.tensor import Tensor
from mindspore.common.parameter import Parameter
import mindspore.common.dtype as mstype
from . import operations
from .operations._inner_ops import _MirrorSilentCheck
from .operations import RmsNorm as OriginRmsNorm
from .operations import LayerNorm as OriginLayerNorm
from .primitive import Primitive
NPU_ASD_ENABLE = 'NPU_ASD_ENABLE'
[文档]class ASDBase:
"""
ASDBase is the base class of operator with accuracy-sensitive detection feature in python.
Args:
cls (Primitive): Original operator requiring accuracy-sensitive detection feature.
args (tuple): A variable parameter tuple to the original operator.
kwargs (dict): A variable parameter dictionary passed the original operator.
Supported Platforms:
``Ascend``
Examples:
>>> from mindspore.ops.silent_check import ASDBase
>>> from mindspore.ops import LayerNorm as OriginLayerNorm
>>> class LayerNormASD(ASDBase):
... def __init__(self, *args, **kwargs):
... super().__init__(OriginLayerNorm, *args, **kwargs)
... # init parameters for accuracy-sensitive detection by calling the base class method generate_params()
... self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
...
... def __call__(self, input_x, gamma, beta):
... if self.enable_check:
... # execute accuracy-sensitive detection by calling the check_op of base class
... input_x = self.check_op(
... input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
... self.cnt += 1
... # return the result of original operator
... return self.op(input_x, gamma, beta)
"""
_index = 0
__ms_class__ = True
def __init__(self, cls, *args, **kwargs):
self.op = cls(*args, **kwargs)
self.check_op = _MirrorSilentCheck()
self._suffix = "ASD_" + cls.__name__
primitive_attr = dir(Primitive)
self._op_attr_dict = {
name for name in primitive_attr if not name.startswith("_")}
self.enable_check = os.environ.get(NPU_ASD_ENABLE) == "1"
def __getattr__(self, name):
def method_wrapper(*args, **kwargs):
out = getattr(self.op, name)(*args, **kwargs)
if out is self.op:
return self
return out
if name in self._op_attr_dict:
if callable(getattr(self.op, name)):
return method_wrapper
if hasattr(self.op, name):
return getattr(self.op, name)
return super().__getattr__(self, name)
def __repr__(self):
return self.op.__repr__()
[文档] def generate_params(self):
"""
Generate support params for accuracy-sensitive detection.
Returns:
tuple consisting of four elements.
The derived class initializes the parameters required for accuracy-sensitive detection by calling
this function.
Examples:
>>> from mindspore.ops.silent_check import ASDBase
>>> from mindspore.ops import LayerNorm as OriginLayerNorm
>>> class LayerNormASD(ASDBase):
... def __init__(self, *args, **kwargs):
... super().__init__(OriginLayerNorm, *args, **kwargs)
... # init parameters for accuracy-sensitive detection by calling the base class function
... self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
"""
pre_val = Parameter(Tensor(0, mstype.float32),
name=f"{self._suffix}_pre_val_{self._index}",
requires_grad=False)
min_val = Parameter(Tensor(0, mstype.float32),
name=f"{self._suffix}_min_val_{self._index}",
requires_grad=False)
max_val = Parameter(Tensor(0, mstype.float32),
name=f"{self._suffix}_max_val_{self._index}",
requires_grad=False)
cnt = Parameter(Tensor(0, mstype.int32),
name=f"{self._suffix}_cnt_{self._index}",
requires_grad=False)
ASDBase._index += 1
return pre_val, min_val, max_val, cnt
class RmsNormASD(ASDBase):
"""
RmsNorm with ASD.
"""
def __init__(self, *args, **kwargs):
super().__init__(OriginRmsNorm, *args, **kwargs)
self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
def __call__(self, input_x, gamma):
if self.enable_check:
input_x = self.check_op(
input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
self.cnt += 1
return self.op(input_x, gamma)
class LayerNormASD(ASDBase):
"""
LayerNorm with ASD.
"""
def __init__(self, *args, **kwargs):
super().__init__(OriginLayerNorm, *args, **kwargs)
self.pre_val, self.min_val, self.max_val, self.cnt = self.generate_params()
def __call__(self, input_x, gamma, beta):
if self.enable_check:
input_x = self.check_op(
input_x, self.pre_val, self.min_val, self.max_val, self.cnt, None)
self.cnt += 1
return self.op(input_x, gamma, beta)
def _silent_check():
if os.environ.get(NPU_ASD_ENABLE) == "1":
operations.LayerNorm = LayerNormASD
operations.RmsNorm = RmsNormASD