def gen():
source_path = 'dataset/normalized_syllables_rhythm_notes.json-seqlen-30.hdf5'
train_dataset = T_H5PYDataset(source_path, which_sets=('train',))
main_loop = load('./checkpoint-pitches.zip')
model = main_loop.model
print [x.name for x in model.shared_variables]
def read_data(pickle_file, dict_file):
with open(pickle_file, "r") as model_f:
print "Loading Model ", pickle_file, "..."
trained_model = saveload.load(model_f)
print "Done"
param_values = trained_model.model.get_parameter_values()
word_embeddings = param_values["/word_embeddings.W"]
morpho_embeddings = param_values["/morpho_embeddings.W"] # We will need these to make embeds of oov words
with open(dict_file, "r") as dict_f:
D = cPickle.load(dict_f)
word_to_num = D["word_to_ix"]
morpho_to_num = D["morpho_to_ix"]
return word_embeddings, morpho_embeddings, word_to_num, morpho_to_num
def gen(train_dataset, input_syllables):
main_loop = load('./checkpoint.zip')
model = main_loop.model
print[x.name for x in model.shared_variables]
print[x.name for x in model.variables]
tensor_initial = [
x for x in model.shared_variables if x.name == "initial_state"
][0]
tensor_hidden_states = [
x for x in model.intermediary_variables
if x.name == "hidden_apply_states"
][0]
tensor_x = [x for x in model.variables if x.name == "syllables"][0]
tensor_y = [
x for x in model.variables if x.name == "ndim_softmax_apply_output"
][0]
predict_fun = function([tensor_x],
tensor_y,
updates=[
(tensor_initial, tensor_hidden_states[0][0]),
])
input_syllables_encoded = train_dataset.syllables_encode(
input_syllables.split("|"))
print "encoded syllables:"
print input_syllables_encoded
predictions = []
import time
numpy.random.seed(int(time.time()))
for i in range(len(input_syllables_encoded)):
input_char = numpy.zeros((1, 1), dtype=numpy.int32)
input_char[0][0] = input_syllables_encoded[i]
predictions.append(
numpy.random.choice(train_dataset.durations_vocab_size(),
1,
p=predict_fun(input_char)[0])[0])
rhythms = train_dataset.durations_decode(predictions)
print "Predict rhythm:"
print rhythms
return rhythms
def load(self, filename):
self.MainLoop = load(open(filename))
self.Model = self.MainLoop.model
print self.Model.intermediary_variables
model_inputs = [self.get_var_from(source, self.Model.variables) for source in self.InputSources]
model_softmax = self.get_var_from('softmax_log_probabilities_output', self.Model.variables)
parameter_dict = self.Model.get_parameter_dict()
fun_updates = []
for i in range(1,100):
initial_state_key = "/recurrent"+str(i)+".initial_state"
if initial_state_key not in parameter_dict:
break
intermediary_states = self.get_var_from("recurrent"+str(i)+"_apply_states", self.Model.intermediary_variables)
fun_updates.append((parameter_dict[initial_state_key], intermediary_states[0][0]))
self.Function = theano.function(model_inputs, model_softmax,
updates=fun_updates)
v_init = get_var_from("initial_state", model.shared_variables)
v_states = get_var_from("H_apply_states", model.intermediary_variables)
#v_states = get_var_from("H_apply_states",model.intermediary_variables)
f = theano.function([v_inchar],
v_softmax,
updates=[(v_init, v_states[0][0])])
#f = theano.function([v_inchar], v_softmax)
seq = [init_char]
for _ in xrange(num_chars):
dist = f(np.atleast_2d(seq[-1]).astype(np.int32))[0]
sample = np.random.choice(vocab_size, 1, p=dist)[0]
seq.append(sample)
#print seq
return seq
def sample_text(model, num_chars, corpus):
return "".join(
corpus.decode(sample_chars(model, num_chars, corpus.vocab_size())))
corpus = Corpus(open("corpus.txt").read())
args = getArguments()
main_loop = load(args.model)
model = main_loop.model
#print sample_text(model, args.sample_size, corpus)
def gen():
source_path = 'dataset/normalized_syllables_rhythm_notes.json-seqlen-30.hdf5'
train_dataset = T_H5PYDataset(source_path, which_sets=('train', ))
main_loop = load('./checkpoint-pitches.zip')
model = main_loop.model
print[x.name for x in model.shared_variables]
print[x.name for x in model.variables]
tensor_initial = [
x for x in model.shared_variables if x.name == "initial_state"
][0]
tensor_hidden_states = [
x for x in model.intermediary_variables
if x.name == "hidden_apply_states"
][0]
tensor_x = [x for x in model.variables if x.name == "durations"][0]
tensor_y = [
x for x in model.variables if x.name == "ndim_softmax_apply_output"
][0]
predict_fun = function([tensor_x],
tensor_y,
updates=[
(tensor_initial, tensor_hidden_states[0][0]),
])
input_syllables = "love-looks-not-with-the-eyes-but-with-the-mind-and-there-fore-is-winged-cupid-pain-ted-blind"
from predict import gen
input_durations = gen(train_dataset, input_syllables)
input_str_split = input_syllables.split("-")
input_str_arr = train_dataset.syllables_encode(input_str_split)
input_str_arr_decoded = train_dataset.syllables_decode(input_str_arr)
input_durations_arr = train_dataset.durations_encode(input_durations)
print input_str_arr
print input_durations_arr
predictions = []
import time
numpy.random.seed(int(time.time()))
for i in range(len(input_durations_arr)):
input_char = numpy.zeros((1, 1), dtype=numpy.int32)
input_char[0][0] = input_durations_arr[i]
predictions.append(
numpy.random.choice(train_dataset.pitches_vocab_size(),
1,
p=predict_fun(input_char)[0])[0])
pitches = train_dataset.pitches_decode(predictions)
print "Predict:"
print pitches
return mxml_utils.create_mxml(input_str_split, input_str_arr_decoded,
input_durations, pitches)
class MyDataset(H5PYDataset):
def get_data(self, state=None, request=None):
data = list(super(MyDataset, self).get_data(state, request))
data[0] = data[0].T
data[1] = data[1].T
return tuple(data)
with h5py.File(source_path) as f:
charset = json.loads(f.attrs['index_to_char'])
charset_size = len(charset)
instances_num = f['x'].shape[0]
main_loop = load('./checkpoint.zip')
model = main_loop.model
print [x.name for x in model.shared_variables]
print [x.name for x in model.variables]
tensor_initial = [x for x in model.shared_variables if x.name == "initial_state"][0]
tensor_hidden_states = [x for x in model.intermediary_variables if x.name == "hidden_apply_states"][0]
tensor_x = [x for x in model.variables if x.name == "x"][0]
tensor_y = [x for x in model.variables if x.name == "ndim_softmax_apply_output"][0]
predict_fun = function([tensor_x], tensor_y, updates=[
(tensor_initial, tensor_hidden_states[0][0]),
])
v_inchar = get_var_from("inchar", model.variables)
v_softmax = get_var_from("softmax_apply_output", model.variables)
v_init = get_var_from("initial_state", model.shared_variables)
v_states = get_var_from("H_apply_states", model.intermediary_variables)
# v_states = get_var_from("H_apply_states",model.intermediary_variables)
f = theano.function([v_inchar], v_softmax, updates=[(v_init, v_states[0][0])])
# f = theano.function([v_inchar], v_softmax)
seq = [init_char]
for _ in xrange(num_chars):
dist = f(np.atleast_2d(seq[-1]).astype(np.int32))[0]
sample = np.random.choice(vocab_size, 1, p=dist)[0]
seq.append(sample)
# print seq
return seq
def sample_text(model, num_chars, corpus):
return "".join(corpus.decode(sample_chars(model, num_chars, corpus.vocab_size())))
corpus = Corpus(open("corpus.txt").read())
args = getArguments()
main_loop = load(args.model)
model = main_loop.model
# print sample_text(model, args.sample_size, corpus)
def gen(train_dataset, input_syllables):
main_loop = load('./checkpoint.zip')
model = main_loop.model
print [x.name for x in model.shared_variables]