def make_node(self, val, rv=None): """Make an `Observed` random variable. Parameters ---------- val: Variable The observed value. rv: RandomVariable The distribution from which `val` is assumed to be a sample value. """ val = tt.as_tensor_variable(val) if rv: if rv.owner and not isinstance(rv.owner.op, RandomVariable): raise ValueError(f"`rv` must be a RandomVariable type: {rv}") if rv.type.convert_variable(val) is None: raise ValueError( ("`rv` and `val` do not have compatible types:" f" rv={rv}, val={val}")) else: rv = tt.NoneConst.clone() inputs = [val, rv] return tt.Apply(self, inputs, [val.type()])
def make_node(self, *matrices): if not matrices: raise ValueError('no matrices to allocate') matrices = list(map(tt.as_tensor, matrices)) if any(mat.type.ndim != 2 for mat in matrices): raise TypeError('all data arguments must be matrices') if self.sparse: out_type = theano.sparse.matrix(self.format, dtype=largest_common_dtype(matrices)) else: out_type = theano.tensor.matrix(dtype=largest_common_dtype(matrices)) return tt.Apply(self, matrices, [out_type])
def make_node(self, diag): diag = tt.as_tensor_variable(diag) if diag.type.ndim != 2: raise TypeError('data argument must be a matrix', diag.type) return tt.Apply(self, [diag], [tt.tensor3(dtype=diag.dtype)])
def make_node(self, x): x = tt.as_tensor_variable(x) return tt.Apply(self, [x], [x.type()])
def make_node(self, x): x = tt.as_tensor_variable(x) if x.ndim != 2: raise ValueError('Matrix must me two dimensional.') return tt.Apply(self, [x], [x.type()])
def run( model_name='alexnet', layer_names=['data', 'conv1', 'conv2', 'conv3', 'conv4', 'conv5'], layer_target=['conv1', 'conv2', 'conv3', 'conv4', 'conv5'], image_size=(227, 227), target_layer='fc8', ): # paramters dim_target = 1000 directory = './theanomodel' filename_model = ('%s/%s_vlm_%s.pkl' % (directory, model_name, '_'.join(layer_names))) filename_save = ('%s/%s_vlm_%s_reconstructor.pkl' % (directory, model_name, '_'.join(layer_names))) # hyper-parameters lambda_loss = theano.shared(np.zeros(2)) lambda_layer = theano.shared(np.zeros(len(layer_target))) # model = pickle.load(open(filename_model)) # input x_init = np.zeros((1, 3, image_size[0], image_size[1])).astype(np.float32) x = theano.shared(x_init, borrow=False) xx = T.tensor4() xx_shared = theano.shared(np.zeros(x_init.shape).astype(np.float32)) T.Apply(T.add, [x + xx], [model['data']]) # loss_target target_shared = theano.shared(np.zeros(dim_target).astype(np.float32)) mean_std = pickle.load( open('%s/%s_mean_std_%s.pkl' % (directory, model_name, target_layer))) loss_target = ( ((model[target_layer] - target_shared[None, :, None, None]) / mean_std['std'][None, :, None, None])**2).mean() # loss_lm loss_lm = T.sum([ lambda_layer[i] * model['loss_lm_%s' % layer_target[i]] for i in range(len(layer_target)) ]) # total loss loss = (lambda_loss[0] * loss_target + lambda_loss[1] * loss_lm) # functions solver = solvers.SGD(loss, [], [x], givens={xx: xx_shared}) # save data = { 'solver': solver, 'x': x, 'lambda_loss': lambda_loss, 'lambda_layer': lambda_layer, 'target': target_shared, } sys.setrecursionlimit(100000) pickle.dump( data, open(filename_save, 'wb'), protocol=pickle.HIGHEST_PROTOCOL, )