La formation d'un réseau de convolution avec l'opération 2 convolution avec des poids partagés qui doit maintenir une norme de 1

voix
0

Je veux former un réseau de convolution avec 4 opérations de convolution avec 2 filtres qui partagent des poids, mais avec une norme qui reste à 1 entre les éléments des filtres. Disons que j'ai matrice d'entrée A et B, et le filtre C et D. L'opération que je veux faire est:

M1 = tf.conv2d (A, C)

M2 = tf.conv2d (B, C)

M3 = tf.conv2d (A, D)

M4 = tf.conv2d (B, D)

En même temps, je dois sqrt (C ^ 2 + D ^ 2) = 1

Je l' ai trouvé un moyen de partager les poids entre les différentes opérations de convolution en utilisant la même couche deux fois, comme cela a été demandé dans une question précédente Comment partager les noyaux de convolution entre les couches en keras? .

Mais je ne sais pas comment formuler les contraintes de la norme à 1.

Merci!

J'ai essayé d'introduire une couche d'entrée qui serait formé par une couche dense avec la dimension de mon filtre à noyau, puis remodeler et diviser en 2 en utilisant cos (x) sin (x) avant l'opération de convolution (je suis déjà ce faisant dans le code pour moduler l'image d'entrée). J'utilise ensuite une opération tf.nn.conv2d manuelle (). Mais avec les noyaux que je reçois une dimension du lot comme la dimension 0 et ce qui est incompatible avec la dimension requise du noyau [filter_height, filter_width, in_channels, out_channels]. Serrant il ne fonctionnera pas.

conv2d_layer_real= Conv2D(1,data_Mat2.shape[1],padding='same',kernel_constraint=max_norm(1),use_bias =False)
conv2d_layer_imag = Conv2D(1,data_Mat2.shape[1],padding='same',kernel_constraint=max_norm(1),use_bias =False)

input_shape = (data_Mat2.shape[1], data_Mat2.shape[1],1);
input_shape2 = (1,);

inputs_r = Input(shape=input_shape)
inputs_r2 = Input(shape=input_shape2)

phase_r2 = Dense(data_Mat2.shape[1]*data_Mat2.shape[1],activation = 'tanh',use_bias =False,kernel_initializer=RandomNormal(mean=0.0, stddev=0.5, seed=None))(inputs_r2)

phase_real = Lambda(lambda x:tf.cos(x*3.1416))(phase_r2)
phase_imag = Lambda(lambda x:tf.sin(x*3.1416))(phase_r2)

phase_real2 = Reshape((data_Mat2.shape[1], data_Mat2.shape[1],1))(phase_real)
phase_imag2 = Reshape((data_Mat2.shape[1], data_Mat2.shape[1],1))(phase_imag)

Mat_real = Multiply()([inputs_r,phase_real2])
Mat_imag = Multiply()([inputs_r,phase_imag2])

out_conv1 = conv2d_layer_real(Mat_real)
out_conv2 = conv2d_layer_real(Mat_imag)

out_conv3 = conv2d_layer_imag(Mat_real)
out_conv4 = conv2d_layer_imag(Mat_imag)

out_real = Add()([out_conv1,-out_conv4])
out_imag = Add()([out_conv2,out_conv3])

image_out = tf.complex(out_real,out_imag)
image_out = tf.square(tf.abs(image_out))

image_out = AveragePooling2D(pool_size=(pool_s, pool_s))(image_out)

vector_out = Reshape((9,))(image_out)

outputs = Softmax()(vector_out)

Ce dernier code fonctionne bien, mais ne sera pas une norme de 1 pour les couches des poids des moyeux conv2D car pas de telles contraintes est faite

Créé 24/10/2019 à 12:52
source utilisateur
Dans d'autres langues...                            

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more