def __init__(self, **kwargs):
"""Initializes an inner product layer.
kwargs:
num_output: the number of outputs.
reg: the regularizer to be used to add regularization terms.
should be a sparse.base.Regularizer instance. Default None.
filler: a filler to initialize the weights. Should be a
sparse.base.Filler instance. Default None.
bias_filler: a filler to initialize the bias.
bias: if True, the inner product will contain a bias term.
Default True.
"""
base.Layer.__init__(self, **kwargs)
self._num_output = self.spec.get('num_output', 0)
if self._num_output <= 0:
raise base.InvalidLayerError(
'Incorrect or unspecified num_output for %s' % self.name)
self._reg = self.spec.get('reg', None)
self._filler = self.spec.get('filler', None)
self._weight = base.Blob(filler=self._filler)
self._has_bias = self.spec.get('bias', True)
if self._has_bias:
self._bias_filler = self.spec.get('bias_filler', None)
self._bias = base.Blob(filler=self._bias_filler)
self._param = [self._weight, self._bias]
else:
self._param = [self._weight]
def whitened_images(dtype=np.float64):
"""Returns the whitened images provided in the Sparsenet website:
http://redwood.berkeley.edu/bruno/sparsenet/
The returned data will be in the shape (10,512,512,1) to fit
the blob convension.
"""
npzdata = np.load(os.path.join(_DATA_PATH, 'whitened_images.npz'))
blob = base.Blob(npzdata['images'].shape, dtype)
blob.data().flat = npzdata['images'].flat
return blob
def __init__(self, **kwargs):
"""Initializes a Dropout layer.
kwargs:
name: the layer name.
ratio: the ratio to carry out dropout.
debug_freeze: a debug flag. If set True, the mask will only
be generated once when running. You should not use it other
than purposes like gradient check.
"""
base.Layer.__init__(self, **kwargs)
filler = fillers.DropoutFiller(ratio=self.spec['ratio'])
self._mask = base.Blob(filler=filler)
def initialize_status(self):
"""Initializes the status."""
# we need to maintain the momentum history
params = self._sparse_net.params()
self._accum = [
base.Blob(p.data().shape,
p.data().dtype) for p in params
]
for accum in self._accum:
accum_data = accum.data()
accum_data[:] = self.spec['base_accum']
# we initialize the diff as a buffer when computing things later.
accum.init_diff()
def __init__(self, **kwargs):
"""Initalizes the layer.
kwargs:
k, alpha, beta: as defined in the equation.
size: the local range.
"""
base.Layer.__init__(self, **kwargs)
self._k = self.spec['k']
self._alpha = self.spec['alpha']
self._beta = self.spec['beta']
self._size = self.spec['size']
self._scale = base.Blob()
def _collect_params(self, realloc=False):
"""Collect the network parameters into a long vector.
"""
params_list = self._sparse_net.params()
if self._param is None or realloc:
total_size = sum(p.data().size for p in params_list)
dtype = max(p.data().dtype for p in params_list)
self._param = base.Blob(shape=total_size, dtype=dtype)
self._param.init_diff()
current = 0
collected_param = self._param.data()
collected_diff = self._param.diff()
for param in params_list:
size = param.data().size
collected_param[current:current + size] = param.data().flat
# If we are computing mpi, we will need to reduce the diff.
diff = param.diff()
if mpi.SIZE > 1:
part = collected_diff[current:current + size]
part.shape = diff.shape
mpi.COMM.Allreduce(diff, part)
else:
collected_diff[current:current + size] = diff.flat
current += size
NUM_HIDDEN = 25
INIT_SCALE = np.sqrt(6. / (NUM_HIDDEN + PSIZE * PSIZE + 1))
MAXFUN = 500
np.random.seed(1701)
################################################
# Generating training data.
################################################
logging.getLogger().setLevel(logging.INFO)
logging.info('*** Get patches ***')
images = smalldata.whitened_images()
patch_extractor = core_layers.RandomPatchLayer(name='extractor',
psize=PSIZE,
factor=NUM_PATCHES / 10)
patches = base.Blob()
patch_extractor.forward([images], [patches])
logging.info('*** Patch stats: %s', str(patches.data().shape))
logging.info('*** Normalize patches ***')
patches_data = patches.data()
# subtract mean
patches_data -= patches_data.mean(axis=0)
std = patches_data.std()
np.clip(patches_data, -std * 3, std * 3, out=patches_data)
# We shrink the patch range a little, to [0.1, 0.9]
patches_data *= 0.4 / std / 3.
patches_data += 0.5
logging.info('*** Finished Patch Preparation ***')
#############################################
# Creating the decaf net for the autoencoder.
def __getstate__(self):
"""When pickling, we will remove the intermediate data."""
self._scale = base.Blob()
return self.__dict__
def __init__(self, **kwargs):
base.LossLayer.__init__(self, **kwargs)
self._prob = base.Blob()
else:
# EXECUTION
file_name = net.layers['input-layer'].input_file.split('/')[-1].split('.')[0]
net.load_from(NET_MODEL)
net.layers['fc8']._num_output = 2
fp = open('feat.%s'%(file_name), 'w')
fp_rnorm1 = open('plibsvm_1.%s'%(file_name), 'w')
fp_rnorm2 = open('plibsvm_2.%s'%(file_name), 'w')
fp_conv3 = open('plibsvm_3.%s'%(file_name), 'w')
fp_conv4 = open('plibsvm_4.%s'%(file_name), 'w')
fp_conv5 = open('plibsvm_5.%s'%(file_name), 'w')
fp_flatten = open('plibsvm_6.%s'%(file_name), 'w')
for i in range(net.layers['input-layer'].get_num_images()):
print "\nprocessing image %d"%(i)
top = [base.Blob(), base.Blob()]
feat = net.predict(output_blobs=['rnorm1_cudanet_out', 'rnorm2_cudanet_out', 'conv3_neuron_cudanet_out',
'conv4_neuron_cudanet_out', 'conv5_neuron_cudanet_out', '_sparse_fc6_flatten_out', 'labels',])
label = np.where(feat['labels'][0] == 1.)[0][0]
fp_rnorm1.write('%d '%(label))
fp_rnorm2.write('%d '%(label))
fp_conv3.write('%d '%(label))
fp_conv4.write('%d '%(label))
fp_conv5.write('%d '%(label))
fp_flatten.write('%d '%(label))
#first layer
cnt = 1
for val in feat['rnorm1_cudanet_out'].reshape((10, np.prod(feat['rnorm1_cudanet_out'].shape[1:])))[4]:
def __init__(self, **kwargs):
"""Initializes the convolution layer. Strictly, this is a correlation
layer since the kernels are not reversed spatially as in a classical
convolution operation.
kwargs:
name: the name of the layer.
num_kernels: the number of kernels.
ksize: the kernel size. Kernels will be square shaped and have the
same number of channels as the data.
stride: the kernel stride.
mode: 'valid', 'same', or 'full'.
pad: if set, this value will overwrite the mode and we will use
the given pad size. Default None.
reg: the regularizer to be used to add regularization terms.
should be a sparse.base.Regularizer instance. Default None.
filler: a filler to initialize the weights. Should be a
sparse.base.Filler instance. Default None.
has_bias: specifying if the convolutional network should have a
bias term. Note that the same bias is going to be applied
regardless of the location. Default True.
bias_filler: a filler to unitialize the bias. Should be a
sparse.base.Filler instance. Default None.
large_mem: if set True, the layer will consume a lot of memory by
storing all the intermediate im2col results, but will increase
the backward operation time. Default False.
When computing convolutions, we will always start from the top left
corner, and any rows/columns on the right and bottom sides that do not
fit the stride will be discarded. To enforce the 'same' mode to return
results of the same size as the data, we require the 'same' mode to be
paired with an odd number as the kernel size.
"""
base.Layer.__init__(self, **kwargs)
#now self.spec = kwargs
self._num_kernels = self.spec['num_kernels']
self._ksize = self.spec['ksize']
self._stride = self.spec['stride'] #<------- ------- -------- -------- How much we should move (step)
self._large_mem = self.spec.get('large_mem', False)
self._reg = self.spec.get('reg', None)
self._has_bias = self.spec.get('has_bias', True)
if self._ksize <= 1:
raise ValueError('Invalid kernel size. Kernel size should > 1.')
# since the im2col operation often creates large intermediate matrices,
# we will process them in batches.
self._padded = base.Blob()
self._col = base.Blob()
# set up the parameter
self._kernels = base.Blob(filler=self.spec.get('filler', None))
self._base_kernels = base.Blob(filler=self.spec.get('filler', None))
if self._has_bias:
self._bias = base.Blob(filler=self.spec.get('bias_filler', None))
self._param = [self._kernels, self._bias]
else:
self._param = [self._kernels]
self._pad_size = self.spec.get('pad', None)
if self._pad_size is None:
self._mode = self.spec['mode']
if self._mode == 'same' and self._ksize % 2 == 0:
raise ValueError(
'The "same" mode should have an odd kernel size.')
if self._mode == 'valid':
self._pad_size = 0
elif self._mode == 'full':
self._pad_size = self._ksize - 1
elif self._mode == 'same':
self._pad_size = int(self._ksize / 2)
else:
raise ValueError('Unknown mode: %s' % self._mode)
