```
class Network(nn.Module):
def __init__(self,weight_matrix=embedding_matrix,hidden_dim=12):
super().__init__()
vocab_size = weight_matrix.shape[0]
vector_dim = weight_matrix.shape[1]
#text data
self.hidden_dim = 12
self.embedding = nn.Embedding(vocab_size,vector_dim)
self.embedding.weight.data.copy_(torch.from_numpy(weight_matrix))
self.embedding.weight.requires_grad = False
self.lstm = nn.LSTM(input_size = vector_dim, hidden_size = hidden_dim,num_layers=1,batch_first=True)
# categorical inputs
# make a 4d vector for each school_state input
# 51 is the size of dictionary we keep
self.state_embedding = nn.Embedding(51,2)
self.prefix_embedding = nn.Embedding(5,3)
self.cat_embedding = nn.Embedding(50,26)
self.sub_cat_embedding = nn.Embedding(401,20)
self.grade_embedding = nn.Embedding(4,2)
#numerical inputs
self.numeric = nn.Linear(3,12)
**self.linear1 = nn.Linear(hidden_dim , 128)**
self.linear2 = nn.Linear(128,32)
self.linear3 = nn.Linear(32,2)
def forward(self,text,state,prefix,cat,sub_cat,grade,num):
x1 = self.embedding(text)
lstm_out, (h,c) = self.lstm(x1) #lstm_out #[128, 250, 12]
out = lstm_out.contiguous().view(-1,self.hidden_dim)
x2 = self.state_embedding(state) #[128,2]
x3 = self.prefix_embedding(prefix) #[128,3]
x4 = self.cat_embedding(cat) ##[128,26]
x5 = self.sub_cat_embedding(sub_cat) #[128,20]
x6 = self.grade_embedding(grade) ##[128,2]
x7 = self.numeric(num)
print(x7.shape)
combined = torch.cat((out,x2,x3,x4,x5,x6,x7),axis=1)
x = F.relu(self.linear1(out))
x = F.relu(self.linear2(x))
x = F.sigmoid(self.linear3(x))[:,-1]
return x
```

In the bolded code portion I would like to flatten the LSTM output to dim (batch_size, -1).

How to do that. Please anyone help. Actually Iam trying to concatinate different inputs.