以下のコードを動かそうと思っているのですが、
エラーが出力されてしまいます。
もしよろしければ、ご教授よろしくお願いいたします
何卒、よろしくお願いいたします。

python3 '/home/hoge/train.py'
Traceback (most recent call last):
File "/home/hoge/train.py", line 56, in
model = RNN(n_vocab, embedding_dim, hidden_dim)
File "/home/hoge/train.py", line 24, in init
self.decoder = nn.Linear(hidden_dim, n_vocab)
File "/home/hoge/.local/lib/python3.6/site-packages/torch/nn/modules/linear.py", line 44, in init
self.reset_parameters()
File "/home/hoge/.local/lib/python3.6/site-packages/torch/nn/modules/linear.py", line 47, in reset_parameters
stdv = 1. / math.sqrt(self.weight.size(1))
RuntimeError: invalid argument 2: dimension 1 out of range of 0D tensor at /pytorch/torch/lib/TH/generic/THTensor.c:24

import time
from urllib import request
from bs4 import BeautifulSoup
import MeCab


def get_data(url):
    req = request.urlopen(url)
    soup = BeautifulSoup(req.read(), 'html.parser')

    # 俳句
    poem_elem = soup.select('td[height=40] b')[0]
    poem = poem_elem.text.replace('*', '').strip()  # サニタイズ
    if not poem:
        return False  # 存在しないID
    return {'poem': poem}


def write2file(i, morphemes):
    with open('poem.txt', 'a', encoding="utf-8") as f:
        f.write(morphemes + '\n')

def get_morphemes(sentences):
    temp = tagger.parse(sentences).split()
    return " ".join(temp)

tagger = MeCab.Tagger("-Owakati")
MAX_ID = 10  # 登録されているIDの最大値
for i in range(1, MAX_ID):
    url = 'http://www.haiku-data.jp/work_detail.php?cd= 
{id}'.format(id=i)
    print('fetching data... ' + url, end=' ')
    d = get_data(url)
    if d:
       print('result: SUCCESS')
       morphemes = get_morphemes(d['poem'])
       write2file(i, morphemes)
    else:
        print('result: MISSING')

    time.sleep(1)

data_util.py

# -*- coding: utf-8 -*-
import codecs


def read_file(fname):
    """ Read file
    :param fname: file name
    :return: word list in the file
    """
    with codecs.open('poem.txt', 'a', encoding='utf-8') as f:
        return f.read().splitlines()

def select_sentences(sentences):
    dataset = []
    for sent in sentences:
        morphemes = sent.split()
        if len(morphemes) > 30:
           continue
        for i in range(len(morphemes)-2):
            if morphemes[i] == morphemes[i+1]:
                break
            if morphemes[i] == morphemes[i+2]:
                break
        else:
            dataset.append(sent)
    return dataset

def make_vocab(sentences):
    """ make dictionary
    :param sentences: word list ex. ["I", "am", "stupid"]
    """
    global word2id

    for sent in sentences:
        for morpheme in sent.split():
            if morpheme in word2id:
                continue
            word2id[morpheme] = len(word2id)

def sent2id(sentences):
    id_list = []
    for sent in sentences:
        temp = []
        for morpheme in sent.split():
            temp.append(word2id[morpheme])
        id_list.append(temp)
    return id_list

def get_dataset():
    fname_list = []
    dataset = []
    # make dictionary
    for fname in fname_list:
        sentences = read_file(fname)
        sentences = select_sentences(sentences)
        make_vocab(sentences)
        dataset = dataset + sentences
    id2sent = sent2id(dataset)
    return word2id, id2sent, dataset


word2id = {}

train.py

import random
import data_util as U
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as O
from torch.autograd import Variable

### Prepare data ###
word2id, id2sent, dataset = U.get_dataset()

USE_CUDA = False
FloatTensor = torch.cuda.FloatTensor if USE_CUDA else 
torch.FloatTensor
LongTensor = torch.cuda.LongTensor if USE_CUDA else torch.LongTensor
class RNN(nn.Module):
    def __init__(self, n_vocab, embedding_dim, hidden_dim):
        super(RNN, self).__init__()
        self.encoder = nn.Embedding(n_vocab, embedding_dim)
        self.gru = nn.GRU(embedding_dim, hidden_dim)
        self.decoder = nn.Linear(hidden_dim, n_vocab)
        self.embedding_dim = embedding_dim
        self.num_layers = 1
        self.dropout = nn.Dropout(0.1)
        self.init_hidden()

    def init_hidden(self):
        self.hidden = Variable(\
                        FloatTensor(self.num_layers, 1, 
self.embedding_dim).fill_(0))
        if USE_CUDA:
            self.hidden.cuda()

    def forward(self, x):
        x = self.encoder(x.view(1, -1))
        x = self.dropout(x)
        y, self.hidden = self.gru(x.view(1, 1, -1), self.hidden)
        y = self.decoder(y.view(1, -1))
        return y

def variable(index):
    tensor = LongTensor(index)
    if USE_CUDA:
        return Variable(tensor).cuda()
    return Variable(tensor)

### Training ###
n_epochs = 10
n_vocab = len(word2id)
embedding_dim = 128
hidden_dim = 128
learning_rate = 0.01

model = RNN(n_vocab, embedding_dim, hidden_dim)
if USE_CUDA:
    model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = O.Adam(model.parameters(), lr=learning_rate)

print("USE_CUDA: {}\nn_epochs: {}\nn_vocab: {}\n".format(USE_CUDA, 
n_epochs, n_vocab))

for epoch in range(n_epochs):
    if (epoch+1) % 1 == 0:
        print("Epoch {}".format(epoch+1))
    random.shuffle(id2sent)
    for indices in id2sent:
        model.init_hidden()
        model.zero_grad()
        source = variable(indices[:-1])
        target = variable(indices[1:])
        loss = 0
        for x, t in zip(source, target):
            y = model(x)
            loss += criterion(y, t)
        loss.backward()
        optimizer.step()
#model_name = "/output/example_gpu.model" if USE_CUDA else 
#"/output/example.model"
model_name = "example_gpu.model" if USE_CUDA else "example.model"
torch.save(model.state_dict(), model_name)

環境
Ubuntu 18.04

Python 3.6.6
torch (0.2.0.post2)
mecab-python3 (0.7)
beautifulsoup4 (4.6.0)