def create_model(self):
self.log('Creating model')
self.log('vocab size : ' + str(len(self.vocab_to_ints)))
self.model = LSTM(input_units=self.maxlen,
hidden_units=self.hidden_dim,
vocab_size=len(self.vocab_to_ints) + 1,
embedding_size=self.embedding_size) #.to(device)
class RNNAcceptor(DECAY_RNN_Model):
def update_dump_dict(self, key,x_test_minibatch, y_test_minibatch, predicted):
x = x_test_minibatch.tolist()
y = y_test_minibatch.tolist()
p = predicted
string = self.input_to_string(x)
self.dump_dict[key].append((string, y, p))
def test_model(self):
# create the batched examples of data
print("Entered testing phase")
result_dict = {}
self.dump_dict = {}
if not hasattr(self,"testing_dict"):
self.demark_testing()
with torch.no_grad():
for keys in (self.testing_dict.keys()):
self.dump_dict[keys]=[]
accuracy=0
total_example=0
for x_test, y_test in self.testing_dict[keys]:
total_example += 1
y_test = np.asarray(y_test)
x_test = torch.tensor(x_test, dtype=torch.long)
pred, _, _ = self.model(x_test)
if (pred[0][0] > pred[0][1]) :
predicted = 0
else :
predicted = 1
if(predicted==(y_test)) :
accuracy+=1
self.update_dump_dict(keys, x_test, y_test, predicted)
result_dict[keys] = (accuracy/total_example, total_example)
dump_dict_to_csv(self.dump_dict)
self.log(str(result_dict))
return result_dict
def result_demarcated(self):
if not hasattr(self, "testing_dict"):
self.demark_testing()
result_dict={}
with torch.no_grad():
for key in self.testing_dict.keys():
predicted=[]
accuracy=0
tot=0
for x_test, y_test in self.testing_dict[key]:
tot += 1
y_test = np.asarray(y_test)
x_test = torch.tensor(x_test, dtype=torch.long)
pred, _, _ = self.model(x_test)
if (pred[0][0] > pred[0][1]) :
predicted=0
else :
predicted=1
if(predicted==(y_test)) :
accuracy+=1
result_dict[key] = (accuracy/tot , tot)
self.log(str(result_dict))
return result_dict
def create_train_and_test(self, examples, test_size, data_name, save_data=False):
d = [[], []]
for i, s, dep in examples:
d[i].append((i, s, dep))
random.seed(1)
random.shuffle(d[0])
random.shuffle(d[1])
if self.equalize_classes:
l = min(len(d[0]), len(d[1]))
examples = d[0][:l] + d[1][:l]
else:
examples = d[0] + d[1]
random.shuffle(examples)
Y, X, deps = zip(*examples)
Y = np.asarray(Y)
X = pad_sequences(X, maxlen = self.maxlen)
n_train = int(self.prop_train * len(X))
# self.log('ntrain', n_train, self.prop_train, len(X), self.prop_train * len(X))
self.X_train, self.Y_train = X[:n_train], Y[:n_train]
self.deps_train = deps[:n_train]
if (test_size > 0) :
self.X_test, self.Y_test = X[n_train : n_train+test_size], Y[n_train : n_train+test_size]
self.deps_test = deps[n_train : n_train+test_size]
else :
self.X_test, self.Y_test = X[n_train:], Y[n_train:]
self.deps_test = deps[n_train:]
if (save_data) :
with open('X_' + data_name + '_data.pkl', 'wb') as f:
pickle.dump(X, f)
with open('Y_' + data_name + '_data.pkl', 'wb') as f:
pickle.dump(Y, f)
with open('deps_' + data_name + '_data.pkl', 'wb') as f:
pickle.dump(deps, f)
def load_train_and_test(self, test_size, data_name):
# Y = np.asarray(Y)
# X = pad_sequences(X, maxlen = self.maxlen)
with open('../grammar_data/' + data_name + '_v2i.pkl', 'rb') as f:
self.vocab_to_ints = pickle.load(f)
with open('../grammar_data/' + data_name + '_i2v.pkl', 'rb') as f:
self.ints_to_vocab = pickle.load(f)
X = []
Y = []
with open('../grammar_data/X_' + data_name + '_data.pkl', 'rb') as f:
X = pickle.load(f)
with open('../grammar_data/Y_' + data_name + '_data.pkl', 'rb') as f:
Y = pickle.load(f)
with open('../grammar_data/deps_' + data_name + '_data.pkl', 'rb') as f:
deps = pickle.load(f)
n_train = int(self.prop_train * len(X))
self.X_train, self.Y_train = X[:n_train], Y[:n_train]
self.deps_train = deps[:n_train]
if (test_size > 0) :
self.X_test, self.Y_test = X[n_train : n_train+test_size], Y[n_train : n_train+test_size]
self.deps_test = deps[n_train : n_train+test_size]
else :
self.X_test, self.Y_test = X[n_train:], Y[n_train:]
self.deps_test = deps[n_train:]
def create_model_batched(self, batch_size=32):
self.log('Creating Batched model')
self.log('vocab size : ' + str(len(self.vocab_to_ints)))
self.model = batch_lstm.LSTM(input_units = self.maxlen ,hidden_units = self.hidden_dim, vocab_size = len(self.vocab_to_ints)+1, batch_size=batch_size)#.to(self.device)
def create_model(self):
self.log('Creating model')
self.log('vocab size : ' + str(len(self.vocab_to_ints)))
self.model = LSTM(input_units = self.maxlen ,hidden_units = self.hidden_dim, vocab_size = len(self.vocab_to_ints)+1)#.to(device)
def results_batched(self):
self.log('Processing test set')
predicted = []
x_test = torch.tensor(self.X_test, dtype=torch.long)#.to(self.device)
# x_test = self.X_test
self.log(str(len(self.X_train)) + ', ' + str(len(x_test)))
with torch.no_grad():
for index in range(len(x_test)) :
pred, hidden, output = self.model.pred_forward(x_test[index])
if (pred[0][0] > pred[0][1]) :
predicted.append([0])
else :
predicted.append([1])
recs = []
columns = ['correct', 'prediction', 'label'] + dependency_fields
for dep, prediction in zip(self.deps_test, predicted):
prediction = self.code_to_class[prediction[0]]
recs.append((prediction == dep['label'], prediction, dep['label']) + tuple(dep[x] for x in dependency_fields))
self.test_results = pd.DataFrame(recs, columns=columns)
xxx = self.test_results['correct']
self.log('Accuracy : ' + str(sum(xxx)))
return sum(xxx)
def results(self):
self.log('Processing test set')
predicted = []
x_test = torch.tensor(self.X_test, dtype=torch.long)#.to(cpu)
# x_test = self.X_test
self.log(str(len(self.X_train)) + ', ' + str(len(x_test)))
with torch.no_grad():
for index in range(len(x_test)) :
pred, hidden, output = self.model(x_test[index])
if (pred[0][0] > pred[0][1]) :
predicted.append([0])
else :
predicted.append([1])
recs = []
columns = ['correct', 'prediction', 'label'] + dependency_fields
for dep, prediction in zip(self.deps_test, predicted):
prediction = self.code_to_class[prediction[0]]
recs.append((prediction == dep['label'], prediction, dep['label']) + tuple(dep[x] for x in dependency_fields))
self.test_results = pd.DataFrame(recs, columns=columns)
xxx = self.test_results['correct']
self.log('Accuracy : ' + str(sum(xxx)))
return sum(xxx)
def validate_training(self, batch_list):
# This function will evaluate the training accuracy for the batches so far.
validation_size=len(batch_list)
accurate = 0
total = 0
self.log("Started Training data validataion")
self.log("Validating on {} batches of training data".format(validataion_size))
total_validation_done = 0
with torch.no_grad():
for x_val, y_val in batch_list:
pred, hidden, output = self.model(x_val)
for i in range(pred.shape[0]):
total+=1
if pred[i][0]>pred[i][1]:
if y_val[i].item()==0 :
accurate=accurate+1
if pred[i][0]<pred[i][1]:
if y_val[i].item()==1 :
accurate=accurate+1
self.log("Total accurate : {}/{}".format(accurate, total))
print("Total accurate : {}/{}".format(accurate, total))
def results_verbose(self, df_name='_verbose_.pkl'):
self.log('Processing test set')
predicted, all_hidden, all_output = [], [], []
x_test = torch.tensor(self.X_test, dtype=torch.long)
self.log(str(len(self.X_train)) + ', ' + str(len(x_test)))
with torch.no_grad():
for index in range(len(x_test)) :
if (index % 1000 == 0):
self.log(index)
pred, hidden, output = self.model(x_test[index])
# all_hidden.append(hidden)
# all_output.append(output)
if (pred[0][0] > pred[0][1]) :
predicted.append([0])
else :
predicted.append([1])
recs = []
columns = ['correct', 'prediction', 'label'] + dependency_fields
for dep, prediction in zip(self.deps_test, predicted):
prediction = self.code_to_class[prediction[0]]
recs.append((prediction == dep['label'], prediction, dep['label']) + tuple(dep[x] for x in dependency_fields))
self.test_results = pd.DataFrame(recs, columns=columns)
self.test_results.to_pickle(df_name)
# self.test_results['activations'] = all_hidden
# self.test_results['outputs'] = all_output
# self.test_results.to_pickle(df_name)
xxx = self.test_results['correct']
self.log('Accuracy : ' + str(sum(xxx)))
return sum(xxx)
def results_train(self):
self.log('Processing train set')
predicted = []
x_train = torch.tensor(self.X_train, dtype=torch.long)#.to(cpu)
self.log(len(x_train))
with torch.no_grad():
for index in range(len(x_train)) :
pred = self.model(x_train[index])
if (pred[0][0] > pred[0][1]) :
predicted.append([0])
else :
predicted.append([1])
recs = []
columns = ['correct', 'prediction', 'label'] + dependency_fields
for dep, prediction in zip(self.deps_train, predicted):
prediction = self.code_to_class[prediction[0]]
recs.append((prediction == dep['label'], prediction, dep['label']) + tuple(dep[x] for x in dependency_fields))
self.test_results = pd.DataFrame(recs, columns=columns)
xxx = self.test_results['correct']
self.log('Accuracy : ' + str(sum(xxx)))
return sum(xxx)