I am getting strange behavior during evaluation of a saimese network when I change the batch dimension of input data from whatever it is during training, to 1. After doing a forward pass with any batch_size > 1, the prediction shape for batch_sizes == 1 will be broadcast to the larger size.

Is there something I’m not understanding w.r.t. how pytorch handles different mini-batch inputs?

Thanks in advance.

eg

```
model = SaimeseNet(chars_size=chars, word_len=max_len,
embedding_dim=char_emb.shape[1], hidden_dim=15,
num_layers=2, out_dim=5)
model.eval()
var1 = Variable(test_inputs[:1])
var56 = Variable(test_inputs)
test_inputs.size()
>>> torch.Size([56, 42])
var56.size()
>>> torch.Size([56, 42]) # Batch_size x Max sequence length
var1.size()
>>> torch.Size([1, 42])
```

Doing a forward pass on these test datasets gives the following result. (actual output values not important).

```
model(var1, var1)
>>> Variable containing:
>>> 1.0000
>>> [torch.FloatTensor of size 1]
model(var56, var56)
>>> Variable containing:
>>> 1.0000
>>> 0.9999
>>> 0.9999
>>> 1.0000
>>> ....
>>> 1.0000
>>> [torch.FloatTensor of size 56]
# Call on batch_size=1 variable again
model(var1, var1)
>>> Variable containing:
>>> 1.0000
>>> 1.0000
>>> 1.0000
>>> 1.0000
>>> ....
>>> 1.0000
>>> [torch.FloatTensor of size 56]
```

```
class SaimeseNet(nn.Module):
def __init__(self, chars_size, word_len,
embedding_dim, hidden_dim, num_layers,
out_dim):
super(SaimeseNet, self).__init__()
self.hidden_dim = hidden_dim
self.num_layers = num_layers
self.out_dim = out_dim
self.emb = nn.Embedding(chars_size, embedding_dim)
self.emb.weight = nn.Parameter(
torch.from_numpy(char_emb).type(torch.FloatTensor),
requires_grad=False)
self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers,
bidirectional=True, batch_first=True)
self.fc = nn.Linear(2 * self.hidden_dim, self.out_dim)
self.energy = nn.CosineSimilarity(dim=1)
self.hidden = self.init_hidden()
def init_hidden(self):
# Requires dim of (2, 1, hidden_dim) for bidirectional
return (Variable(torch.zeros(2 * self.num_layers, 1, self.hidden_dim)),
Variable(torch.zeros(2 * self.num_layers, 1, self.hidden_dim)))
def _forward_alg(self, inp):
x = self.emb(inp)
lstm_out, self.hidden = self.lstm(x, self.hidden)
# Average outputs across time
avg_lstm = torch.mean(lstm_out, dim=1)
# Fully connected layer
fc = self.fc(avg_lstm)
return fc
def forward(self, inp1, inp2):
x1 = self._forward_alg(inp1)
x2 = self._forward_alg(inp2)
energy = self.energy(x1, x2)
return energy
```