rec_postprocess.py 29.7 KB
Newer Older
W
WenmuZhou 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
# copyright (c) 2020 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.
14

W
WenmuZhou 已提交
15 16 17
import numpy as np
import paddle
from paddle.nn import functional as F
A
andyjpaddle 已提交
18
import re
W
WenmuZhou 已提交
19 20 21 22 23


class BaseRecLabelDecode(object):
    """ Convert between text-label and text-index """

T
tink2123 已提交
24
    def __init__(self, character_dict_path=None, use_space_char=False):
T
tink2123 已提交
25 26
        self.beg_str = "sos"
        self.end_str = "eos"
T
topduke 已提交
27
        self.reverse = False
T
tink2123 已提交
28 29
        self.character_str = []
        if character_dict_path is None:
A
add vl  
andyjpaddle 已提交
30
            self.character_str = "0123456789abcdefghijklmnopqrstuvwxyz"
W
WenmuZhou 已提交
31
            dict_character = list(self.character_str)
T
tink2123 已提交
32
        else:
W
WenmuZhou 已提交
33 34 35 36
            with open(character_dict_path, "rb") as fin:
                lines = fin.readlines()
                for line in lines:
                    line = line.decode('utf-8').strip("\n").strip("\r\n")
W
WenmuZhou 已提交
37
                    self.character_str.append(line)
W
WenmuZhou 已提交
38
            if use_space_char:
W
WenmuZhou 已提交
39
                self.character_str.append(" ")
W
WenmuZhou 已提交
40
            dict_character = list(self.character_str)
T
topduke 已提交
41 42
            if 'arabic' in character_dict_path:
                self.reverse = True
T
tink2123 已提交
43

W
WenmuZhou 已提交
44 45 46 47 48 49
        dict_character = self.add_special_char(dict_character)
        self.dict = {}
        for i, char in enumerate(dict_character):
            self.dict[char] = i
        self.character = dict_character

50 51 52 53
    def pred_reverse(self, pred):
        pred_re = []
        c_current = ''
        for c in pred:
T
Topdu 已提交
54
            if not bool(re.search('[a-zA-Z0-9 :*./%+-]', c)):
55 56 57 58 59 60 61 62 63 64 65
                if c_current != '':
                    pred_re.append(c_current)
                pred_re.append(c)
                c_current = ''
            else:
                c_current += c
        if c_current != '':
            pred_re.append(c_current)

        return ''.join(pred_re[::-1])

W
WenmuZhou 已提交
66 67 68
    def add_special_char(self, dict_character):
        return dict_character

L
littletomatodonkey 已提交
69
    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
W
WenmuZhou 已提交
70 71 72 73 74
        """ convert text-index into text-label. """
        result_list = []
        ignored_tokens = self.get_ignored_tokens()
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
            selection = np.ones(len(text_index[batch_idx]), dtype=bool)
            if is_remove_duplicate:
                selection[1:] = text_index[batch_idx][1:] != text_index[
                    batch_idx][:-1]
            for ignored_token in ignored_tokens:
                selection &= text_index[batch_idx] != ignored_token

            char_list = [
                self.character[text_id]
                for text_id in text_index[batch_idx][selection]
            ]
            if text_prob is not None:
                conf_list = text_prob[batch_idx][selection]
            else:
                conf_list = [1] * len(selection)
            if len(conf_list) == 0:
                conf_list = [0]

W
WenmuZhou 已提交
93
            text = ''.join(char_list)
94 95 96 97

            if self.reverse:  # for arabic rec
                text = self.pred_reverse(text)

98
            result_list.append((text, np.mean(conf_list).tolist()))
W
WenmuZhou 已提交
99 100 101 102 103 104 105 106 107
        return result_list

    def get_ignored_tokens(self):
        return [0]  # for ctc blank


class CTCLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

T
tink2123 已提交
108
    def __init__(self, character_dict_path=None, use_space_char=False,
W
WenmuZhou 已提交
109 110
                 **kwargs):
        super(CTCLabelDecode, self).__init__(character_dict_path,
T
tink2123 已提交
111
                                             use_space_char)
W
WenmuZhou 已提交
112 113

    def __call__(self, preds, label=None, *args, **kwargs):
L
LDOUBLEV 已提交
114
        if isinstance(preds, tuple) or isinstance(preds, list):
115
            preds = preds[-1]
W
WenmuZhou 已提交
116 117
        if isinstance(preds, paddle.Tensor):
            preds = preds.numpy()
W
WenmuZhou 已提交
118 119
        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
W
WenmuZhou 已提交
120
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
W
WenmuZhou 已提交
121 122
        if label is None:
            return text
L
littletomatodonkey 已提交
123
        label = self.decode(label)
W
WenmuZhou 已提交
124 125 126 127 128 129 130
        return text, label

    def add_special_char(self, dict_character):
        dict_character = ['blank'] + dict_character
        return dict_character


littletomatodonkey's avatar
littletomatodonkey 已提交
131 132 133 134 135 136 137 138 139
class DistillationCTCLabelDecode(CTCLabelDecode):
    """
    Convert 
    Convert between text-label and text-index
    """

    def __init__(self,
                 character_dict_path=None,
                 use_space_char=False,
littletomatodonkey's avatar
littletomatodonkey 已提交
140
                 model_name=["student"],
141
                 key=None,
A
andyjpaddle 已提交
142
                 multi_head=False,
littletomatodonkey's avatar
littletomatodonkey 已提交
143
                 **kwargs):
T
tink2123 已提交
144 145
        super(DistillationCTCLabelDecode, self).__init__(character_dict_path,
                                                         use_space_char)
littletomatodonkey's avatar
littletomatodonkey 已提交
146 147
        if not isinstance(model_name, list):
            model_name = [model_name]
littletomatodonkey's avatar
littletomatodonkey 已提交
148
        self.model_name = model_name
littletomatodonkey's avatar
littletomatodonkey 已提交
149

150
        self.key = key
A
andyjpaddle 已提交
151
        self.multi_head = multi_head
littletomatodonkey's avatar
littletomatodonkey 已提交
152 153

    def __call__(self, preds, label=None, *args, **kwargs):
littletomatodonkey's avatar
littletomatodonkey 已提交
154 155 156 157 158
        output = dict()
        for name in self.model_name:
            pred = preds[name]
            if self.key is not None:
                pred = pred[self.key]
A
andyjpaddle 已提交
159 160
            if self.multi_head and isinstance(pred, dict):
                pred = pred['ctc']
littletomatodonkey's avatar
littletomatodonkey 已提交
161 162
            output[name] = super().__call__(pred, label=label, *args, **kwargs)
        return output
littletomatodonkey's avatar
littletomatodonkey 已提交
163 164


W
WenmuZhou 已提交
165 166 167
class AttnLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

T
tink2123 已提交
168
    def __init__(self, character_dict_path=None, use_space_char=False,
W
WenmuZhou 已提交
169 170
                 **kwargs):
        super(AttnLabelDecode, self).__init__(character_dict_path,
T
tink2123 已提交
171
                                              use_space_char)
W
WenmuZhou 已提交
172 173

    def add_special_char(self, dict_character):
L
LDOUBLEV 已提交
174 175 176 177
        self.beg_str = "sos"
        self.end_str = "eos"
        dict_character = dict_character
        dict_character = [self.beg_str] + dict_character + [self.end_str]
W
WenmuZhou 已提交
178 179
        return dict_character

L
LDOUBLEV 已提交
180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
        """ convert text-index into text-label. """
        result_list = []
        ignored_tokens = self.get_ignored_tokens()
        [beg_idx, end_idx] = self.get_ignored_tokens()
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                if text_index[batch_idx][idx] in ignored_tokens:
                    continue
                if int(text_index[batch_idx][idx]) == int(end_idx):
                    break
                if is_remove_duplicate:
                    # only for predict
                    if idx > 0 and text_index[batch_idx][idx - 1] == text_index[
                            batch_idx][idx]:
                        continue
A
andyjpaddle 已提交
199 200
                char_list.append(self.character[int(text_index[batch_idx][
                    idx])])
L
LDOUBLEV 已提交
201 202 203 204 205
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)
            text = ''.join(char_list)
206
            result_list.append((text, np.mean(conf_list).tolist()))
L
LDOUBLEV 已提交
207 208
        return result_list

L
LDOUBLEV 已提交
209 210
    def __call__(self, preds, label=None, *args, **kwargs):
        """
W
WenmuZhou 已提交
211
        text = self.decode(text)
L
LDOUBLEV 已提交
212 213 214 215 216 217 218 219 220 221 222
        if label is None:
            return text
        else:
            label = self.decode(label, is_remove_duplicate=False)
            return text, label
        """
        if isinstance(preds, paddle.Tensor):
            preds = preds.numpy()

        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
L
LDOUBLEV 已提交
223
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
L
LDOUBLEV 已提交
224 225
        if label is None:
            return text
L
LDOUBLEV 已提交
226
        label = self.decode(label, is_remove_duplicate=False)
L
LDOUBLEV 已提交
227 228
        return text, label

W
WenmuZhou 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241
    def get_ignored_tokens(self):
        beg_idx = self.get_beg_end_flag_idx("beg")
        end_idx = self.get_beg_end_flag_idx("end")
        return [beg_idx, end_idx]

    def get_beg_end_flag_idx(self, beg_or_end):
        if beg_or_end == "beg":
            idx = np.array(self.dict[self.beg_str])
        elif beg_or_end == "end":
            idx = np.array(self.dict[self.end_str])
        else:
            assert False, "unsupport type %s in get_beg_end_flag_idx" \
                          % beg_or_end
M
MissPenguin 已提交
242
        return idx
T
tink2123 已提交
243 244


T
tink2123 已提交
245 246 247
class SEEDLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

T
tink2123 已提交
248
    def __init__(self, character_dict_path=None, use_space_char=False,
T
tink2123 已提交
249 250
                 **kwargs):
        super(SEEDLabelDecode, self).__init__(character_dict_path,
T
tink2123 已提交
251
                                              use_space_char)
T
tink2123 已提交
252 253

    def add_special_char(self, dict_character):
T
tink2123 已提交
254
        self.padding_str = "padding"
T
tink2123 已提交
255
        self.end_str = "eos"
T
tink2123 已提交
256 257 258 259
        self.unknown = "unknown"
        dict_character = dict_character + [
            self.end_str, self.padding_str, self.unknown
        ]
T
tink2123 已提交
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
        return dict_character

    def get_ignored_tokens(self):
        end_idx = self.get_beg_end_flag_idx("eos")
        return [end_idx]

    def get_beg_end_flag_idx(self, beg_or_end):
        if beg_or_end == "sos":
            idx = np.array(self.dict[self.beg_str])
        elif beg_or_end == "eos":
            idx = np.array(self.dict[self.end_str])
        else:
            assert False, "unsupport type %s in get_beg_end_flag_idx" % beg_or_end
        return idx

    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
        """ convert text-index into text-label. """
        result_list = []
        [end_idx] = self.get_ignored_tokens()
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                if int(text_index[batch_idx][idx]) == int(end_idx):
                    break
                if is_remove_duplicate:
                    # only for predict
                    if idx > 0 and text_index[batch_idx][idx - 1] == text_index[
                            batch_idx][idx]:
                        continue
                char_list.append(self.character[int(text_index[batch_idx][
                    idx])])
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)
            text = ''.join(char_list)
298
            result_list.append((text, np.mean(conf_list).tolist()))
T
tink2123 已提交
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
        return result_list

    def __call__(self, preds, label=None, *args, **kwargs):
        """
        text = self.decode(text)
        if label is None:
            return text
        else:
            label = self.decode(label, is_remove_duplicate=False)
            return text, label
        """
        preds_idx = preds["rec_pred"]
        if isinstance(preds_idx, paddle.Tensor):
            preds_idx = preds_idx.numpy()
        if "rec_pred_scores" in preds:
            preds_idx = preds["rec_pred"]
            preds_prob = preds["rec_pred_scores"]
        else:
            preds_idx = preds["rec_pred"].argmax(axis=2)
            preds_prob = preds["rec_pred"].max(axis=2)
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
        if label is None:
            return text
        label = self.decode(label, is_remove_duplicate=False)
        return text, label


T
tink2123 已提交
326 327 328
class SRNLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

T
tink2123 已提交
329
    def __init__(self, character_dict_path=None, use_space_char=False,
T
tink2123 已提交
330 331
                 **kwargs):
        super(SRNLabelDecode, self).__init__(character_dict_path,
T
tink2123 已提交
332
                                             use_space_char)
333
        self.max_text_length = kwargs.get('max_text_length', 25)
T
tink2123 已提交
334 335 336 337 338 339 340 341 342 343 344

    def __call__(self, preds, label=None, *args, **kwargs):
        pred = preds['predict']
        char_num = len(self.character_str) + 2
        if isinstance(pred, paddle.Tensor):
            pred = pred.numpy()
        pred = np.reshape(pred, [-1, char_num])

        preds_idx = np.argmax(pred, axis=1)
        preds_prob = np.max(pred, axis=1)

345
        preds_idx = np.reshape(preds_idx, [-1, self.max_text_length])
T
tink2123 已提交
346

347
        preds_prob = np.reshape(preds_prob, [-1, self.max_text_length])
T
tink2123 已提交
348

T
tink2123 已提交
349
        text = self.decode(preds_idx, preds_prob)
T
tink2123 已提交
350 351

        if label is None:
L
LDOUBLEV 已提交
352
            text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
T
tink2123 已提交
353
            return text
T
tink2123 已提交
354
        label = self.decode(label)
T
tink2123 已提交
355 356
        return text, label

L
LDOUBLEV 已提交
357
    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
T
tink2123 已提交
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
        """ convert text-index into text-label. """
        result_list = []
        ignored_tokens = self.get_ignored_tokens()
        batch_size = len(text_index)

        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                if text_index[batch_idx][idx] in ignored_tokens:
                    continue
                if is_remove_duplicate:
                    # only for predict
                    if idx > 0 and text_index[batch_idx][idx - 1] == text_index[
                            batch_idx][idx]:
                        continue
                char_list.append(self.character[int(text_index[batch_idx][
                    idx])])
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)

            text = ''.join(char_list)
382
            result_list.append((text, np.mean(conf_list).tolist()))
T
tink2123 已提交
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
        return result_list

    def add_special_char(self, dict_character):
        dict_character = dict_character + [self.beg_str, self.end_str]
        return dict_character

    def get_ignored_tokens(self):
        beg_idx = self.get_beg_end_flag_idx("beg")
        end_idx = self.get_beg_end_flag_idx("end")
        return [beg_idx, end_idx]

    def get_beg_end_flag_idx(self, beg_or_end):
        if beg_or_end == "beg":
            idx = np.array(self.dict[self.beg_str])
        elif beg_or_end == "end":
            idx = np.array(self.dict[self.end_str])
        else:
            assert False, "unsupport type %s in get_beg_end_flag_idx" \
                          % beg_or_end
        return idx
W
WenmuZhou 已提交
403 404


A
andyjpaddle 已提交
405 406 407
class SARLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

T
tink2123 已提交
408
    def __init__(self, character_dict_path=None, use_space_char=False,
A
andyjpaddle 已提交
409 410
                 **kwargs):
        super(SARLabelDecode, self).__init__(character_dict_path,
T
tink2123 已提交
411
                                             use_space_char)
A
andyjpaddle 已提交
412

A
andyjpaddle 已提交
413
        self.rm_symbol = kwargs.get('rm_symbol', False)
A
andyjpaddle 已提交
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431

    def add_special_char(self, dict_character):
        beg_end_str = "<BOS/EOS>"
        unknown_str = "<UKN>"
        padding_str = "<PAD>"
        dict_character = dict_character + [unknown_str]
        self.unknown_idx = len(dict_character) - 1
        dict_character = dict_character + [beg_end_str]
        self.start_idx = len(dict_character) - 1
        self.end_idx = len(dict_character) - 1
        dict_character = dict_character + [padding_str]
        self.padding_idx = len(dict_character) - 1
        return dict_character

    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
        """ convert text-index into text-label. """
        result_list = []
        ignored_tokens = self.get_ignored_tokens()
A
andyjpaddle 已提交
432

A
andyjpaddle 已提交
433 434 435 436 437 438 439 440
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                if text_index[batch_idx][idx] in ignored_tokens:
                    continue
                if int(text_index[batch_idx][idx]) == int(self.end_idx):
A
andyjpaddle 已提交
441
                    if text_prob is None and idx == 0:
A
andyjpaddle 已提交
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
                        continue
                    else:
                        break
                if is_remove_duplicate:
                    # only for predict
                    if idx > 0 and text_index[batch_idx][idx - 1] == text_index[
                            batch_idx][idx]:
                        continue
                char_list.append(self.character[int(text_index[batch_idx][
                    idx])])
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)
            text = ''.join(char_list)
457 458 459 460
            if self.rm_symbol:
                comp = re.compile('[^A-Z^a-z^0-9^\u4e00-\u9fa5]')
                text = text.lower()
                text = comp.sub('', text)
461
            result_list.append((text, np.mean(conf_list).tolist()))
A
andyjpaddle 已提交
462 463 464 465 466 467 468
        return result_list

    def __call__(self, preds, label=None, *args, **kwargs):
        if isinstance(preds, paddle.Tensor):
            preds = preds.numpy()
        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
A
andyjpaddle 已提交
469

A
andyjpaddle 已提交
470 471 472 473 474 475 476 477 478
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)

        if label is None:
            return text
        label = self.decode(label, is_remove_duplicate=False)
        return text, label

    def get_ignored_tokens(self):
        return [self.padding_idx]
479 480


A
andyjpaddle 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
class DistillationSARLabelDecode(SARLabelDecode):
    """
    Convert 
    Convert between text-label and text-index
    """

    def __init__(self,
                 character_dict_path=None,
                 use_space_char=False,
                 model_name=["student"],
                 key=None,
                 multi_head=False,
                 **kwargs):
        super(DistillationSARLabelDecode, self).__init__(character_dict_path,
                                                         use_space_char)
        if not isinstance(model_name, list):
            model_name = [model_name]
        self.model_name = model_name

        self.key = key
        self.multi_head = multi_head

    def __call__(self, preds, label=None, *args, **kwargs):
        output = dict()
        for name in self.model_name:
            pred = preds[name]
            if self.key is not None:
                pred = pred[self.key]
            if self.multi_head and isinstance(pred, dict):
                pred = pred['sar']
            output[name] = super().__call__(pred, label=label, *args, **kwargs)
        return output


515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
class PRENLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=False,
                 **kwargs):
        super(PRENLabelDecode, self).__init__(character_dict_path,
                                              use_space_char)

    def add_special_char(self, dict_character):
        padding_str = '<PAD>'  # 0 
        end_str = '<EOS>'  # 1
        unknown_str = '<UNK>'  # 2

        dict_character = [padding_str, end_str, unknown_str] + dict_character
        self.padding_idx = 0
        self.end_idx = 1
        self.unknown_idx = 2

        return dict_character

    def decode(self, text_index, text_prob=None):
        """ convert text-index into text-label. """
        result_list = []
        batch_size = len(text_index)

        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                if text_index[batch_idx][idx] == self.end_idx:
                    break
                if text_index[batch_idx][idx] in \
                    [self.padding_idx, self.unknown_idx]:
                    continue
                char_list.append(self.character[int(text_index[batch_idx][
                    idx])])
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)

            text = ''.join(char_list)
            if len(text) > 0:
558
                result_list.append((text, np.mean(conf_list).tolist()))
559 560 561 562 563 564 565 566 567 568 569 570 571 572
            else:
                # here confidence of empty recog result is 1
                result_list.append(('', 1))
        return result_list

    def __call__(self, preds, label=None, *args, **kwargs):
        preds = preds.numpy()
        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
        text = self.decode(preds_idx, preds_prob)
        if label is None:
            return text
        label = self.decode(label)
        return text, label
A
add vl  
andyjpaddle 已提交
573 574


575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
class NRTRLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=True, **kwargs):
        super(NRTRLabelDecode, self).__init__(character_dict_path,
                                              use_space_char)

    def __call__(self, preds, label=None, *args, **kwargs):

        if len(preds) == 2:
            preds_id = preds[0]
            preds_prob = preds[1]
            if isinstance(preds_id, paddle.Tensor):
                preds_id = preds_id.numpy()
            if isinstance(preds_prob, paddle.Tensor):
                preds_prob = preds_prob.numpy()
            if preds_id[0][0] == 2:
                preds_idx = preds_id[:, 1:]
                preds_prob = preds_prob[:, 1:]
            else:
                preds_idx = preds_id
            text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
            if label is None:
                return text
            label = self.decode(label[:, 1:])
        else:
            if isinstance(preds, paddle.Tensor):
                preds = preds.numpy()
            preds_idx = preds.argmax(axis=2)
            preds_prob = preds.max(axis=2)
            text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
            if label is None:
                return text
            label = self.decode(label[:, 1:])
        return text, label

    def add_special_char(self, dict_character):
        dict_character = ['blank', '<unk>', '<s>', '</s>'] + dict_character
        return dict_character

    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
        """ convert text-index into text-label. """
        result_list = []
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
            char_list = []
            conf_list = []
            for idx in range(len(text_index[batch_idx])):
                try:
                    char_idx = self.character[int(text_index[batch_idx][idx])]
                except:
                    continue
                if char_idx == '</s>':  # end
                    break
                char_list.append(char_idx)
                if text_prob is not None:
                    conf_list.append(text_prob[batch_idx][idx])
                else:
                    conf_list.append(1)
            text = ''.join(char_list)
            result_list.append((text.lower(), np.mean(conf_list).tolist()))
        return result_list


class ViTSTRLabelDecode(NRTRLabelDecode):
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=False,
                 **kwargs):
        super(ViTSTRLabelDecode, self).__init__(character_dict_path,
                                                use_space_char)

    def __call__(self, preds, label=None, *args, **kwargs):
        if isinstance(preds, paddle.Tensor):
            preds = preds[:, 1:].numpy()
        else:
            preds = preds[:, 1:]
        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
        if label is None:
            return text
        label = self.decode(label[:, 1:])
        return text, label

    def add_special_char(self, dict_character):
        dict_character = ['<s>', '</s>'] + dict_character
        return dict_character


class ABINetLabelDecode(NRTRLabelDecode):
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=False,
                 **kwargs):
        super(ABINetLabelDecode, self).__init__(character_dict_path,
                                                use_space_char)

    def __call__(self, preds, label=None, *args, **kwargs):
        if isinstance(preds, dict):
            preds = preds['align'][-1].numpy()
        elif isinstance(preds, paddle.Tensor):
            preds = preds.numpy()
        else:
            preds = preds

        preds_idx = preds.argmax(axis=2)
        preds_prob = preds.max(axis=2)
        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=False)
        if label is None:
            return text
        label = self.decode(label)
        return text, label

    def add_special_char(self, dict_character):
        dict_character = ['</s>'] + dict_character
        return dict_character
A
add vl  
andyjpaddle 已提交
692 693


694
class SPINLabelDecode(AttnLabelDecode):
xuyang2233's avatar
add pr  
xuyang2233 已提交
695 696 697 698
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=False,
                 **kwargs):
699
        super(SPINLabelDecode, self).__init__(character_dict_path,
xuyang2233's avatar
add pr  
xuyang2233 已提交
700 701 702 703 704 705 706
                                              use_space_char)

    def add_special_char(self, dict_character):
        self.beg_str = "sos"
        self.end_str = "eos"
        dict_character = dict_character
        dict_character = [self.beg_str] + [self.end_str] + dict_character
707 708 709
        return dict_character


A
add vl  
andyjpaddle 已提交
710 711 712 713 714 715
class VLLabelDecode(BaseRecLabelDecode):
    """ Convert between text-label and text-index """

    def __init__(self, character_dict_path=None, use_space_char=False,
                 **kwargs):
        super(VLLabelDecode, self).__init__(character_dict_path, use_space_char)
A
andyjpaddle 已提交
716 717
        self.max_text_length = kwargs.get('max_text_length', 25)
        self.nclass = len(self.character) + 1
A
andyjpaddle 已提交
718 719
        self.character = self.character[10:] + self.character[
            1:10] + [self.character[0]]
A
add vl  
andyjpaddle 已提交
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750

    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
        """ convert text-index into text-label. """
        result_list = []
        ignored_tokens = self.get_ignored_tokens()
        batch_size = len(text_index)
        for batch_idx in range(batch_size):
            selection = np.ones(len(text_index[batch_idx]), dtype=bool)
            if is_remove_duplicate:
                selection[1:] = text_index[batch_idx][1:] != text_index[
                    batch_idx][:-1]
            for ignored_token in ignored_tokens:
                selection &= text_index[batch_idx] != ignored_token

            char_list = [
                self.character[text_id - 1]
                for text_id in text_index[batch_idx][selection]
            ]
            if text_prob is not None:
                conf_list = text_prob[batch_idx][selection]
            else:
                conf_list = [1] * len(selection)
            if len(conf_list) == 0:
                conf_list = [0]

            text = ''.join(char_list)
            result_list.append((text, np.mean(conf_list).tolist()))
        return result_list

    def __call__(self, preds, label=None, length=None, *args, **kwargs):
        if len(preds) == 2:  # eval mode
A
andyjpaddle 已提交
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784
            text_pre, x = preds
            b = text_pre.shape[1]
            lenText = self.max_text_length
            nsteps = self.max_text_length

            if not isinstance(text_pre, paddle.Tensor):
                text_pre = paddle.to_tensor(text_pre, dtype='float32')

            out_res = paddle.zeros(
                shape=[lenText, b, self.nclass], dtype=x.dtype)
            out_length = paddle.zeros(shape=[b], dtype=x.dtype)
            now_step = 0
            for _ in range(nsteps):
                if 0 in out_length and now_step < nsteps:
                    tmp_result = text_pre[now_step, :, :]
                    out_res[now_step] = tmp_result
                    tmp_result = tmp_result.topk(1)[1].squeeze(axis=1)
                    for j in range(b):
                        if out_length[j] == 0 and tmp_result[j] == 0:
                            out_length[j] = now_step + 1
                    now_step += 1
            for j in range(0, b):
                if int(out_length[j]) == 0:
                    out_length[j] = nsteps
            start = 0
            output = paddle.zeros(
                shape=[int(out_length.sum()), self.nclass], dtype=x.dtype)
            for i in range(0, b):
                cur_length = int(out_length[i])
                output[start:start + cur_length] = out_res[0:cur_length, i, :]
                start += cur_length
            net_out = output
            length = out_length

A
add vl  
andyjpaddle 已提交
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
        else:  # train mode
            net_out = preds[0]
            length = length
            net_out = paddle.concat([t[:l] for t, l in zip(net_out, length)])
        text = []
        if not isinstance(net_out, paddle.Tensor):
            net_out = paddle.to_tensor(net_out, dtype='float32')
        net_out = F.softmax(net_out, axis=1)
        for i in range(0, length.shape[0]):
            preds_idx = net_out[int(length[:i].sum()):int(length[:i].sum(
            ) + length[i])].topk(1)[1][:, 0].tolist()
            preds_text = ''.join([
                self.character[idx - 1]
                if idx > 0 and idx <= len(self.character) else ''
                for idx in preds_idx
            ])
            preds_prob = net_out[int(length[:i].sum()):int(length[:i].sum(
            ) + length[i])].topk(1)[0][:, 0]
            preds_prob = paddle.exp(
                paddle.log(preds_prob).sum() / (preds_prob.shape[0] + 1e-6))
A
andyjpaddle 已提交
805
            text.append((preds_text, preds_prob.numpy()[0]))
A
add vl  
andyjpaddle 已提交
806 807 808 809
        if label is None:
            return text
        label = self.decode(label)
        return text, label