Class PseudoDataset

functions.py:154–204

class PseudoDataset(Dataset):
    def __init__(self, occ, prc, lb, pt, device, adj, law, num_layers=2, prop=0.4):  # adj
        occ, label = create_rnn_data(occ, lb, pt)
        prc, _ = create_rnn_data(prc, lb, pt)
        self.occ = torch.Tensor(occ)
        self.prc = torch.Tensor(prc)
        self.label = torch.Tensor(label)
        self.device = device
        self.adj = adj
        self.eye = torch.eye(adj.shape[0])
        self.deg = torch.sum(adj, dim=0)
        self.num_layers = num_layers
        self.prop = prop  # Proportion of nodes with price changes
        self.law = -law

        # price changes
        node_score = torch.rand(size=[self.occ.shape[2]])
        shred = torch.quantile(node_score, self.prop)
        prc_chg = torch.randn_like(node_score) / 2  # Percentage change in price
        prc_chg[torch.where(node_score > self.prop)] = 0
        self.prc_chg = prc_chg

        # label changes
        label_chg = self.law * prc_chg  # Percentage change in occupancy
        label_chg = torch.unsqueeze(label_chg, dim=1)  # [node, 1]
        hop_chg = -label_chg
        label_chg = [label_chg]
        deg = torch.unsqueeze(self.deg, dim=1)  # [node, 1]
        for n in range(self.num_layers):  # graph propagation
            hop_chg = torch.matmul(self.adj-self.eye, hop_chg) * (1 / deg)
            label_chg.append(hop_chg)
        label_chg = torch.stack(label_chg, dim=1)  # [node, num_layers]
        label_chg = torch.sum(label_chg, dim=1)  # [node, ]
        self.label_chg = torch.squeeze(label_chg, dim=1)

    def __len__(self):
        return len(self.occ)

    def __getitem__(self, idx):  # occ: batch, seq, node
        # sampling
        pseudo_prc = torch.Tensor(self.prc[idx, :, :] * (1+self.prc_chg))  # [node, seq]
        pseudo_label = torch.tan(torch.Tensor(self.label[idx, :] * (1+self.label_chg)))  # [node, ]

        # to device
        output_occ = torch.transpose(self.occ[idx, :, :], 0, 1).to(self.device)
        output_prc = torch.transpose(self.prc[idx, :, :], 0, 1).to(self.device)
        output_label = self.label[idx, :].to(self.device)
        output_pseudo_prc = torch.transpose(pseudo_prc, 0, 1).to(self.device)
        output_pseudo_label = pseudo_label.to(self.device)

        return output_occ, output_prc, output_label, output_pseudo_prc, output_pseudo_label


def meta_division(data, support_rate, query_rate):