Access value of the weights of these models

I have this notebook:

It contains 3 networks: vgg_a, vgg_b and vgg_star. In particular I have vgg_star and vgg_star after the sum of the weights of vgg_a and vgg_b.
I want to see the numerical values of the weights (to see if there are patterns for example) of vgg_star and vgg_star after the sum of weights.
What I have to change in order to do this? I have to use .parameters() or .weight?

mode.parameters() gives a generator. convert into list and you can print the weights

Ok, thanks
But how can I access the weights of vgg_star before and after the summation of weights?

The code is too big to study, maybe share a minimal code block? however, why don’t you just print the parameters of the model before and after?

what do you mean by sum are you looping over all parameters and just adding them?

Yes, with sum you are right: I take vgg_a and vgg_b and I sum layer per layer their weights.
For showing the parameters, I mean this, I am not doing in a right way the print of the weights.

I have these:

model1 = VGG16((1,32,32),batch_norm=True)
model2 = VGG16((1,32,32),batch_norm=True)
model3 = VGG16((1,32,32),batch_norm=True)
classifier = Classifier(num_classes=1)

nets = [model1,model2,model3,classifier]

where VGG16 and Classifier are:

class VGGBlock(nn.Module):
    def __init__(self, in_channels, out_channels,batch_norm=False):


        conv2_params = {'kernel_size': (3, 3),
                        'stride'     : (1, 1),
                        'padding'   : 1

        noop = lambda x : x

        self._batch_norm = batch_norm

        self.conv1 = nn.Conv2d(in_channels=in_channels,out_channels=out_channels , **conv2_params)
        self.bn1 = nn.BatchNorm2d(out_channels) if batch_norm else noop

        self.conv2 = nn.Conv2d(in_channels=out_channels,out_channels=out_channels, **conv2_params)
        self.bn2 = nn.BatchNorm2d(out_channels) if batch_norm else noop

        self.max_pooling = nn.MaxPool2d(kernel_size=(2, 2), stride=(2, 2))

    def batch_norm(self):
        return self._batch_norm

    def forward(self,x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = F.relu(x)

        x = self.conv2(x)
        x = self.bn2(x)
        x = F.relu(x)

        x = self.max_pooling(x)

        return x

class VGG16(nn.Module):

  def __init__(self, input_size, batch_norm=False):
    super(VGG16, self).__init__()

    self.in_channels,self.in_width,self.in_height = input_size

    self.block_1 = VGGBlock(self.in_channels,64,batch_norm=batch_norm)
    self.block_2 = VGGBlock(64, 128,batch_norm=batch_norm)
    self.block_3 = VGGBlock(128, 256,batch_norm=batch_norm)
    self.block_4 = VGGBlock(256,512,batch_norm=batch_norm)

  def input_size(self):
      return self.in_channels,self.in_width,self.in_height

  def forward(self, x):

    x = self.block_1(x)
    x = self.block_2(x)
    x = self.block_3(x)
    x = self.block_4(x)
    # x = self.avgpool(x)
    x = torch.flatten(x,1)

    return x

class Classifier(nn.Module):

    def __init__(self,num_classes=1):

        self.classifier = nn.Sequential(
            nn.Linear(2048, 2048),
            nn.Linear(2048, 512),
            nn.Linear(512, num_classes)

    def forward(self,x):

        return self.classifier(x)

And in the train there is this part to do the sum:

for n in model_a:
              layer_a = model_a[n]
              layer_b = model_b[n]
              layer_c = model_c[n]
              if (isinstance(layer_a,nn.Conv2d)):
                loss += lambda_reg * reg_loss(combo_fn(layer_a.weight,layer_b.weight),layer_c.weight)
                if (layer_a.bias is not None):
                  loss += lambda_reg * reg_loss(combo_fn(layer_a.bias, layer_b.bias), layer_c.bias)