修改fastNLP/core/callbacks/callback_event.py默认参数

fastNLP/core/callbacks/callback_event.py

@@ -10,15 +10,15 @@ __all__ = [
 
 def check_legality(fn):
     @wraps(fn)
-    def wrap(every=1, once=None, filter_fn=None):
+    def wrap(every=None, once=None, filter_fn=None):
         if (every is None) and (once is None) and (filter_fn is None):
-            raise ValueError("If you mean your decorated function should be called every time, you do not need this filter.")
+            every = 1
 
         if not ((every is not None) ^ (once is not None) ^ (filter_fn is not None)):
             raise ValueError("These three values should be only set one.")
 
         if (filter_fn is not None) and not callable(filter_fn):
-            raise TypeError("Argument event_filter should be a callable")
+            raise TypeError("Argument filter_fn should be a callable")
 
         if (every is not None) and not (isinstance(every, int) and every > 0):
             raise ValueError("Argument every should be integer and greater than zero")
@@ -33,9 +33,17 @@ class Event:
     every: Optional[int]
     once: Optional[int]
 
-    def __init__(self, value: str, every: Optional[int] = 1, once: Optional[int] = False,
+    def __init__(self, value: str, every: Optional[int] = None, once: Optional[int] = None,
                  filter_fn: Optional[Callable] = None):
+        """
+        请勿直接使用本对象，而是通过调用 Event.on_after_trainer_initialized() 等方式调用。
 
+        :param value: Trainer 的 callback 时机。
+        :param int every: 触发了多少次，才真正运行一次。
+        :param bool once: 是否只在第一次运行后就不再执行了。
+        :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
+            filter.num_executed 两个变了分别获取当前被调用了多少次，真正执行了多少次。trainer 对象即为当前正在运行的 Trainer 。
+        """
         self.every = every
         self.once = once
         self.filter_fn = filter_fn
@@ -46,11 +54,11 @@ class Event:
                                                                                 self.filter_fn)
     @staticmethod
     @check_legality
-    def on_after_trainer_initialized(every=1, once=None, filter_fn=None):
+    def on_after_trainer_initialized(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_after_trainer_initialized 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。默认为
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -61,11 +69,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_sanity_check_begin(every=1, once=None, filter_fn=None):
+    def on_sanity_check_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_sanity_check_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -76,11 +84,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_sanity_check_end(every=1, once=None, filter_fn=None):
+    def on_sanity_check_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_sanity_check_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -91,11 +99,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_begin(every=1, once=None, filter_fn=None):
+    def on_train_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -106,11 +114,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_end(every=1, once=None, filter_fn=None):
+    def on_train_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -121,11 +129,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_epoch_begin(every=1, once=None, filter_fn=None):
+    def on_train_epoch_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_epoch_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -136,11 +144,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_epoch_end(every=1, once=None, filter_fn=None):
+    def on_train_epoch_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_epoch_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -151,11 +159,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_fetch_data_begin(every=1, once=None, filter_fn=None):
+    def on_fetch_data_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_fetch_data_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -166,11 +174,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_fetch_data_end(every=1, once=None, filter_fn=None):
+    def on_fetch_data_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_fetch_data_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -181,11 +189,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_batch_begin(every=1, once=None, filter_fn=None):
+    def on_train_batch_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_batch_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -196,11 +204,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_train_batch_end(every=1, once=None, filter_fn=None):
+    def on_train_batch_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_train_batch_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -211,11 +219,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_exception(every=1, once=None, filter_fn=None):
+    def on_exception(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_exception 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -226,11 +234,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_save_model(every=1, once=None, filter_fn=None):
+    def on_save_model(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_save_model 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -241,11 +249,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_load_model(every=1, once=None, filter_fn=None):
+    def on_load_model(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_load_model 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -256,11 +264,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_save_checkpoint(every=1, once=None, filter_fn=None):
+    def on_save_checkpoint(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_save_checkpoint 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -271,11 +279,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_load_checkpoint(every=1, once=None, filter_fn=None):
+    def on_load_checkpoint(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_load_checkpoint 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -286,11 +294,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_load_checkpoint(every=1, once=None, filter_fn=None):
+    def on_load_checkpoint(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_load_checkpoint 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -301,11 +309,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_before_backward(every=1, once=None, filter_fn=None):
+    def on_before_backward(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_before_backward 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -316,11 +324,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_after_backward(every=1, once=None, filter_fn=None):
+    def on_after_backward(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_after_backward 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -331,11 +339,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_before_optimizers_step(every=1, once=None, filter_fn=None):
+    def on_before_optimizers_step(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_before_optimizers_step 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -346,11 +354,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_after_optimizers_step(every=1, once=None, filter_fn=None):
+    def on_after_optimizers_step(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_after_optimizers_step 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -361,11 +369,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_before_zero_grad(every=1, once=None, filter_fn=None):
+    def on_before_zero_grad(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_before_zero_grad 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -376,11 +384,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_after_zero_grad(every=1, once=None, filter_fn=None):
+    def on_after_zero_grad(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_after_zero_grad 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -391,11 +399,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_evaluate_begin(every=1, once=None, filter_fn=None):
+    def on_evaluate_begin(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_evaluate_begin 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -406,11 +414,11 @@ class Event:
 
     @staticmethod
     @check_legality
-    def on_evaluate_end(every=1, once=None, filter_fn=None):
+    def on_evaluate_end(every=None, once=None, filter_fn=None):
         """
         当 Trainer 运行到 on_evaluate_end 时
 
-        以下三个参数互斥，只能设置其中一个。
+        以下三个参数互斥，只能设置其中一个。默认为行为等同于 every=1 。
         :param int every: 触发了多少次，才真正运行一次。
         :param bool once: 是否只在第一次运行后就不再执行了。
         :param Callable filter_fn: 输入参数的应该为 (filter, trainer)，其中 filter 对象中包含了 filter.num_called 和
@@ -421,7 +429,7 @@ class Event:
 
 
 class Filter:
-    def __init__(self, every: Optional[int] = 1, once: Optional[bool] = False, filter_fn: Optional[Callable] = None):
+    def __init__(self, every: Optional[int] = None, once: Optional[bool] = None, filter_fn: Optional[Callable] = None):
         r"""
         通过该 `Filter` 作为函数修饰器来控制一个函数的实际的运行频率；
 
@@ -432,6 +440,8 @@ class Filter:
         """
         # check legality
         check_legality(lambda *args,**kwargs:...)(every, once, filter_fn)
+        if (every is None) and (once is None) and (filter_fn is None):
+            every = 1
         # 设置变量，包括全局变量；
         self.num_called = 0
         self.num_executed = 0