def cost(self, data, weightcost):
cost = 0.0
if type(data) != type([]):
data = [data]
numcases = len(data)
for i in range(numcases):
inp = matrix(data[i][0])
out = data[i][1]
T = inp.shape[0]
alpha = zeros((self.numclasses, T), dtype=float)
alpha[:,0][:,newaxis] = \
self.singlenodescore(inp[0,:],range(self.numclasses))
for t in range(1, T):
for y in range(self.numclasses):
alpha[y,t] = self.singlenodescore(inp[t,:],y)+\
logsumexp(alpha[:,t-1].flatten()+\
self.dualnodescore(inp,(arange(self.numclasses),y)))
cost -= logsumexp(alpha[:, -1])
for t in range(T):
cost += self.singlenodescore(inp[t, :], out[t])
for t in range(T - 1):
cost += self.dualnodescore(inp, (out[t], out[t + 1]))
cost = cost.flatten()[0]
cost /= double(numcases)
cost -= 0.5 * weightcost * sum((self.params)**2)
return -cost
def cost(self,data,weightcost):
cost = 0.0
if type(data)!=type([]):
data = [data]
numcases = len(data)
for i in range(numcases):
inp = matrix(data[i][0])
out = data[i][1]
T = inp.shape[0]
alpha = zeros((self.numclasses,T),dtype=float)
alpha[:,0][:,newaxis] = \
self.singlenodescore(inp[0,:],range(self.numclasses))
for t in range(1,T):
for y in range(self.numclasses):
alpha[y,t] = self.singlenodescore(inp[t,:],y)+\
logsumexp(alpha[:,t-1].flatten()+\
self.dualnodescore(inp,(arange(self.numclasses),y)))
cost -= logsumexp(alpha[:,-1])
for t in range(T):
cost += self.singlenodescore(inp[t,:],out[t])
for t in range(T-1):
cost += self.dualnodescore(inp,(out[t],out[t+1]))
cost = cost.flatten()[0]
cost /= double(numcases)
cost -= 0.5*weightcost*sum((self.params)**2)
return -cost
def cost(self, features, labels, weightcost):
#labels = onehot(labels)
scores = dot(self.weights,features) + self.biases[:,newaxis]
if self.regularizebiases:
negloglik = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(features.shape[1]) + \
weightcost * sum(sum(self.params**2))
else:
negloglik = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(features.shape[1])+ \
weightcost * sum(sum(self.weights**2))
return negloglik
def cost(self, features, labels, weightcost):
#labels = onehot(labels)
scores = dot(self.weights, features) + self.biases[:, newaxis]
if self.regularizebiases:
negloglik = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(features.shape[1]) + \
weightcost * sum(sum(self.params**2))
else:
negloglik = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(features.shape[1])+ \
weightcost * sum(sum(self.weights**2))
return negloglik
def cost(self,features,labels,weightcost):
labels = labels.astype(float)
numcases = features.shape[1]
scores = self.scorefunc.fprop(features)
if self.regularizebiases:
cost = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(numcases) + \
weightcost * sum(sum(self.params**2))
else:
cost = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(numcases) + \
weightcost * sum(sum(self.weightsbeforebiases**2))
return cost
def cost(self, features, labels, weightcost):
labels = labels.astype(float)
numcases = features.shape[1]
scores = self.scorefunc.fprop(features)
if self.regularizebiases:
cost = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(numcases) + \
weightcost * sum(sum(self.params**2))
else:
cost = (-sum(sum(labels*scores)) + \
sum(logsumexp(scores,0)))/double(numcases) + \
weightcost * sum(sum(self.weightsbeforebiases**2))
return cost
def outputmarginals(self, input):
"""Returns a tuple with the dual-node and single-node marginals for
the given input-sequence."""
T = input.shape[0]
alpha = zeros((self.numclasses, T), dtype=float)
beta = zeros((self.numclasses, T), dtype=float)
p_s = []
p_d = []
for t in range(T):
p_s.append(zeros(self.numclasses, dtype=float))
p_d.append(zeros((self.numclasses, self.numclasses), dtype=float))
#forward-backward:
alpha[:,0][:,newaxis] = \
self.singlenodescore(input[0,:],range(self.numclasses))
for t in range(1, T):
for y in range(self.numclasses):
alpha[y,t] = self.singlenodescore(input[t,:],y)+\
logsumexp(alpha[:,t-1].flatten()+\
self.dualnodescore(input,(arange(self.numclasses),y)))
beta[:,-1][:,newaxis] = \
self.singlenodescore(input[-1,:],range(self.numclasses))
for t in range(T - 2, -1, -1):
for y in range(self.numclasses):
beta[y,t] = self.singlenodescore(input[t,:],y)+\
logsumexp(beta[:,t+1].flatten()+\
self.dualnodescore(input,(y,arange(self.numclasses))))
logZ = logsumexp(alpha[:, -1])
#get dual-node marginals:
for t in range(T - 1):
for y in range(self.numclasses):
for y_ in range(self.numclasses):
p_d[t][y,y_] = exp(alpha[y,t]+\
self.dualnodescore(input,(y,y_))+\
beta[y_,t+1]\
-logZ)
#get single-node marginals by further marginalizing:
for t in range(T - 1):
for y in range(self.numclasses):
p_s[t][y] = sum(p_d[t][y, :])
p_s[-1] = sum(p_d[T - 2][:, :], 0)
p_d = p_d[:-1]
return p_s, p_d
def outputmarginals(self,input):
"""Returns a tuple with the dual-node and single-node marginals for
the given input-sequence."""
T = input.shape[0]
alpha = zeros((self.numclasses,T),dtype=float)
beta = zeros((self.numclasses,T),dtype=float)
p_s = []
p_d = []
for t in range(T):
p_s.append(zeros(self.numclasses,dtype=float))
p_d.append(zeros((self.numclasses,self.numclasses),dtype=float))
#forward-backward:
alpha[:,0][:,newaxis] = \
self.singlenodescore(input[0,:],range(self.numclasses))
for t in range(1,T):
for y in range(self.numclasses):
alpha[y,t] = self.singlenodescore(input[t,:],y)+\
logsumexp(alpha[:,t-1].flatten()+\
self.dualnodescore(input,(arange(self.numclasses),y)))
beta[:,-1][:,newaxis] = \
self.singlenodescore(input[-1,:],range(self.numclasses))
for t in range(T-2,-1,-1):
for y in range(self.numclasses):
beta[y,t] = self.singlenodescore(input[t,:],y)+\
logsumexp(beta[:,t+1].flatten()+\
self.dualnodescore(input,(y,arange(self.numclasses))))
logZ = logsumexp(alpha[:,-1])
#get dual-node marginals:
for t in range(T-1):
for y in range(self.numclasses):
for y_ in range(self.numclasses):
p_d[t][y,y_] = exp(alpha[y,t]+\
self.dualnodescore(input,(y,y_))+\
beta[y_,t+1]\
-logZ)
#get single-node marginals by further marginalizing:
for t in range(T-1):
for y in range(self.numclasses):
p_s[t][y] = sum(p_d[t][y,:])
p_s[-1] = sum(p_d[T-2][:,:],0)
p_d = p_d[:-1]
return p_s,p_d
def cost(self,data,weightcost):
if type(data)!=type([]):
data = [data]
numcases = len(data)
cost = 0.0
for i in range(numcases):
input = data[i][0]
output = data[i][1]
modeloutput = self.scorefuncs[0](input)
cost += sum(modeloutput[output]-logsumexp(modeloutput,0))/\
double(numcases*input.shape[1])
cost += 0.5 * weightcost * sum(self.params**2)
return cost
def cost(self, data, weightcost):
if type(data) != type([]):
data = [data]
numcases = len(data)
cost = 0.0
for i in range(numcases):
input = data[i][0]
output = data[i][1]
modeloutput = self.scorefuncs[0](input)
cost += sum(modeloutput[output]-logsumexp(modeloutput,0))/\
double(numcases*input.shape[1])
cost += 0.5 * weightcost * sum(self.params**2)
return cost
def nadarayawatson(traininputs, trainoutputs, testinputs, h):
""" Nadaraya Watson kernel regression using isotropic Gaussian kernels.
traininputs: Float array of training inputs (columnwise).
trainoutputs: Float array of training outputs (columnwise).
testinputs: Float array of test inputs (columnwise).
h: 2 * variance of the input kernel.
Output: Nadaraya watson regression applied to the testinputs.
"""
if len(traininputs.shape) < 2:
traininputs = traininputs[newaxis, :]
if len(trainoutputs.shape) < 2:
trainoutputs = trainoutputs[newaxis, :]
if len(testinputs.shape) < 2:
testinputs = testinputs[newaxis, :]
K = -(1.0/h)*\
(sum(testinputs**2,0)[:,newaxis]+sum(traininputs**2,0)[newaxis,:]\
-2*dot(testinputs.T,traininputs))
K = exp(K-logsumexp(K,1)[:,newaxis])
return sum(trainoutputs[newaxis,:,:].transpose(0,2,1)*K[:,:,newaxis],1).T
def nadarayawatson(traininputs, trainoutputs, testinputs, h):
""" Nadaraya Watson kernel regression using isotropic Gaussian kernels.
traininputs: Float array of training inputs (columnwise).
trainoutputs: Float array of training outputs (columnwise).
testinputs: Float array of test inputs (columnwise).
h: 2 * variance of the input kernel.
Output: Nadaraya watson regression applied to the testinputs.
"""
if len(traininputs.shape) < 2:
traininputs = traininputs[newaxis, :]
if len(trainoutputs.shape) < 2:
trainoutputs = trainoutputs[newaxis, :]
if len(testinputs.shape) < 2:
testinputs = testinputs[newaxis, :]
K = -(1.0/h)*\
(sum(testinputs**2,0)[:,newaxis]+sum(traininputs**2,0)[newaxis,:]\
-2*dot(testinputs.T,traininputs))
K = exp(K - logsumexp(K, 1)[:, newaxis])
return sum(
trainoutputs[newaxis, :, :].transpose(0, 2, 1) * K[:, :, newaxis], 1).T
def probabilities(self, features):
scores = dot(self.weights,features) + self.biases[:,newaxis]
return exp(scores - logsumexp(scores,0))
def probabilities(self, features):
scores = self.scorefunc.fprop(features)
return exp(scores - logsumexp(scores,0))
def probabilities(self, features):
scores = dot(self.weights, features) + self.biases[:, newaxis]
return exp(scores - logsumexp(scores, 0))
def probabilities(self, features):
scores = self.scorefunc.fprop(features)
return exp(scores - logsumexp(scores, 0))
