Het trainen van een convolutie netwerk met 2 convolutiebewerkingssectie met gedeelde gewichten die een norm van 1 moeten houden

stemmen
0

Ik wil een convolutie netwerk te trainen met 4 convolutiebewerkingen met 2 filters die gewichten te delen, maar met een norm die blijft tot 1 tussen de elementen van de filters. Stel dat ik invoermatrix A en B en filter C en D. De werking ik wil maken is:

M1 = tf.conv2d (A, C)

M2 = tf.conv2d (B, C)

M3 = tf.conv2d (A, D)

M4 = tf.conv2d (B, D)

Tegelijkertijd, ik sqrt (C ^ D ^ 2 + 2) = 1

Ik heb een manier om de gewichten tussen de verschillende convolutiebewerkingsstap delen via dezelfde laag tweemaal gevonden, zoals werd gevraagd in een vorige vraag Hoe convolutie kernels tussen lagen in Keras delen? .

Maar ik heb geen idee hoe de beperkingen van de norm te formuleren op 1.

Dankje!

Ik heb geprobeerd om een ​​Input laag die zou worden opgeleid via een dichte laag met de afmeting van mijn kernel filter in te voeren, en vervolgens opnieuw vorm te geven en opgesplitst in 2 met behulp van cos (x) sin (x) vóór de convolutiebewerkingsstap (Ik ben al dit in de code om het ingangsbeeld te moduleren). Ik gebruik dan een handmatige tf.nn.conv2d () operatie. Maar met de kernels krijg ik een afmeting van de partij als de 0 dimensie en dit is in strijd met de vereiste afmeting van de kernel [filter_height, filter_width, in_channels, out_channels]. Knijpen het zal niet werken.

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)

Deze laatste code werkt goed, maar zal niet over een norm van 1 voor de weigths van de conv2D lagen omdat er geen dergelijke beperkingen wordt gemaakt

De vraag is gesteld op 24/10/2019 om 12:52
bron van user
In andere talen...                            

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