def expanded_sample(self): # get the int from Variable or Tensor if self.n.data.dim() == 2: n = int(self.n.data.cpu()[0][0]) else: n = int(self.n.data.cpu()[0]) return Variable(torch_multinomial(self.ps.data, n, replacement=True))
def expanded_sample(self): # get the int from Variable or Tensor if self.n.data.dim() == 2: n = int(self.n.data.cpu()[0][0]) else: n = int(self.n.data.cpu()[0]) return Variable(torch_multinomial(self.ps.data, n, replacement=True))
def __init__(self, input_dim, hidden_dim, output_dim_multiplier=1, mask_encoding=None, permutation=None): super(AutoRegressiveNN, self).__init__() self.input_dim = input_dim self.hidden_dim = hidden_dim self.output_dim_multiplier = output_dim_multiplier if mask_encoding is None: # the dependency structure is chosen at random self.mask_encoding = 1 + torch_multinomial( torch.ones(input_dim - 1) / (input_dim - 1), num_samples=hidden_dim, replacement=True) else: # the dependency structure is given by the user self.mask_encoding = mask_encoding if permutation is None: # a permutation is chosen at random self.permutation = torch.randperm(input_dim) else: # the permutation is chosen by the user self.permutation = permutation # these masks control the autoregressive structure self.mask1 = Variable(torch.zeros(hidden_dim, input_dim)) self.mask2 = Variable( torch.zeros(input_dim * self.output_dim_multiplier, hidden_dim)) for k in range(hidden_dim): # fill in mask1 m_k = self.mask_encoding[k] slice_k = torch.cat( [torch.ones(m_k), torch.zeros(input_dim - m_k)]) for j in range(input_dim): self.mask1[k, self.permutation[j]] = slice_k[j] # fill in mask2 slice_k = torch.cat( [torch.zeros(m_k), torch.ones(input_dim - m_k)]) for r in range(self.output_dim_multiplier): for j in range(input_dim): self.mask2[r * input_dim + self.permutation[j], k] = slice_k[j] self.lin1 = MaskedLinear(input_dim, hidden_dim, self.mask1) self.lin2 = MaskedLinear(hidden_dim, input_dim * output_dim_multiplier, self.mask2) self.relu = nn.ReLU()
def sample(self): """ Returns a sample which has the same shape as `ps`, except that the last dimension will have the same size as the number of events. :return: sample from the OneHotCategorical distribution :rtype: torch.Tensor """ sample = torch_multinomial(self.ps.data, 1, replacement=True).expand(*self.shape()) sample_one_hot = torch_zeros_like(self.ps.data).scatter_(-1, sample, 1) return Variable(sample_one_hot)
def sample(self): """ Returns a sample which has the same shape as `ps` (or `vs`). The type of the sample is `numpy.ndarray` if `vs` is a list or a numpy array, else a tensor is returned. :return: sample from the Categorical distribution :rtype: numpy.ndarray or torch.LongTensor """ sample = torch_multinomial(self.ps.data, 1, replacement=True).expand(*self.shape()) sample_one_hot = torch_zeros_like(self.ps.data).scatter_(-1, sample, 1) if self.vs is not None: if isinstance(self.vs, np.ndarray): sample_bool_index = sample_one_hot.cpu().numpy().astype(bool) return self.vs[sample_bool_index].reshape(*self.shape()) else: return self.vs.masked_select(sample_one_hot.byte()) return Variable(sample)