fix bugs imgnet and rec train

ppcls/arch/head/arcmargin.py

@@ -50,6 +50,8 @@ class ArcMargin(nn.Layer):
         weight = paddle.divide(weight, weight_norm)
 
         cos = paddle.matmul(input, weight)
+        if not self.training:
+            return cos
         sin = paddle.sqrt(1.0 - paddle.square(cos) + 1e-6)
         cos_m = math.cos(self.margin)
         sin_m = math.sin(self.margin)

ppcls/configs/Vehicle/ResNet50.yaml

@@ -39,6 +39,9 @@ Loss:
     - TripletLossV2:
         weight: 1.0
         margin: 0.5
+  Eval:
+    - CELoss:
+        weight: 1.0
 
 Optimizer:
   name: Momentum

ppcls/engine/trainer.py

@@ -244,7 +244,10 @@ class Trainer(object):
             batch[0] = paddle.to_tensor(batch[0]).astype("float32")
             batch[1] = paddle.to_tensor(batch[1]).reshape([-1, 1])
             # image input
-            out = self.model(batch[0])
+            if self.is_rec:
+                out = self.model(batch[0], batch[1])
+            else:
+                out = self.model(batch[0])
             # calc build
             if loss_func is not None:
                 loss_dict = loss_func(out, batch[-1])

ppcls/losses/__init__.py

@@ -43,6 +43,6 @@ class CombinedLoss(nn.Layer):
 
 
 def build_loss(config):
-    module_class = CombinedLoss(config)
+    module_class = CombinedLoss(copy.deepcopy(config))
     logger.info("build loss {} success.".format(module_class))
     return module_class

ppcls/losses/celoss.py

@@ -22,6 +22,7 @@ class Loss(object):
     """
     Loss
     """
+
     def __init__(self, class_dim=1000, epsilon=None):
         assert class_dim > 1, "class_dim=%d is not larger than 1" % (class_dim)
         self._class_dim = class_dim
@@ -35,22 +36,26 @@ class Loss(object):
     #do label_smoothing
     def _labelsmoothing(self, target):
         if target.shape[-1] != self._class_dim:
-            one_hot_target = F.one_hot(target, self._class_dim)  #do ont hot(23,34,46)-> 3 * _class_dim
+            one_hot_target = F.one_hot(
+                target,
+                self._class_dim)  #do ont hot(23,34,46)-> 3 * _class_dim
         else:
             one_hot_target = target
 
         #do label_smooth
-        soft_target = F.label_smooth(one_hot_target, epsilon=self._epsilon)   #(1 - epsilon) * input + eposilon / K.
+        soft_target = F.label_smooth(
+            one_hot_target,
+            epsilon=self._epsilon)  #(1 - epsilon) * input + eposilon / K.
         soft_target = paddle.reshape(soft_target, shape=[-1, self._class_dim])
         return soft_target
 
     def _crossentropy(self, input, target, use_pure_fp16=False):
         if self._label_smoothing:
             target = self._labelsmoothing(target)
-            input = -F.log_softmax(input, axis=-1)      #softmax and do log
+            input = -F.log_softmax(input, axis=-1)  #softmax and do log
             cost = paddle.sum(target * input, axis=-1)  #sum  
         else:
-            cost = F.cross_entropy(input=input, label=target) 
+            cost = F.cross_entropy(input=input, label=target)
 
         if use_pure_fp16:
             avg_cost = paddle.sum(cost)
@@ -64,9 +69,10 @@ class Loss(object):
             (target + eps) / (input + eps)) * self._class_dim
         return cost
 
-    def _jsdiv(self, input, target):  #so the input and target is the fc output; no softmax
+    def _jsdiv(self, input,
+               target):  #so the input and target is the fc output; no softmax
         input = F.softmax(input)
-        target = F.softmax(target) 
+        target = F.softmax(target)
 
         #two distribution
         cost = self._kldiv(input, target) + self._kldiv(target, input)
@@ -87,14 +93,19 @@ class CELoss(Loss):
         super(CELoss, self).__init__(class_dim, epsilon)
 
     def __call__(self, input, target, use_pure_fp16=False):
-        logits = input["logits"]
+        if type(input) is dict:
+            logits = input["logits"]
+        else:
+            logits = input
         cost = self._crossentropy(logits, target, use_pure_fp16)
         return {"CELoss": cost}
 
+
 class JSDivLoss(Loss):
     """
     JSDiv loss
     """
+
     def __init__(self, class_dim=1000, epsilon=None):
         super(JSDivLoss, self).__init__(class_dim, epsilon)
 
@@ -112,4 +123,3 @@ class KLDivLoss(paddle.nn.Layer):
             p = paddle.nn.functional.softmax(p)
             q = paddle.nn.functional.softmax(q)
         return -(p * paddle.log(q + 1e-8)).sum(1).mean()
-