openocr-python 0.0.9__py3-none-any.whl → 0.1.0.dev0__py3-none-any.whl

openocr/openrec/modeling/decoders/mdiff_decoder.py

@@ -0,0 +1,587 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+from openrec.modeling.common import Mlp
+from openrec.modeling.decoders.nrtr_decoder import PositionalEncoding, Embeddings, MultiheadAttention
+
+
+class MDiffDecoder(nn.Module):
+    """A transformer model. User is able to modify the attributes as needed.
+    The architechture is based on the paper "Attention Is All You Need". Ashish
+    Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N
+    Gomez, Lukasz Kaiser, and Illia Polosukhin. 2017. Attention is all you
+    need. In Advances in Neural Information Processing Systems, pages
+    6000-6010.
+
+    Args:
+        d_model: the number of expected features in the encoder/decoder inputs (default=512).
+        nhead: the number of heads in the multiheadattention models (default=8).
+        num_encoder_layers: the number of sub-encoder-layers in the encoder (default=6).
+        num_decoder_layers: the number of sub-decoder-layers in the decoder (default=6).
+        dim_feedforward: the dimension of the feedforward network model (default=2048).
+        dropout: the dropout value (default=0.1).
+        custom_encoder: custom encoder (default=None).
+        custom_decoder: custom decoder (default=None).
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 nhead=None,
+                 num_decoder_layers=6,
+                 max_len=25,
+                 attention_dropout_rate=0.0,
+                 residual_dropout_rate=0.1,
+                 scale_embedding=True,
+                 parallel_decoding=False,
+                 autoregressive_decoding=False,
+                 sampler_step=5,
+                 low_confidence_decoding=False,
+                 random_mask_decoding=False,
+                 semi_autoregressive_decoding=False,
+                 cloze_mask_decoding=False,
+                 rec_loss_weight=1.0,
+                 reflect_loss_weight=1.0,
+                 sample_k=0,
+                 temperature=1.0):
+        super(MDiffDecoder, self).__init__()
+        self.out_channels = out_channels
+        self.ignore_index = out_channels - 1
+        self.mask_token_id = out_channels - 2
+        self.eos = 0
+        self.max_len = max_len
+        d_model = in_channels
+        dim_feedforward = d_model * 4
+        self.pd = parallel_decoding
+        self.ar = autoregressive_decoding
+        self.sampler_step = sampler_step
+        self.lc = low_confidence_decoding
+        self.rm = random_mask_decoding
+        self.semiar = semi_autoregressive_decoding
+        self.cm = cloze_mask_decoding
+        self.rec_loss_weight = rec_loss_weight
+        self.reflect_loss_weight = reflect_loss_weight
+        self.temperature = temperature
+        self.sample_k = sample_k
+        nhead = nhead if nhead is not None else d_model // 32
+        self.embedding = Embeddings(
+            d_model=d_model,
+            vocab=self.out_channels,
+            padding_idx=0,
+            scale_embedding=scale_embedding,
+        )
+        self.pos_embed = nn.Parameter(torch.zeros(
+            [1, self.max_len + 1, d_model], dtype=torch.float32),
+                                      requires_grad=True)
+        nn.init.trunc_normal_(self.pos_embed, std=0.02)
+        self.positional_encoding = PositionalEncoding(
+            dropout=residual_dropout_rate, dim=d_model)
+
+        self.decoder = nn.ModuleList([
+            TransformerBlock(
+                d_model,
+                nhead,
+                dim_feedforward,
+                attention_dropout_rate,
+                residual_dropout_rate,
+                with_self_attn=True,
+                with_cross_attn=True,
+            ) for i in range(num_decoder_layers)
+        ])
+
+        self.num_decoder_layers = num_decoder_layers
+
+        self.d_model = d_model
+        self.nhead = nhead
+        self.tgt_word_prj = nn.Linear(d_model,
+                                      self.out_channels - 2,
+                                      bias=False)
+        w0 = np.random.normal(0.0, d_model**-0.5,
+                              (d_model, self.out_channels - 2)).astype(
+                                  np.float32)
+        self.tgt_word_prj.weight.data = torch.from_numpy(w0.transpose())
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.xavier_normal_(m.weight)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+
+    def forward_train(self, memory, data=None):
+        labels, reflect_ids, noisy_batch, masked_indices, p_mask, length = data
+        p_mask = p_mask[:, None].repeat(1, labels.shape[1])
+        noisy_data_length = length + 1
+        noisy_data_length = noisy_data_length[:,
+                                              None].repeat(1, labels.shape[1])
+
+        tgts = self.embedding(noisy_batch)
+        tgts = self.positional_encoding(tgts) + self.pos_embed
+
+        for decoder_layer in self.decoder:
+            tgts = decoder_layer(tgts, memory, self_mask=None)
+        logits = self.tgt_word_prj(tgts)
+        token_loss = F.cross_entropy(
+            logits[masked_indices],
+            labels[masked_indices],
+            reduction='none',
+            ignore_index=self.ignore_index) / p_mask[masked_indices]
+        loss = torch.sum(
+            token_loss / noisy_data_length[masked_indices]) / labels.shape[0]
+
+        if reflect_ids is not None:
+            reflect_tgts = self.embedding(reflect_ids)
+            reflect_tgts = self.positional_encoding(
+                reflect_tgts) + self.pos_embed
+            for decoder_layer in self.decoder:
+                reflect_tgts = decoder_layer(reflect_tgts,
+                                             memory,
+                                             self_mask=None)
+            reflect_logits = self.tgt_word_prj(reflect_tgts)
+            reflect_loss = F.cross_entropy(reflect_logits.flatten(0, 1),
+                                           labels.flatten(0, 1),
+                                           reduction='mean',
+                                           ignore_index=self.ignore_index)
+            loss = self.rec_loss_weight * loss + self.reflect_loss_weight * reflect_loss
+
+        return loss
+
+    def forward_train_all(self, memory, data=None):
+
+        labels, reflect_ids_all, noisy_batch_all, masked_indices_all, p_mask_all, length = data
+        bs, L = labels.shape
+        tgts = self.embedding(noisy_batch_all.flatten(0, 1))
+        tgts = self.positional_encoding(tgts) + self.pos_embed
+        tgts = tgts.reshape(bs, self.sample_k, L, -1)
+
+        for decoder_layer in self.decoder:
+            tgts = decoder_layer(tgts,
+                                 memory,
+                                 self_mask=None,
+                                 sample_k=self.sample_k)
+        logits_all = self.tgt_word_prj(tgts)  # bs, sample_k, L, c_num
+
+        reflect_tgts = self.embedding(reflect_ids_all.flatten(0, 1))
+        reflect_tgts = self.positional_encoding(reflect_tgts) + self.pos_embed
+        reflect_tgts = reflect_tgts.reshape(bs, self.sample_k, L, -1)
+
+        for decoder_layer in self.decoder:
+            reflect_tgts = decoder_layer(reflect_tgts,
+                                         memory,
+                                         self_mask=None,
+                                         sample_k=self.sample_k)
+        reflect_logits_all = self.tgt_word_prj(reflect_tgts)
+
+        loss = []
+        for i in range(self.sample_k):
+            p_mask = p_mask_all[:, i]
+            masked_indices = masked_indices_all[:, i]
+            logits = logits_all[:, i]
+
+            p_mask = p_mask[:, None].repeat(1, labels.shape[1])
+            noisy_data_length = length + 1
+            noisy_data_length = noisy_data_length[:, None].repeat(
+                1, labels.shape[1])
+            token_loss = F.cross_entropy(
+                logits[masked_indices],
+                labels[masked_indices],
+                reduction='none',
+                ignore_index=self.ignore_index) / p_mask[masked_indices]
+            denoise_loss_i = torch.sum(
+                token_loss /
+                noisy_data_length[masked_indices]) / labels.shape[0]
+
+            reflect_logits = reflect_logits_all[:, i]
+            reflect_loss_i = F.cross_entropy(reflect_logits.flatten(0, 1),
+                                             labels.flatten(0, 1),
+                                             reduction='mean',
+                                             ignore_index=self.ignore_index)
+            loss_i = self.rec_loss_weight * denoise_loss_i + self.reflect_loss_weight * reflect_loss_i
+            loss.append(loss_i)
+
+        return sum(loss) / len(loss)
+
+    def forward(self, src, data=None):
+        """Take in and process masked source/target sequences.
+        Args:
+            src: the sequence to the encoder (required).
+            tgt: the sequence to the decoder (required).
+        Shape:
+            - src: :math:`(B, sN, C)`.
+            - tgt: :math:`(B, tN, C)`.
+        Examples:
+            >>> output = transformer_model(src, tgt)
+        """
+
+        if self.training:
+            if self.sample_k > 0:
+                res = self.forward_train_all(src, data)
+            else:
+                res = self.forward_train(src, data)
+        else:
+            if self.pd:
+                res = self.forward_parallel_decoding(src)
+            elif self.ar:
+                res = self.forward_autoregressive_decoding(src)
+            elif self.lc:
+                res = self.forward_low_confidence_decoding(src)
+            elif self.rm:
+                res = self.forward_random_mask_decoding(src)
+            elif self.semiar:
+                res = self.forward_semi_autoregressive_decoding(src)
+            elif self.cm:
+                res = self.forward_cloze_mask_decoding(src)
+            else:
+                res = self.forward_parallel_decoding(src)
+
+        return res
+
+    def forward_decoding(self, src, tgts, step_i=0):
+
+        tgts = self.embedding(tgts)
+        tgts = self.positional_encoding(tgts) + self.pos_embed
+        for decoder_layer in self.decoder:
+            tgts = decoder_layer(tgts, src, self_mask=None)
+
+        return tgts
+
+    def forward_reflect(self, src, pred_indexs, step_i=0):
+        """Reflect decoding."""
+
+        # reflect
+        masked_indices_eos = self.get_masked_indice_after_eos(
+            pred_indexs
+        )  # [bs, max_len + 1] bool tensor False False(eos) True True ..
+        pred_indexs[
+            masked_indices_eos] = self.mask_token_id  # 保留eos之后的token为mask token
+
+        reflect_tgts = self.forward_decoding(src, pred_indexs, step_i=step_i)
+        logits_reflect = F.softmax(self.tgt_word_prj(reflect_tgts), -1)
+
+        return logits_reflect
+
+    def forward_parallel_decoding(self, src):
+        bs = src.shape[0]
+        noisy_batch = torch.full((bs, self.max_len + 1),
+                                 self.mask_token_id,
+                                 dtype=torch.int64,
+                                 device=src.get_device())
+        tgts = self.forward_decoding(src, noisy_batch)
+        logits = F.softmax(self.tgt_word_prj(tgts), -1)
+        return logits
+
+    def get_masked_indice_after_eos(self, noisy_batch):
+        """Get the indices of the masked tokens after the first EOS token."""
+        # noisy_batch: [batch_size, max_len + 1]
+        eos_mask = noisy_batch == self.eos  # [batch_size, seq_len]
+
+        # 找到每行第一个eos的位置
+        eos_indices = eos_mask.float().argmax(dim=1)  # [batch_size]
+
+        # 如果没有eos，argmax会返回0，但我们不想在这些地方mask，需要过滤
+        eos_exists = eos_mask.any(dim=1)  # [batch_size]
+
+        batch_size, seq_len = noisy_batch.shape
+        arange = torch.arange(seq_len,
+                              device=noisy_batch.device).unsqueeze(0).expand(
+                                  batch_size, -1)  # [batch_size, seq_len]
+
+        # 创建掩码：只对eos之后的token设为True
+        masked_indices = arange > eos_indices.unsqueeze(1)
+        masked_indices = masked_indices | ~eos_exists.unsqueeze(1)
+
+        return masked_indices
+
+    def forward_low_confidence_decoding(self, src):
+        bs = src.shape[0]
+        noisy_batch = torch.full((bs, self.max_len + 1),
+                                 self.mask_token_id,
+                                 dtype=torch.int64,
+                                 device=src.get_device())
+        masked_indices_pre = torch.full((bs, self.max_len + 1),
+                                        True,
+                                        dtype=torch.bool,
+                                        device=src.get_device())
+        flag_exit = False
+        for step_i in range(self.sampler_step):
+
+            tgts = self.forward_decoding(src, noisy_batch, step_i=step_i)
+            pred_step = self.tgt_word_prj(tgts)
+            pred_step = F.softmax(pred_step, -1)
+            if step_i == 0:
+                logits = pred_step.clone()
+            logits[masked_indices_pre] = pred_step[masked_indices_pre]
+            pred_step_prob, pred_step_index = torch.max(
+                pred_step, dim=-1)  # [bs, max_len + 1], [bs, max_len + 1]
+            masked_indices_eos = self.get_masked_indice_after_eos(
+                pred_step_index
+            )  # [bs, max_len + 1] bool tensor False False(eos) True True ..
+
+            # 仅计算mask token位置以及eos之前token的平均概率
+            valid_indices = masked_indices_pre & ~masked_indices_eos
+            pred_step_prob = pred_step_prob * valid_indices.float()
+            pred_step_prob_avg = pred_step_prob.sum(
+                dim=1, keepdim=True) / valid_indices.sum(
+                    dim=1, keepdim=True)  # [bs, 1]
+
+            # 高于平均置信度的token
+            top_confidence_mask = pred_step_prob > pred_step_prob_avg
+            top_confidence_mask = top_confidence_mask & valid_indices
+            noisy_batch[top_confidence_mask] = pred_step_index[
+                top_confidence_mask]
+            # 低置信度的token或者eos之后的token均保留为 self.mask_token_id， 其他则替换为 pred_step_index
+            masked_indices_pre = noisy_batch == self.mask_token_id
+            masked_indices_vaild = masked_indices_pre & ~masked_indices_eos
+            if flag_exit:
+                # 如果已经满足退出条件，直接返回
+                break
+            if (masked_indices_vaild.sum(dim=-1) <= 1).all():
+                # 如果每个batch中只有一个或者0个token被mask，说明下次已经没有足够的token可以被mask了，再进行一次就结束
+                flag_exit = True
+
+        return logits
+
+    def forward_random_mask_decoding(self, src):
+        bs = src.shape[0]
+        noisy_batch = torch.full((bs, self.max_len + 1),
+                                 self.mask_token_id,
+                                 dtype=torch.int64,
+                                 device=src.get_device())
+        masked_indices_pre = torch.full((bs, self.max_len + 1),
+                                        True,
+                                        dtype=torch.bool,
+                                        device=src.get_device())
+        flag_exit = False
+        for step_i in range(self.sampler_step):
+
+            tgts = self.forward_decoding(src, noisy_batch, step_i=step_i)
+
+            pred_step = self.tgt_word_prj(tgts)
+            pred_step = F.softmax(pred_step, -1)
+            if step_i == 0:
+                logits = pred_step.clone()
+            else:
+                logits[masked_indices_pre] = pred_step[masked_indices_pre]
+            pred_step_prob, pred_step_index = torch.max(
+                pred_step, dim=-1)  # [bs, max_len + 1], [bs, max_len + 1]
+            masked_indices_eos = self.get_masked_indice_after_eos(
+                pred_step_index)  # [bs, max_len + 1] bool tensor
+
+            # 采用mask token位置以及eos之前token作为可用token
+            valid_indices = masked_indices_pre & ~masked_indices_eos
+            # 在这些可用token中随机选择一些进行mask
+            rand_mask_prob = torch.rand((bs, self.max_len + 1),
+                                        device=src.get_device())
+            # rand_mask_prob = rand_mask_prob * valid_indices.float()
+            random_res = rand_mask_prob > 0.5  # 50%的概率进行mask
+            # 仅保留mask token位置以及eos之前token的高置信度token
+            random_res = random_res & valid_indices
+            # random_mask = random_mask & masked_indices_pre
+            noisy_batch[random_res] = pred_step_index[random_res]
+            # 随机mask token或者eos之后的token均保留为 self.mask_token_id， 其他则替换为 pred_step_index
+            masked_indices_pre = noisy_batch == self.mask_token_id
+            masked_indices_vaild = masked_indices_pre & ~masked_indices_eos
+            if flag_exit:
+                # 如果已经满足退出条件，直接返回
+                break
+            if (masked_indices_vaild.sum(dim=-1) <= 1).all():
+                # 如果每个batch中只有一个或者0个token被mask，说明下次已经没有足够的token可以被mask了，再进行一次就结束
+                flag_exit = True
+
+        return logits
+
+    def forward_semi_autoregressive_decoding(self, src):
+        bs = src.shape[0]
+        noisy_batch = torch.full((bs, self.max_len + 1),
+                                 self.mask_token_id,
+                                 dtype=torch.int64,
+                                 device=src.get_device())
+        block_size = (self.max_len + 1) // self.sampler_step
+        masked_indices_pre = torch.full((bs, self.max_len + 1),
+                                        True,
+                                        dtype=torch.bool,
+                                        device=src.get_device())
+        flag_exit = False
+        for step_i in range(self.sampler_step):
+
+            tgts = self.forward_decoding(src, noisy_batch, step_i=step_i)
+
+            pred_step = self.tgt_word_prj(tgts)
+
+            pred_step = pred_step / self.temperature
+            pred_step = F.softmax(pred_step, -1)
+            if step_i == 0:
+                logits = pred_step.clone()
+            else:
+                logits[masked_indices_pre] = pred_step[masked_indices_pre]
+            pred_step_prob, pred_step_index = torch.max(
+                pred_step, dim=-1)  # [bs, max_len + 1], [bs, max_len + 1]
+            masked_indices_eos = self.get_masked_indice_after_eos(
+                pred_step_index
+            )  # [bs, max_len + 1] bool tensor False False(eos) True True ..
+
+            block_vaild_indices = torch.full((bs, self.max_len + 1),
+                                             False,
+                                             dtype=torch.bool,
+                                             device=src.get_device())
+
+            if step_i <= 2:
+                if self.sampler_step > 2:
+                    block_vaild_indices[:, :block_size * (step_i + 1)] = True
+                else:
+                    block_vaild_indices = ~block_vaild_indices
+            elif step_i >= self.sampler_step - 2:
+                block_vaild_indices[:, block_size * (step_i - 1):] = True
+            else:
+                block_vaild_indices[:, block_size * (step_i - 1):block_size *
+                                    (step_i + 1)] = True
+
+            # 仅计算mask token位置, eos之前token以及当前block中token的平均概率
+            valid_indices = masked_indices_pre & ~masked_indices_eos & block_vaild_indices
+            pred_step_prob = pred_step_prob * valid_indices.float()
+            pred_step_prob_avg = pred_step_prob.sum(
+                dim=1, keepdim=True) / valid_indices.sum(
+                    dim=1, keepdim=True)  # [bs, 1]
+
+            # 高于平均置信度的token
+            top_confidence_mask = pred_step_prob > pred_step_prob_avg
+            top_confidence_mask = top_confidence_mask & valid_indices
+
+            noisy_batch[top_confidence_mask] = pred_step_index[
+                top_confidence_mask]
+
+            # 低置信度的token或者eos之后的token均保留为 self.mask_token_id， 其他则替换为 pred_step_index
+            masked_indices_pre = noisy_batch == self.mask_token_id
+            masked_indices_vaild = masked_indices_pre & ~masked_indices_eos
+            if flag_exit:
+                # 如果已经满足退出条件，直接返回
+                break
+            if (masked_indices_vaild.sum(dim=-1) <= 1).all():
+                # 如果每个batch中只有一个或者0个token被mask，说明下次已经没有足够的token可以被mask了，再进行一次就结束
+                flag_exit = True
+
+        return logits
+
+    def forward_autoregressive_decoding(self, src):
+        bs = src.shape[0]
+        noisy_batch = torch.full((bs, self.max_len + 1),
+                                 self.mask_token_id,
+                                 dtype=torch.int64,
+                                 device=src.get_device())
+        logits = []
+        for step_i in range(self.max_len + 1):
+
+            tgts = self.forward_decoding(src, noisy_batch, step_i=step_i)
+
+            pred_step = self.tgt_word_prj(tgts[:, step_i:step_i + 1, :])
+            pred_step = F.softmax(pred_step, -1)
+            logits.append(pred_step)
+            pred_step = torch.argmax(pred_step, dim=-1)
+            noisy_batch[:, step_i] = pred_step[:, 0]
+            if (noisy_batch == self.eos).any(dim=-1).all():
+                break
+        logits = torch.cat(logits, dim=1)
+        return logits
+
+    def forward_cloze_mask_decoding(self, src, noisy_batch=None):
+        """Cloze Mask Decoding."""
+        bs = src.shape[0]
+        if noisy_batch is None:
+            noisy_batch = torch.full((bs, self.max_len + 1),
+                                     self.mask_token_id,
+                                     dtype=torch.int64,
+                                     device=src.get_device())
+            tgts = self.forward_decoding(src, noisy_batch)
+            pred_step = self.tgt_word_prj(tgts)
+            pred_step = F.softmax(pred_step, -1)
+            noisy_batch = torch.argmax(pred_step, dim=-1)
+            masked_indices_eos = self.get_masked_indice_after_eos(
+                noisy_batch)  # [bs, max_len + 1] bool tensor
+            noisy_batch[
+                masked_indices_eos] = self.mask_token_id  # 保留eos之后的token为mask token
+
+        logits = torch.rand((bs, self.max_len + 1, self.out_channels - 2),
+                            dtype=torch.float32,
+                            device=src.get_device())
+        for step_i in range(self.max_len + 1):
+            noisy_batch[:, step_i] = self.mask_token_id
+
+            tgts = self.forward_decoding(src, noisy_batch, step_i=step_i)
+
+            pred_step = self.tgt_word_prj(tgts[:, step_i:step_i + 1, :])
+            pred_step = F.softmax(pred_step, -1)
+            logits[:, step_i:step_i + 1, :] = pred_step
+            pred_step = torch.argmax(pred_step, dim=-1)
+            noisy_batch[:, step_i] = pred_step[:, 0]
+            if (torch.argmax(logits, dim=-1) == self.eos).any(dim=-1).all():
+                break
+        return logits
+
+
+class TransformerBlock(nn.Module):
+
+    def __init__(
+        self,
+        d_model,
+        nhead,
+        dim_feedforward=2048,
+        attention_dropout_rate=0.0,
+        residual_dropout_rate=0.1,
+        with_self_attn=True,
+        with_cross_attn=False,
+        epsilon=1e-5,
+    ):
+        super(TransformerBlock, self).__init__()
+        self.with_self_attn = with_self_attn
+        if with_self_attn:
+            self.self_attn = MultiheadAttention(d_model,
+                                                nhead,
+                                                dropout=attention_dropout_rate,
+                                                self_attn=with_self_attn)
+            self.norm1 = nn.LayerNorm(d_model, eps=epsilon)
+            self.dropout1 = nn.Dropout(residual_dropout_rate)
+        self.with_cross_attn = with_cross_attn
+        if with_cross_attn:
+            self.cross_attn = MultiheadAttention(
+                d_model, nhead, dropout=attention_dropout_rate
+            )  # for self_attn of encoder or cross_attn of decoder
+            self.norm2 = nn.LayerNorm(d_model, eps=epsilon)
+            self.dropout2 = nn.Dropout(residual_dropout_rate)
+
+        self.mlp = Mlp(
+            in_features=d_model,
+            hidden_features=dim_feedforward,
+            act_layer=nn.ReLU,
+            drop=residual_dropout_rate,
+        )
+
+        self.norm3 = nn.LayerNorm(d_model, eps=epsilon)
+
+        self.dropout3 = nn.Dropout(residual_dropout_rate)
+
+    def forward(self,
+                tgt,
+                memory=None,
+                self_mask=None,
+                cross_mask=None,
+                sample_k=0):
+
+        if self.with_self_attn:
+            if sample_k > 0:
+                bs, _, L, Dim = tgt.shape
+                tgt = tgt.flatten(0, 1)
+            tgt1 = self.self_attn(tgt, attn_mask=self_mask)
+            tgt = self.norm1(tgt + self.dropout1(tgt1))
+
+        if self.with_cross_attn:
+            if sample_k > 0:
+                tgt = tgt.reshape(bs, sample_k, L, Dim).flatten(1, 2)
+            tgt2 = self.cross_attn(tgt, key=memory, attn_mask=cross_mask)
+            tgt = self.norm2(tgt + self.dropout2(tgt2))
+        tgt = self.norm3(tgt + self.dropout3(self.mlp(tgt)))
+
+        if sample_k > 0:
+            tgt = tgt.reshape(bs, sample_k, L, Dim)
+
+        return tgt