This is the structure of my model:
class ConvNet(nn.Module):
    
    #Definición de layers y parámetros
    def __init__(self):
        super(ConvNet, self).__init__()
        
        #Input Layer (CNN)
        self.inp_layer = nn.Sequential(
            nn.Conv2d(in_channels = 3,
                      out_channels = 64,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(64),
            nn.ReLU()
        )
        
        #Hidden Layer 1 (CNN)
        self.hid_layer_1 = nn.Sequential(
            nn.Conv2d(in_channels = 64,
                      out_channels = 128,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(128),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2,
                         stride = 2)
        )
        
        #Hidden Layer 2 (CNN)
        self.hid_layer_2 = nn.Sequential(
            nn.Conv2d(in_channels = 128,
                      out_channels = 256,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(256),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2,
                         stride = 2)
        )
        
        #Hidden Layer 3 (CNN)
        self.hid_layer_3 = nn.Sequential(
            nn.Conv2d(in_channels = 256,
                      out_channels = 512,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2,
                         stride = 2)
        )
        
        #Hidden Layer 4 (CNN)
        self.hid_layer_4 = nn.Sequential(
            nn.Conv2d(in_channels = 512,
                      out_channels = 512,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2,
                         stride = 2)
        )
        
        #Hidden Layer 5 (CNN)
        self.hid_layer_5 = nn.Sequential(
            nn.Conv2d(in_channels = 512,
                      out_channels = 512,
                      kernel_size = 5,
                      stride = 1,
                      padding = 2),
            nn.BatchNorm2d(512),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size = 2,
                         stride = 2)
        )
        
        #Hidden Layer 6 (FCL)
        self.hid_layer_6 = nn.Sequential(
            nn.Linear(in_features = 7*7*512,
                      out_features = 7*7*512),
            nn.ReLU()
        )
        
        #Hidden Layer 7 (FCL)
        self.hid_layer_7 = nn.Sequential(
            nn.Linear(in_features = 7*7*512,
                      out_features = 1000),
            nn.ReLU()
        )
        
        #Hidden Layer 8 (FCL)
        self.hid_layer_8 = nn.Sequential(
            nn.Linear(in_features = 1000,
                      out_features = 1000),
            nn.ReLU()
        )
        
        #Output Layer (FCL)
        self.out_layer = nn.Sequential(
            nn.Linear(in_features = 1000,
                      out_features = 120),
            nn.Softmax(dim = 1)
        )
        
    def forward(self, x):
        
        #First Convolutonal (ReLU)
        out = self.inp_layer(x)
        
        #Second Convolutonal (ReLU)
        out = self.hid_layer_1(out)
        
        #Third Convolutonal (ReLU)
        out = self.hid_layer_2(out)
        
        #Fourth Convolutonal (ReLU)
        out = self.hid_layer_3(out)
        
        #Fifth Convolutonal (ReLU)
        out = self.hid_layer_4(out)
        
        #Sixth Convolutonal (ReLU)
        out = self.hid_layer_5(out)
        
        #Size of flatten input
        size = out.size()[1] * out.size()[2] * out.size()[3]
        
        #Flatten
        out = out.view(-1, size)
        
        #First Fully Connected Layer (ReLU)
        out = self.hid_layer_6(out)
        
        #Second Fully Connected Layer (ReLU)
        out = self.hid_layer_7(out)
        
        #Third Fully Connected Layer (ReLU)
        out = self.hid_layer_8(out)
        
        #Fourth Fully Connected Layer (SoftMax)
        out = self.out_layer(out)
        
        #Return
        return out

To check the storage of my GPU i run the next code:
model = ConvNet().cuda(device = 0)
print('GPU storage used = ' + str(np.float(torch.cuda.memory_allocated() / torch.cuda.memory_cached()) * 100) + '%')

#GPU storage used = 99.97678608366593%
This is the error that appears when i try to train my model:
RuntimeError: CUDA out of memory. Tried to allocate 2.34 GiB (GPU 0; 7.76 GiB total capacity; 4.21 GiB already allocated; 1.61 GiB free; 978.56 MiB cached)