Skip to content

Decoding

BaseDecoder(model, i2s, max_length=30, eos_id=2, bos_id=1, pad_id=0)

Base model decoder.

Source code in instanovo/transformer/decoding.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def __init__(
    self,
    model: nn.Module,
    i2s: dict[int, str],
    max_length: int = 30,
    eos_id: int = 2,
    bos_id: int = 1,
    pad_id: int = 0,
) -> None:
    self.model = model
    self.i2s = i2s
    self.max_length = max_length
    self.eos_id = eos_id
    self.bos_id = bos_id
    self.pad_id = pad_id

__call__(*args, **kwargs)

Decoder call.

Source code in instanovo/transformer/decoding.py 
53
54
55
def __call__(self, *args: Any, **kwargs: Any) -> Any:
    """Decoder call."""
    return self.decode(*args, **kwargs)

batch_idx_to_aa(idx)

Decode a batch of indices to aa lists.

Source code in instanovo/transformer/decoding.py 
49
50
51
def batch_idx_to_aa(self, idx: Tensor) -> list[list[str]]:
    """Decode a batch of indices to aa lists."""
    return [self.idx_to_aa(i) for i in idx]

decode(*args, **kwds) abstractmethod

Abstract decoding method.

Source code in instanovo/transformer/decoding.py 
32
33
34
35
@abstractmethod
def decode(self, *args: Any, **kwds: Any) -> Any:
    """Abstract decoding method."""
    pass

idx_to_aa(idx)

Decode a single sample of indices to aa list.

Source code in instanovo/transformer/decoding.py 
37
38
39
40
41
42
43
44
45
46
47
def idx_to_aa(self, idx: Tensor) -> list[str]:
    """Decode a single sample of indices to aa list."""
    idx = idx.cpu().numpy()
    t = []
    for i in idx:
        if i == self.eos_id:
            break
        if i == self.bos_id or i == self.pad_id:
            continue
        t.append(i)
    return [self.i2s[x.item()] for x in t]

GreedyDecoder(model, i2s, max_length=30, eos_id=2, bos_id=1, pad_id=0)

Bases: BaseDecoder

Greedy model decoder.

Source code in instanovo/transformer/decoding.py 
61
62
63
64
65
66
67
68
69
70
def __init__(
    self,
    model: InstaNovo,
    i2s: dict[int, str],
    max_length: int = 30,
    eos_id: int = 2,
    bos_id: int = 1,
    pad_id: int = 0,
) -> None:
    super().__init__(model, i2s, max_length, eos_id, bos_id, pad_id)

decode(spectra, precursors, spectra_mask)

Greedy model decode.

Source code in instanovo/transformer/decoding.py 
90
91
92
93
94
def decode(
    self, spectra: Tensor, precursors: Tensor, spectra_mask: Tensor
) -> tuple[Tensor, Tensor]:
    """Greedy model decode."""
    return self.greedy(spectra, precursors, spectra_mask)

greedy(spectra, precursors, spectra_mask)

Greedy decoding strategy.

Source code in instanovo/transformer/decoding.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
def greedy(
    self, spectra: Tensor, precursors: Tensor, spectra_mask: Tensor
) -> tuple[Tensor, Tensor]:
    """Greedy decoding strategy."""
    device = spectra.device
    bs = spectra.shape[0]

    y = torch.ones((bs, 1)).to(device).long()
    y_mask = torch.zeros((bs, 1), dtype=bool, device=device)  # BS, N
    eos_reached = torch.zeros(bs, dtype=bool, device=device)  # BS

    for _ in range(self.max_length):
        with torch.no_grad():
            logits = self.model(spectra, precursors, y, spectra_mask, y_mask, add_bos=False)
        preds = logits[:, -1].argmax(dim=-1)
        y = torch.cat([y, preds[:, None]], dim=-1)

        eos_reached = eos_reached | (y[:, -1] == self.eos_id)
        y_mask = torch.cat(
            [
                y_mask,
                eos_reached[:, None],
            ],
            axis=1,
        ).bool()

        if eos_reached.all():
            break

    # TODO check if logits is corrects shape
    return y, logits

score(spectra, precursors, peptide, spectra_mask, y_mask)

Score peptide sequences.

Source code in instanovo/transformer/decoding.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
def score(
    self,
    spectra: Tensor,
    precursors: Tensor,
    peptide: Tensor,
    spectra_mask: Tensor,
    y_mask: Tensor,
) -> tuple[Tensor, Tensor]:
    """Score peptide sequences."""
    with torch.no_grad():
        logits = self.model(spectra, precursors, peptide, spectra_mask, y_mask, add_bos=True)

    logits = logits[:, :-1].softmax(dim=-1)  # check this
    aa_scores = torch.gather(logits, peptide, dim=2)

    return aa_scores, aa_scores.mean(dim=1)