In [73]:

    

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

from keras import initializers 
igu = initializers.get('glorot_uniform')
iz = initializers.get('zeros')
  
class CDENSE(Layer):
    # FC: Simplified complex fully connected layer
    def __init__(self, No, **kwargs):
        self.No = No
        super().__init__(**kwargs)

    def build(self, inshape_l):
        inshape = inshape_l[0] # Real and Imag are the same shape
        self.w_r = self.add_weight("w_r", (inshape[1], self.No), initializer=igu)
        self.w_i = self.add_weight("w_i", (inshape[1], self.No), initializer=igu)
        self.b_r = self.add_weight("b_r", (self.No,), initializer=iz)        
        self.b_i = self.add_weight("b_i", (self.No,), initializer=iz) 
        self.w = tf.complex(self.w_r, self.w_i)
        self.b = tf.complex(self.b_r, self.b_i)
        super().build(inshape)  

    def call(self, x_l):
        x_r, x_i = x_l
        x = tf.complex(x_r, x_i)
        y = tf.matmul(x, self.w) + self.b
        y_r = tf.real(y)
        y_i = tf.imag(y)
        return [y_r, y_i]

    def compute_output_shape(self, inshape_l):
        # real and image are the same length
        return [(inshape_l[0], self.No), (inshape_l[0], self.No)]

    
def modeling(input_shape):
    x_r = keras.layers.Input(input_shape)
    x_i = keras.layers.Input(input_shape)
    [y_r, y_i] = CDENSE(1, input_shape=(1,))([x_r, x_i])
    return keras.models.Model([x_r, x_i], [y_r, y_i])


def cfit(model, x, y, **kwargs):
    x_l = [np.real(x), np.imag(x)]
    y_l = [np.real(y), np.imag(y)]        
    return model.fit(x_l, y_l, **kwargs)

def cpredict(model, x, **kwargs):
    x_l = [np.real(x), np.imag(x)]
    y_l = model.predict(x_l)
    return y_l[0] + 1j * y_l[1]

def cget_weights(model):
    [w_r, w_i, b_r, b_i] = model.get_weights()
    return([w_r + 1j * w_i], [b_r + 1j * b_i])    
    
def cmain():
    model = modeling((1,))
    model.compile(keras.optimizers.sgd(), 'mse')

    x = np.array([0, 1, 2, 3, 4]) + 1j*np.array([4, 3, 2, 1, 0])
    y = x * (2 + 1j) + (1 + 2j)

    # Training
    h = cfit(model, x[:2], y[:2], epochs=5000, verbose=0)
    
    # Testing
    y_pred = cpredict(model, x[2:])
    print('Targets:', y[2:])    
    print(y_pred) 

    # Weights
    [w, b] = cget_weights(model)
    print('weight:', w)
    print('bias:', b)


    

In [74]:

    

cmain()


    

    




Targets: [ 3.+8.j  6.+7.j  9.+6.j]
[[ 3.00877428+7.9657917j ]
 [ 6.01544905+6.94412136j]
 [ 9.02212429+5.92245197j]]
weight: [array([[ 2.01417232+0.99250239j]], dtype=complex64)]
bias: [array([ 0.96543461+1.95244229j], dtype=complex64)]

In [ ]: