Thank you so much for your reply. I made some “research” after your hints.
First of all, yes, I do a copy of the first nn.Sequential (convolutional layers 1-5)  to  self.features. And after that; I freeze all of these convolutional layers. Printing the requires_grad state yields False, which is the expected one.
For better understanding of my intention, I do following in Network.py, or I want to do it at least  (hopefully, I did it correctly):

first, I call the structure of the original Network from pretraining step
then, I load the model from pretraining
freeze the convolutional layers by requires_grad = False

change the fully connected layer fc6 dimensions (different input than in the pretraining network)
In the forward function, I start with self.features(x) (which is the freezed conv-net), and pass the output to fully connected layer fc6.

To check if it is correct what I did, I did following tests:

Printed the requires_grad by following code:

for name, param in self.features.named_parameters():
   print('f_name: ', name)
   print('f_param.shape: ', param.shape)
   print('f_param.requires_grad: ', param.requires_grad)
   print('=====')


This yields:
f_name:  0.conv1_s1.weight
f_param.shape:  torch.Size([24, 3, 3, 7])
f_param.requires_grad:  False
=====
f_name:  0.conv1_s1.bias
f_param.shape:  torch.Size([24])
f_param.requires_grad:  False
=====
f_name:  0.conv2_s1.weight
f_param.shape:  torch.Size([64, 12, 3, 3])
f_param.requires_grad:  False
=====
f_name:  0.conv2_s1.bias
f_param.shape:  torch.Size([64])
f_param.requires_grad:  False
=====
f_name:  0.conv3_s1.weight
f_param.shape:  torch.Size([96, 64, 3, 3])
f_param.requires_grad:  False
=====
f_name:  0.conv3_s1.bias
f_param.shape:  torch.Size([96])
f_param.requires_grad:  False
=====
f_name:  0.conv4_s1.weight
f_param.shape:  torch.Size([96, 48, 3, 3])
f_param.requires_grad:  False
=====
f_name:  0.conv4_s1.bias
f_param.shape:  torch.Size([96])
f_param.requires_grad:  False
=====
f_name:  0.conv5_s1.weight
f_param.shape:  torch.Size([64, 48, 3, 3])
f_param.requires_grad:  False
=====
f_name:  0.conv5_s1.bias
f_param.shape:  torch.Size([64])
f_param.requires_grad:  False
=====

I checked the requires_grad state additionally by printing the weights values in each epoch by following code:
        print("# features data done in epoch:", epoch)
        for p in net.features.parameters():
          print("features data:\n", p.data)

        print("### fc6 data:\n")
        for p in net.fc6.parameters():
          print("fc6 data:\n", p.data)

        print("### fc7 data:\n")
        for p in net.fc7.parameters():
          print("fc6 data:\n", p.data)
        
        print("### classifier data:\n")
        for p in net.classifier.parameters():
          print("classifier data:\n", p.data)

This yields for the convolutional net.features.parameters() always the same values, whereas the fc-layers values change, e.g. the I get always these values in each epoch from epoch 1 to 50:
# features data done in epoch: 50
features data:
 tensor([[[[-2.9370e-02, -2.4781e-02, -3.6837e-02,  ..., -1.9737e-02,
           -5.3319e-02,  1.2129e-02],
          [ 1.9878e-02,  2.2050e-03,  1.1819e-02,  ...,  1.5220e-02,
            3.8971e-02,  1.6507e-02],
          [-4.5968e-02, -4.0048e-02, -2.5076e-02,  ..., -6.9785e-03,
            2.7164e-02,  2.5658e-02],
          ...,
          [-1.2946e-01, -9.4483e-02, -9.1339e-02,  ..., -8.9851e-02,
           -1.3448e-01, -3.0433e-02],
          [-4.5213e-02, -1.4098e-02, -7.2459e-02,  ...,  6.4320e-02,
            3.4375e-02,  1.5377e-02],
          [ 7.3047e-02,  1.0381e-01, -2.7192e-02,  ..., -4.1457e-02,
            1.5289e-02, -1.4070e-02]]]], device='cuda:0')

features data:
 tensor([-0.0733, -0.1775, -0.2160, -0.3278, -0.2497, -0.2964, -0.4560, -0.2895,
        -0.1183, -0.2846,  0.0662, -0.2177, -0.2982, -0.2366, -0.2577, -0.2406,
        -0.0741, -0.4508, -0.3050, -0.1537, -0.0788, -0.2600, -0.4483, -0.5219,
        -0.2005, -0.1901, -0.3734, -0.1820, -0.1335, -0.1852, -0.5939, -0.0357],
       device='cuda:0')

With requires_grad=True, the weight values of the convolutional layers 1-5 change in each epoch.
With requires_grad=False, the weight values of the convolutional layers remaine the same in each epoch. The fully connected layers (fc6, fc7 and classification)  weights changed in each epoch.
Is this a proof, that the loading and freezing the conv-net layer is correct?
If I understood you correctly, you worked on a similar transfer learning task and observed, that with pretraining the performance was worse than training with fully manually annoted data, correct? Do you mean the “accuracy” if you mention performance? In my case, the accuracy is in general also lower than training with manually annotated data from scratch. But depending on the filter sizes in the convolutional layers, classification with very little data (e.g. 15-20 per class)  seem to be slightly better when the pretrained model is used. But I have to verify it more in detail.
In the pretraining, the image data is split in 4 tiles. Therefore, I have 4 parallel shared conv-nets and the fc6. After that the results are stacked in fc7. In the classification, I want to train the fully connected layers, fc6,fc7,and classification. The input size of the fc6 in the pretraining and in the classification task is different, because of the smaller image tiles (split in 4 parts) in the pretraining task. In the classification task, the whole image is scanned and there is no splitting in parallel nets.