Add files via upload

Author: yangzeyu1998

code/models/awareness.py

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+import torch.nn as nn
+
+
+class DAN(nn.Module):
+    """Distance awareness network.
+    """
+
+    def __init__(self, total_locs):
+        super(DAN, self).__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_features=total_locs, out_features=total_locs),
+            nn.Sigmoid(),
+        )
+        self.weight_init()
+
+    def forward(self, x):
+        weights = self.net(x)
+        return weights
+
+    def weight_init(self):
+        for param in self.parameters():
+            param.data.uniform_(-0.05, 0.05)

code/models/discriminator.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Discriminator(nn.Module):
+    """Basic discriminator.
+    """
+
+    def __init__(
+            self,
+            total_locations=8606,
+            embedding_net=None,
+            embedding_dim=64,
+            dropout=0.6):
+        super(Discriminator, self).__init__()
+        num_filters = [100, 200, 200, 200, 200, 100, 100, 100, 100, 100, 160, 160]
+        filter_sizes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20]
+        if embedding_net:
+            self.embedding = embedding_net
+        else:
+            self.embedding = nn.Embedding(
+                num_embeddings=total_locations,
+                embedding_dim=embedding_dim)
+        self.convs = nn.ModuleList([nn.Conv2d(1, n, (f, embedding_dim)) for (
+            n, f) in zip(num_filters, filter_sizes)])
+        self.highway = nn.Linear(sum(num_filters), sum(num_filters))
+        self.dropout = nn.Dropout(p=dropout)
+        self.linear = nn.Linear(sum(num_filters), 2)
+        self.init_parameters()
+
+    def forward(self, x):
+        """
+        Args:
+            x: (batch_size * seq_len)
+        """
+        emb = self.embedding(x).unsqueeze(
+            1)  # batch_size * 1 * seq_len * emb_dim
+        # [batch_size * num_filter * length]
+        convs = [F.relu(conv(emb)).squeeze(3) for conv in self.convs]
+        pools = [F.max_pool1d(conv, conv.size(2)).squeeze(2)
+                 for conv in convs]  # [batch_size * num_filter]
+        pred = torch.cat(pools, 1)  # batch_size * num_filters_sum
+        highway = self.highway(pred)
+        pred = torch.sigmoid(highway) * F.relu(highway) + \
+            (1. - torch.sigmoid(highway)) * pred
+        pred = F.log_softmax(self.linear(self.dropout(pred)), dim=-1)
+        return pred
+
+    def init_parameters(self):
+        for param in self.parameters():
+            param.data.uniform_(-0.05, 0.05)
+
+
+class TCDiscriminator(nn.Module):
+
+    def __init__(self,
+            total_locations=8606,
+            embedding_net=None,
+            sembedding_dim=64,
+            tembedding_dim=16,
+            dropout=0.6):
+        super(TCDiscriminator, self).__init__()
+        num_filters = [100, 200, 200, 200, 200, 100, 100, 100, 100, 100, 160, 160]
+        filter_sizes = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20]
+        if embedding_net:
+            self.tembedding = embedding_net[0]
+            self.sembedding = embedding_net[1]
+        else:
+            self.tembedding = nn.Embedding(
+                num_embeddings=total_locations,
+                embedding_dim=tembedding_dim)
+            self.sembedding = nn.Embedding(
+                num_embeddings=total_locations,
+                embedding_dim=sembedding_dim)
+        self.convs = nn.ModuleList([nn.Conv2d(1, n, (f, tembedding_dim + sembedding_dim)) for (
+            n, f) in zip(num_filters, filter_sizes)])
+        self.highway = nn.Linear(sum(num_filters), sum(num_filters))
+        self.dropout = nn.Dropout(p=dropout)
+        self.linear = nn.Linear(sum(num_filters), 2)
+        self.init_parameters()
+
+    def forward(self, xt, xs):
+        """
+        Args:
+            x: (batch_size * seq_len)
+        """
+        temb = self.tembedding(xt)
+        semb = self.sembedding(xs)
+        emb = torch.cat([temb, semb], dim=-1).unsqueeze(1)
+        # [batch_size * num_filter * length]
+        convs = [F.relu(conv(emb)).squeeze(3) for conv in self.convs]
+        pools = [F.max_pool1d(conv, conv.size(2)).squeeze(2)
+                 for conv in convs]  # [batch_size * num_filter]
+        pred = torch.cat(pools, 1)  # batch_size * num_filters_sum
+        highway = self.highway(pred)
+        pred = torch.sigmoid(highway) * F.relu(highway) + \
+               (1. - torch.sigmoid(highway)) * pred
+        pred = F.log_softmax(self.linear(self.dropout(pred)), dim=-1)
+        return pred
+
+    def init_parameters(self):
+        for param in self.parameters():
+            param.data.uniform_(-0.05, 0.05)

code/models/gan_loss.py

@@ -0,0 +1,132 @@
+# coding: utf-8
+import pdb
+import torch
+import numpy as np
+import torch.nn as nn
+from torch.autograd import Variable
+
+
+class GANLoss(nn.Module):
+    """Reward-Refined NLLLoss Function for adversial training of Gnerator"""
+
+    def __init__(self):
+        super(GANLoss, self).__init__()
+
+    def forward(self, prob, target, reward, device, ploss=False):
+        """
+        Args:
+            prob: (N, C), torch Variable
+            target : (N, ), torch Variable
+            reward : (N, ), torch Variable
+        """
+        N = target.size(0)
+        C = prob.size(1)
+        one_hot = torch.zeros((N, C))
+        if prob.is_cuda:
+            one_hot = one_hot.to(device)
+        one_hot.scatter_(1, target.data.view((-1, 1)), 1)
+        one_hot = one_hot.type(torch.ByteTensor)
+        one_hot = Variable(one_hot)
+        if prob.is_cuda:
+            one_hot = one_hot.to(device)
+        loss = torch.masked_select(prob, one_hot)
+        loss = loss * reward
+        loss = -torch.sum(loss)
+        return loss
+
+class distance_loss(nn.Module):
+
+    def __init__(self, datasets, device):
+        super(distance_loss, self).__init__()
+        if datasets == 'mobile':
+            with open('../data/mobile/gps') as f:
+                gpss = f.readlines()
+        else:
+             with open('../data/geolife/gps') as f:
+                gpss = f.readlines()
+        self.X = []
+        self.Y = []
+        for gps in gpss:
+            x, y = float(gps.split()[0]), float(gps.split()[1])
+            self.X.append(x)
+            self.Y.append(y)
+        self.X = torch.Tensor(np.array(self.X)).float()
+        self.Y = torch.Tensor(np.array(self.Y)).float()
+        self.X = self.X.to(device)
+        self.Y = self.Y.to(device)
+
+    def forward(self, x):
+        """
+
+        :param x: generated sequence, batch_size * seq_len
+        :return:
+        """
+        x = x.long()
+        x1 = torch.index_select(self.X, 0, x[:, :-1].contiguous().view(-1))
+        x2 = torch.index_select(self.X, 0, x[:, 1:].contiguous().view(-1))
+        y1 = torch.index_select(self.Y, 0, x[:, :-1].contiguous().view(-1))
+        y2 = torch.index_select(self.Y, 0, x[:, 1:].contiguous().view(-1))
+        dx = x1 - x2
+        dy = y1 - y2
+        loss = dx**2 + dy**2
+        loss = torch.sum(loss) / loss.size(0)
+        return loss
+
+
+class period_loss(nn.Module):
+
+    def __init__(self, time_interval):
+        super(period_loss, self).__init__()
+        self.time_interval = time_interval
+        self.mse = nn.MSELoss()
+
+    def forward(self, x):
+        """
+
+        :param x: generated sequence, batch_size * seq_len
+        :return:
+        """
+        loss = 0.
+        for i in range(0, x.size(1) - self.time_interval):
+            loss += torch.sum(torch.ne(x[:, i], x[:, i + self.time_interval]))
+        return loss
+
+
+class embd_distance_loss(nn.Module):
+
+    def __init__(self, embd):
+        super(embd_distance_loss, self).__init__()
+        self.embd = embd
+
+    def forward(self, x, embd_size):
+        """
+
+        :param x: generated sequence, batch_size * seq_len
+        :return:
+        """
+        emb = self.embd(x)
+        emb = emb.permute(1, 0, 2)
+        curr = emb[: x.size(1) - 1].contiguous().view(-1, embd_size)
+        next = emb[1: x.size(1)].contiguous().view(-1, embd_size)
+        loss = torch.nn.functional.mse_loss(curr, next, reduction='sum')
+        return loss
+
+
+class embd_period_loss(nn.Module):
+
+    def __init__(self, embd):
+        super(embd_period_loss, self).__init__()
+        self.embd = embd
+
+    def forward(self, x, embd_size):
+        """
+
+        :param x: generated sequence, batch_size * seq_len
+        :return:
+        """
+        emb = self.embd(x)
+        emb = emb.permute(1, 0, 2)
+        curr = emb[: 24].contiguous().view(-1, embd_size)
+        next = emb[24:].contiguous().view(-1, embd_size)
+        loss = torch.nn.functional.mse_loss(curr, next, reduction='sum')
+        return loss