Hello,
I get crash after running a small Conv1d network on cpu. Here is a code example that crushes:
import numpy as np
import random
import matplotlib
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision.transforms as T
from torch.autograd import Variable

BATCH = 64
def get_xy():
    X = np.random.randn(BATCH, 50)
    Y = np.random.randn(BATCH, 1)
    return X, Y

use_cuda = False
FloatTensor = torch.cuda.FloatTensor if use_cuda else torch.FloatTensor
LongTensor = torch.cuda.LongTensor if use_cuda else torch.LongTensor
ByteTensor = torch.cuda.ByteTensor if use_cuda else torch.ByteTensor
Tensor = FloatTensor

class CNNRet(nn.Module):
    def __init__(self):
        super(CNNRet, self).__init__()
        self.cnn1 = nn.Conv1d(in_channels=1, out_channels=5, kernel_size=10, stride=5)
        self.cnn2 = nn.Conv1d(in_channels=5, out_channels=3, kernel_size=5, stride=2)
        self.lin = nn.Linear(9, 1)
    
    def forward(self, x):
        print x
        x = torch.unsqueeze(x, 1)
        x = self.cnn1(x)
        x = F.relu(x)
        x = self.cnn2(x)
        x = F.relu(x)
        x = x.view(-1, 9)
        x = self.lin(x)
        return x

model = CNNRet()
if use_cuda:
    model.cuda()
    
def get_loss():
    X, Y = get_xy()
    X = X.astype(np.float32)
    Y = Y.astype(np.float32)
    X = torch.from_numpy(X)
    Y = torch.from_numpy(Y)
    if use_cuda:
        X = X.cuda()
        Y = Y.cuda()
    X = Variable(X, requires_grad=False)
    Y = Variable(Y, requires_grad=False)
    p = model(X)
    loss = F.mse_loss(p, Y)
    return loss
    
def optimize_model(opt):
    opt.zero_grad()
    loss = get_loss()
    loss.backward()
    opt.step(get_loss)
    return loss

optimizer = optim.RMSprop(model.parameters(), lr=0.001, momentum=0.9)
mloss = 0.0
for it in xrange(10000):
    loss = optimize_model(optimizer)
    mloss = loss * 0.01 + 0.99 * mloss
    if it % 1000 == 999:
        print it, mloss

The error:
PC: @           0x4a6f8a PyErr_Occurred
*** SIGSEGV (@0x48) received by PID 10298 (TID 0x7f98c5d50700) from PID 72; stack trace: ***
@     0x7f994bdd3390 (unknown)
@           0x4a6f8a PyErr_Occurred
@     0x7f993cc73b27 _array_dealloc_buffer_info
@     0x7f993cc2615e array_dealloc
@     0x7f98ffeca8d5 NumpyArrayAllocator::free()
@     0x7f98f3a2844e THFloatStorage_free
@     0x7f98f3a3ebd7 THFloatTensor_free
@     0x7f98f329e029 thpp::THTensor<>::~THTensor()
@     0x7f98fff00ae1 torch::autograd::ConvBackward::releaseVariables()
@     0x7f98ffed2d8b torch::autograd::Engine::evaluate_function()
@     0x7f98ffed3573 torch::autograd::Engine::thread_main()
@     0x7f98ffef7417 PythonEngine::thread_main()
@     0x7f98ffed777a std::thread::_Impl<>::_M_run()
@     0x7f9900cd7a20 execute_native_thread_routine
@     0x7f994bdc96ba start_thread
@     0x7f994baff3dd clone
@                0x0 (unknown)
The strange thing that this code doesn’t crush on gpu, but the prediction - p has a cyclic structure (if you plot it).