def generate(self): ''' Generates the initial state and returns the samples and logjoint evaluated at initial samples ''' ################## Start FOPPL input ########## logp = [] dim = 1 params = Variable(torch.FloatTensor(1,dim).zero_()) a = VariableCast(0.0) b = VariableCast(2.236) normal_object = dis.Normal(a, b) x = Variable(normal_object.sample().data, requires_grad = True) params = x std = VariableCast(1.4142) obs2 = VariableCast(7.0) p_y_g_x = dis.Normal(params[0,:], std) logp.append(normal_object.logpdf(params)) logp.append(p_y_g_x.logpdf(obs2)) ################# End FOPPL output ############ dim_values = params.size()[0] # sum up all logs logp_x_y = VariableCast(torch.zeros(1,1)) for logprob in logp: logp_x_y = logp_x_y + logprob return logp_x_y, params, VariableCast(self.calc_grad(logp_x_y,params)), dim_values
def eval(self, values, grad=False, grad_loop=False): ''' Takes a map of variable names, to variable values ''' assert (isinstance(values, Variable)) ################## Start FOPPL input ########## values = Variable(values.data, requires_grad=True) a = VariableCast(0.0) b = VariableCast(2) normal_obj1 = dis.Normal(a, b) # log of prior p(x) logp_x = normal_obj1.logpdf(values) # else: # x = normal_object.sample() # x = Variable(x.data, requires_grad = True) if torch.gt(values.data, torch.zeros(values.size()))[0][0]: y = VariableCast(5) normal_obj2 = dis.Normal(values + b, b) logp_y_x = normal_obj2.logpdf(y) else: y = VariableCast(-5) normal_obj3 = dis.Normal(values-b, b) logp_y_x = normal_obj3.logpdf(y) logjoint = Variable.add(logp_x, logp_y_x) if grad: gradients = self.calc_grad(logjoint, values) return gradients elif grad_loop: gradients = self.calc_grad(logjoint, values) return logjoint, gradients else: return logjoint, values
def eval(self, values, grad=False, grad_loop=False): ''' Takes a map of variable names, to variable values ''' assert(isinstance(values, Variable)) ################## Start FOPPL input ########## values = Variable(values.data, requires_grad=True) a = VariableCast(0.0) b = VariableCast(1.0) normal_obj = dis.Normal(a,b) c = VariableCast(3.0) i = 0 logp_x = normal_obj.logpdf(values) grad1 = self.calc_grad(logp_x, values) while(i<10): normal_obj_while = dis.Normal(values, c ) values = Variable(normal_obj_while.sample().data, requires_grad = True) i = i + 1 logp_x_g_x = normal_obj_while.logpdf(values) grad2 = self.calc_grad(logp_x_g_x, values) gradients = grad1 + grad2 logjoint = Variable.add(logp_x, logp_x_g_x) if grad: return gradients elif grad_loop: return logjoint, gradients else: return logjoint, values
def generate(self): ''' Generates the initial state and returns the samples and logjoint evaluated at initial samples ''' ################## Start FOPPL input ########## logp = [] # empty list to store logps of each variable a = VariableCast(0.0) b = VariableCast(2.236) normal_object = dis.Normal(a, b) x = Variable(normal_object.sample().data, requires_grad=True) std = VariableCast(1.4142) obs2 = VariableCast(7.0) p_y_g_x = dis.Normal(x, std) # TO DO Ask Yuan, is it either possible to have once an '.logpdf' method is initiated can we do a # logp.append(<'variable upon which .logpdf method used'>) logp.append(normal_object.logpdf(x)) logp.append(p_y_g_x.logpdf(obs2)) # TO DO We will need to su m all the logs here. # Do I have them stored in a dictionary with the value # or do we have a separate thing for the logs? ################# End FOPPL output ############ # sum up all logs logp_x_y = VariableCast(torch.zeros(1, 1)) for logprob in logp: logp_x_y = logp_x_y + logprob return logp_x_y, x, VariableCast(self.calc_grad(logp_x_y, x))
def eval(self, values, grad=False, grad2=False): ''' Takes a map of variable names, to variable values ''' a = VariableCast(0.0) b = VariableCast(1) c1 = VariableCast(-1) normal_obj1 = dis.Normal(a, b) values = Variable(values.data, requires_grad=True) logp_x = normal_obj1.logpdf(values) # else: # x = normal_object.sample() # x = Variable(x.data, requires_grad = True) if torch.gt(values.data, torch.zeros(values.size()))[0][0]: y = VariableCast(1) normal_obj2 = dis.Normal(b, b) logp_y_x = normal_obj2.logpdf(y) else: y = VariableCast(1) normal_obj3 = dis.Normal(c1, b) logp_y_x = normal_obj3.logpdf(y) logjoint = Variable.add(logp_x, logp_y_x) if grad: gradients = self.calc_grad(logjoint, values) return VariableCast(gradients) elif grad2: gradients = self.calc_grad(logjoint, values) return logjoint, VariableCast(gradients) else: return logjoint, values
def generate(self): logp = [] # empty list to store logps of each variable a = VariableCast(0.0) b = VariableCast(1) c1 = VariableCast(-1) normal_obj1 = dis.Normal(a, b) x = Variable(normal_obj1.sample().data, requires_grad=True) logp_x = normal_obj1.logpdf(x) if torch.gt(x.data, torch.zeros(x.size()))[0][0]: y = VariableCast(1) normal_obj2 = dis.Normal(b, b) logp_y_x = normal_obj2.logpdf(y) else: y = VariableCast(1) normal_obj3 = dis.Normal(c1, b) logp_y_x = normal_obj3.logpdf(y) logp_x_y = logp_x + logp_y_x return logp_x_y, x, VariableCast(self.calc_grad(logp_x_y, x)) # sum up all logs logp_x_y = VariableCast(torch.zeros(1, 1)) for logprob in logp: logp_x_y = logp_x_y + logprob return logp_x_y, x, VariableCast(self.calc_grad(logp_x_y, x))
def testing_normal(mean, std): mean = Variable(mean, requires_grad=True) std = Variable(std, requires_grad=True) normal_obj = dis.Normal(mean, std) sample = normal_obj.sample(num_samples=mean.size()[1]) samplex = Variable(sample.data, requires_grad=True) normal_logpdf = normal_obj.logpdf(samplex) test_list = [samplex, mean] diff_logpdf = torch.autograd.grad([normal_logpdf], test_list, grad_outputs=torch.ones(mean.size()), retain_graph=True) diff_logpdf2 = torch.autograd.grad([normal_logpdf], [mean], grad_outputs=torch.ones(mean.size()), retain_graph=True)[0] diff_logpdf3 = torch.autograd.grad([normal_logpdf], [std], grad_outputs=torch.ones(std.size()), retain_graph=True)[0] # diff_logpdf4 = normal_obj.sample_grad() print(normal_obj.iscontinous()) # Pytorch gradients print('Printing autograd gradients: ') print(diff_logpdf) print(diff_logpdf2) print(diff_logpdf3) # # print('Sample Gradient' , diff_logpdf4) # # True gradients print() print('Printing true gradients ') print('grad_sample', true_grad_normal(sample, mean, std, diff='sample').data) print('grad_mean', true_grad_normal(sample, mean, std, diff='mean').data) print('grad_std', true_grad_normal(sample, mean, std, diff='std').data)
def eval(self, values, grad= False, grad_loop= False): ''' Takes a map of variable names, to variable values . This will be continually called within the leapfrog step values - Type: python dict object Size: len(self.params) Description: dictionary of 'parameters of interest' grad - Type: bool Size: - Description: Flag to denote whether the gradients are needed or not ''' logp = [] # empty list to store logps of each variable # In addition to foopl input assert (isinstance(values, Variable)) ################## Start FOPPL input ########## values = Variable(values.data, requires_grad = True) a = VariableCast(0.0) b = VariableCast(2.236) normal_object = dis.Normal(a, b) std = VariableCast(1.4142) obs2 = VariableCast(7.0) # Need a better way of dealing with values. As ideally we have a dictionary (hash map) # then we say if values['x'] # values[0,:] = Variable(values[0,:].data, requires_grad = True) p_y_g_x = dis.Normal(values[0,:], std) logp.append(normal_object.logpdf(values[0,:])) logp.append(p_y_g_x.logpdf(obs2)) ################# End FOPPL output ############ logjoint = VariableCast(torch.zeros(1, 1)) for logprob in logp: logjoint = logjoint + logprob # grad2 is a hack so that we can call this at the start if grad: gradients = self.calc_grad(logjoint, values) return gradients elif grad_loop: gradients = self.calc_grad(logjoint, values) return logjoint, gradients else: return logjoint, values
def generate(self): dim = 1 logp = [] params = [] values = Variable(torch.FloatTensor(1, dim).zero_()) a = VariableCast(0.0) c1 = VariableCast(10.0) b = VariableCast(1.0) c2 = VariableCast(2.0) normal_obj1 = dis.Normal(a, b) x1 = Variable(normal_obj1.sample().data, requires_grad=True) params.append(x1) logp_x1 = normal_obj1.logpdf(x1) logp.append(logp_x1) print(torch.gt(x1.data, 0.5*torch.ones(x1.size()))[0][0]) if torch.gt(x1.data, 0.5*torch.ones(x1.size()))[0][0]: normal_obj2 = dis.Normal(c1, c2) x2 = Variable(normal_obj2.sample().data, requires_grad = True) params.append(x2) logp_x2_x1 = normal_obj2.logpdf(x2) logp.append(logp_x2_x1) logjoint = VariableCast(torch.zeros(1, 1)) for logprob in logp: logjoint = logprob + logjoint for i in range(len(params)): if i == 0: values = params[i] else: values = torch.cat((values, params[i]), dim=0) grad = torch.autograd.grad(logjoint, params, grad_outputs=torch.ones(values.size())) gradients = torch.zeros(1,1) for i in grad: gradients += 1/values.size()[0] * i.data gradients = Variable(gradients) if len(params) > 1: values = values[1,:].unsqueeze(-1) return logjoint,values, gradients, dim
def eval(self, values, grad=False, grad_loop=False): ''' Takes a map of variable names, to variable values : double x; 2: x ~ Gaussian(0, 1); 3: if (x > 0.5) then 4: x ~ Gaussian(10, 2); 5: return x; https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/final.pdf ''' logp = [] assert (isinstance(values, Variable)) values = Variable(values.data, requires_grad = True) ################## Start FOPPL input ########## a = VariableCast(0.0) c1 = VariableCast(10.0) b = VariableCast(1.0) c2 = VariableCast(1.41) normal_obj1 = dis.Normal(a, b) logp_x1 = normal_obj1.logpdf(values) logp.append(logp_x1) # else: # x = normal_object.sample() # x = Variable(x.data, requires_grad = True) if torch.gt(values.data, torch.Tensor([0.5]))[0]: normal_obj2 = dis.Normal(c1, c2) logp_x1_x1 = normal_obj2.logpdf(values) logp.append(logp_x1_x1) logjoint = VariableCast(torch.zeros(1, 1)) for logprob in logp: logjoint = logprob + logjoint if grad: gradients = self.calc_grad(logjoint, values) return gradients elif grad_loop: gradients = self.calc_grad(logjoint, values) return logjoint, gradients else: return logjoint, values
def generate(self): dim = 1 params = Variable(torch.FloatTensor(1, dim).zero_()) a = VariableCast(0) b = VariableCast(2) normal_obj1 = dis.Normal(a, b) x = Variable(normal_obj1.sample().data, requires_grad=True) params = x logp_x = normal_obj1.logpdf(x) if torch.gt(x.data, torch.zeros(x.size()))[0][0]: y = VariableCast(5) normal_obj2 = dis.Normal(x+b, b) logp_y_x = normal_obj2.logpdf(y) else: y = VariableCast(-5) normal_obj3 = dis.Normal(x-b, b) logp_y_x = normal_obj3.logpdf(y) logp_x_y = logp_x + logp_y_x return logp_x_y, params, self.calc_grad(logp_x_y, params), dim
def generate(self): dim = 1 params = Variable(torch.FloatTensor(1, dim).zero_()) a = VariableCast(0.0) b = VariableCast(1.0) normal_obj1 = dis.Normal(a, b) x = Variable(normal_obj1.sample().data, requires_grad=True) logp_x = normal_obj1.logpdf(x) c = VariableCast(3.0) grad1 = self.calc_grad(logp_x, x) i=0 while (i < 10): normal_obj_while = dis.Normal(x, c) x = Variable(normal_obj_while.sample().data, requires_grad=True) i = i + 1 logp_x_g_x = normal_obj_while.logpdf(x) grad2 = self.calc_grad(logp_x_g_x, x) gradients = grad1 + grad2 logp_x_y = logp_x + logp_x_g_x return logp_x_y, x, gradients, dim
def eval(self, values, grad=False, grad_loop=False): logp = [] assert(isinstance(values, Variable)) values = Variable(values.data) for i in range(values.data.size()[0]): values[i,:] = Variable(values[i,:].data, requires_grad = True) c23582 = VariableCast(0.0).unsqueeze(-1) c23583 = VariableCast(10.0).unsqueeze(-1) normal_obj1 = dis.Normal(c23582, c23583) x23474 = values[0,:].unsqueeze(-1)# sample # append first entry of params p23585 = normal_obj1.logpdf(x23474) # prior logp.append(p23585) c23586 = VariableCast(0.0).unsqueeze(-1) c23587 = VariableCast(10.0).unsqueeze(-1) normal_obj2 = dis.Normal(c23586, c23587) x23471 = values[1,:].unsqueeze(-1)# sample p23589 = normal_obj2.logpdf(x23471) # prior logp.append(p23589) c23590 = VariableCast(1.0).unsqueeze(-1) x23591 = x23471 * c23590 + x23474 # some problem on Variable, Variable.data # x23592 = Variable(x23591.data + x23474.data, requires_grad = True) c23593 = VariableCast(1.0).unsqueeze(-1) normal_obj2 = dis.Normal(x23591, c23593) c23595 = VariableCast(2.1).unsqueeze(-1) y23481 = c23595 p23596 = normal_obj2.logpdf(y23481) # obs, log likelihood logp.append(p23596) c23597 = VariableCast(2.0).unsqueeze(-1) # This is highly likely to be the next variable x23598 = torch.mul(x23471, c23597) + x23474 # x23599 = torch.add(x23598, x23474) c23600 = VariableCast(1.0).unsqueeze(-1) # x23601 = dis.Normal(x23599, c23600) normal_obj3 = dis.Normal(x23598, c23600) c23602 = VariableCast(3.9).unsqueeze(-1) y23502 = c23602 p23603 = normal_obj3.logpdf(y23502) # obs, log likelihood logp.append(p23603) c23604 = VariableCast(3.0).unsqueeze(-1) x23605 = torch.mul(x23471, c23604) x23606 = torch.add(x23605, x23474) c23607 = VariableCast(1.0).unsqueeze(-1) normal_obj4 = dis.Normal(x23606, c23607) c23609 = VariableCast(5.3).unsqueeze(-1) y23527 = c23609 p23610 = normal_obj4.logpdf(y23527) # obs, log likelihood logp.append(p23610) p23611 = Variable(torch.zeros(1, 1)) for logprob in logp: p23611 = logprob + p23611 if grad: gradients = 1 / values.size()[0] * torch.autograd.grad(p23611, values, grad_outputs=torch.ones(values.size()))[0].data # For some reason all the gradients are d times bigger than they should be, where d is the dimension return Variable(gradients) elif grad_loop: gradients = 1 / values.size()[0] * \ torch.autograd.grad(p23611, values, grad_outputs=torch.ones(values.size()))[0].data # For some reason all the gradients are d times bigger than they should be, where d is the dimension return p23611, Variable(gradients) else: return p23611, values
def generate(self): ''' Returns log_joint a tensor.float of size (1,1) params a Variable FloatTensor of size (#parameters of interest,dim) contains all variables gradients a Variable tensor of gradients wrt to parameters ''' # I will need Yuan to spit out the number of dimensions of the parameters # of interest dim = 1 logp = [] params = [] values = Variable(torch.FloatTensor(1,dim).zero_()) c23582 = VariableCast(0.0).unsqueeze(-1) c23583 = VariableCast(10.0).unsqueeze(-1) normal_obj1 = dis.Normal(c23582, c23583) x23474 = Variable(normal_obj1.sample().data, requires_grad = True) # sample # append first entry of params params.append(x23474) p23585 = normal_obj1.logpdf(x23474) # prior logp.append(p23585) c23586 = VariableCast(0.0).unsqueeze(-1) c23587 = VariableCast(10.0).unsqueeze(-1) normal_obj2 = dis.Normal(c23586, c23587) x23471 = Variable(normal_obj2.sample().data, requires_grad = True) # sample # append second entry to params params.append(x23471) p23589 = normal_obj2.logpdf(x23471) # prior logp.append(p23589) c23590 = VariableCast(1.0).unsqueeze(-1) x23591 = x23471 * c23590 + x23474 # some problem on Variable, Variable.data # x23592 = Variable(x23591.data + x23474.data, requires_grad = True) c23593 = VariableCast(1.0).unsqueeze(-1) normal_obj2 = dis.Normal(x23591, c23593) c23595 = VariableCast(2.1).unsqueeze(-1) y23481 = c23595 p23596 = normal_obj2.logpdf(y23481) # obs, log likelihood logp.append(p23596) c23597 = VariableCast(2.0).unsqueeze(-1) # This is highly likely to be the next variable x23598 = x23471.mm(c23597) + x23474 # x23599 = torch.add(x23598, x23474) c23600 = VariableCast(1.0).unsqueeze(-1) # x23601 = dis.Normal(x23599, c23600) normal_obj3 = dis.Normal(x23598, c23600) c23602 = VariableCast(3.9).unsqueeze(-1) y23502 = c23602 p23603 = normal_obj3.logpdf(y23502) # obs, log likelihood logp.append(p23603) c23604 = VariableCast(3.0).unsqueeze(-1) x23605 = x23471.mm(c23604) x23606 = torch.add(x23605, x23474) c23607 = VariableCast(1.0).unsqueeze(-1) normal_obj4 = dis.Normal(x23606, c23607) c23609 = VariableCast(5.3).unsqueeze(-1) y23527 = c23609 p23610 = normal_obj4.logpdf(y23527) # obs, log likelihood logp.append(p23610) p23611 = Variable(torch.zeros(1,1)) for logprob in logp: p23611 = logprob + p23611 for i in range(len(params)): if i == 0: values = params[i] else: values = torch.cat((values, params[i]), dim=0) dim_values = values.size()[0] # dim_values = values.size()[0] # return E from the model # Do I want the gradients of x23471 and x23474? and nothing else. grad = torch.autograd.grad(p23611, params, grad_outputs=torch.ones(values.size())) # For some reason all the gradients are d times bigger than they should be, where d is the dimension gradients = Variable(torch.Tensor(values.size())) for i in range(len(params)): gradients[i, :] = 1 / len(params) * grad[i][0].data.unsqueeze(0) # ensures that each row of the grads represents a params grad return p23611,values, gradients, dim_values
def eval(self, values, grad=False, grad2=False): logp = [] parms = [] for value in values: if isinstance(value, Variable): temp = Variable(value.data, requires_grad=True) parms.append(temp) else: temp = VariableCast(value) temp = Variable(value.data, requires_grad=True) parms.append(value) c23582 = VariableCast(torch.Tensor([0.0])) c23583 = VariableCast(torch.Tensor([10.0])) normal_obj1 = dis.Normal(c23582, c23583) x23474 = parms[0] # sample parms.append(x23474) p23585 = normal_obj1.logpdf(x23474) # prior logp.append(p23585) c23586 = VariableCast(torch.Tensor([0.0])) c23587 = VariableCast(torch.Tensor([10.0])) normal_obj2 = dis.Normal(c23586, c23587) x23471 = parms[1] # sample parms.append(x23471) p23589 = normal_obj2.logpdf(x23471) # prior logp.append(p23589) c23590 = VariableCast(torch.Tensor([1.0])) # Do I cast this as a variable with requires_grad = True ??? x23591 = x23471 * c23590 + x23474 # some problem on Variable, Variable.data # x23592 = Variable(x23591.data + x23474.data, requires_grad = True) c23593 = VariableCast(torch.Tensor([1.0])) normal_obj2 = dis.Normal(x23591, c23593) c23595 = VariableCast(torch.Tensor([2.1])) y23481 = c23595 p23596 = normal_obj2.logpdf(y23481) # obs, log likelihood logp.append(p23596) c23597 = VariableCast(torch.Tensor([2.0])) # This is highly likely to be the next variable x23598 = torch.mul(x23471, c23597) + x23474 # x23599 = torch.add(x23598, x23474) c23600 = torch.Tensor([1.0]) # x23601 = dis.Normal(x23599, c23600) normal_obj3 = dis.Normal(x23598, c23600) c23602 = torch.Tensor([3.9]) y23502 = c23602 p23603 = normal_obj3.logpdf(y23502) # obs, log likelihood logp.append(p23603) c23604 = torch.Tensor([3.0]) x23605 = Variable(torch.mul(x23471, c23604).data, requires_grad=True) x23606 = torch.add(x23605, x23474) c23607 = torch.Tensor([1.0]) normal_obj4 = dis.Normal(x23606, c23607) c23609 = torch.Tensor([5.3]) y23527 = c23609 p23610 = normal_obj4.log_pdf(y23527) # obs, log likelihood logp.append(p23610) p23611 = torch.add([p23585, p23589, p23596, p23603, p23610]) # return E from the model # Do I want the gradients of x23471 and x23474? and nothing else. if grad: gradients = self.calc_grad(p23611, parms) return VariableCast(gradients) elif grad2: gradients = self.calc_grad(p23611, values) return p23611, VariableCast(gradients) else: return p23611, values
# -*- coding: utf-8 -*- ''' Author: Bradley Gram-Hansen Time created: 08:59 Date created: 05/09/2017 License: MIT ''' import torch from Utils.core import VariableCast from torch.autograd import Variable import Distributions.distributions as dis c24039 = VariableCast(1.0) c24040 = VariableCast(2.0) x24041 = dis.Normal(c24039, c24040) x22542 = x24041.sample() #sample if isinstance(Variable, x22542): x22542 = Variable(x22542.data, requires_grad=True) else: x22542 = Variable(VariableCast(x22542).data, requires_grad=True) p24042 = x24041.logpdf(x22542) c24043 = VariableCast(3.0) x24044 = dis.Normal(x22542, c24043) c24045 = VariableCast(7.0) y22543 = c24045 p24046 = x24044.logpdf(y22543) p24047 = Variable.add(p24042, p24046) print(x22542) print(p24047)