def load_model(model_filename): with open(model_filename, 'rb') as f: checkpoint = torch.load(f) n_hidden, n_layers, state_dict, chars = checkpoint['n_hidden'], checkpoint['n_layers'], \ checkpoint['state_dict'], checkpoint['chars'] model = CharRNN(chars=chars, n_hidden=n_hidden, n_layers=n_layers) model.load_state_dict(state_dict=state_dict) return model
def start_text(start_text, n_words=250): # Here we have loaded in a model that trained over 20 epochs `rnn_20_epoch.net` with open('saved_model/rnn_20_epoch.net', 'rb') as f: checkpoint = torch.load(f) loaded = CharRNN(checkpoint['tokens'], n_hidden=checkpoint['n_hidden'], n_layers=checkpoint['n_layers']) loaded.load_state_dict(checkpoint['state_dict']) generated_text = sample(loaded, n_words, top_k=5, prime='{} '.format(start_text)) generated_text = generated_text.replace('\n', ' ') generated_text = '{}.'.format(generated_text.split('.')[0]) return generated_text
from multiprocessing import Value import numpy as np import torch from flask import Flask, request, jsonify, render_template from torch.nn import functional as F from model import CharRNN from settings import * from utils import load_dict, create_tune_header app = Flask(__name__) print("Environment:", app.config["ENV"]) # Create and load model model = CharRNN(n_char) model.load_state_dict(torch.load(default_model_path, map_location='cpu')) model.eval() # Load necessary dictionaries int2char = load_dict(int2char_path) char2int = load_dict(char2int_path) counter = Value("i", 0) error_message = "We created some tunes, but it seems like we can't create music from these melodies.Please try again!" print("Ready!") @app.route("/") def generate_song():
quotes = read_file(file) tokens = list(set(''.join(quotes))) token_to_id = {token: idx for idx, token in enumerate(tokens)} id_to_token = {idx: token for token, idx in token_to_id.items()} num_tokens = len(tokens) # encode the text encoded = np.array([token_to_id[ch] for ch in quotes]) # Here we have loaded in a model that trained over 2 epochs `rnn_20_epoch.net` with open('rnn_50_epoch.net', 'rb') as f: checkpoint = torch.load(f) loaded = CharRNN(num_tokens, n_hidden=checkpoint['n_hidden'], n_layers=checkpoint['n_layers']) loaded.load_state_dict(checkpoint['state_dict']) def predict(net, char, h=None, top_k=None): ''' Given a character, predict the next character. Returns the predicted character and the hidden state. ''' # tensor inputs x = np.array([[token_to_id[char]]]) inputs = torch.from_numpy(x) if (train_on_gpu): inputs = inputs.cuda() # detach hidden state from history h = tuple([each.data for each in h])
o, h = model(inp, h) out_dist = o.view(-1).div(temperature).view(-1).exp().cpu() top_i = torch.multinomial(out_dist, 1)[0] result.append(top_i) return seed_characters + int2str(result, all_chars) if __name__ == '__main__': all_characters = string.printable input_size = len(all_characters) pre = torch.load("./model_50_RNN.pth") models_RNN = CharRNN(input_size, 512, input_size, 4).cuda() models_RNN.load_state_dict(pre) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") temp = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0] rnns = [] for i in temp: result = generate(models_RNN, "A", i, device) rnns.append(result) with open("RNN_Result_50.txt", "w") as f: for item in rnns: f.write("%s\n" % item) f.close() pre = torch.load("./model_50_LSTM.pth")
pred += vocab.idx_to_char(topi.item()) input = torch.from_numpy( np.array([convert_idx_to_one_hot(vocab, topi.item())])).unsqueeze(0) input = input.float().to(config.device) return pred def load_checkpoint(path: str): checkpoint = torch.load(path) vocab = load_vocab_from_chars(checkpoint['vocab_chars']) model_state_dict = checkpoint['model_state_dict'] return model_state_dict, vocab if __name__ == '__main__': state_dict, vocab = load_checkpoint(sys.argv[1]) # TODO: load hyperparameters from checkpoint? model = CharRNN(len(vocab), 256, 2) model.load_state_dict(state_dict) model.to(config.device) for _ in range(25): print(sample(model, vocab))