Skip to content

caveat.encoding.cont_weighting

act_weight_library = {'unit': unit_weights, 'act_inverse': act_inverse_weights, 'act_dur_inverse': act_and_dur_inverse_weights} module-attribute #

seq_weight_library = {'unit': unit_weight, 'act_inverse': seq_inverse_weight, 'act_dur_inverse': act_and_dur_inverse_weight, 'max': seq_max_weight} module-attribute #

act_and_dur_inverse_weight(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
def act_and_dur_inverse_weight(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    activities = sequences[:, :, 0]
    durations = sequences[:, :, 1]
    binned = (durations * 144).to(torch.int)  # 10 minute bins
    combined = torch.stack([activities, binned], dim=-1)
    _, locs, ws = torch.unique(
        combined, dim=0, return_counts=True, return_inverse=True
    )
    weights = 1 / ws[locs].float()
    weights = weights / weights.mean()
    return weights.unsqueeze(-1)

act_and_dur_inverse_weights(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def act_and_dur_inverse_weights(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    activities = sequences[:, :, 0]
    durations = sequences[:, :, 1]
    binned = (durations * 144).to(torch.int)  # 10 minute bins
    combined = torch.stack([activities, binned], dim=-1)
    _, locs, ws = torch.unique(
        combined.view(-1, 2), dim=0, return_counts=True, return_inverse=True
    )
    # set sos and eos weights
    ws[sos_idx] = 0
    ws[eos_idx] = 0
    max_act_weight = ws.max()
    ws[eos_idx] = max_act_weight
    ws[sos_idx] = max_act_weight

    weights = 1 / ws[locs]
    weights = weights.view(sequences.shape[0], -1)

    if trim_eos:
        eos_mask = trim_eos_mask(activities, eos_idx)
        weights = weights * eos_mask  # apply to weights

    weights = weights / weights.mean()
    return weights

act_inverse_weights(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def act_inverse_weights(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    activities = sequences[:, :, 0]
    _, locs, ws = torch.unique(
        activities, return_counts=True, return_inverse=True
    )
    # set sos and eos weights
    ws[sos_idx] = 0
    ws[eos_idx] = 0
    max_act_weight = ws.max()
    ws[eos_idx] = max_act_weight
    ws[sos_idx] = max_act_weight

    weights = 1 / ws[locs].float()

    if trim_eos:
        eos_mask = trim_eos_mask(activities, eos_idx)
        weights = weights * eos_mask  # apply to weights

    weights = weights / weights.mean()

    return weights

seq_inverse_weight(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
82
83
84
85
86
87
88
89
90
91
def seq_inverse_weight(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    activities = sequences[:, :, 0]
    _, locs, ws = torch.unique(
        activities, dim=0, return_counts=True, return_inverse=True
    )
    weights = 1 / ws[locs].float()
    weights = weights / weights.mean()
    return weights.unsqueeze(-1)

seq_max_weight(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
def seq_max_weight(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    activities = sequences[:, :, 0]
    _, locs, ws = torch.unique(
        activities, return_counts=True, return_inverse=True
    )
    # set eos weight to sos weight (ignore trailing eos)
    ws[eos_idx] = ws[sos_idx]
    weights = 1 / ws[locs].float()

    if trim_eos:
        eos_mask = trim_eos_mask(activities, eos_idx)
        weights = weights * eos_mask  # apply to weights

    weights = weights.max(dim=-1).values.unsqueeze(-1)
    weights = weights / weights.mean()
    return weights

trim_eos_mask(activities, eos_idx=1) #

Source code in caveat/encoding/cont_weighting.py 
132
133
134
135
136
137
def trim_eos_mask(activities: Tensor, eos_idx: int = 1) -> Tensor:
    eos_mask = activities == eos_idx
    first_eos = eos_mask.to(torch.long).argmax(dim=-1)
    eos_mask[torch.arange(first_eos.shape[0]), first_eos] = False
    eos_mask = eos_mask.to(torch.float) * -1 + 1  # reverse
    return eos_mask

unit_weight(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
75
76
77
78
79
def unit_weight(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    B, _, _ = sequences.shape
    return torch.ones((B, 1)).float()

unit_weights(sequences, sos_idx=0, eos_idx=1, trim_eos=True) #

Source code in caveat/encoding/cont_weighting.py 
 7
 8
 9
10
11
12
13
14
15
16
def unit_weights(
    sequences: Tensor, sos_idx: int = 0, eos_idx: int = 1, trim_eos: bool = True
) -> Tensor:
    B, L, _ = sequences.shape
    weights = torch.ones((B, L)).float()
    if trim_eos:
        activities = sequences[:, :, 0]
        eos_mask = trim_eos_mask(activities, eos_idx)
        weights = weights * eos_mask  # apply to weights
    return weights