paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

PaddleClas/ppcls/loss/comfunc.py

@@ -1,45 +0,0 @@
-#   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 absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import numpy as np
-
-
-def rerange_index(batch_size, samples_each_class):
-    tmp = np.arange(0, batch_size * batch_size)
-    tmp = tmp.reshape(-1, batch_size)
-    rerange_index = []
-
-    for i in range(batch_size):
-        step = i // samples_each_class
-        start = step * samples_each_class
-        end = (step + 1) * samples_each_class
-
-        pos_idx = []
-        neg_idx = []
-        for j, k in enumerate(tmp[i]):
-            if j >= start and j < end:
-                if j == i:
-                    pos_idx.insert(0, k)
-                else:
-                    pos_idx.append(k)
-            else:
-                neg_idx.append(k)
-        rerange_index += (pos_idx + neg_idx)
-
-    rerange_index = np.array(rerange_index).astype(np.int32)
-    return rerange_index

PaddleClas/ppcls/loss/deephashloss.py

@@ -1,92 +0,0 @@
-#copyright (c) 2021 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.
-
-import paddle
-import paddle.nn as nn
-
-class DSHSDLoss(nn.Layer):
-    """
-    # DSHSD(IEEE ACCESS 2019)
-    # paper [Deep Supervised Hashing Based on Stable Distribution](https://ieeexplore.ieee.org/document/8648432/)
-    # [DSHSD] epoch:70,  bit:48,  dataset:cifar10-1,  MAP:0.809, Best MAP: 0.809
-    # [DSHSD] epoch:250, bit:48,  dataset:nuswide_21, MAP:0.809, Best MAP: 0.815
-    # [DSHSD] epoch:135, bit:48,  dataset:imagenet,   MAP:0.647, Best MAP: 0.647
-    """
-    def __init__(self, alpha, multi_label=False):
-        super(DSHSDLoss, self).__init__()
-        self.alpha = alpha
-        self.multi_label = multi_label
-
-    def forward(self, input, label):
-        feature = input["features"]
-        logits = input["logits"]
-
-        dist = paddle.sum(paddle.square(
-            (paddle.unsqueeze(feature, 1) - paddle.unsqueeze(feature, 0))),
-                          axis=2)
-
-        # label to ont-hot
-        label = paddle.flatten(label)
-        n_class = logits.shape[1]
-        label = paddle.nn.functional.one_hot(label, n_class).astype("float32")
-
-        s = (paddle.matmul(
-            label, label, transpose_y=True) == 0).astype("float32")
-        margin = 2 * feature.shape[1]
-        Ld = (1 - s) / 2 * dist + s / 2 * (margin - dist).clip(min=0)
-        Ld = Ld.mean()
-
-        if self.multi_label:
-            # multiple labels classification loss
-            Lc = (logits - label * logits + (
-                (1 + (-logits).exp()).log())).sum(axis=1).mean()
-        else:
-            # single labels classification loss
-            Lc = (-paddle.nn.functional.softmax(logits).log() * label).sum(
-                axis=1).mean()
-
-        return {"dshsdloss": Lc + Ld * self.alpha}
-
-
-class LCDSHLoss(nn.Layer):
-    """
-    # paper [Locality-Constrained Deep Supervised Hashing for Image Retrieval](https://www.ijcai.org/Proceedings/2017/0499.pdf)
-    # [LCDSH] epoch:145, bit:48, dataset:cifar10-1,  MAP:0.798, Best MAP: 0.798
-    # [LCDSH] epoch:183, bit:48, dataset:nuswide_21, MAP:0.833, Best MAP: 0.834
-    """
-    def __init__(self, n_class, _lambda):
-        super(LCDSHLoss, self).__init__()
-        self._lambda = _lambda
-        self.n_class = n_class
-
-    def forward(self, input, label):
-        feature = input["features"]
-
-        # label to ont-hot
-        label = paddle.flatten(label)
-        label = paddle.nn.functional.one_hot(label,  self.n_class).astype("float32")
-        
-        s = 2 * (paddle.matmul(label, label, transpose_y=True) > 0).astype("float32") - 1
-        inner_product = paddle.matmul(feature, feature, transpose_y=True) * 0.5
-
-        inner_product = inner_product.clip(min=-50, max=50)
-        L1 = paddle.log(1 + paddle.exp(-s * inner_product)).mean()
-
-        b = feature.sign()
-        inner_product_ = paddle.matmul(b, b, transpose_y=True) * 0.5
-        sigmoid = paddle.nn.Sigmoid()
-        L2 = (sigmoid(inner_product) - sigmoid(inner_product_)).pow(2).mean()
-
-        return {"lcdshloss": L1 + self._lambda * L2}
-

PaddleClas/ppcls/loss/distanceloss.py

@@ -1,43 +0,0 @@
-#copyright (c) 2021 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.
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-from paddle.nn import L1Loss
-from paddle.nn import MSELoss as L2Loss
-from paddle.nn import SmoothL1Loss
-
-
-class DistanceLoss(nn.Layer):
-    """
-    DistanceLoss:
-        mode: loss mode
-    """
-
-    def __init__(self, mode="l2", **kargs):
-        super().__init__()
-        assert mode in ["l1", "l2", "smooth_l1"]
-        if mode == "l1":
-            self.loss_func = nn.L1Loss(**kargs)
-        elif mode == "l2":
-            self.loss_func = nn.MSELoss(**kargs)
-        elif mode == "smooth_l1":
-            self.loss_func = nn.SmoothL1Loss(**kargs)
-        self.mode = mode
-
-    def forward(self, x, y):
-        loss = self.loss_func(x, y)
-        return {"loss_{}".format(self.mode): loss}

PaddleClas/ppcls/loss/distillationloss.py

@@ -1,141 +0,0 @@
-#copyright (c) 2021 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.
-
-import paddle
-import paddle.nn as nn
-
-from .celoss import CELoss
-from .dmlloss import DMLLoss
-from .distanceloss import DistanceLoss
-
-
-class DistillationCELoss(CELoss):
-    """
-    DistillationCELoss
-    """
-
-    def __init__(self,
-                 model_name_pairs=[],
-                 epsilon=None,
-                 key=None,
-                 name="loss_ce"):
-        super().__init__(epsilon=epsilon)
-        assert isinstance(model_name_pairs, list)
-        self.key = key
-        self.model_name_pairs = model_name_pairs
-        self.name = name
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            out1 = predicts[pair[0]]
-            out2 = predicts[pair[1]]
-            if self.key is not None:
-                out1 = out1[self.key]
-                out2 = out2[self.key]
-            loss = super().forward(out1, out2)
-            for key in loss:
-                loss_dict["{}_{}_{}".format(key, pair[0], pair[1])] = loss[key]
-        return loss_dict
-
-
-class DistillationGTCELoss(CELoss):
-    """
-    DistillationGTCELoss
-    """
-
-    def __init__(self,
-                 model_names=[],
-                 epsilon=None,
-                 key=None,
-                 name="loss_gt_ce"):
-        super().__init__(epsilon=epsilon)
-        assert isinstance(model_names, list)
-        self.key = key
-        self.model_names = model_names
-        self.name = name
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, name in enumerate(self.model_names):
-            out = predicts[name]
-            if self.key is not None:
-                out = out[self.key]
-            loss = super().forward(out, batch)
-            for key in loss:
-                loss_dict["{}_{}".format(key, name)] = loss[key]
-        return loss_dict
-
-
-class DistillationDMLLoss(DMLLoss):
-    """
-    """
-
-    def __init__(self,
-                 model_name_pairs=[],
-                 act=None,
-                 key=None,
-                 name="loss_dml"):
-        super().__init__(act=act)
-        assert isinstance(model_name_pairs, list)
-        self.key = key
-        self.model_name_pairs = model_name_pairs
-        self.name = name
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            out1 = predicts[pair[0]]
-            out2 = predicts[pair[1]]
-            if self.key is not None:
-                out1 = out1[self.key]
-                out2 = out2[self.key]
-            loss = super().forward(out1, out2)
-            if isinstance(loss, dict):
-                for key in loss:
-                    loss_dict["{}_{}_{}_{}".format(key, pair[0], pair[1],
-                                                   idx)] = loss[key]
-            else:
-                loss_dict["{}_{}".format(self.name, idx)] = loss
-        return loss_dict
-
-
-class DistillationDistanceLoss(DistanceLoss):
-    """
-    """
-
-    def __init__(self,
-                 mode="l2",
-                 model_name_pairs=[],
-                 key=None,
-                 name="loss_",
-                 **kargs):
-        super().__init__(mode=mode, **kargs)
-        assert isinstance(model_name_pairs, list)
-        self.key = key
-        self.model_name_pairs = model_name_pairs
-        self.name = name + "_l2"
-
-    def forward(self, predicts, batch):
-        loss_dict = dict()
-        for idx, pair in enumerate(self.model_name_pairs):
-            out1 = predicts[pair[0]]
-            out2 = predicts[pair[1]]
-            if self.key is not None:
-                out1 = out1[self.key]
-                out2 = out2[self.key]
-            loss = super().forward(out1, out2)
-            for key in loss:
-                loss_dict["{}_{}_{}".format(self.name, key, idx)] = loss[key]
-        return loss_dict

PaddleClas/ppcls/loss/dmlloss.py

@@ -1,46 +0,0 @@
-# copyright (c) 2021 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.
-
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-
-class DMLLoss(nn.Layer):
-    """
-    DMLLoss
-    """
-
-    def __init__(self, act="softmax"):
-        super().__init__()
-        if act is not None:
-            assert act in ["softmax", "sigmoid"]
-        if act == "softmax":
-            self.act = nn.Softmax(axis=-1)
-        elif act == "sigmoid":
-            self.act = nn.Sigmoid()
-        else:
-            self.act = None
-
-    def forward(self, out1, out2):
-        if self.act is not None:
-            out1 = self.act(out1)
-            out2 = self.act(out2)
-
-        log_out1 = paddle.log(out1)
-        log_out2 = paddle.log(out2)
-        loss = (F.kl_div(
-            log_out1, out2, reduction='batchmean') + F.kl_div(
-                log_out2, out1, reduction='batchmean')) / 2.0
-        return {"DMLLoss": loss}

PaddleClas/ppcls/loss/emlloss.py

@@ -1,97 +0,0 @@
-#   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 absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import math
-import paddle
-import numpy as np
-from .comfunc import rerange_index
-
-
-class EmlLoss(paddle.nn.Layer):
-    def __init__(self, batch_size=40, samples_each_class=2):
-        super(EmlLoss, self).__init__()
-        assert (batch_size % samples_each_class == 0)
-        self.samples_each_class = samples_each_class
-        self.batch_size = batch_size
-        self.rerange_index = rerange_index(batch_size, samples_each_class)
-        self.thresh = 20.0
-        self.beta = 100000
-
-    def surrogate_function(self, beta, theta, bias):
-        x = theta * paddle.exp(bias)
-        output = paddle.log(1 + beta * x) / math.log(1 + beta)
-        return output
-
-    def surrogate_function_approximate(self, beta, theta, bias):
-        output = (
-            paddle.log(theta) + bias + math.log(beta)) / math.log(1 + beta)
-        return output
-
-    def surrogate_function_stable(self, beta, theta, target, thresh):
-        max_gap = paddle.to_tensor(thresh, dtype='float32')
-        max_gap.stop_gradient = True
-
-        target_max = paddle.maximum(target, max_gap)
-        target_min = paddle.minimum(target, max_gap)
-
-        loss1 = self.surrogate_function(beta, theta, target_min)
-        loss2 = self.surrogate_function_approximate(beta, theta, target_max)
-        bias = self.surrogate_function(beta, theta, max_gap)
-        loss = loss1 + loss2 - bias
-        return loss
-
-    def forward(self, input, target=None):
-        features = input["features"]
-        samples_each_class = self.samples_each_class
-        batch_size = self.batch_size
-        rerange_index = self.rerange_index
-
-        #calc distance
-        diffs = paddle.unsqueeze(
-            features, axis=1) - paddle.unsqueeze(
-                features, axis=0)
-        similary_matrix = paddle.sum(paddle.square(diffs), axis=-1)
-
-        tmp = paddle.reshape(similary_matrix, shape=[-1, 1])
-        rerange_index = paddle.to_tensor(rerange_index)
-        tmp = paddle.gather(tmp, index=rerange_index)
-        similary_matrix = paddle.reshape(tmp, shape=[-1, batch_size])
-
-        ignore, pos, neg = paddle.split(
-            similary_matrix,
-            num_or_sections=[
-                1, samples_each_class - 1, batch_size - samples_each_class
-            ],
-            axis=1)
-        ignore.stop_gradient = True
-
-        pos_max = paddle.max(pos, axis=1, keepdim=True)
-        pos = paddle.exp(pos - pos_max)
-        pos_mean = paddle.mean(pos, axis=1, keepdim=True)
-
-        neg_min = paddle.min(neg, axis=1, keepdim=True)
-        neg = paddle.exp(neg_min - neg)
-        neg_mean = paddle.mean(neg, axis=1, keepdim=True)
-
-        bias = pos_max - neg_min
-        theta = paddle.multiply(neg_mean, pos_mean)
-
-        loss = self.surrogate_function_stable(self.beta, theta, bias,
-                                              self.thresh)
-        loss = paddle.mean(loss)
-        return {"emlloss": loss}

PaddleClas/ppcls/loss/googlenetloss.py

@@ -1,41 +0,0 @@
-# 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 paddle.nn as nn
-import paddle.nn.functional as F
-
-
-class GoogLeNetLoss(nn.Layer):
-    """
-    Cross entropy loss used after googlenet
-    """
-    def __init__(self, epsilon=None):
-        super().__init__()
-        assert (epsilon is None or epsilon <= 0 or epsilon >= 1), "googlenet is not support label_smooth"
-            
-
-    def forward(self, inputs, label):
-        input0, input1, input2 = inputs
-        if isinstance(input0, dict):
-            input0 = input0["logits"]
-        if isinstance(input1, dict):
-            input1 = input1["logits"]
-        if isinstance(input2, dict):
-            input2 = input2["logits"]
-
-        loss0 = F.cross_entropy(input0, label=label, soft_label=False)
-        loss1 = F.cross_entropy(input1, label=label, soft_label=False)
-        loss2 = F.cross_entropy(input2, label=label, soft_label=False)
-        loss = loss0 + 0.3 * loss1 + 0.3 * loss2
-        loss = loss.mean()
-        return {"GooleNetLoss": loss}

PaddleClas/ppcls/loss/msmloss.py

@@ -1,78 +0,0 @@
-#   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 absolute_import
-from __future__ import division
-from __future__ import print_function
-import paddle
-from .comfunc import rerange_index
-
-
-class MSMLoss(paddle.nn.Layer):
-    """
-    MSMLoss Loss, based on triplet loss. USE P * K samples.
-    the batch size is fixed. Batch_size = P * K;  but the K may vary between batches.
-    same label gather together
-    
-            supported_metrics = [
-            'euclidean',
-            'sqeuclidean',
-            'cityblock',
-        ]
-    only consider samples_each_class = 2
-    """
-
-    def __init__(self, batch_size=120, samples_each_class=2, margin=0.1):
-        super(MSMLoss, self).__init__()
-        self.margin = margin
-        self.samples_each_class = samples_each_class
-        self.batch_size = batch_size
-        self.rerange_index = rerange_index(batch_size, samples_each_class)
-
-    def forward(self, input, target=None):
-        #normalization 
-        features = input["features"]
-        features = self._nomalize(features)
-        samples_each_class = self.samples_each_class
-        rerange_index = paddle.to_tensor(self.rerange_index)
-
-        #calc sm
-        diffs = paddle.unsqueeze(
-            features, axis=1) - paddle.unsqueeze(
-                features, axis=0)
-        similary_matrix = paddle.sum(paddle.square(diffs), axis=-1)
-
-        #rerange 
-        tmp = paddle.reshape(similary_matrix, shape=[-1, 1])
-        tmp = paddle.gather(tmp, index=rerange_index)
-        similary_matrix = paddle.reshape(tmp, shape=[-1, self.batch_size])
-
-        #split
-        ignore, pos, neg = paddle.split(
-            similary_matrix,
-            num_or_sections=[1, samples_each_class - 1, -1],
-            axis=1)
-        ignore.stop_gradient = True
-
-        hard_pos = paddle.max(pos)
-        hard_neg = paddle.min(neg)
-
-        loss = hard_pos + self.margin - hard_neg
-        loss = paddle.nn.ReLU()(loss)
-        return {"msmloss": loss}
-
-    def _nomalize(self, input):
-        input_norm = paddle.sqrt(
-            paddle.sum(paddle.square(input), axis=1, keepdim=True))
-        return paddle.divide(input, input_norm)

PaddleClas/ppcls/loss/multilabelloss.py

@@ -1,43 +0,0 @@
-import paddle
-import paddle.nn as nn
-import paddle.nn.functional as F
-
-
-class MultiLabelLoss(nn.Layer):
-    """
-    Multi-label loss
-    """
-
-    def __init__(self, epsilon=None):
-        super().__init__()
-        if epsilon is not None and (epsilon <= 0 or epsilon >= 1):
-            epsilon = None
-        self.epsilon = epsilon
-
-    def _labelsmoothing(self, target, class_num):
-        if target.ndim == 1 or target.shape[-1] != class_num:
-            one_hot_target = F.one_hot(target, class_num)
-        else:
-            one_hot_target = target
-        soft_target = F.label_smooth(one_hot_target, epsilon=self.epsilon)
-        soft_target = paddle.reshape(soft_target, shape=[-1, class_num])
-        return soft_target
-
-    def _binary_crossentropy(self, input, target, class_num):
-        if self.epsilon is not None:
-            target = self._labelsmoothing(target, class_num)
-            cost = F.binary_cross_entropy_with_logits(
-                logit=input, label=target)
-        else:
-            cost = F.binary_cross_entropy_with_logits(
-                logit=input, label=target)
-
-        return cost
-
-    def forward(self, x, target):
-        if isinstance(x, dict):
-            x = x["logits"]
-        class_num = x.shape[-1]
-        loss = self._binary_crossentropy(x, target, class_num)
-        loss = loss.mean()
-        return {"MultiLabelLoss": loss}

PaddleClas/ppcls/loss/npairsloss.py

@@ -1,38 +0,0 @@
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-import paddle
-
-
-class NpairsLoss(paddle.nn.Layer):
-    def __init__(self, reg_lambda=0.01):
-        super(NpairsLoss, self).__init__()
-        self.reg_lambda = reg_lambda
-
-    def forward(self, input, target=None):
-        """
-        anchor and positive(should include label)
-        """
-        features = input["features"]
-        reg_lambda = self.reg_lambda
-        batch_size = features.shape[0]
-        fea_dim = features.shape[1]
-        num_class = batch_size // 2
-
-        #reshape
-        out_feas = paddle.reshape(features, shape=[-1, 2, fea_dim])
-        anc_feas, pos_feas = paddle.split(out_feas, num_or_sections=2, axis=1)
-        anc_feas = paddle.squeeze(anc_feas, axis=1)
-        pos_feas = paddle.squeeze(pos_feas, axis=1)
-
-        #get simi matrix
-        similarity_matrix = paddle.matmul(
-            anc_feas, pos_feas, transpose_y=True)  #get similarity matrix
-        sparse_labels = paddle.arange(0, num_class, dtype='int64')
-        xentloss = paddle.nn.CrossEntropyLoss()(
-            similarity_matrix, sparse_labels)  #by default: mean
-
-        #l2 norm
-        reg = paddle.mean(paddle.sum(paddle.square(features), axis=1))
-        l2loss = 0.5 * reg_lambda * reg
-        return {"npairsloss": xentloss + l2loss}