Hi,

I am trying to train the following model on GPU:

```
import torch.nn as nn
class ConvLSTM(nn.Module):
"""Convolutional lstm model to classify raw waveform files. The
architecture is:
Input -> Conv -> ReLU -> Pooling -> LSTM -> Softmax
Properties:
CONVOLUTIONAL LAYER:
conv_kernel_size : The size of the filters for the conv. layer
conv_stride: Stride for the conv. layer
num_features: Number of output channels for conv. layer
MAX POOLING LAYER:
pooling_kernel: Size of the max-pooling window
LSTM:
hidden_size: The dimension of the hidden state
num_layers: Number of hidden layers inside lstm
num_of_classes: Number of classes to classify into
bias: Have/not have bias terms in the layers
"""
def __init__(self, conv_kernel_size, conv_stride, num_features,
pooling_kernel, hidden_size, num_layers = 1,
num_of_classes = 2, bias = True, ):
super(ConvLSTM, self).__init__()
self.conv_kernel_size = conv_kernel_size
self.conv_stride = conv_stride
self.num_features = num_features
self.pooling_kernel = pooling_kernel
self.hidden_size = hidden_size
self.num_layers = num_layers
self.num_of_classes = num_of_classes
self.bias = bias
self.conv = nn.Conv1d(
in_channels = 1,
out_channels = num_features,
kernel_size = conv_kernel_size,
stride = conv_stride,
bias = bias
)
self.relu = nn.ReLU()
if pooling_kernel > 1:
self.pooling = nn.MaxPool1d(
kernel_size = pooling_kernel
)
self.lstm = nn.LSTM(
input_size = num_features,
hidden_size = hidden_size,
num_layers = num_layers,
dropout = 0.5,
bias = bias
)
self.linear = nn.Linear(
in_features = hidden_size,
out_features = num_of_classes,
bias = bias
)
self.softmax = nn.Softmax(dim = 1)
def forward(self, wav_minibatch):
""" Forward pass of the Convolutional LSTM audio based
ideology classifying network.
INPUT:
wav_minibatch: The raw waveform of a spoken word
hidden_init: Initial hidden state
cell_init: Initial cell state
OUTPUT:
prob_score: Probability scores over the classes"""
x = self.conv(wav_minibatch)
x = self.relu(x)
if self.pooling_kernel > 1:
x = self.pooling(x)
x = x.permute(2,0,1)
output, x = self.lstm(x)
x = self.linear(x[0][0,:,:])
probs = self.softmax(x)
return probs
```

However, when I try to put the model onto Cuda:

```
classifier = ConvLSTM(
conv_kernel_size = 5,
conv_stride = 1,
num_features = 32,
pooling_kernel = 2,
hidden_size = 1024,
num_layers = 1,
num_of_classes = 2,
bias = True
)
if torch.cuda.is_available():
classifier = classifier.cuda()
```

I get the following error without any further error message:

```
AssertionErrorTraceback (most recent call last)
<ipython-input-23-9dc2b59bee55> in <module>()
3 if torch.cuda.is_available():
----> 4 classifier = classifier.cuda()
/home/zsolt/anaconda3/lib/python3.5/site-packages/torch/nn/modules/module.py in cuda(self, device)
214 Module: self
215 """
--> 216 return self._apply(lambda t: t.cuda(device))
217
218 def cpu(self):
/home/zsolt/anaconda3/lib/python3.5/site-packages/torch/nn/modules/module.py in _apply(self, fn)
144 def _apply(self, fn):
145 for module in self.children():
--> 146 module._apply(fn)
147
148 for param in self._parameters.values():
/home/zsolt/anaconda3/lib/python3.5/site-packages/torch/nn/modules/rnn.py in _apply(self, fn)
121 def _apply(self, fn):
122 ret = super(RNNBase, self)._apply(fn)
--> 123 self.flatten_parameters()
124 return ret
125
/home/zsolt/anaconda3/lib/python3.5/site-packages/torch/nn/modules/rnn.py in flatten_parameters(self)
109 # Slice off views into weight_buf
110 all_weights = [[p.data for p in l] for l in self.all_weights]
--> 111 params = rnn.get_parameters(fn, handle, fn.weight_buf)
112
113 # Copy weights and update their storage
/home/zsolt/anaconda3/lib/python3.5/site-packages/torch/backends/cudnn/rnn.py in get_parameters(fn, handle, weight_buf)
163 # might as well merge the CUDNN ones into a single tensor as well
164 if linear_id == 0 or linear_id == num_linear_layers / 2:
--> 165 assert filter_dim_a.prod() == filter_dim_a[0]
166 size = (filter_dim_a[0] * num_linear_layers // 2, filter_dim_a[2])
167 param = fn.weight_buf.new().set_(
AssertionError:
```

Any suggestions?