openocr-python 0.0.2__py3-none-any.whl

openocr/openrec/metrics/__init__.py

@@ -0,0 +1,19 @@
+import copy
+
+__all__ = ['build_metric']
+
+from .rec_metric import RecMetric
+from .rec_metric_gtc import RecGTCMetric
+from .rec_metric_long import RecMetricLong
+from .rec_metric_mgp import RecMPGMetric
+
+support_dict = ['RecMetric', 'RecMetricLong', 'RecGTCMetric', 'RecMPGMetric']
+
+
+def build_metric(config):
+    config = copy.deepcopy(config)
+    module_name = config.pop('name')
+    assert module_name in support_dict, Exception(
+        'metric only support {}'.format(support_dict))
+    module_class = eval(module_name)(**config)
+    return module_class

openocr/openrec/metrics/rec_metric.py

@@ -0,0 +1,270 @@
+import string
+import numpy as np
+from rapidfuzz.distance import Levenshtein
+
+
+def match_ss(ss1, ss2):
+    s1_len = len(ss1)
+    for c_i in range(s1_len):
+        if ss1[c_i:] == ss2[:s1_len - c_i]:
+            return ss2[s1_len - c_i:]
+    return ss2
+
+
+def stream_match(text):
+    bs = len(text)
+    s_list = []
+    conf_list = []
+    for s_conf in text:
+        s_list.append(s_conf[0])
+        conf_list.append(s_conf[1])
+    s_n = bs
+    s_start = s_list[0][:-1]
+    s_new = s_start
+    for s_i in range(1, s_n):
+        s_start = match_ss(
+            s_start, s_list[s_i][1:-1] if s_i < s_n - 1 else s_list[s_i][1:])
+        s_new += s_start
+    return s_new, sum(conf_list) / bs
+
+
+class RecMetric(object):
+
+    def __init__(self,
+                 main_indicator='acc',
+                 is_filter=False,
+                 is_lower=True,
+                 ignore_space=True,
+                 stream=False,
+                 with_ratio=False,
+                 max_len=25,
+                 max_ratio=4,
+                 **kwargs):
+        self.main_indicator = main_indicator
+        self.is_filter = is_filter
+        self.is_lower = is_lower
+        self.ignore_space = ignore_space
+        self.stream = stream
+        self.eps = 1e-5
+        self.with_ratio = with_ratio
+        self.max_len = max_len
+        self.max_ratio = max_ratio
+        self.reset()
+
+    def _normalize_text(self, text):
+        text = ''.join(
+            filter(lambda x: x in (string.digits + string.ascii_letters),
+                   text))
+        return text
+
+    def __call__(self,
+                 pred_label,
+                 batch=None,
+                 training=False,
+                 *args,
+                 **kwargs):
+        if self.with_ratio and not training:
+            return self.eval_all_metric(pred_label, batch)
+        else:
+            return self.eval_metric(pred_label)
+
+    def eval_metric(self, pred_label, *args, **kwargs):
+        preds, labels = pred_label
+        correct_num = 0
+        all_num = 0
+        norm_edit_dis = 0.0
+        for (pred, pred_conf), (target, _) in zip(preds, labels):
+            if self.stream:
+                assert len(labels) == 1
+                pred, _ = stream_match(preds)
+            if self.ignore_space:
+                pred = pred.replace(' ', '')
+                target = target.replace(' ', '')
+            if self.is_filter:
+                pred = self._normalize_text(pred)
+                target = self._normalize_text(target)
+            if self.is_lower:
+                pred = pred.lower()
+                target = target.lower()
+            norm_edit_dis += Levenshtein.normalized_distance(pred, target)
+            if pred == target:
+                correct_num += 1
+            all_num += 1
+        self.correct_num += correct_num
+        self.all_num += all_num
+        self.norm_edit_dis += norm_edit_dis
+        return {
+            'acc': correct_num / (all_num + self.eps),
+            'norm_edit_dis': 1 - norm_edit_dis / (all_num + self.eps),
+        }
+
+    def eval_all_metric(self, pred_label, batch=None, *args, **kwargs):
+        if self.with_ratio:
+            ratio = batch[-1]
+        preds, labels = pred_label
+        correct_num = 0
+        correct_num_real = 0
+        correct_num_lower = 0
+        correct_num_ignore_space = 0
+        correct_num_ignore_space_lower = 0
+        correct_num_ignore_space_symbol = 0
+        all_num = 0
+        norm_edit_dis = 0.0
+        each_len_num = [0 for _ in range(self.max_len)]
+        each_len_correct_num = [0 for _ in range(self.max_len)]
+        each_len_norm_edit_dis = [0 for _ in range(self.max_len)]
+        each_ratio_num = [0 for _ in range(self.max_ratio)]
+        each_ratio_correct_num = [0 for _ in range(self.max_ratio)]
+        each_ratio_norm_edit_dis = [0 for _ in range(self.max_ratio)]
+        for (pred, pred_conf), (target, _) in zip(preds, labels):
+            if self.stream:
+                assert len(labels) == 1
+                pred, _ = stream_match(preds)
+            if pred == target:
+                correct_num_real += 1
+
+            if pred.lower() == target.lower():
+                correct_num_lower += 1
+
+            if self.ignore_space:
+                pred = pred.replace(' ', '')
+                target = target.replace(' ', '')
+            if pred == target:
+                correct_num_ignore_space += 1
+
+            if pred.lower() == target.lower():
+                correct_num_ignore_space_lower += 1
+
+            if self.is_filter:
+                pred = self._normalize_text(pred)
+                target = self._normalize_text(target)
+            if pred == target:
+                correct_num_ignore_space_symbol += 1
+
+            if self.is_lower:
+                pred = pred.lower()
+                target = target.lower()
+            dis = Levenshtein.normalized_distance(pred, target)
+            norm_edit_dis += dis
+            ratio_i = ratio[all_num] - 1 if ratio[
+                all_num] < self.max_ratio else self.max_ratio - 1
+            len_i = max(0, min(self.max_len, len(target)) - 1)
+            if pred == target:
+                correct_num += 1
+                each_len_correct_num[len_i] += 1
+                each_ratio_correct_num[ratio_i] += 1
+            each_len_num[len_i] += 1
+            each_len_norm_edit_dis[len_i] += dis
+
+            each_ratio_num[ratio_i] += 1
+            each_ratio_norm_edit_dis[ratio_i] += dis
+            all_num += 1
+        self.correct_num += correct_num
+        self.correct_num_real += correct_num_real
+        self.correct_num_lower += correct_num_lower
+        self.correct_num_ignore_space += correct_num_ignore_space
+        self.correct_num_ignore_space_lower += correct_num_ignore_space_lower
+        self.correct_num_ignore_space_symbol += correct_num_ignore_space_symbol
+        self.all_num += all_num
+        self.norm_edit_dis += norm_edit_dis
+        self.each_len_num = self.each_len_num + np.array(each_len_num)
+        self.each_len_correct_num = self.each_len_correct_num + np.array(
+            each_len_correct_num)
+        self.each_len_norm_edit_dis = self.each_len_norm_edit_dis + np.array(
+            each_len_norm_edit_dis)
+        self.each_ratio_num = self.each_ratio_num + np.array(each_ratio_num)
+        self.each_ratio_correct_num = self.each_ratio_correct_num + np.array(
+            each_ratio_correct_num)
+        self.each_ratio_norm_edit_dis = self.each_ratio_norm_edit_dis + np.array(
+            each_ratio_norm_edit_dis)
+        return {
+            'acc': correct_num / (all_num + self.eps),
+            'norm_edit_dis': 1 - norm_edit_dis / (all_num + self.eps),
+        }
+
+    def get_metric(self, training=False):
+        """
+        return metrics {
+                 'acc': 0,
+                 'norm_edit_dis': 0,
+            }
+        """
+        if self.with_ratio and not training:
+            return self.get_all_metric()
+        acc = 1.0 * self.correct_num / (self.all_num + self.eps)
+        norm_edit_dis = 1 - self.norm_edit_dis / (self.all_num + self.eps)
+        num_samples = self.all_num
+        self.reset()
+        return {
+            'acc': acc,
+            'norm_edit_dis': norm_edit_dis,
+            'num_samples': num_samples
+        }
+
+    def get_all_metric(self):
+        """
+        return metrics {
+                 'acc': 0,
+                 'norm_edit_dis': 0,
+            }
+        """
+        acc = 1.0 * self.correct_num / (self.all_num + self.eps)
+        acc_real = 1.0 * self.correct_num_real / (self.all_num + self.eps)
+        acc_lower = 1.0 * self.correct_num_lower / (self.all_num + self.eps)
+        acc_ignore_space = 1.0 * self.correct_num_ignore_space / (
+            self.all_num + self.eps)
+        acc_ignore_space_lower = 1.0 * self.correct_num_ignore_space_lower / (
+            self.all_num + self.eps)
+        acc_ignore_space_symbol = 1.0 * self.correct_num_ignore_space_symbol / (
+            self.all_num + self.eps)
+
+        norm_edit_dis = 1 - self.norm_edit_dis / (self.all_num + self.eps)
+        num_samples = self.all_num
+        each_len_acc = (self.each_len_correct_num /
+                        (self.each_len_num + self.eps)).tolist()
+        each_len_norm_edit_dis = (1 -
+                                  ((self.each_len_norm_edit_dis) /
+                                   ((self.each_len_num) + self.eps))).tolist()
+        each_len_num = self.each_len_num.tolist()
+        each_ratio_acc = (self.each_ratio_correct_num /
+                          (self.each_ratio_num + self.eps)).tolist()
+        each_ratio_norm_edit_dis = (1 - ((self.each_ratio_norm_edit_dis) / (
+            (self.each_ratio_num) + self.eps))).tolist()
+        each_ratio_num = self.each_ratio_num.tolist()
+        self.reset()
+        return {
+            'acc': acc,
+            'acc_real': acc_real,
+            'acc_lower': acc_lower,
+            'acc_ignore_space': acc_ignore_space,
+            'acc_ignore_space_lower': acc_ignore_space_lower,
+            'acc_ignore_space_symbol': acc_ignore_space_symbol,
+            'acc_ignore_space_lower_symbol': acc,
+            'each_len_num': each_len_num,
+            'each_len_acc': each_len_acc,
+            'each_len_norm_edit_dis': each_len_norm_edit_dis,
+            'each_ratio_num': each_ratio_num,
+            'each_ratio_acc': each_ratio_acc,
+            'each_ratio_norm_edit_dis': each_ratio_norm_edit_dis,
+            'norm_edit_dis': norm_edit_dis,
+            'num_samples': num_samples
+        }
+
+    def reset(self):
+        self.correct_num = 0
+        self.all_num = 0
+        self.norm_edit_dis = 0
+        self.correct_num_real = 0
+        self.correct_num_lower = 0
+        self.correct_num_ignore_space = 0
+        self.correct_num_ignore_space_lower = 0
+        self.correct_num_ignore_space_symbol = 0
+        self.each_len_num = np.array([0 for _ in range(self.max_len)])
+        self.each_len_correct_num = np.array([0 for _ in range(self.max_len)])
+        self.each_len_norm_edit_dis = np.array(
+            [0. for _ in range(self.max_len)])
+        self.each_ratio_num = np.array([0 for _ in range(self.max_ratio)])
+        self.each_ratio_correct_num = np.array(
+            [0 for _ in range(self.max_ratio)])
+        self.each_ratio_norm_edit_dis = np.array(
+            [0. for _ in range(self.max_ratio)])

openocr/openrec/metrics/rec_metric_gtc.py

@@ -0,0 +1,58 @@
+from .rec_metric import RecMetric
+
+
+class RecGTCMetric(object):
+
+    def __init__(self,
+                 main_indicator='acc',
+                 is_filter=False,
+                 ignore_space=True,
+                 stream=False,
+                 with_ratio=False,
+                 max_len=25,
+                 max_ratio=4,
+                 **kwargs):
+        self.main_indicator = main_indicator
+        self.is_filter = is_filter
+        self.ignore_space = ignore_space
+        self.eps = 1e-5
+        self.gtc_metric = RecMetric(main_indicator=main_indicator,
+                                    is_filter=is_filter,
+                                    ignore_space=ignore_space,
+                                    stream=stream,
+                                    with_ratio=with_ratio,
+                                    max_len=max_len,
+                                    max_ratio=max_ratio)
+        self.ctc_metric = RecMetric(main_indicator=main_indicator,
+                                    is_filter=is_filter,
+                                    ignore_space=ignore_space,
+                                    stream=stream,
+                                    with_ratio=with_ratio,
+                                    max_len=max_len,
+                                    max_ratio=max_ratio)
+
+    def __call__(self,
+                 pred_label,
+                 batch=None,
+                 training=False,
+                 *args,
+                 **kwargs):
+
+        ctc_metric = self.ctc_metric(pred_label[1], batch, training=training)
+        gtc_metric = self.gtc_metric(pred_label[0], batch, training=training)
+        ctc_metric['gtc_acc'] = gtc_metric['acc']
+        ctc_metric['gtc_norm_edit_dis'] = gtc_metric['norm_edit_dis']
+        return ctc_metric
+
+    def get_metric(self):
+        """
+        return metrics {
+                 'acc': 0,
+                 'norm_edit_dis': 0,
+            }
+        """
+        ctc_metric = self.ctc_metric.get_metric()
+        gtc_metric = self.gtc_metric.get_metric()
+        ctc_metric['gtc_acc'] = gtc_metric['acc']
+        ctc_metric['gtc_norm_edit_dis'] = gtc_metric['norm_edit_dis']
+        return ctc_metric

openocr/openrec/metrics/rec_metric_long.py

@@ -0,0 +1,142 @@
+import string
+
+import numpy as np
+from rapidfuzz.distance import Levenshtein
+
+from .rec_metric import stream_match
+
+# f_pred = open('pred_focal_subs_rand1_h2_bi_first.txt', 'w')
+
+
+class RecMetricLong(object):
+
+    def __init__(self,
+                 main_indicator='acc',
+                 is_filter=False,
+                 ignore_space=True,
+                 stream=False,
+                 **kwargs):
+        self.main_indicator = main_indicator
+        self.is_filter = is_filter
+        self.ignore_space = ignore_space
+        self.stream = stream
+        self.eps = 1e-5
+        self.max_len = 201
+        self.reset()
+
+    def _normalize_text(self, text):
+        text = ''.join(
+            filter(lambda x: x in (string.digits + string.ascii_letters),
+                   text))
+        return text.lower()
+
+    def __call__(self, pred_label, *args, **kwargs):
+        preds, labels = pred_label
+        correct_num = 0
+        correct_num_slice = 0
+        f_l_acc = 0
+        all_num = 0
+        norm_edit_dis = 0.0
+        len_acc = 0
+        each_len_num = [0 for _ in range(self.max_len)]
+        each_len_correct_num = [0 for _ in range(self.max_len)]
+        each_len_norm_edit_dis = [0 for _ in range(self.max_len)]
+        for (pred, pred_conf), (target, _) in zip(preds, labels):
+            if self.stream:
+                assert len(labels) == 1
+                pred, _ = stream_match(preds)
+            if self.ignore_space:
+                pred = pred.replace(' ', '')
+                target = target.replace(' ', '')
+            if self.is_filter:
+                pred = self._normalize_text(pred)
+                target = self._normalize_text(target)
+            dis = Levenshtein.normalized_distance(pred, target)
+            norm_edit_dis += dis
+            # print(pred, target)
+            if pred == target:
+                correct_num += 1
+                each_len_correct_num[len(target)] += 1
+            each_len_num[len(target)] += 1
+            each_len_norm_edit_dis[len(target)] += dis
+            #     f_pred.write(pred+'\t'+target+'\t1'+'\n')
+            #     print(pred, target, 1)
+            # else:
+            #     f_pred.write(pred+'\t'+target+'\t0'+'\n')
+            #     print(pred, target, 0)
+            if len(pred) >= 1 and len(target) >= 1:
+                if pred[0] == target[0] and pred[-1] == target[-1]:
+                    f_l_acc += 1
+            if len(pred) == len(target):
+                len_acc += 1
+            if pred == target[:len(pred)]:
+                # if pred == target[-len(pred):]:
+                correct_num_slice += 1
+            all_num += 1
+        self.correct_num += correct_num
+        self.correct_num_slice += correct_num_slice
+        self.f_l_acc += f_l_acc
+        self.all_num += all_num
+        self.len_acc += len_acc
+        self.each_len_num = self.each_len_num + np.array(each_len_num)
+        self.each_len_correct_num = self.each_len_correct_num + np.array(
+            each_len_correct_num)
+        self.each_len_norm_edit_dis = self.each_len_norm_edit_dis + np.array(
+            each_len_norm_edit_dis)
+        self.norm_edit_dis += norm_edit_dis
+        return {
+            'acc': correct_num / (all_num + self.eps),
+            'norm_edit_dis': 1 - norm_edit_dis / (all_num + self.eps),
+        }
+
+    def get_metric(self):
+        """
+        return metrics {
+                 'acc': 0,
+                 'norm_edit_dis': 0,
+            }
+        """
+        acc = 1.0 * self.correct_num / (self.all_num + self.eps)
+        acc_slice = 1.0 * self.correct_num_slice / (self.all_num + self.eps)
+        f_l_acc = 1.0 * self.f_l_acc / (self.all_num + self.eps)
+        len_acc = 1.0 * self.len_acc / (self.all_num + self.eps)
+        norm_edit_dis = 1 - self.norm_edit_dis / (self.all_num + self.eps)
+        each_len_acc = (self.each_len_correct_num /
+                        (self.each_len_num + self.eps)).tolist()
+        # each_len_acc_25 = each_len_acc[:26]
+        # each_len_acc_26 = each_len_acc[26:]
+        each_len_norm_edit_dis = (1 -
+                                  ((self.each_len_norm_edit_dis) /
+                                   ((self.each_len_num) + self.eps))).tolist()
+        # each_len_norm_edit_dis_25 = each_len_norm_edit_dis[:26]
+        # each_len_norm_edit_dis_26 = each_len_norm_edit_dis[26:]
+        each_len_num = self.each_len_num.tolist()
+        all_num = self.all_num
+        self.reset()
+        return {
+            'acc': acc,
+            'norm_edit_dis': norm_edit_dis,
+            'acc_slice': acc_slice,
+            'f_l_acc': f_l_acc,
+            'len_acc': len_acc,
+            'each_len_num': each_len_num,
+            'each_len_acc': each_len_acc,
+            # "each_len_acc_25": each_len_acc_25,
+            # "each_len_acc_26": each_len_acc_26,
+            'each_len_norm_edit_dis': each_len_norm_edit_dis,
+            # "each_len_norm_edit_dis_25":each_len_norm_edit_dis_25,
+            # "each_len_norm_edit_dis_26":each_len_norm_edit_dis_26,
+            'all_num': all_num
+        }
+
+    def reset(self):
+        self.correct_num = 0
+        self.all_num = 0
+        self.norm_edit_dis = 0
+        self.correct_num_slice = 0
+        self.each_len_num = np.array([0 for _ in range(self.max_len)])
+        self.each_len_correct_num = np.array([0 for _ in range(self.max_len)])
+        self.each_len_norm_edit_dis = np.array(
+            [0. for _ in range(self.max_len)])
+        self.f_l_acc = 0
+        self.len_acc = 0

openocr/openrec/metrics/rec_metric_mgp.py

@@ -0,0 +1,93 @@
+from .rec_metric import RecMetric
+
+
+class RecMPGMetric(object):
+
+    def __init__(self,
+                 main_indicator='acc',
+                 is_filter=False,
+                 ignore_space=True,
+                 stream=False,
+                 with_ratio=False,
+                 max_len=25,
+                 max_ratio=4,
+                 **kwargs):
+        self.main_indicator = main_indicator
+        self.is_filter = is_filter
+        self.ignore_space = ignore_space
+        self.eps = 1e-5
+        self.char_metric = RecMetric(main_indicator=main_indicator,
+                                     is_filter=is_filter,
+                                     ignore_space=ignore_space,
+                                     stream=stream,
+                                     with_ratio=with_ratio,
+                                     max_len=max_len,
+                                     max_ratio=max_ratio)
+        self.bpe_metric = RecMetric(main_indicator=main_indicator,
+                                    is_filter=is_filter,
+                                    ignore_space=ignore_space,
+                                    stream=stream,
+                                    with_ratio=with_ratio,
+                                    max_len=max_len,
+                                    max_ratio=max_ratio)
+
+        self.wp_metric = RecMetric(main_indicator=main_indicator,
+                                   is_filter=is_filter,
+                                   ignore_space=ignore_space,
+                                   stream=stream,
+                                   with_ratio=with_ratio,
+                                   max_len=max_len,
+                                   max_ratio=max_ratio)
+        self.final_metric = RecMetric(main_indicator=main_indicator,
+                                      is_filter=is_filter,
+                                      ignore_space=ignore_space,
+                                      stream=stream,
+                                      with_ratio=with_ratio,
+                                      max_len=max_len,
+                                      max_ratio=max_ratio)
+
+    def __call__(self,
+                 pred_label,
+                 batch=None,
+                 training=False,
+                 *args,
+                 **kwargs):
+
+        char_metric = self.char_metric((pred_label[0], pred_label[-1]),
+                                       batch,
+                                       training=training)
+        bpe_metric = self.bpe_metric((pred_label[1], pred_label[-1]),
+                                     batch,
+                                     training=training)
+        wp_metric = self.wp_metric((pred_label[2], pred_label[-1]),
+                                   batch,
+                                   training=training)
+        final_metric = self.final_metric((pred_label[3], pred_label[-1]),
+                                         batch,
+                                         training=training)
+        final_metric['char_acc'] = char_metric['acc']
+        final_metric['char_norm_edit_dis'] = char_metric['norm_edit_dis']
+        final_metric['bpe_acc'] = bpe_metric['acc']
+        final_metric['bpe_norm_edit_dis'] = bpe_metric['norm_edit_dis']
+        final_metric['wp_acc'] = wp_metric['acc']
+        final_metric['wp_norm_edit_dis'] = wp_metric['norm_edit_dis']
+        return final_metric
+
+    def get_metric(self):
+        """
+        return metrics {
+                 'acc': 0,
+                 'norm_edit_dis': 0,
+            }
+        """
+        char_metric = self.char_metric.get_metric()
+        bpe_metric = self.bpe_metric.get_metric()
+        wp_metric = self.wp_metric.get_metric()
+        final_metric = self.final_metric.get_metric()
+        final_metric['char_acc'] = char_metric['acc']
+        final_metric['char_norm_edit_dis'] = char_metric['norm_edit_dis']
+        final_metric['bpe_acc'] = bpe_metric['acc']
+        final_metric['bpe_norm_edit_dis'] = bpe_metric['norm_edit_dis']
+        final_metric['wp_acc'] = wp_metric['acc']
+        final_metric['wp_norm_edit_dis'] = wp_metric['norm_edit_dis']
+        return final_metric

openocr/openrec/modeling/__init__.py

@@ -0,0 +1,11 @@
+import copy
+
+from .base_recognizer import BaseRecognizer
+
+__all__ = ['build_model']
+
+
+def build_model(config):
+    config = copy.deepcopy(config)
+    rec_model = BaseRecognizer(config)
+    return rec_model

openocr/openrec/modeling/base_recognizer.py

@@ -0,0 +1,69 @@
+import torch
+from torch import nn
+
+from openrec.modeling.decoders import build_decoder
+from openrec.modeling.encoders import build_encoder
+from openrec.modeling.transforms import build_transform
+
+__all__ = ['BaseRecognizer']
+
+
+class BaseRecognizer(nn.Module):
+
+    def __init__(self, config):
+        """the module for OCR.
+
+        args:
+            config (dict): the super parameters for module.
+        """
+        super(BaseRecognizer, self).__init__()
+        in_channels = config.get('in_channels', 3)
+        self.use_wd = config.get('use_wd', True)
+        # build transfrom,
+        # for rec, transfrom can be TPS,None
+        if 'Transform' not in config or config['Transform'] is None:
+            self.use_transform = False
+        else:
+            self.use_transform = True
+            config['Transform']['in_channels'] = in_channels
+            self.transform = build_transform(config['Transform'])
+            in_channels = self.transform.out_channels
+
+        # build backbone
+        if 'Encoder' not in config or config['Encoder'] is None:
+            self.use_encoder = False
+        else:
+            self.use_encoder = True
+            config['Encoder']['in_channels'] = in_channels
+            self.encoder = build_encoder(config['Encoder'])
+            in_channels = self.encoder.out_channels
+
+        # build decoder
+        if 'Decoder' not in config or config['Decoder'] is None:
+            self.use_decoder = False
+        else:
+            self.use_decoder = True
+            config['Decoder']['in_channels'] = in_channels
+            self.decoder = build_decoder(config['Decoder'])
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        if self.use_wd:
+            if hasattr(self.encoder, 'no_weight_decay'):
+                no_weight_decay = self.encoder.no_weight_decay()
+            else:
+                no_weight_decay = {}
+            if hasattr(self.decoder, 'no_weight_decay'):
+                no_weight_decay.update(self.decoder.no_weight_decay())
+            return no_weight_decay
+        else:
+            return {}
+
+    def forward(self, x, data=None):
+        if self.use_transform:
+            x = self.transform(x)
+        if self.use_encoder:
+            x = self.encoder(x)
+        if self.use_decoder:
+            x = self.decoder(x, data=data)
+        return x