Your code will work with CloningLinear (again, hope i understand what you try to do)
import torch.nn as nn
import torch.nn.functional as F
import torch

class CloningLinear(nn.Linear):
    def forward(self, inputs):
        return F.linear(inputs, self.weight.clone(), self.bias.clone())

class Model(nn.Module):
    def __init__(self,in_state,out_feats):
        super(Model, self).__init__()
        self.apply_1 = nn.ModuleList([CloningLinear(4*in_state,32), 
                                      nn.ReLU(),
					                  CloningLinear(32,out_feats),
 					                  nn.Softmax(dim=1)])
                                    
    def forward(self,inp):
        hidden = inp
        for layer in self.apply_1:
            hidden = layer(hidden)
        return hidden
  
    
mymodel = Model(3,12)
inp1 = torch.rand(1,12)
inp2 = torch.rand(1,12)
out1 = mymodel(inp1) 
out2 = mymodel(inp2)

optimizer = torch.optim.Adam(mymodel.parameters(),lr=0.1)

loss = torch.log(out1[0][0])*-10
optimizer.zero_grad()
loss.backward(retain_graph=True)
optimizer.step()
loss = torch.log(out2[0][0])*-10
optimizer.zero_grad()
loss.backward(retain_graph=True) #<--- still think you should reconsider this retain_graph
optimizer.step()