循环神经网络进阶-------自动写歌词

 RNN,LSTM,GRU,循环RNN, 深度LSTM，四个模型自动写杰伦歌词

import os 
import numpy as np
import torch
from torch import nn,optim
import torch.nn.functional as F
import sys
import time
import math
sys.path.append("###")  #将其加入环境
device =torch.device('duda' if torch.cuda.is_available() else 'cpu')


class RNNModel(nn.Module):
    def __init__(self, rnn_layer, vocab_size):
        super(RNNModel, self).__init__()
        self.rnn = rnn_layer
        self.hidden_size = rnn_layer.hidden_size * (2 if rnn_layer.bidirectional else 1) 
        self.vocab_size = vocab_size
        self.dense = nn.Linear(self.hidden_size, vocab_size)

    def forward(self, inputs,state):
        # inputs.shape: (batch_size, num_steps)
        X = to_onehot(inputs, self.vocab_size)
        X = torch.stack(X)  # X.shape: (num_steps, batch_size, vocab_size)
        hiddens, state = self.rnn(X, state)
        hiddens = hiddens.view(-1, hiddens.shape[-1])  # hiddens.shape: (num_steps * batch_size, hidden_size)
        output = self.dense(hiddens)
        return output, state
        
        
def load_data_jay_lyrics(txt_path,):
    with open(txt_path) as f:
        corpus_chars = f.read()
    corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ')
    corpus_chars = corpus_chars[0:10000]
    idx_to_char = list(set(corpus_chars))
    char_to_idx = dict([(char, i) for i, char in enumerate(idx_to_char)])
    vocab_size = len(char_to_idx)
    corpus_indices = [char_to_idx[char] for char in corpus_chars]
    return corpus_indices, char_to_idx, idx_to_char, vocab_size
    
def data_iter_random(corpus_indices, batch_size, num_steps, device):
    # 减1是因为对于长度为n的序列，X最多只有包含其中的前n - 1个字符
    num_examples = (len(corpus_indices) - 1) // num_steps  #