Inheritance diagram for Relations:

Public Member Functions
	__init__ (self, number_features, hidden_feature_shape=[30, 30, 30, 30], activation=tanh, **kwargs)

	build (self, input_shape)

	call (self, inputs)

	compute_output_shape (self, input_shape)

	get_config (self)

Public Attributes
	number_features = number_features
	Number of features.

int	number_groups = 0
	Number of groups in input.

	hidden_feature_shape = hidden_feature_shape
	shape of hidden layers used for extracting relations

	activation = activations.get(activation)
	activation used for hidden layer in shared weights.

int	group_len = 0
	how many neurons has one comparable object

list	weightvariables = []
	saves weights for call

int	combinations = 0
	number of relation combinations

Detailed Description

This is a class which implements Relational Layer into Keras.
Relational Layer compares every combination of two feature groups with shared weights.
Use this class as every other Layer in Keras.
Relevant Paper: https://arxiv.org/abs/1706.01427
RN(O) = f_phi(sum_phi(g_theta(o_i,o_j)))
For flexibility reason only the part g(o_i,o_j) is modelled
f_phi corresponds to a MLP net
To sum over all permutations please use GlobalAveragePooling1D from keras.

Definition at line 18 of file keras_relational.py.

Constructor & Destructor Documentation

◆ init()

__init__	(		self,
			number_features,
			hidden_feature_shape = [30, 30, 30, 30],
			activation = tanh,
		**	kwargs )

Init class.

Definition at line 30 of file keras_relational.py.

    def __init__(self, number_features, hidden_feature_shape=[30, 30, 30, 30], activation=tanh, **kwargs):
        """
        Init class.
        """
 
        self.number_features = number_features
        
        self.number_groups = 0
        
        self.hidden_feature_shape = hidden_feature_shape
        
        self.activation = activations.get(activation)
        
        self.group_len = 0
        
        self.weightvariables = []
        
        self.combinations = 0
 
        super().__init__(**kwargs)

Member Function Documentation

◆ build()

build	(		self,
			input_shape )

Build all weights for Relations Layer
:param input_shape: Input shape of tensor
:return:  Nothing

Definition at line 52 of file keras_relational.py.

    def build(self, input_shape):
        """
        Build all weights for Relations Layer
        :param input_shape: Input shape of tensor
        :return:  Nothing
        """
        # only accept 2D layers
        assert(len(input_shape) == 3)
 
        self.number_groups = input_shape[1]
 
        self.group_len = input_shape[2]
 
        self.combinations = np.int32(np.math.factorial(self.number_groups) / (2 * np.math.factorial(self.number_groups - 2)))
 
        dense_shape = [2 * self.group_len] + self.hidden_feature_shape + [self.number_features]
 
        for i in range(len(dense_shape[:-1])):
            weights = self.add_weight(name=f'relation_weights_{i}',
                                      shape=list(dense_shape[i:i + 2]), initializer='glorot_uniform', trainable=True)
            bias = self.add_weight(name=f'relation_weights_{i}',
                                   shape=(dense_shape[i + 1],), initializer='zeros', trainable=True)
 
            self.weightvariables.append([weights, bias])
 
        super().build(input_shape)
 

◆ call()

call	(		self,
			inputs )

Compute Relational Layer
:param inputs: input tensor
:return: output tensor

Definition at line 79 of file keras_relational.py.

    def call(self, inputs):
        """
        Compute Relational Layer
        :param inputs: input tensor
        :return: output tensor
        """
        input_groups = [inputs[:, i, :] for i in range(self.number_groups)]
        outputs = []
        for index, group1 in enumerate(input_groups[:-1]):
            for group2 in input_groups[index + 1:]:
                net = K.dot(K.concatenate([group1, group2]), self.weightvariables[0][0])
                net = K.bias_add(net, self.weightvariables[0][1])
                for variables in self.weightvariables[1:]:
                    net = self.activation(net)
                    net = K.dot(net, variables[0])
                    net = K.bias_add(net, variables[1])
                outputs.append(sigmoid(net))
 
        flat_result = K.concatenate(outputs)
        return Reshape((self.combinations, self.number_features,))(flat_result)
 

◆ compute_output_shape()

compute_output_shape	(		self,
			input_shape )

Compute Output shape
:return: Output shape

Definition at line 100 of file keras_relational.py.

    def compute_output_shape(self, input_shape):
        """
        Compute Output shape
        :return: Output shape
        """
        # only 2D layers
        assert(len(input_shape) == 3)
 
        self.combinations = np.int32(np.math.factorial(self.number_groups) / (2 * np.math.factorial(self.number_groups - 2)))
 
        return (input_shape[0], self.combinations, self.number_features)
 

◆ get_config()

get_config ( self )

Config required for saving parameters in keras model.

Definition at line 112 of file keras_relational.py.

    def get_config(self):
        """
        Config required for saving parameters in keras model.
        """
        config = {
            'number_features': self.number_features,
            'hidden_feature_shape': self.hidden_feature_shape,
            'activation': activations.serialize(self.activation)
        }
        base_config = super().get_config()
        return dict(list(base_config.items()) + list(config.items()))
 
 

Member Data Documentation

◆ activation

activation = activations.get(activation)

activation used for hidden layer in shared weights.

For output sigmoid will always be used.

Definition at line 42 of file keras_relational.py.

◆ combinations

combinations = 0

number of relation combinations

Definition at line 48 of file keras_relational.py.

◆ group_len

int group_len = 0

how many neurons has one comparable object

Definition at line 44 of file keras_relational.py.

◆ hidden_feature_shape

hidden_feature_shape = hidden_feature_shape

shape of hidden layers used for extracting relations

Definition at line 40 of file keras_relational.py.

◆ number_features

number_features = number_features

Number of features.

Number of different shared weights used for comparison for each relation.

Definition at line 36 of file keras_relational.py.

◆ number_groups

int number_groups = 0

Number of groups in input.

Definition at line 38 of file keras_relational.py.

◆ weightvariables

list weightvariables = []

saves weights for call

Definition at line 46 of file keras_relational.py.

The documentation for this class was generated from the following file:

mva/scripts/basf2_mva_extensions/keras_relational.py

Public Member Functions

Public Attributes