Exemplo n.º 1
0
    def create_small_net_with_conv_layer(self, conv_layer,
                                               outputs_per_channel):
        self.conv_layer = conv_layer
        self.conv_layer.set_inputs(self.input_layer)

        self.flatten_layer = blobs.Flatten()
        self.flatten_layer.set_inputs(self.conv_layer)

        self.dense_layer = blobs.Dense(
                           W=(np.array(
                              [([1.0]*outputs_per_channel)+
                               ([-1.0]*outputs_per_channel)]).T
                              .astype("float32")),
                           b=np.array([1]).astype("float32"),
                           dense_mxts_mode=DenseMxtsMode.Linear)
        self.dense_layer.set_inputs(self.flatten_layer)

        self.dense_layer.build_fwd_pass_vars()
        self.input_layer.reset_mxts_updated()
        self.dense_layer.set_scoring_mode(blobs.ScoringMode.OneAndZeros)
        self.dense_layer.set_active()
        self.input_layer.update_mxts()

        self.inp = (np.arange(16).reshape((2,2,4))
                    .astype("float32"))
Exemplo n.º 2
0
 def prepare_batch_norm_deeplift_model(self, axis):
     self.input_layer = blobs.Input(num_dims=None, shape=(None,2,2,2))
     if (self.keras_version <= 0.3):
         std = self.std
         epsilon = self.epsilon
     else:
         std = np.sqrt(self.std+self.epsilon)
         epsilon = 0
     self.batch_norm_layer = blobs.BatchNormalization(
                              gamma=self.gamma,
                              beta=self.beta,
                              axis=axis,
                              mean=self.mean,
                              std=std,
                              epsilon=epsilon)
     self.batch_norm_layer.set_inputs(self.input_layer)
     self.flatten_layer = blobs.Flatten()
     self.flatten_layer.set_inputs(self.batch_norm_layer)
     self.dense_layer = blobs.Dense(
                         W=np.ones((1,8)).T,
                         b=np.zeros(1),
                         dense_mxts_mode=DenseMxtsMode.Linear)
     self.dense_layer.set_inputs(self.flatten_layer)
     self.dense_layer.build_fwd_pass_vars()
     self.dense_layer.set_scoring_mode(blobs.ScoringMode.OneAndZeros)
     self.dense_layer.set_active()
     self.dense_layer.update_task_index(0)
     self.input_layer.update_mxts()
Exemplo n.º 3
0
    def create_small_net_with_pool_layer(self, pool_layer,
                                         outputs_per_channel):
        self.pool_layer = pool_layer
        self.pool_layer.set_inputs(self.input_layer)

        self.flatten_layer = blobs.Flatten()
        self.flatten_layer.set_inputs(self.pool_layer)

        self.dense_layer = blobs.Dense(W=np.array([
            ([2] * outputs_per_channel) + ([3] * outputs_per_channel)
        ]).astype("float32").T,
                                       b=np.array([1]).astype("float32"),
                                       dense_mxts_mode=DenseMxtsMode.Linear)
        self.dense_layer.set_inputs(self.flatten_layer)

        self.dense_layer.build_fwd_pass_vars()
        self.dense_layer.set_scoring_mode(blobs.ScoringMode.OneAndZeros)
        self.dense_layer.set_active()
        self.input_layer.update_mxts()
Exemplo n.º 4
0
    def setUp(self):
        self.input_layer1 = blobs.Input(num_dims=None, shape=(None,1,1,1))
        self.input_layer2 = blobs.Input(num_dims=None, shape=(None,1,1,1))
        self.concat_layer = blobs.Concat(axis=1)
        self.concat_layer.set_inputs([self.input_layer1, self.input_layer2])
        self.flatten_layer = blobs.Flatten()
        self.flatten_layer.set_inputs(self.concat_layer)
        self.dense_layer = blobs.Dense(
         W=np.array([([1,2])]).T, b=[1], dense_mxts_mode=DenseMxtsMode.Linear)
        self.dense_layer.set_inputs(self.flatten_layer)
        self.dense_layer.build_fwd_pass_vars()

        self.input_layer1.reset_mxts_updated()
        self.input_layer2.reset_mxts_updated()
        self.dense_layer.set_scoring_mode(blobs.ScoringMode.OneAndZeros)
        self.dense_layer.set_active()
        self.input_layer1.update_mxts()
        self.input_layer2.update_mxts()

        self.inp1 = np.arange(2).reshape((2,1,1,1))+1
        self.inp2 = np.arange(2).reshape((2,1,1,1))+1
Exemplo n.º 5
0
def flatten_conversion(layer, name, verbose, **kwargs):
    return [blobs.Flatten(name=name, verbose=verbose)]
Exemplo n.º 6
0
def flatten_conversion(layer, name, mxts_mode):
    #mxts_mode not used
    return [blobs.Flatten(name=name)]