Problem
Given a dataset consisting of 48-hour sequence of hospital records and a binary target determining whether the patient survives or not, when the model is given a test sequence of 48 hours record, it needs to predict whether the patient survives or not.
Data
I have constructed a dummy dataset as following:
input_ = torch.randn(100, 48, 76)
target_ = torch.randint(0, 2, (100,))

and loading the training data as following:
trainloader = DataLoader(TensorDataset(input_, target_), 
                         batch_size=50, 
                         shuffle=True)

Model
I have constructed an LSTM based model as following:
class LSTMClassification(nn.Module):

    def __init__(self, input_dim, hidden_dim, target_size):
        super(LSTMClassification, self).__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, target_size)

    def forward(self, input_):
        lstm_out, (h, c) = self.lstm(input_)
        logits = self.fc(lstm_out[-1])
        scores = F.sigmoid(logits)
        return scores

with training function as following:
def train(model, n_epochs):
    loss_function = nn.BCEWithLogitsLoss()
    optimizer = optim.SGD(model.parameters(), lr=0.1)

    history = {
        'loss': []
    }
    for epoch in range(n_epochs):
        losses = []
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data

            model.zero_grad()

            tag_scores = model(inputs)

            labels = labels.unsqueeze(1)
            
            loss = loss_function(tag_scores, labels)
            
            loss.backward()
            optimizer.step()
            losses.append(float(loss))
        avg_loss = np.mean(losses)
        history['loss'].append(avg_loss)
        print("Epoch {} / {}: Loss = {:.3f}".format(epoch+1, n_epochs, avg_loss))
    return history

The model construction is as following:
model = LSTMClassification(input_.shape[2], 
                        hidden_dim=6, 
                        target_size=1)

However, when I train the model, I’m getting an error
ValueError: Target size (torch.Size([50, 1])) must be the same as input size (torch.Size([48, 1]))

I’m not sure how to get my model to yield a tensor of size (50,1) whereby for each group of time series data, it yields an output of 0 or 1.