Training custom constellations

[nadh-amar]

Hi,
I have a parameter, for example radius of a PSK constellation point. I wish to train the constellation based on that radius instead of positions of the PSK constellation points, so that the final constellation looks PSK itself, but only the radius may change from the initial value. Ofcourse, in a way the position will change, but the idea is that it should remain PSK itself and doesnt look distorted.
Is it possible to train a parameter and apply it to a custom constellation, with/without training the positions of the constellation?

I tried:

###################
initialValue = 5.0
trainVar = tf.Variable(initial_value=initialValue ,trainable=True) # ( a value in range of 10^-3 to be obtained)
trainVar_constrained = tf.clip_by_value(trainVar , start_val, end_val) # to restrict between a max and min value

#define my constellation
r = trainVar
an_array = [r.exp(j0), r.exp(jpi/8), r.exp(j2pi/8), r.exp(j3pi/8) ...]
initial_value_array = np.array(an_array) # ( array with values as a function of trainVar_constrained, initial points for constellation)

constellation = Constellation("custom",num_bits_per_symbol, initial_value_array, trainable=True, normalize=True, center=True) ##Trainable= True or False , I have tried both, but trainVar value doesnt seem to change.
#######################

Can you please help me ?

[SebastianCa]

Hi,
a few quick comments without knowing the rest of your experiment:

• the clipping operation has no impact on the tfVariable. If you want to change the value of a variable you need to call trainVar.assign(value)
• The intermediate numpy operation prevents TensorFlow from doing back-propagation.
• Your constellation is centered and normalized. Scaling the PSK with the same factor will have no impact, as the constellation will always re-scales to unit average power. Though, I cannot see where you impose this constraint.

It seems like you have very specific constraints on the constellation and I would suggest to write a custom constellation class for this experiment.

[SebastianCa]

A simple solution is to inherit from the Constellation class and define a custom call function (i.e., override the behavior of the current method).

[nadh-amar]

I tried to create a custom class, and tried to override the call, build functions. call is same. build i have changed and added the parameter fs that I wish to train. and I am defining the points based on this fs. Basically what I want to achieve is that the constellation here will look similar, however the parameter fs should be trained for various snr. fs determines the position points on the plane. but for me the value remains same. Should it be such that it directly influences the loss function or something?

[SebastianCa]

Unfortunately, your code snippet is a bit difficult to read due to the formatting.

class MyConstellation(Constellation):
      
  def __init__(self,constellation_type,num_bits_per_symbol,initial_value=None,normalize=True,center=False,trainable=False,dtype=tf.complex64,  radius=1.,**kwargs):

        super().__init__(constellation_type,
                        num_bits_per_symbol,
                        initial_value,
                        normalize,
                        center,
                        trainable,
                        dtype,
                        **kwargs)

        self._radius = tf.Variable(radius,dtype=tf.complex64)

    @property
    def radius(self):
        return self._radius
    @radius.setter
    def radius(self, value):
        self._radius.assign(tf.cast(value, tf.complex64))

    def call(self, inputs): #pylint: disable=unused-argument
        x = self._points
        x = tf.complex(x[0], x[1])
        x = tf.multiply(x, self._radius)
        # you could also add norm center here
        return x

Your constellation is now scaled by a variable called radius. If you set the original constellation as non-trainable, the only parameter that will be updated is the radius. Please keep in mind that internal normalization would remove the scaling.

 c = MyConstellation("qam", 2, normalize=False, radius=2.)
 c.show();
 c.radius=5
 c.show();

[nadh-amar]

Thank you so much for your reply. I am so sorry about my negligence. let me explain the problem clearly. Hope you could help me.

I am trying to create a constellation which is not one of the pre-defined one. It is a constellation based on a parameter fs . It is a spiral, which can be potted based on this single parameter fs.

Here I have also tried defining fs as trainable in the init function. still the value of fs remains at the intial value. I have tried both keeping the constellation as trainable and not trainable. Would like to mention that this is a custom constellation, so I assume, we would have to define the initial_values array and give it as input. But the tricky part for me was that this fs is required in all the training iterations, and should change. this also influences the position (x,y) of all the points

[SebastianCa]

In TensorFlow/Keras, there are essentially 3 "stages" of execution:

• Layer initialization: This is where you initialize all objects and constants. In your case, only the constant fs_init is initialized
• Build: This function is called when you first call the Layer (or if the input signature changes, but let's ignore this). In your case this is where you initialize the tf.Variable f_s and the points. This is only called during the first call of the layer (i.e., once!). You can verify this buy adding a print statement in the function. Most likely this happens already outside of your gradient tape.
• Call: This is the part of the code that is executed when you call the layer. As you didn't overwrite the call, it will simply return the value from the tf.Variable points. From the backpropagation perspective this is the trainable variable what will get updated.

For further details, please see TF guide.

A possible solution is to include the code that is currently in build during the call and always derive the points from the tf.Variable f_s and the points Variable must be removed. This will ensure that the gradient update will update f_s.