The output of my neural network is negative even if i am using ReLU on every layer
I am a beginner at deep learning.I am using PyTorch to implement a neural network to train some chemical data. the input range between (0 to 1 )  with no negative values and I am using the ReLu activation function on every layer so I didn't expect to see a negative value in the output
my input size: 9 features
the output size: 7 Features
number of layers: 5
I can predict 6 of the 7 features correctly without problem only I found one of them has always negative values which I don't know why !. As far as i know, ReLU can't generate negative values
This is my neural network model:
class NNModel(nn.Module):
    
    def __init__(self, in_size, hidden_size, out_size):
        super().__init__()
        # hidden layers
        self.linear1 = nn.Linear(in_size, hidden_size)
        self.relu1 = nn.ReLU()

        self.linear2 = nn.Linear(hidden_size, hidden_size)
        self.relu2 = nn.ReLU()

        self.linear3 = nn.Linear(hidden_size, hidden_size)
        self.relu3 = nn.ReLU()

        self.linear4 = nn.Linear(hidden_size, hidden_size)
        self.relu4 = nn.ReLU()
        # output layer
        self.linear5 = nn.Linear(hidden_size, out_size)

    def forward(self, xb):
        
        # Get intermediate outputs using hidden layer
        out = self.linear1(xb)
        # Apply activation function
        out = self.relu1(out)

        out=self.linear2(out)
        out = self.relu2(out)

        out=self.linear3(out)
        out = self.relu3(out)

        out=self.linear4(out)
        out = self.relu4(out)
        # Get predictions using output layer
        out = self.linear5(out)
        return out
    
    def training_step(self, batch):
        inputs, targets = batch 
        out = self(inputs)                  # Generate predictions
        L=nn.MSELoss()
        loss = L(out, targets) # Calculate loss
              
        return loss
    
    def validation_step(self, batch):
        inputs, targets = batch 
        out = self(inputs)                    # Generate predictions
        L=nn.MSELoss()
        loss = L(out, targets)   # Calculate loss
        return {'val_loss': loss.detach() }
        
    def validation_epoch_end(self, outputs):
        batch_losses = [x['val_loss'] for x in outputs]
        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses
        return {'val_loss': epoch_loss.item()}
    
    def epoch_end(self, epoch, result):
        print(&quot;Epoch [{}], val_loss: {}&quot;.format(epoch+1, result['val_loss']))

Any help, tips, or advice will be appreciated

You are using a linear layer after relu, you can rewrite your last layer as:
out = self.relu(self.linear5(out))

and your model definition from:
self.relu1 = nn.ReLU()
self.relu2 = nn.ReLU()
self.relu3 = nn.ReLU()

to a single definition:
self.relu = nn.ReLU()

and reuse this self.relu, as it is just a function without any learnable parameters.
Based on you features, i would recommend some things:
use pyramidal like neurons by layer, eg:
layer 1: 512
layer 2: 256
layer 3: 125
last layer activation function:
use a linear then a sigmoid (don't use relu in the mid,otherwise you will clip you outputs in the range 0.5 to 1).
Normalize your output data, and store mean and variance for reversing the transformation after that. Also, take a closer look, it is very likely that the values you are failing to predict are in a different range/distribution compared to the ones you are doing ok.
Try adam optimizer with 0.001 learning rate.
Try different batch sizes, ranging from 1,2,8,16,32,64,128.
Try add dropout.
After all, you may need more data.
