def __init__(self, input_tensor, is_training, reuse):
        # net = layers.Input(shape=input_tensor)
        net = input_tensor
        with tf.variable_scope('Encoder'):
            with tf.variable_scope('Convolution'):
                # Layer 1: A conventional Conv2D layer
                net = layers.Conv2D(filters=16,
                                    kernel_size=5,
                                    strides=1,
                                    padding='same',
                                    activation='relu',
                                    name='conv1')(net)
                self.conv1 = net

                # Reshape layer to be 1 capsule x [filters] atoms
                _, H, W, C = net.get_shape()
                net = layers.Reshape((H.value, W.value, 1, C.value))(net)

            # Layer 1: Primary Capsule: Conv cap with routing 1
            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=2,
                                                  num_atoms=8,
                                                  strides=2,
                                                  padding='same',
                                                  routings=1,
                                                  name='primarycaps')(net)
            self.primary_caps = net

            # Layer 2: Convolutional Capsules
            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=4,
                                                  num_atoms=8,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='conv_cap_2')(net)
            self.conv_cap_2 = net

            # Layer 3: Convolutional Capsules
            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=8,
                                                  num_atoms=16,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='conv_cap_3')(net)
            self.conv_cap_3 = net

            # Layer 4: Convolutional Capsules
            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=8,
                                                  num_atoms=32,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='conv_cap_4')(net)

            self.output = net
예제 #2
0
    def __init__(self, input_tensor, is_training, reuse):
        self.input_tensor = input_tensor
        with tf.variable_scope('Encoder'):

            # conv1 = layers.Conv2D(filters=16, kernel_size=5, strides=1, padding='same', activation='relu', name='conv1')(x)

            _, H, W, C = self.input_tensor.get_shape()
            net = layers.Reshape(
                (H.value, W.value, 1, C.value))(self.input_tensor)

            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=2,
                                                  num_atoms=2,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='caps_conv1')(net)
            net = mf.batch_norm(net, is_training=is_training, reuse=reuse)
            self.caps_conv1 = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=4,
                                                  num_atoms=4,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='caps_conv2')(net)
            net = mf.batch_norm(net, is_training=is_training, reuse=reuse)
            self.caps_conv2 = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=8,
                                                  num_atoms=8,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='caps_conv3')(net)
            net = mf.batch_norm(net, is_training=is_training, reuse=reuse)
            self.caps_conv3 = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=16,
                                                  num_atoms=16,
                                                  strides=2,
                                                  padding='same',
                                                  routings=3,
                                                  name='caps_conv4')(net)
            #self.caps_conv4 = net

            #net = capsule_layers.ConvCapsuleLayer(kernel_size=5, num_capsule=32, num_atoms=2, strides=2, padding='same',
            #                                      routings=3, name='caps_conv5')(net)
            #self.caps_conv5 = net

            #net = capsule_layers.ConvCapsuleLayer(kernel_size=5, num_capsule=64, num_atoms=2, strides=2, padding='same',
            #                                      routings=3, name='caps_conv6')(net)
            self.output = net
예제 #3
0
    def __init__(self, mixed_mag, name='SegCaps_CapsNetBasic'):
        """
        input_tensor: Tensor with shape [batch_size, height, width, channels]
        is_training:  Boolean - should the model be trained on the current input or not
        name:         Model instance name
        """
        with tf.variable_scope(name):
            self.mixed_mag = mixed_mag

            with tf.variable_scope('Convolution'):
                conv1 = mf.conv(mixed_mag,
                                filters=128,
                                kernel_size=5,
                                stride=(1, 1))

                # Reshape layer to be 1 capsule x [filters] atoms
                _, H, W, C = conv1.get_shape()
                conv1 = layers.Reshape((H.value, W.value, 1, C.value))(conv1)
                self.conv1 = conv1

            with tf.variable_scope('Primary_Caps'):
                primary_caps = capsule_layers.ConvCapsuleLayer(
                    kernel_size=5,
                    num_capsule=8,
                    num_atoms=32,
                    strides=1,
                    padding='same',
                    routings=1,
                    name='primarycaps')(conv1)
                self.primary_caps = primary_caps

            with tf.variable_scope('Seg_Caps'):
                seg_caps = capsule_layers.ConvCapsuleLayer(
                    kernel_size=1,
                    num_capsule=1,
                    num_atoms=16,
                    strides=1,
                    padding='same',
                    routings=3,
                    name='seg_caps')(primary_caps)
                self.seg_caps = seg_caps

            with tf.variable_scope('Reconstruction'):
                reconstruction = capsule_layers.ConvCapsuleLayer(
                    kernel_size=1,
                    num_capsule=1,
                    num_atoms=1,
                    strides=1,
                    padding='same',
                    routings=3,
                    name='seg_caps')(primary_caps)
                reconstruction = tf.squeeze(reconstruction, -1)

            self.output = reconstruction
예제 #4
0
    def __init__(self, mixed_mag, name):
        """
        A basic capsule network operating on magnitude spectrograms.
        """
        with tf.variable_scope(name):
            self.mixed_mag = mixed_mag

            with tf.variable_scope('Convolution'):
                net = mf.conv(mixed_mag,
                              filters=128,
                              kernel_size=5,
                              stride=(1, 1))

                # Reshape layer to be 1 capsule x [filters] atoms
                _, H, W, C = net.get_shape()
                net = layers.Reshape((H.value, W.value, 1, C.value))(net)
                self.conv1 = net

            with tf.variable_scope('Primary_Caps'):
                net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                      num_capsule=8,
                                                      num_atoms=8,
                                                      strides=1,
                                                      padding='same',
                                                      routings=1,
                                                      name='primarycaps')(net)
                self.primary_caps = net

            with tf.variable_scope('Seg_Caps'):
                net = capsule_layers.ConvCapsuleLayer(kernel_size=1,
                                                      num_capsule=1,
                                                      num_atoms=8,
                                                      strides=1,
                                                      padding='same',
                                                      routings=3,
                                                      name='seg_caps')(net)
                self.seg_caps = net

            with tf.variable_scope('Reconstruction'):
                net = capsule_layers.ConvCapsuleLayer(
                    kernel_size=1,
                    num_capsule=1,
                    num_atoms=1,
                    strides=1,
                    padding='same',
                    routings=3,
                    name='reconstruction')(net)
                net = tf.squeeze(net, -1)

            self.output = net
    def __init__(self, input_tensor, name):
        """
        A basic capsule network operating on magnitude spectrograms.
        """
        with tf.variable_scope(name):
            self.input_tensor = input_tensor
            if tf.rank(self.input_tensor) == 3:
                self.out_depth = 1
            else:
                self.out_depth = input_tensor.shape[3].value

            with tf.variable_scope('layer_1'):
                net = mf.conv(input_tensor,
                              filters=128,
                              kernel_size=5,
                              stride=(1, 1))

                # Reshape layer to be 1 capsule x [filters] atoms
                _, H, W, C = net.get_shape()
                net = layers.Reshape((H.value, W.value, 1, C.value))(net)
                self.conv1 = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=5,
                                                  num_capsule=8,
                                                  num_atoms=16,
                                                  strides=1,
                                                  padding='same',
                                                  routings=1,
                                                  name='layer_2')(net)
            self.primary_caps = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=1,
                                                  num_capsule=1,
                                                  num_atoms=16,
                                                  strides=1,
                                                  padding='same',
                                                  routings=3,
                                                  name='layer_3')(net)
            self.seg_caps = net

            net = capsule_layers.ConvCapsuleLayer(kernel_size=1,
                                                  num_capsule=self.out_depth,
                                                  num_atoms=1,
                                                  strides=1,
                                                  padding='same',
                                                  routings=3,
                                                  name='mask')(net)
            net = tf.squeeze(net, -1)

            self.output = net
    def __init__(self, input_tensor):
        net = input_tensor
        with tf.variable_scope('encoder'):
            with tf.variable_scope('layer-1'):
                # Reshape layer to be 1 capsule x [filters] atoms
                _, self.H, self.W, self.C = net.get_shape()
                net = layers.Reshape((self.H.value, self.W.value, 1, self.C.value))(net)
                self.l1 = net

            with tf.variable_scope('layer-2'):
                net = capsule_layers.ConvCapsuleLayer(kernel_size=5, num_capsule=8, num_atoms=2, strides=2,
                                                      padding='same',
                                                      routings=1, name='primarycaps')(net)
                self.l2 = net

            with tf.variable_scope('layer-3'):
                net = capsule_layers.ConvCapsuleLayer(kernel_size=5, num_capsule=32, num_atoms=2, strides=2,
                                                      padding='same',
                                                      routings=1, name='primarycaps')(net)

        self.output = net
예제 #7
0
    def __init__(self, input_tensor, encoder, is_training, reuse):
        net = input_tensor
        with tf.variable_scope('Decoder'):
            with tf.variable_scope('UpCaps_1'):
                # Layer 1 Up: Deconvolutional capsules, skip connection, convolutional capsules
                net = capsule_layers.DeconvCapsuleLayer(
                    kernel_size=4,
                    num_capsule=8,
                    num_atoms=32,
                    upsamp_type='deconv',
                    scaling=2,
                    padding='same',
                    routings=3,
                    name='deconv_cap_1_1')(net)
                self.upcap_1_1 = net

                net = layers.Concatenate(
                    axis=-2, name='up_1')([net, encoder.conv_cap_3_1])

                net = capsule_layers.ConvCapsuleLayer(
                    kernel_size=5,
                    num_capsule=4,
                    num_atoms=32,
                    strides=1,
                    padding='same',
                    routings=3,
                    name='deconv_cap_1_2')(net)
                self.upcap_1_2 = net

            with tf.variable_scope('UpCaps_2'):
                # Layer 2 Up: Deconvolutional capsules, skip connection, convolutional capsules
                net = capsule_layers.DeconvCapsuleLayer(
                    kernel_size=4,
                    num_capsule=4,
                    num_atoms=16,
                    upsamp_type='deconv',
                    scaling=2,
                    padding='same',
                    routings=3,
                    name='deconv_cap_2_1')(net)
                self.upcap_2_1 = net

                net = layers.Concatenate(
                    axis=-2, name='up_2')([net, encoder.conv_cap_2_1])

                net = capsule_layers.ConvCapsuleLayer(
                    kernel_size=5,
                    num_capsule=4,
                    num_atoms=16,
                    strides=1,
                    padding='same',
                    routings=3,
                    name='deconv_cap_2_2')(net)
                self.upcap_2_2 = net

            with tf.variable_scope('UpCaps_3'):
                # Layer 3 Up: Deconvolutional capsules, skip connection
                net = capsule_layers.DeconvCapsuleLayer(
                    kernel_size=4,
                    num_capsule=2,
                    num_atoms=16,
                    upsamp_type='deconv',
                    scaling=2,
                    padding='same',
                    routings=3,
                    name='deconv_cap_3_1')(net)
                self.upcap_3_1 = net

                net = layers.Concatenate(axis=-2,
                                         name='up_3')([net, encoder.conv1])
            with tf.variable_scope('Reconstruction'):
                # Layer 4: Reconstruction - Convolutional Capsule: 1x1, 3x conventional Conv2D layers
                net = capsule_layers.ConvCapsuleLayer(kernel_size=1,
                                                      num_capsule=1,
                                                      num_atoms=16,
                                                      strides=1,
                                                      padding='same',
                                                      routings=3,
                                                      name='seg_caps')(net)

                _, H, W, C, D = net.get_shape()

                net = layers.Reshape((H.value, W.value, D.value))(net)

                net = layers.Conv2D(filters=64,
                                    kernel_size=1,
                                    padding='same',
                                    kernel_initializer='he_normal',
                                    activation='relu',
                                    name='recon_1')(net)

                net = layers.Conv2D(filters=128,
                                    kernel_size=1,
                                    padding='same',
                                    kernel_initializer='he_normal',
                                    activation='relu',
                                    name='recon_2')(net)

                net = layers.Conv2D(filters=1,
                                    kernel_size=1,
                                    padding='same',
                                    kernel_initializer='he_normal',
                                    activation='sigmoid',
                                    name='out_recon')(net)

            self.output = net