text: 
  import numpy as np
  import theano,theano.tensor as T
  
  from lasagne.layers import *
  from lasagne.layers import Conv2DLayer as ConvLayer
  from lasagne.layers import MaxPool2DLayer as PoolLayerDNN
  from lasagne.layers import MaxPool2DLayer as PoolLayer
  from lasagne.layers import LocalResponseNormalization2DLayer as LRNLayer
  from lasagne.nonlinearities import softmax, linear
  
  
  def build_inception_module(name, input_layer, nfilters):
      # nfilters: (pool_proj, 1x1, 3x3_reduce, 3x3, 5x5_reduce, 5x5)
      net = {}
      net['pool'] = PoolLayerDNN(input_layer, pool_size=3, stride=1, pad=1)
      net['pool_proj'] = ConvLayer(net['pool'], nfilters[0], 1)
  
      net['1x1'] = ConvLayer(input_layer, nfilters[1], 1)
  
      net['3x3_reduce'] = ConvLayer(input_layer, nfilters[2], 1)
      net['3x3'] = ConvLayer(net['3x3_reduce'], nfilters[3], 3, pad=1)
  
      net['5x5_reduce'] = ConvLayer(input_layer, nfilters[4], 1)
      net['5x5'] = ConvLayer(net['5x5_reduce'], nfilters[5], 5, pad=2)
  
      net['output'] = ConcatLayer([
          net['1x1'],
          net['3x3'],
          net['5x5'],
          net['pool_proj'],
          ])
  
      return {'{}/{}'.format(name, k): v for k, v in net.items()}
  
  
  def build_model():
      net = {}
      net['input'] = InputLayer((None, 3, None, None))
      net['conv1/7x7_s2'] = ConvLayer(net['input'], 64, 7, stride=2, pad=3)
      net['pool1/3x3_s2'] = PoolLayer(net['conv1/7x7_s2'],
                                      pool_size=3,
                                      stride=2,
                                      ignore_border=False)
      net['pool1/norm1'] = LRNLayer(net['pool1/3x3_s2'], alpha=0.00002, k=1)
      net['conv2/3x3_reduce'] = ConvLayer(net['pool1/norm1'], 64, 1)
      net['conv2/3x3'] = ConvLayer(net['conv2/3x3_reduce'], 192, 3, pad=1)
      net['conv2/norm2'] = LRNLayer(net['conv2/3x3'], alpha=0.00002, k=1)
      net['pool2/3x3_s2'] = PoolLayer(net['conv2/norm2'], pool_size=3, stride=2)
  
      net.update(build_inception_module('inception_3a',
                                        net['pool2/3x3_s2'],
                                        [32, 64, 96, 128, 16, 32]))
      net.update(build_inception_module('inception_3b',
                                        net['inception_3a/output'],
                                        [64, 128, 128, 192, 32, 96]))
      net['pool3/3x3_s2'] = PoolLayer(net['inception_3b/output'],
                                      pool_size=3, stride=2)
  
      net.update(build_inception_module('inception_4a',
                                        net['pool3/3x3_s2'],
                                        [64, 192, 96, 208, 16, 48]))
      net.update(build_inception_module('inception_4b',
                                        net['inception_4a/output'],
                                        [64, 160, 112, 224, 24, 64]))
      net.update(build_inception_module('inception_4c',
                                        net['inception_4b/output'],
                                        [64, 128, 128, 256, 24, 64]))
      net.update(build_inception_module('inception_4d',
                                        net['inception_4c/output'],
                                        [64, 112, 144, 288, 32, 64]))
      net.update(build_inception_module('inception_4e',
                                        net['inception_4d/output'],
                                        [128, 256, 160, 320, 32, 128]))
      net['pool4/3x3_s2'] = PoolLayer(net['inception_4e/output'],
                                      pool_size=3, stride=2)
  
      net.update(build_inception_module('inception_5a',
                                        net['pool4/3x3_s2'],
                                        [128, 256, 160, 320, 32, 128]))
      net.update(build_inception_module('inception_5b',
                                        net['inception_5a/output'],
                                        [128, 384, 192, 384, 48, 128]))
  
      net['pool5/7x7_s1'] = GlobalPoolLayer(net['inception_5b/output'])
      net['loss3/classifier'] = DenseLayer(net['pool5/7x7_s1'],
                                           num_units=1000,
                                           nonlinearity=linear)
      net['prob'] = NonlinearityLayer(net['loss3/classifier'],
                                      nonlinearity=softmax)
      return net
  
  
  import skimage.transform
  import numpy as np
  MEAN_VALUES = np.array([104, 117, 123]).reshape((3,1,1))
  def preprocess(im):
      if len(im.shape) == 2:
          im = im[:, :, np.newaxis]
          im = np.repeat(im, 3, axis=2)
      # Resize so smallest dim = 224, preserving aspect ratio
      h, w, _ = im.shape
      if h < w:
          im = skimage.transform.resize(im, (224, w*224//h), preserve_range=True)
      else:
          im = skimage.transform.resize(im, (h*224//w, 224), preserve_range=True)
  
      # Central crop to 224x224
      h, w, _ = im.shape
      im = im[h//2-112:h//2+112, w//2-112:w//2+112]
      
      rawim = np.copy(im).astype('uint8')
      
      # Shuffle axes to c01
      im = np.swapaxes(np.swapaxes(im, 1, 2), 0, 1)
      
      # Convert to BGR
      im = im[::-1, :, :]
  
      im = im - MEAN_VALUES
      return im[np.newaxis].astype('float32')
  
  #build and compile model
  import pickle
  lenet = build_model()
  lenet_weights = pickle.load(open('data/blvc_googlenet.pkl'))['param values']
  set_all_param_values(lenet["prob"], lenet_weights)
  
  cnn_input_var = lenet['input'].input_var
  cnn_feature_layer = lenet['inception_5b/output']
  get_cnn_features = theano.function([cnn_input_var], get_output(cnn_feature_layer))
  
  pca = pickle.load(open("./data/svd.pcl"))
  
  
  def image_to_features(im):
      assert len(im.shape) ==3 and im.shape[2]==3,"You should provide an RGB image of shape [h,w,3]"
      im = preprocess(im)
      cnn_features = get_cnn_features(im)[0]
      H,W = cnn_features.shape[-2:]
      cnn_features_flat = cnn_features.transpose([1,2,0]).reshape([-1,1024])
      svd_features_flat = pca.transform(cnn_features_flat)
      return svd_features_flat.reshape([H,W,-1]).transpose([2,0,1])
  