I am trying to implement IOC Network and thus am required to impose a non negative weight rule for all the layers except the first(along with ELU as activation function to allow flow of negative values)
I have got a tensorflow code up and running perfectly, which is:
class WeightClip(Constraint):
    def __init__(self, c=100):
        self.c = c
    def __call__(self, p):
        return K.clip(p, 0, self.c)
    def get_config(self):
        return {'name': self.__class__.__name__,'c': self.c}
def get_model(model_select):
    inp_1 = Input(shape=(2,))
    l11 = Dense(8, activation='elu',kernel_initializer='glorot_uniform')(inp_1)
    if model_select == 'NN':
        l12 = Dense(8, activation='elu',kernel_initializer='glorot_uniform')(l11)
        l13 = Dense(8, activation='elu',kernel_initializer='glorot_uniform')(l12)
        out = Dense(1, activation='sigmoid',kernel_initializer='glorot_uniform')(l13)
    elif(model_select == 'IOC'):
        l12 = Dense(8, activation='elu',kernel_initializer='glorot_uniform',W_constraint = WeightClip(2))(l11)
        l13 = Dense(8, activation='elu',kernel_initializer='glorot_uniform',W_constraint = WeightClip(2))(l12)
        out = Dense(1, activation='sigmoid',kernel_initializer='glorot_uniform',W_constraint = WeightClip(2))(l13)
    else:
        print ("invalid model")
        return 0
    model = Model(inputs=[inp_1], outputs=[out])
    return model

However as suggest in this post, I tried to make my Weight Constraint class which I’m applying after every iteration.
My Pytorch code looks like:
class weightConstraint(object):
    def __init__(self):
        pass
    
    def __call__(self,module):
        if hasattr(module,'weight'):
#             print("Entered")
            w=module.weight.data
#             w[torch.where(w<0)] = 0
            w=w.clamp(min = 0)
            module.weight.data=w
class Net(nn.Module):
    def __init__(self,type_ = "single"):
        super().__init__()
        if type_ == "one-hot":
            self.type = type_
        elif type_ == "single":
            self.type = type_
        else:
            print('{} type not defined. Proceeding with default single'.format(type_))
            self.type = "single"
        
        self.activation = F.elu
        
        self.dense1 = nn.Linear(2, 8)
        self.dense2 = nn.Linear(8, 8)
        self.dense3 = nn.Linear(8, 8)
        self.dense4 = nn.Linear(8, 8)
        self.dense5 = nn.Linear(8, 1) if self.type == 'single' else nn.Linear(8, 2)
        if self.type == 'single':
            self.out_activation = nn.Sigmoid()
            
        
    def forward(self,x):
        out = x.view(x.shape[0],-1)
        out = self.activation(self.dense1(out))
        out = self.activation(self.dense2(out))
        out = self.activation(self.dense3(out))
        out = self.activation(self.dense4(out))
        out = self.dense5(out)
        if self.type == 'single':
            out = self.out_activation(out)
        return out


I am later using constraints = weightConstraint() for the IOC case, followed by a loop on the modules, applying the constraint after every iteration.
def applyIOCConstraint(model, constraint):
    if 'module' in model._modules.keys():
        # if DataParallel is used
        idx = 0
        for key,val in model._modules['module']._modules.items():
            if hasattr(val,'weight'):
                if idx>0:
                    val.apply(constraint)
                idx += 1
    else:
        idx = 0
        for key,val in model._modules.items():
            if hasattr(val,'weight'):
                if idx>0:
                    val.apply(constraint)
                idx += 1

However, this doesn’t work for some reason with my code. I’d like to know if you guys are spotting an incorrect usage in here, or otherwise, is their a option to add a weight constraint inherently in the layer itself