Любой способ правильно реализовать расширение Тейлора сверточного NN в керасах?

Question

Я пытаюсь реализовать расширяемый CNN, используя нелинейное расширение Тейлора в keras. Основная идея c заключается в том, что первый входной узел может быть разложен на несколько узлов с разными порядками и коэффициентами. Разложение отдельных узлов на несколько может генерировать разные нелинейные линейные соединения, которые генерируются сериями Тейлора. Может кто-нибудь дать мне возможную идею о том, как расширить CNN с нелинейным расширением Тейлора? Как эффективно сделать нелинейное разложение Тейлора на CNN? Любая мысль?

математическое представление о том, как расширить входной узел следующим образом:

Я не совсем понимаю, как разложить вход узел к нескольким с различными нелинейными линейными связями, которые производятся по серии Тейлора. Насколько я знаю, ряд Тейлора является функцией приближения, но разлагающийся узел не совсем интуитивен для меня с точки зрения реализации. Как реализовать декомпозицию входного узла на несколько в python? Как сделать это легко? Любая идея?

моя попытка :

import tensorflow as tf
import numpy as np
import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten
from keras.datasets import cifar10
from keras.utils import to_categorical

(train_imgs, train_label), (test_imgs, test_label)= cifar10.load_data()
output_class = np.unique(train_label)
n_class = len(output_class)

nrows_tr, ncols_tr, ndims_tr = train_imgs.shape[1:]
nrows_ts, ncols_ts, ndims_ts = test_imgs.shape[1:]
train_data = train_imgs.reshape(train_imgs.shape[0], nrows_tr, ncols_tr, ndims_tr)

test_data = test_imgs.reshape(test_imgs.shape[0], nrows_ts, ncols_ts, ndims_ts)
input_shape = (nrows_tr, ncols_tr, ndims_tr)
train_data = train_data.astype('float32')
trast_data = test_data.astype('float32')
train_data //= 255
test_data //= 255
train_label_one_hot = to_categorical(train_label)
test_label_one_hot = to_categorical(test_label)

def pown(x,n):
    return(x**n)

def expandable_cnn(input_shape, output_shape, approx_order):
    inputs=Input(shape=(input_shape))
    x= Dense(input_shape)(inputs)
    y= Dense(output_shape)(x)
    model = Sequential()
    model.add(Conv2D(filters=32, kernel_size=(3,3), padding='same', activation="relu", input_shape=input_shape))
    model.add(Conv2D(filters=32, kernel_size=(3,3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2,2)))
    model.add(Dropout(0.25))

    model.add(Flatten())
    model.add(Dense(512, activation='relu'))
    model.add(Dropout(0.5))
    for i in range(2, approx_order+1):
        y=add([y, Dense(output_shape)(Activation(lambda x: pown(x, n=i))(x))])
    model.add(Dense(n_class, activation='softmax')(y))
    return model

, но когда я запустил вышеупомянутую модель, у меня была куча ошибок компиляции и ошибки измерения. Я предполагаю, что способ нелинейного расширения Тайлора для модели CNN может быть неправильным. Кроме того, я не уверен, как измерить вес. Как заставить это работать? Любая возможная идея, как исправить мою попытку?

желаемый вывод :

Я ожидаю расширить CNN с нелинейным расширением Тейлора, как сделать вышеописанную реализацию правильно и эффективно? Кто-нибудь может указать мне, как правильно реализовать расширяемый CNN с серией Тейлор? Любая возможная идея или подход?

Answer 1

Интересный вопрос. Я реализовал модель Keras, которая вычисляет разложение Тейлора, как вы описали:

from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Input, Lambda


def taylor_expansion_network(input_dim, max_pow):
    x = Input((input_dim,))

    # 1. Raise input x_i to power p_i for each i in [0, max_pow].
    def raise_power(x, max_pow):
        x_ = x[..., None]  # Shape=(batch_size, input_dim, 1)
        x_ = tf.tile(x_, multiples=[1, 1, max_pow + 1])  # Shape=(batch_size, input_dim, max_pow+1)
        pows = tf.range(0, max_pow + 1, dtype=tf.float32)  # Shape=(max_pow+1,)
        x_p = tf.pow(x_, pows)  # Shape=(batch_size, input_dim, max_pow+1)
        x_p_ = x_p[..., None]  # Shape=(batch_size, input_dim, max_pow+1, 1)
        return x_p_

    x_p_ = Lambda(lambda x: raise_power(x, max_pow))(x)

    # 2. Multiply by alpha coefficients
    h = LocallyConnected2D(filters=1,
                           kernel_size=1,  # This layer is computing a_i * x^{p_i} for each i in [0, max_pow]
                           use_bias=False)(x_p_)  # Shape=(batch_size, input_dim, max_pow+1, 1)

    # 3. Compute s_i for each i in [0, max_pow]
    def cumulative_sum(h):
        h = tf.squeeze(h, axis=-1)  # Shape=(batch_size, input_dim, max_pow+1)
        s = tf.cumsum(h, axis=-1)  # s_i = sum_{j=0}^i h_j. Shape=(batch_size, input_dim, max_pow+1)
        s_ = s[..., None]  # Shape=(batch_size, input_dim, max_pow+1, 1)
        return s_

    s_ = Lambda(cumulative_sum)(h)

    # 4. Compute sum w_i * s_i each i in [0, max_pow]
    s_ = LocallyConnected2D(filters=1,  # This layer is computing w_i * s_i for each i in [0, max_pow]
                            kernel_size=1,
                            use_bias=False)(s_)  # Shape=(batch_size, input_dim, max_pow+1)
    y = Lambda(lambda s_: tf.reduce_sum(tf.squeeze(s_, axis=-1), axis=-1))(s_)  # Shape=(batch_size, input_dim)

    # Return Taylor expansion model
    model = Model(inputs=x, outputs=y)
    model.summary()
    return model

Реализация применяет одно и то же разложение Тейлора к каждому элементу сплющенного тензора с формой (batch_size, input_dim=512), поступающей из сверточной сети.

---

ОБНОВЛЕНИЕ : Как мы уже обсуждали в разделе комментариев, здесь приведен код, демонстрирующий, как ваша функция expandable_cnn может быть изменена для интеграции определенной выше модели:

def expandable_cnn(input_shape, nclass, approx_order):
    inputs = Input(shape=(input_shape))
    h = inputs
    h = Conv2D(filters=32, kernel_size=(3, 3), padding='same', activation='relu', input_shape=input_shape)(h)
    h = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(h)
    h = MaxPooling2D(pool_size=(2, 2))(h)
    h = Dropout(0.25)(h)
    h = Flatten()(h)
    h = Dense(512, activation='relu')(h)
    h = Dropout(0.5)(h)
    taylor_model = taylor_expansion_network(input_dim=512, max_pow=approx_order)
    h = taylor_model(h)
    h = Activation('relu')(h)
    print(h.shape)
    h = Dense(nclass, activation='softmax')(h)
    model = Model(inputs=inputs, outputs=h)
    return model

Обратите внимание, что я не гарантирую, что ваша модель будет работать (например, что вы получите хорошую производительность). Я только что предложил решение, основанное на моей интерпретации того, что вы хотите.