def __init__(self,
layer,
state,
alpha=None,
beta=None,
bias=True,
copy_weights=False):
alpha, beta = rutils.assert_infer_lrp_alpha_beta_param(
alpha, beta, self)
self._alpha = alpha
self._beta = beta
# prepare positive and negative weights for computing positive
# and negative preactivations z in apply_accordingly.
if copy_weights:
weights = layer.get_weights()
if not bias:
weights = weights[:-1]
positive_weights = [x * (x > 0) for x in weights]
negative_weights = [x * (x < 0) for x in weights]
else:
weights = layer.weights
if not bias:
weights = weights[:-1]
positive_weights = [x * iK.to_floatx(x > 0) for x in weights]
negative_weights = [x * iK.to_floatx(x < 0) for x in weights]
self._layer_wo_act_positive = kgraph.copy_layer_wo_activation(
layer,
keep_bias=bias,
weights=positive_weights,
name_template="reversed_kernel_positive_%s")
self._layer_wo_act_negative = kgraph.copy_layer_wo_activation(
layer,
keep_bias=bias,
weights=negative_weights,
name_template="reversed_kernel_negative_%s")
def __init__(self, layer, state, copy_weights=False):
# W-square rule works with squared weights and no biases.
if copy_weights:
weights = layer.get_weights()
else:
weights = layer.weights
if layer.use_bias:
weights = weights[:-1]
weights = [x**2 for x in weights]
self._layer_wo_act_b = kgraph.copy_layer_wo_activation(
layer,
keep_bias=False,
weights=weights,
name_template="reversed_kernel_%s")
def __init__(self, layer, state, copy_weights=False):
# The z-plus rule only works with positive weights and
# no biases.
#TODO: assert that layer inputs are always >= 0
if copy_weights:
weights = [
x * iK.to_floatx(x > 0) for x in layer.get_weights()[:-1]
]
else:
weights = [x * iK.to_floatx(x > 0) for x in layer.weights[:-1]]
self._layer_wo_act_b_positive = kgraph.copy_layer_wo_activation(
layer,
keep_bias=False,
weights=weights,
name_template="reversed_kernel_positive_%s")
def get_stats_from_batch(self):
# Get the neuron-wise I/O for this layer.
layer = kgraph.copy_layer_wo_activation(self.layer,
keep_bias=False,
reuse_symbolic_tensors=False)
# Readjust the layer nodes.
for i in range(kgraph.get_layer_inbound_count(self.layer)):
layer(self.layer.get_input_at(i))
Xs, Ys = get_active_neuron_io(layer, self._active_node_indices)
if len(Ys) != 1:
raise ValueError("Assume that kernel layer have only one output.")
X, Y = Xs[0], Ys[0]
# Create layers that keep a running mean for the desired stats.
self.mean_x = ilayers.RunningMeans()
self.mean_y = ilayers.RunningMeans()
self.mean_xy = ilayers.RunningMeans()
# Compute mask and active neuron counts.
mask = ilayers.AsFloatX()(self._get_neuron_mask())
Y_masked = keras.layers.multiply([Y, mask])
count = ilayers.CountNonZero(axis=0)(mask)
count_all = ilayers.Sum(axis=0)(ilayers.OnesLike()(mask))
# Get means ...
def norm(x, count):
return ilayers.SafeDivide(factor=1)([x, count])
# ... along active neurons.
mean_x = norm(ilayers.Dot()([ilayers.Transpose()(X), mask]), count)
mean_xy = norm(ilayers.Dot()([ilayers.Transpose()(X), Y_masked]),
count)
_, a = self.mean_x([mean_x, count])
_, b = self.mean_xy([mean_xy, count])
# ... along all neurons.
mean_y = norm(ilayers.Sum(axis=0)(Y), count_all)
_, c = self.mean_y([mean_y, count_all])
# Create a dummy output to have a connected graph.
# Needs to have the shape (mb_size, 1)
dummy = keras.layers.Average()([a, b, c])
return ilayers.Sum(axis=None)(dummy)
def __init__(self, layer, state, copy_weights=False):
# The flat rule works with weights equal to one and
# no biases.
if copy_weights:
weights = layer.get_weights()
if layer.use_bias:
weights = weights[:-1]
weights = [np.ones_like(x) for x in weights]
else:
weights = layer.weights
if layer.use_bias:
weights = weights[:-1]
weights = [K.ones_like(x) for x in weights]
self._layer_wo_act_b = kgraph.copy_layer_wo_activation(
layer,
keep_bias=False,
weights=weights,
name_template="reversed_kernel_%s")
def __init__(self, layer, state):
#print("in AddReverseLayer.init:", layer.__class__.__name__,"-> Dedicated ReverseLayer class" ) #debug
self._layer_wo_act = kgraph.copy_layer_wo_activation(layer,
name_template="reversed_kernel_%s")
input_channels = [int(i.shape[-1]) for i in layer.input]
self._merge_layer = keras.layers.Concatenate()
self._sum_layer_with_kernel = keras.layers.Conv2D(input_channels[0], (1, 1),
#kernel_initializer=add_init,
use_bias=False)
self._sum_layer_with_kernel.build((None, None, None, sum(input_channels)))
#self._sum_layer_with_kernel.weights[0].initializer.run(session=K.get_session())
weight_shape = [int(d) for d in self._sum_layer_with_kernel.weights[0].shape]
self._sum_layer_with_kernel.set_weights([add_init(weight_shape)])
x = self._merge_layer(layer.input)
x = self._sum_layer_with_kernel(x)
self._rule = rule(self._sum_layer_with_kernel, state)
def __init__(self, layer, state):
##print("in AveragePoolingRerseLayer.init:", layer.__class__.__name__,"-> Dedicated ReverseLayer class" ) #debug
self._layer_wo_act = kgraph.copy_layer_wo_activation(
layer, name_template="reversed_kernel_%s")
def __init__(self, layer, state, epsilon=1e-7, bias=True):
self._epsilon = rutils.assert_lrp_epsilon_param(epsilon, self)
self._layer_wo_act = kgraph.copy_layer_wo_activation(
layer, keep_bias=bias, name_template="reversed_kernel_%s")
def __init__(self, layer, state, bias=True):
self._layer_wo_act = kgraph.copy_layer_wo_activation(
layer, keep_bias=bias, name_template="reversed_kernel_%s")
def __init__(self, layer, state):
self._activation = keras.layers.Activation("relu")
self._layer_wo_relu = kgraph.copy_layer_wo_activation(
layer,
name_template="reversed_%s",
)
segmentshigher = []
segmentslower = []
shapelets_orig = []
shapelets_new = []
# load json and create model
json_file = open('modelsmall0.35.json', 'r')
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json)
# load weights into new model
model.load_weights("smallmodel0.35.h5")
# Create a model without sigmoid for gradient a/descent.
layer = model.layers[-1]
layer_wo_act = copy_layer_wo_activation(layer)
output_layer = layer_wo_act(layer.input)
model_wo_sigm = keras.models.Model(inputs=model.inputs,outputs=[output_layer])
model_wo_sigm.save_weights("model_wo_sigm.h5")
# Create an intermediate model for shapelet detection.
int_model = Model(input=model.inputs, output=[model.layers[-2].output])
for i, layer in enumerate(int_model.layers):
layer.name = 'layer_' + str(i)
train_x = np.load("train_x.npy")
predictions = model.predict(train_x)
def __init__(self, layer: Layer, state, bias: bool = True) -> None:
self._layer_wo_act = kgraph.copy_layer_wo_activation(
layer, keep_bias=bias, name_template="reversed_kernel_%s")
super().__init__(layer, state)
