# -*- coding: utf-8 -*-
# ELEKTRONN - Neural Network Toolkit
#
# Copyright (c) 2014 - now
# Max-Planck-Institute for Medical Research, Heidelberg, Germany
# Authors: Marius Killinger, Gregor Urban
import time
import numpy as np
import theano
import theano.tensor as T
from theano.tensor.nnet import conv
import pooling
from netutils import initWeights
from gaborfilters import makeGaborFilters, blob
[docs]def getOutputShape(insh, fsh, pool, mfp, r=1):
"""
Returns shape of convolution result from (bs, ch, x, y) * (nof, ch, xf, yf)
"""
# insh = (1 if input_shape[0]==None else input_shape[0],)+input_shape[1:]
if insh[0] is None:
bs = None
else:
bs = insh[0] * np.prod(pool) if mfp else insh[0]
ch = fsh[0] if r == 1 else fsh[0] // r
x = (insh[2] - fsh[2] + 1) // pool[0]
y = (insh[3] - fsh[3] + 1) // pool[1]
return (bs, ch, x, y)
[docs]def getProbShape(output_shape, mfp_strides):
"""
Given outputshape (bs, ch, x, y) and mfp_stride (sx, sy) returns shape of Class Prob output
"""
if mfp_strides is None:
return output_shape
else:
return (1, output_shape[1], output_shape[2] * mfp_strides[1], output_shape[3] * mfp_strides[1])
[docs]class ConvLayer2d(object):
"""
Conv-Pool Layer of a CNN
:type input: theano.tensor.dtensor4 ('batch', 'channel', x, y)
:param input: symbolic image tensor, of shape input_shape
:type input_shape: tuple or list of length 4
:param input_shape: (batch size, num input feature maps, image height, image width)
:type filter_shape: tuple or list of length 4
:param filter_shape: (number of filters, input_channels, filter height,filter width)
:type pool: int 2-tuple
:param pool: the down-sampling (max-pooling) factor
:type activation_func: string
:param activation_func: Options: tanh, relu, sig, abs, linear, maxout <i>
:type enable_dropout: Bool
:param enable_dropout: whether to enable dropout in this layer. The default rate is 0.5 but it can be changed with
self.activation_noise.set_value(set_value(np.float32(p)) or using cnn.setDropoutRates
:type use_fragment_pooling: Bool
:param use_fragment_pooling: whether to use max fragment pooling in this layer (MFP)
:type reshape_output: Bool
:param reshape_output: whether to reshape class_probabilities to (bs, cls, x, y) and re-assemble fragments
to dense images if MFP was enabled. Use this in for the last layer.
:type mfp_offsets: list of list of ints
:param mfp_offsets: this lists specifies the offsets that the MFP-fragments have w.r.t to the original patch.
Only needed if MFP is enabled.
:type mfp_strides: list of int
:param mfp_strides: the strides of the output in each dimension
:type input_layer: layer object
:param input_layer: just for keeping track of un-usual input layers
:type W: np.ndarray or T.TensorVariable
:param W: weight matrix. If array, the values are used to initialise a shared variable for this layer.
If TensorVariable, than this variable is directly used (weight sharing with the
layer from which this variable comes from)
:type b: np.ndarray or T.TensorVariable
:param b: bias vector. If array, the values are used to initialise a shared variable for this layer.
If TensorVariable, than this variable is directly used (weight sharing with the
layer from which this variable comes from)
:type pooling_mode: str
:param pooling_mode: 'max' or 'maxabs' where the first is normal maxpooling and the second also retains
sign of large negative values
"""
def __init__(self,
input,
input_shape,
filter_shape,
pool,
activation_func,
enable_dropout,
use_fragment_pooling,
reshape_output,
mfp_offsets,
mfp_strides,
input_layer=None,
W=None,
b=None,
pooling_mode='max'):
assert input_shape[1] == filter_shape[1]
self.input = input
self.pool = pool
self.number_of_filters = filter_shape[0]
self.filter_shape = filter_shape
self.activation_func = activation_func
self.input_shape = input_shape
self.input_layer = input_layer
self.mfp_strides = mfp_strides
self.mfp_offsets = mfp_offsets
self.reshape_output = reshape_output
print "2DConv: input=", input_shape, "\tfilter=", filter_shape #,"@std=",W_bound
if W is None:
W_values = np.asarray(
initWeights(filter_shape,
scale='glorot',
mode='normal',
pool=pool),
dtype='float32')
self.W = theano.shared(W_values, name='W_conv', borrow=True)
else:
if isinstance(W, np.ndarray):
self.W = theano.shared(
W.astype(np.float32),
name='W_conv',
borrow=True)
else:
assert isinstance(W, T.TensorVariable), "W must be either np.ndarray or theano var"
self.W = W
if b is None:
n_out = filter_shape[0]
if activation_func == 'relu' or activation_func == 'ReLU':
norm = filter_shape[2] * filter_shape[3]
b_values = np.asarray(
initWeights(
(n_out, ),
scale=1.0 / norm,
mode='const'),
dtype='float32')
elif activation_func == 'sigmoid':
b_values = np.asarray(
initWeights(
(n_out, ),
scale=0.5,
mode='const'),
dtype='float32')
else: # activation_func=='tanh':
b_values = np.asarray(
initWeights(
(n_out, ),
scale=1e-6,
mode='fix-uni'),
dtype='float32')
self.b = theano.shared(value=b_values, borrow=True, name='b_conv')
else:
if isinstance(b, np.ndarray):
self.b = theano.shared(
b.astype(np.float32),
name='b_conv',
borrow=True)
else:
assert isinstance(b, T.TensorVariable), "b must be either np.ndarray or theano var"
self.b = b
# store parameters of this layer
self.params = [self.W, self.b]
# convolve input feature maps with filters
# shape of pooled_out , e.g.: (1,2,27,27) for 2 class-output
self.conv_out = conv.conv2d(
input=input,
filters=self.W,
border_mode='valid',
filter_shape=filter_shape
) # image_shape = input_shape if input_shape[0] is not None else None)
# down-sample each feature map individually, using maxpooling
if np.any(pool != 1):
pool_func = lambda x: pooling.pooling2d(x, pool_shape=pool, mode=pooling_mode)
if use_fragment_pooling:
pooled_out, self.mfp_offsets, self.mfp_strides = self.fragmentpool(
self.conv_out, pool, mfp_offsets, mfp_strides, pool_func)
else:
#pooled_out = downsample.max_pool_2d(input=self.conv_out, ds=pool, ignore_border=True)
pooled_out = pool_func(self.conv_out)
else:
pooled_out = self.conv_out
if enable_dropout:
#print "Dropout: ACTIVE"
self.activation_noise = theano.shared(np.float32(0.5), name='Dropout Rate')
rng = T.shared_randomstreams.RandomStreams(int(time.time()))
p = 1 - self.activation_noise
self.dropout_gate = 1.0 / p * rng.binomial(
(pooled_out.shape[2], pooled_out.shape[3]),
1,
p,
dtype='float32')
pooled_out = pooled_out * self.dropout_gate.dimshuffle(('x', 'x', 0, 1))
# add the bias term. Since the bias is a vector (1D array), we first
# reshape it to a tensor of shape (1,n_filters,1,1). Each bias will
# thus be broadcasted across mini-batches and feature maps
# width & height
r = 1 # maxout factor
lin_output = pooled_out + self.b.dimshuffle('x', 0, 'x', 'x')
if activation_func == 'tanh':
self.output = T.tanh(lin_output) # shape: (batch_size, num_outputs)
elif activation_func in ['ReLU', 'relu']: #rectified linear unit
self.output = lin_output * (lin_output > 0) # shape: (batch_size, num_outputs)
elif activation_func in ['sigmoid']:
self.output = T.nnet.sigmoid(lin_output)
elif activation_func in ['abs']:
self.output = T.abs_(lin_output)
elif activation_func in ['linear']:
self.output = lin_output
elif activation_func.startswith("maxout"):
r = int(activation_func.split(" ")[1])
assert r >= 2
self.output = pooling.maxout(lin_output, factor=r)
else:
raise NotImplementedError()
output_shape = getOutputShape(input_shape, filter_shape, pool, use_fragment_pooling, r)
print "Output =", output_shape, "Dropout", ("ON," if enable_dropout else "OFF,"), "Act:",\
activation_func, "pool:", pooling_mode
self.output_shape = output_shape # e.g. (None, 16, 100, 100)
sh = lin_output.shape # (bs,ch,x,y) # use this shape to reshape the output to image-shape after softmax
sh = (sh[1], sh[2], sh[3], sh[0]) #(ch, x, y, bs)
# put batchsize, at back --> (ch,x,y,bs), flatten this --> (ch, x*y*bs), swap labels --> (x*y*bs, ch)
self.class_probabilities = T.nnet.softmax(lin_output.dimshuffle((1, 2, 3, 0)).flatten(2).dimshuffle((1, 0)))
if reshape_output:
self.reshapeoutput(sh)
if use_fragment_pooling:
self.fragmentstodense(sh)
self.prob_shape = getProbShape(output_shape, self.mfp_strides)
print "Class Prob Output =", self.prob_shape
# compute prediction as class whose "probability" is maximal in symbolic form
self.class_prediction = T.argmax(self.class_probabilities, axis=1)
#output has shape e.g. (1,2,57,57); only the last two may change, 2 classes are predicted
[docs] def fragmentpool(self, conv_out, pool, offsets, strides, pool_func):
result = []
offsets_new = []
if offsets is None:
offsets = np.array([[0, 0]])
if strides is None:
strides = [1, 1]
sh = conv_out.shape
for px in xrange(pool[0]):
for py in xrange(pool[1]):
pxy = pool_func(conv_out[:, :, px:sh[2] - pool[0] + px + 1, py:sh[3] - pool[1] + py + 1])
result.append(pxy)
for p in offsets:
new = p.copy()
new[0] += px * strides[0]
new[1] += py * strides[1]
offsets_new.append(new)
result = T.concatenate(result, axis=0)
offsets_new = np.array(offsets_new)
strides = np.multiply(pool, strides)
return result, offsets_new, strides
[docs] def reshapeoutput(self, sh):
# same shape as result, no significant time cost
self.class_probabilities = self.class_probabilities.dimshuffle((1, 0)).reshape(sh).dimshuffle((3, 0, 1, 2))
[docs] def fragmentstodense(self, sh):
mfp_strides = self.mfp_strides
example_stride = np.prod(mfp_strides) # This stride is conceptually unneeded but theano-grad fails otherwise
zero = np.array((0), dtype='float32')
embedding = T.alloc(zero, 1, sh[0], sh[1] * mfp_strides[0], sh[2] * mfp_strides[1])
ix = self.mfp_offsets
for i, (n, m) in enumerate(ix):
embedding = T.set_subtensor(
embedding[:, :, n::mfp_strides[0], m::mfp_strides[1]], self.class_probabilities[i::example_stride])
self.class_probabilities = embedding
[docs] def randomizeWeights(self, scale='glorot', mode='uni'):
n_out = self.filter_shape[0]
if self.activation_func == 'relu':
norm = self.filter_shape[2] * self.filter_shape[3]
b_values = np.asarray(
initWeights(
(n_out, ),
scale=1.0 / norm,
mode='const'),
dtype='float32')
elif self.activation_func == 'sigmoid':
b_values = np.asarray(
initWeights(
(n_out, ),
scale=0.5,
mode='const'),
dtype='float32')
else: #self.activation_func=='tanh':
b_values = np.asarray(
initWeights(
(n_out, ),
scale=1e-6,
mode='fix-uni'),
dtype='float32')
W_values = np.asarray(
initWeights(self.filter_shape,
scale,
mode,
pool=self.pool),
dtype='float32')
self.W.set_value(W_values)
self.b.set_value(b_values)
[docs] def gaborInitialisation(self):
nof, channel, x, y = self.filter_shape
if nof % 2 == 1:
ga = makeGaborFilters(x,
(nof - 1) / 2) / 10 # generate gabor filters
ga = np.concatenate(
(ga, blob(x)[:np.newaxis, :, :])) # add a blob filter
else:
ga = makeGaborFilters(x,
(nof - 2) / 2) / 10 # generate gabor filters
noise = np.random.normal(loc=0, scale=0.02, size=(x, y))
# add a blob and random filter
ga = np.concatenate(
(ga, blob(x)[np.newaxis, :, :] / 10, noise[np.newaxis, :, :]),
axis=0)
filters = np.zeros(self.filter_shape)
for i in xrange(3): # replicate filters for all colour channels
filters[:, i, :, :] = ga
self.W.set_value(np.asarray(filters, dtype='float32'))
# def negative_log_likelihood(self, y):
# """
# Returns the mean and instance-wise negative log-likelihood of the prediction
# of this model under a given target distribution.
#
# :type y: theano.tensor.TensorType
# :param y: corresponds to a vector that gives for each example the
# correct label
#
# Note: we use the mean instead of the sum so that
# the learning rate is less dependent on the batch size
# """
# # y.shape[0] is (symbolically) the number of rows in y, i.e.,
# # number of examples (call it n) in the minibatch
# # T.arange(y.shape[0]) is a symbolic vector which will contain [0,1,2,... n-1]
# # T.log(self.p_y_given_x) is a matrix of
# # Log-Probabilities (call it LP) with one row per example and
# # one column per class LP[T.arange(y.shape[0]),y] is a vector
# # v containing [LP[0,y[0]], LP[1,y[1]], LP[2,y[2]], ...,
# # LP[n-1,y[n-1]]] and T.mean(LP[T.arange(y.shape[0]),y]) is
# # the mean (across minibatch examples) of the elements in v,
# # i.e., the mean log-likelihood across the minibatch.
# # print "at least, y must be provided in a flattened view (a list of class values)!"
# #[T.arange(y.shape[0]), y] == [ (0,1,2,3,4,...),(1,0,1,1,0,....) ]
# # select in each row the corresponding class entry
# cls = T.arange(self.class_probabilities.shape[1]).dimshuffle('x', 0, 'x', 'x') # (1,4,1, 1 )
# y = y.dimshuffle(0, 'x', 1, 2) # (1,1,10,10)
# select = T.eq(cls, y).nonzero()
# nll_inst = -T.log(self.class_probabilities)[select]
# nll = T.mean(nll_inst)
#
# nll_inst = nll
# return nll, nll_inst
#
# def nll_classwise_masking(self, y, mask_class_labeled, mask_class_not_present):
# """
# Special Training objective function for lazy labelling
#
# :type y: theano.tensor.TensorType
# :param y: true classes (as integer values from 0 to (N_classes-1) ), shape = (batchsize, x, y)
#
#
# :mask_class_labeled:
# shape = (batchsize, num_classes).
# A binary mask indicating whether a class is labeled in ``y``. If an class ``k``
# is (in general) visible in the image data **and** ``mask_class_labeled[k]==1``, then
# the labels **must** obey``y=k`` in all pixels where it is visible.
# If a class ``k`` is visible in the image, but was not labeled (to save time), set the
# ``mask_class_labeled[k]=0``: if the CNN predicts classes which are
# masked to zero it will not incur any loss. Alternative: set ``y=-1`` to the value -1 in areas which shall
# be exempt from Training.
# Limit case: ``mask_class_labeled[:]==1`` will result in the ordinary NLL.
#
# :mask_class_not_present:
# shape = (batchsize, num_classes).
# A binary mask indicating whether a class is visible in the image data.
# ``mask_class_not_present[k]==1`` means that the image does **not** contain examples of this class (irrespective of
# the contents of <y> or <mask_class_labeled>).\
#
# Exemplary use case: set all <y>==-1 or <mask_class_labeled>==0 and indicate which classes should NOT
# be predicted by the classifier by setting the corresponding entries of <mask_class_not_present> to 1.
# This will push the predicted probabilities for those classes to zero.
# Limit case: ``mask_class_labeled[:]==0`` will result in the ordinary NLL.
#
# values of -1 in <y> count as "not labeled / ignore predictions"; \
# but this has NO PRIORITY over <mask_class_not_present>.
# """
# y = y.dimshuffle(0, 'x', 1, 2) #(batchsize, 1, x, y)
# cls = T.arange(self.class_probabilities.shape[1]).dimshuffle('x', 0, 'x', 'x') # available classes
#
# mask_class_labeled = mask_class_labeled.dimshuffle(0, 1, 'x', 'x') #(batchsize, num_classes,1 ,1)
# mask_class_not_present = mask_class_not_present.dimshuffle(0, 1, 'x', 'x') #(batchsize, num_classes,1 ,1)
# # Mask of unlabeled positions.
# # Apply to loss in order to ignore examples with label -1
# label_avail_mask = T.neq(y,-1)
#
# pred = self.class_probabilities # (batchsize, num_classes, x, y)
# # Mask of unlabelled positions but with value 0 where stuff is not labelled
# mod_y = T.where(y<0,0,y) # turns -1 in y to 0!
# # Binary mask with value of 1 at the position of the labeled class (0 for other classes)
# class_selection = T.eq(cls, mod_y)
# # dirty hack: compute "standard" nll when most predictive weight is put on classes which are in fact labeled
# # as indicated in <mask_class_labeled>; threshold is 50%
# votes_for_labeled = T.where( T.sum(pred*mask_class_labeled, axis=1)>=0.5, 1, 0 ).dimshuffle(0,'x',1,2)
#
# # could also add '* mask_class_labeled' inside, but this should not change anything , provided there is
# # no logical conflict between y and mask_class_labeled !
# # standard loss part -> increase p(correct_prediction); thus disabled if the "correct" class is not known
# nll_inst_up = -((T.log(pred) * votes_for_labeled * label_avail_mask * class_selection).sum(axis=1))
# # multiply <pred> with <label_avail_mask> if <y>==-1 should override 'unlabeled' areas (currently not the case).
# nll_inst_dn = -(T.log(1 - (pred * mask_class_not_present).sum(axis=1)))
#
# nll_inst = nll_inst_up + nll_inst_dn
# nll = T.mean(nll_inst)
# return nll, nll_inst
[docs] def NLL(self,
y,
class_weights=None,
mask_class_labeled=None,
mask_class_not_present=None,
label_prop_thresh=None):
"""
Returns the symbolic mean and instance-wise negative log-likelihood of the prediction
of this model under a given target distribution.
y: theano.tensor.TensorType
corresponds to a vector that gives for each example the correct label. Labels < 0 are ignored (e.g. can
be used for label propagation)
class_weights: theano.tensor.TensorType
weight vector of float32 of length ``n_lab``. Values: ``1.0`` (default), ``w < 1.0`` (less important),
``w > 1.0`` (more important class)
The following refers to lazy labels, the masks are always on a per patch basis, depending on the
origin cube of the patch. The masks are properties of the individual image cubes and must be loaded
into CNNData.
mask_class_labeled: theano.tensor.TensorType
shape = (batchsize, num_classes).
Binary masks indicating whether a class is properly labeled in ``y``. If a class ``k``
is (in general) present in the image patches **and** ``mask_class_labeled[k]==1``, then
the labels **must** obey ``y==k`` for all pixels where the class is present.
If a class ``k`` is present in the image, but was not labeled (-> cheaper labels), set
``mask_class_labeled[k]=0``. Then all pixels for which the ``y==k`` will be ignored.
Alternative: set ``y=-1`` to ignore those pixels.
Limit case: ``mask_class_labeled[:]==1`` will result in the ordinary NLL.
mask_class_not_present: theano.tensor.TensorType
shape = (batchsize, num_classes).
Binary mask indicating whether a class is present in the image patches.
``mask_class_not_present[k]==1`` means that the image does **not** contain examples of class ``k``.
Then for all pixels in the patch, class ``k`` predictive probabilities are trained towards ``0``.
Limit case: ``mask_class_not_present[:]==0`` will result in the ordinary NLL.
label_prop_thresh: float (0.5,1)
This threshold allows unsupervised label propagation (only for examples with negative/ignore labels).
If the predictive probability of the most likely class exceeds the threshold, this class is assumed to
be the correct label and the training is pushed in this direction.
Should only be used with pre-trained networks, and values <= 0.5 are disabled.
Examples:
- A cube contains no class ``k``. Instead of labelling the remaining classes they can be
marked as unlabelled by the first mask (``mask_class_labeled[:]==0``, whether ``mask_class_labeled[k]``
is ``0`` or ``1`` is actually indifferent because the labels should not be ``y==k`` anyway in this case).
Additionally ``mask_class_not_present[k]==1`` (otherwise ``0``) to suppress predictions of ``k`` in
in this patch. The actual value of the labels is indifferent, it can either be ``-1`` or it could be the
background class, if the background is marked as unlabelled (i.e. then those labels are ignored).
- Only part of the cube is densely labelled. Set ``mask_class_labeled[:]=1`` for all classes, but set the
label values in the un-labelled part to ``-1`` to ignore this part.
- Only a particular class ``k`` is labelled in the cube. Either set all other label pixels to ``-1`` or the
corresponding flags in ``mask_class_labeled`` for the unlabelled classes.
.. Note::
Using ``-1`` labels or telling that a class is not labelled, is somewhat redundant and just
supported for convenience.
"""
# NOTE: This whole function has a ugly problem with NaN. They arise for pred values close to 0 or 1
# (i.e. for NNs that make very confident and usually also correct predictions) because initially the log of
# all the whole pred tensor is taken. Later we want to use only some indices of the tensor (mask) but
# that is not so easy done. There are two ways:
# 1. advanced indexing: T.log(pred)[mask.nonzero()] --> fails if mask is all zero, cannot be fixed
# 2. mutiplying with 0-1-mask: T.log(pred) * mask.nonzero --> but NaN * 0 = NaN, but we require 0!
# For the second option, in principle, the NaNs could be replaced by 0 using T.switch, but then the gradient
# fails because the replaced value is disconnected from the parameters and gives NaN (mathematically
# the gradient should correctly be 0 then; there is a Theano ticket open to request a fix).
# So finally the best practice is to add a stabilisation to the log: T.log(pred) --> T.log(pred+eps)
# This looks ugly, but does the task and the introduced error is completely negligible.
eps = 1e-6
pred = self.class_probabilities # predictive (bs, cl, x, y)
y = y.dimshuffle(0, 'x', 1, 2) # the labels (bs, 1, x, y)
cls = T.arange(self.class_probabilities.shape[1]).dimshuffle('x', 0, 'x', 'x') # available classes
label_selection = T.eq(cls, y) # selects correct labels
if class_weights is None:
class_weights = T.ones_like(pred)
else:
class_weights = class_weights.dimshuffle('x', 0, 'x', 'x')
# Up vote block
if mask_class_labeled is not None: # Standard
mask_class_labeled = mask_class_labeled.dimshuffle(0, 1, 'x', 'x')
label_selection = (label_selection * mask_class_labeled)
nll_inst_up = -T.log(pred + eps) * label_selection * class_weights
N_up = T.sum(label_selection) # number of labelled examples
if label_prop_thresh is not None: # Label propagation block
above_thresh = pred > label_prop_thresh # this is one for the class with highes prob
prop_mask = above_thresh * (1 - mask_class_labeled) # don't do where training labels are available
nll_inst_up_prop = -T.log(pred + eps) * prop_mask * class_weights
N_up_prop = prop_mask.sum()
nll_inst_up += nll_inst_up_prop
N_up += N_up_prop
if mask_class_not_present is not None: # Down vote block
mask_class_not_present = mask_class_not_present.dimshuffle(0, 1, 'x', 'x')
nll_inst_dn = -T.log(1.0 - (pred * mask_class_not_present * class_weights) + eps)
N_dn = mask_class_not_present.sum() # number of not present classes examples
else:
nll_inst_dn = 0.0
N_dn = 0.0
nll_inst = (nll_inst_up + nll_inst_dn).sum(axis=1)
N_total = (N_up + N_dn)
# patch N_total to be not 0, when this is the case the sum is 0 anyway:
N_total = T.switch(T.eq(N_total, 0), 1, N_total)
nll = (nll_inst_up + nll_inst_dn).sum() / N_total
return nll, nll_inst
[docs] def NLL_weak(self,
y,
class_weights=None,
mask_class_labeled=None,
mask_class_not_present=None,
label_prop_thresh=None):
"""
NLL that mixes the current cnn output and the hard labels as target
"""
eps = 1e-6
pred = self.class_probabilities # predictive (bs, cl, x, y)
y = y.dimshuffle(0, 'x', 1, 2) # the labels (bs, 1, x, y)
cls = T.arange(self.class_probabilities.shape[1]).dimshuffle('x', 0, 'x', 'x') # available classes
hard_labels = T.eq(cls, y) # selects correct labels
soft_labels = 0.5 * hard_labels + 0.5 * pred
if class_weights is None:
class_weights = T.ones_like(pred)
else:
class_weights = class_weights.dimshuffle('x', 0, 'x', 'x')
nll_inst_up = -(soft_labels * T.log(pred + eps)) * class_weights
#nll_inst_up = - 0.5 * (hard_labels * T.log(pred + eps)) - 0.5 * (pred * T.log(pred + eps))
#nll_inst_up = -T.log(pred + eps) * class_weights
N_up = T.sum(hard_labels) # number of labelled examples
nll_inst_dn = 0.0
N_dn = 0.0
N_total = (N_up + N_dn)
# patch N_total to be not 0, when this is the case the sum is 0 anyway:
N_total = T.switch(T.eq(N_total, 0), 1, N_total)
nll = (nll_inst_up + nll_inst_dn).sum() / N_total
return nll, nll
[docs] def squared_distance(self, y):
"""
Returns squared distance between prediction and ``y``
:type y: theano.tensor.TensorType
:param y: corresponds to a vector that gives for each example the
correct label
"""
y = y.dimshuffle(0, 'x', 1, 2,) # add "class" axis
se_inst = (self.output - y)**2
mse = T.mean(se_inst)
return mse, se_inst
[docs] def errors(self, y):
"""
Returns classification accuracy
:type y: theano.tensor.TensorType
:param y: corresponds to a vector that gives for each example the
correct label
"""
# check if y has same dimension of y_pred
if y.ndim != self.class_prediction.ndim:
raise TypeError('y should have the same shape as self.class_prediction',
('y', y.type, 'class_prediction', self.class_prediction.type))
# check if y is of the correct datatype
if y.dtype.startswith('int'):
return T.mean(T.neq(self.class_prediction, y)[T.ge(y, 0).nonzero()])
else:
print "something went wrong"
raise NotImplementedError()
if __name__ == "__main__":
pass
