def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for y, x in dataset:
y_pred = mlp1.predict(x, params)
good += 1 if y_pred == y else 0
bad += 1 if y_pred != y else 0
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
total = good = 0.0
for label, features in dataset:
total += 1
predicted_label = mlp1.predict(feats_to_vec(features), params)
if predicted_label == utils.L2I[label]:
good += 1
return float(good) / total
def test_predictions(dataset, params):
with open('test.pred', 'w') as file:
for index, (label, features) in enumerate(dataset):
x = feats_to_vec(features)
pred = model.predict(x, params)
if not index == 0:
file.write('\n')
file.write(ut.I2L[pred])
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
if m1.predict(features, params) == label:
good += 1
else:
bad += 1
return good / (good + bad)
def get_tag(dataset, params):
"""
Tgas the dataset based on trained params
dataset: a list of (label, feature) pairs.
params: list of parameters (initial values)
"""
f = open('test.pred.mlp1', 'w')
for label, features in dataset:
predicted_label = mlp1.predict(feats_to_vec(features), params)
f.write("%s\n" % utils.I2L[predicted_label])
f.close()
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
x = feats_to_vec(features)
y = ut.L2I[label]
pred = model.predict(x, params)
if pred == y:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
if ml1.predict(features, params) == label:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params, F2I):
good = bad = 0.0
for label, features in dataset:
x = feats_to_vec(features, F2I) # convert features to a vector.
y = ut.L2I[label] # convert the label to number
if m1.predict(x, params) == y:
good += 1
else:
bad += 1
return good / (good + bad)
def test(test_data, params):
prediction_file = open("test.pred", 'w')
for label, features in test_data:
x = feats_to_vec(features) # convert features to a vector.
pred = ml.predict(x, params)
for key, val in ut.L2I.items():
if val == pred:
label = key
break
prediction_file.write(str(label) + "\n")
prediction_file.close()
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for y, x in dataset:
pred = ml.predict(x, params)
if (y == pred):
good += 1
else:
bad += 1
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
return np.divide(good, (good + bad))
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
if utils.L2I[label] == mlp1.predict(feats_to_vec(features), params):
good = good + 1
else:
bad = bad + 1
return good / (good + bad)
def run_test(test_data, params):
pred_file = open("test.pred", 'w')
for label, features in test_data:
x = feats_to_vec(features) # convert features to a vector.
y_hat = ml.predict(x, params)
for key, val in ut.L2I.items(
): # for name, age in dictionary.iteritems(): (for Python 2.x)
if val == y_hat:
label = key
break
pred_file.write(str(label) + "\n")
pred_file.close()
def pred(pred_data, params):
""" Test classifier
"""
I2L = {utils.L2I[l]: l for l in utils.L2I}
with open("test.pred", "w+") as file:
for features in pred_data:
x = feats_to_vec(features) # convert features to a vector.
y_hat = ll.predict(x, params)
file.write(I2L[y_hat])
file.write("\n")
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
x = feats_to_vec(features)
y_pred = mlp1.predict(x, params)
good += 1 if y_pred==L2I[label] else 0
bad += 1 if y_pred!=L2I[label] else 0
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
# in case of no data set, like xor
if not dataset:
return 0
good = bad = 0.0
for label, features in dataset:
y_prediction = mlp1.predict(features, params)
if y_prediction == label:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
pred = mlp1.predict(feats_to_vec(features), params)
if pred == ut.L2I[label]:
good += 1
else:
bad += 1
pass
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = total = 0.0
for label, features in dataset:
x = feats_to_vec(features) # convert features to a vector.
y = L2I.get(label) # convert the label to number if needed.
if mlp1.predict(
x,
params) == y: # compare the prediction and the correct label
good += 1
total += 1
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
return good / total
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
x = feats_to_vec(features) # convert features to a vector.
y = ut.L2I[label] # convert the label to number if needed.
pred = ml.predict(x, params)
if (y == pred):
good += 1
else:
bad += 1
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
x = feats_to_vec(features)
y = utils.L2I[label]
y_hat = mlp1.predict(x, params)
if y == y_hat:
good += 1
else:
bad += 1
pass
return good / (good + bad)
def CreatePredictionsFile(data, parameters):
file_predictions = open("test.pred", 'w')
# list of languages
languages_list = utils.L2I.items()
for tag, features in data:
x = feats_to_vec(features) # convert features to a vector.
predicted_language = mlp1.predict(x, parameters)
for language, text in languages_list: # for name, age in dictionary.iteritems(): (for Python 2.x)
if predicted_language == text:
tag = language
break
file_predictions.write(str(tag) + "\n")
# close the file
file_predictions.close()
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for y, x in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
y_hat = ml.predict(x, params)
if (y == y_hat):
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
feat_vec = feats_to_vec(features)
y_hat = mlp.predict(feat_vec, params)
if label == y_hat:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions
x = feats_to_vec_uni(features)
y = L2I[label]
y_hat = ll.predict(x, params)
if y - y_hat == 0:
good += 1
else:
bad += 1
pass
return good / (good + bad)
def accuracy_on_dataset(dataset, params): good = bad = 0.0 local_l2i = ut.L2I for label, features in dataset: feat_vec = feats_to_vec(features) y_hat = mpl1.predict(feat_vec, params) if local_l2i[label] == y_hat: good += 1 else: bad += 1 # Compute the accuracy (a scalar) of the current parameters # on the dataset. # accuracy is (correct_predictions / all_predictions) return good / (good + bad)
def create_test_file(data_set, params):
"""
create file with results of languages
:param data_set: bigrams of 2 letters
:param params
:return: file with result
"""
test_file = open("test.pred", 'w')
for l, features in data_set:
x = feats_to_vec(features)
index = mlp1.predict(x, params)
for key, value in ut.L2I.items():
if value == index:
l = key
break
test_file.write(l + "\n")
test_file.close()
def accuracy_on_dataset(dataset, params):
"""
calculates the accuracy of the prediction on a given data set
:param dataset: bigrams of 2 letters and languages
:param params, dataset
:return: accuracy of the prediction by precentage
"""
good = bad = 0.0
for label, features in dataset:
x = feats_to_vec(features)
y = ut.L2I[label]
# prediction returned the correct label
if mlp1.predict(x, params) == y:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params, Xor=False):
good = bad = 0.0
for label, features in dataset:
if Xor == False:
x = feats_to_vec(features) # convert features to a vector
else:
x = np.array(features) # convert features to a vector
pred = ml.predict(x, params)
if pred == label:
good += 1
else:
bad += 1
pass
return good / (good + bad)
def create_test_pred_file(test_data, params):
"""
creates a 'test.pred' file
:param test_data: test data to be predicted
:param params: trained params
:return:
"""
f = open("test.pred", 'w')
for label, features in test_data:
x = feats_to_vec(features)
y_hat = mlp1.predict(x, params)
for l, i in utils.L2I.items():
if y_hat == i:
label = l
break
f.write(label + "\n")
f.close()
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
x = feats_to_vec(features) # convert features to a vector.
y = label # convert the label to number if needed.
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
if mlp.predict(x, params) == y:
good += 1
else:
bad += 1
return good / (good + bad)
def accuracy_on_dataset(dataset, params):
good = bad = 0.0
for label, features in dataset:
# YOUR CODE HERE
# Compute the accuracy (a scalar) of the current parameters
# on the dataset.
# accuracy is (correct_predictions / all_predictions)
# one_hot = features XOR PROBLEM
label = utils.L2I[label]
one_hot = feats_to_vec(features)
predicted_label = mlp.predict(one_hot, params)
if (predicted_label != label):
bad += 1
else:
good += 1
return good / (good + bad)
