element-Weise Multiplikation mit Ausstrahlung in keras benutzerdefinierte layer

Ich bin erstellen einer benutzerdefinierten Ebene mit gewichten, die multipliziert werden müssen, durch das element-Weise vor der Aktivierung. Ich kann es funktionieren, wenn der output und input ist die gleiche Form. Das problem tritt auf, wenn ich eine erste Bestellung array als Eingabe eine zweite Bestellung array als Ausgabe. tensorflow.multiplizieren Sie unterstützt broadcasting, aber wenn ich versuche, es zu benutzen in der Schicht.Aufruf(x, self.kernel)
multiplizieren x durch das selbst.kernel-Variablen beschwert es sich, dass Sie die verschiedenen Formen, nämlich:

ValueError: Dimensions must be equal, but are 4 and 3 for 'my_layer_1/Mul' (op: 'Mul') with input shapes: [?,4], [4,3].

hier ist mein code:

from keras import backend as K
from keras.engine.topology import Layer
import tensorflow as tf
from keras.models import Sequential
import numpy as np

class MyLayer(Layer):

    def __init__(self, output_dims, **kwargs):
        self.output_dims = output_dims

        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        # Create a trainable weight variable for this layer.
        self.kernel = self.add_weight(name='kernel',
                                      shape=self.output_dims,
                                      initializer='ones',
                                      trainable=True)


        super(MyLayer, self).build(input_shape)  # Be sure to call this somewhere!

    def call(self, x):
        #multiply wont work here?
        return K.tf.multiply(x, self.kernel)

    def compute_output_shape(self, input_shape):
        return (self.output_dims)

mInput = np.array([[1,2,3,4]])
inShape = (4,)
net = Sequential()
outShape = (4,3)
l1 = MyLayer(outShape, input_shape= inShape)
net.add(l1)
net.compile(loss='mean_absolute_error', optimizer='adam', metrics=['accuracy'])
p = net.predict(x=mInput, batch_size=1)
print(p)

Bearbeiten:
Gegeben Eingabe shape (4,) und output Form (4,3) Gewicht matrix sollte die gleiche Form wie die Ausgabe und initialisiert mit denen. So in dem obigen code wird die Eingabe ist [1,2,3,4], das Gewicht der matrix werden sollte [[1,1,1,1],[1,1,1,1],[1,1,1,1]] und die Ausgabe sollte so Aussehen [[1,2,3,4],[1,2,3,4],[1,2,3,4]]

Betrachten Sie die tf.reshape Methode
Warum ändern Sie das output-Form, wenn Sie wollen, elementweise Multiplikation?
Ich denke, ich hätte, um manuell kopieren Sie die Werte für die einzelnen Zeilen wenn ich tf.neu zu gestalten. Ich fühle mich wie tf.multiplizieren sollte funktionieren, aber vielleicht bin ich nicht der übergabe von Parametern in der richtigen form.
Ich möchte die Eingabe übertragen werden, die über mehrere Zeilen in der Ausgabe: Eingabe: [1,2,3] Ausgabe: [[1,2,3],[1,2,3],[1,2,3]]
Und wie ist die elementweise Multiplikation daran teilnehmen?
Bei der Transformation von (4) in (4,3), wie viele GEWICHTE Sie tun möchten? 12? 4? 3? Was willst du multiplizieren?
wenn das Gewicht der matrix ist [[1,1,1],[1,1,1],[1,1,1]] die Eingabe würde vervielfacht werden, es geben die Ausgabe in meinem obigen Kommentar. Sorry, wenn ich das nicht klar in meinem post.
das Gewicht der matrix sollte die gleiche Form wie die Ausgabe
Ok, aktualisiert meine Antwort.

InformationsquelleAutor buckithed | 2017-11-14

Bevor die Multiplikation, die Sie brauchen, um zu wiederholen die Elemente erhöhen die Form.
Sie können K.repeat_elements für, die. (import keras.backend as K)

class MyLayer(Layer):

    #there are some difficulties for different types of shapes   
    #let's use a 'repeat_count' instead, increasing only one dimension
    def __init__(self, repeat_count,**kwargs):
        self.repeat_count = repeat_count
        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):

        #first, let's get the output_shape
        output_shape = self.compute_output_shape(input_shape)
        weight_shape = (1,) + output_shape[1:] #replace the batch size by 1


        self.kernel = self.add_weight(name='kernel',
                                      shape=weight_shape,
                                      initializer='ones',
                                      trainable=True)


        super(MyLayer, self).build(input_shape)  # Be sure to call this somewhere!

    #here, we need to repeat the elements before multiplying
    def call(self, x):

        if self.repeat_count > 1:

             #we add the extra dimension:
             x = K.expand_dims(x, axis=1)

             #we replicate the elements
             x = K.repeat_elements(x, rep=self.repeat_count, axis=1)


        #multiply
        return x * self.kernel


    #make sure we comput the ouptut shape according to what we did in "call"
    def compute_output_shape(self, input_shape):

        if self.repeat_count > 1:
            return (input_shape[0],self.repeat_count) + input_shape[1:]
        else:
            return input_shape

Das funktioniert Super, danke. Ich bin nur neugierig, jetzt, warum tf.multiplizieren bedeutet das nicht automatisch erweitern die Dimensionen und wiederholen Sie die Elemente, wenn verwendet, die Art, wie ich es habe.
Hmmm... vielleicht haben Sie vergessen, halten input_shape[0]? Es ist eine versteckte batch-Größe dimension. Wenn Sie sagen, die input-Form (4,), es ist eigentlich (None,4), und die Endform ist (None, 4, 3). Wenn Sie hinzufügen, alle Maße richtig, die Multiplikation kann arbeiten.
Für eine Multiplikation wie das funktioniert, müssen Sie die GEWICHTE und die Eingänge haben die gleiche Anzahl von Dimensionen, wie x.shape=(batch,4,1) und weights.shape=(1,4,3). Dies funktioniert, wenn nur eine der Dimensionen ist anders, aber ich habe nie versucht, mit zwei verschiedenen Größen auf einmal.

InformationsquelleAutor Daniel Möller

hier ist eine weitere Lösung, die auf der Grundlage der Antwort von Daniel Möller, nutzt aber tf.vermehren sich wie der ursprüngliche code.

class MyLayer(Layer):

    def __init__(self, output_dim, **kwargs):
        self.output_dim = output_dim

        super(MyLayer, self).__init__(**kwargs)

    def build(self, input_shape):
        # Create a trainable weight variable for this layer.
        output_shape = self.compute_output_shape(input_shape)
        self.kernel = self.add_weight(name='kernel',
                                      shape=(1,) + output_shape[1:],
                                      initializer='ones',
                                      trainable=True)


        super(MyLayer, self).build(input_shape)  # Be sure to call this somewhere!

    def call(self, x):

        return K.tf.multiply(x, self.kernel)

    def compute_output_shape(self, input_shape):
        return (input_shape[0],self.output_dim)+input_shape[1:]

InformationsquelleAutor buckithed

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.