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 test_classifier(test_data, test_raw, trained_params): f = open("test.pred", "w") for i, features in enumerate(test_data): x = feats_to_vec(features) category = mlpn.predict(x, trained_params) #print i, I2L[category], test_raw[i] f.write(I2L[category] + "\n") f.close()
def accuracy_on_dataset(dataset, params): good = bad = 0.0 for label, features in dataset: if mlpn.predict(features, params) == label: good += 1 else: bad += 1 return good / (good + bad)
def predict_on_test(params): with open('test.pred', 'w') as f: test_set = load_test_set('test', 'bigrams') for _, features in test_set: x = feats_to_vec(features) pred = mlp.predict(x, params) print(index_to_lang(pred), file=f)
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 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, 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 mn.predict(x, params) == y: good += 1 else: 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 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 = mlpn.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): 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] == mlpn.predict(feats_to_vec(features), params): good = good + 1 else: bad = bad + 1 return good / (good + bad)
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 = mlpn.predict(x, params) file.write(I2L[y_hat]) file.write("\n")
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 = mlpn.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) feats_vec = feats_to_vec(features) prediction = mlpn.predict(feats_vec, params) if prediction == L2I[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: x = feats_to_vec(features) y = utils.L2I[label] y_hat = mlpn.predict(x, params) if y == y_hat: good += 1 else: bad += 1 pass return good / (good + bad)
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: # 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) # convert features to a vector. y_hat = mlp_n.predict(x, params) if y_hat == ut.L2I[label]: good += 1 else: bad += 1 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 mlpn.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: # YOUR CODE HERE # Compute the accuracy (a scalar) of the current parameters # on the dataset. # accuracy is (correct_predictions / all_predictions) pred_label = mlpn.predict(features, params) if pred_label == 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: # 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 test(parameters): """ test classifier with test data - no labels params - the trained params """ # fd = open("test.pred", 'w') counter = 0 test_ans = '' test_data = ut.read_data('test') for label, feature in test_data: pred = mlpn.predict(feats_to_vec(feature), parameters) for l,i in ut.L2I.items(): if i == pred: test_ans = l counter += 1
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 = L2I[label] y_hat = ll.predict(x, params) if y - y_hat == 0: 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 = mlpn.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 local_l2i = ut.L2I for label, features in dataset: feat_vec = feats_to_vec(features) y_hat = mlpn.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 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) label = L2I[label] features = feats_to_vec(features) if mlpn.predict(features, params) == label: good += 1 else: bad += 1 pass accuracy = good / (good + bad) return accuracy
def fileData(fData): data = [] for [lang, bigrams] in fData: features = np.zeros(len(all_bigrams)) for bigram in bigrams: if bigram in all_bigrams: features[all_bigrams[bigram]] += 1 language = all_langs[lang] if lang in all_langs else -1 data.append([language, features]) return data # process the training and dev data and print accuracy #params = mlp.create_classifier(len(all_bigrams), int(math.log(len(all_bigrams) * len(all_langs))), len(all_langs)) params = mlp.create_classifier( [len(all_bigrams), 20, 30, 40, 10, len(all_langs)]) trained_params = train_classifier(fileData(utils.TRAIN), fileData(utils.DEV), num_iterations, learning_rate, params) # run prediction on the test data predict = [] for [label, data] in fileData(utils.TEST): predict.append(lang_to_id[mlp.predict(data, trained_params)]) """ In comment in order not to run over the file # write the prediction to a file predict_file = open('test.pred', 'w') predict_file.writelines(["%s\n" % item for item in predict]) predict_file.close() """
""" Written by Ari Bornstein """ import pickle import utils import mlpn as mlp params = pickle.load(open("model.p", "rb")) test = utils.TEST_BIGRAMS out = open(r'..\data\test.pred.', 'w') for x in test: pred = utils.I2L[mlp.predict(x, params)] out.write("{}\n".format(pred)) out.close()
for b in bs: if b not in bigrams: bigrams[b] = i i += 1 def dataFromFile(fileData): data = [] for [lang, bs] in fileData: features = np.zeros(len(bigrams)) for b in bs: if b in bigrams: features[bigrams[b]] += 1 language = languages[lang] if lang in languages else -1 data.append([language, features]) return data trainData = dataFromFile(utils.TRAIN) devData = dataFromFile(utils.DEV) testData = dataFromFile(utils.TEST) params = mlpn.create_classifier([len(bigrams), 13, 13, len(languages)]) trainedParams = train_classifier(trainData, devData, 20, 0.01, params) predictions = [] for [label, data] in testData: predictions.append(languagesBack[mlpn.predict(data, trainedParams)]) outF = open('test.pred', 'w') outF.write("\n".join(predictions)) outF.close()
print(I, train_loss, train_accuracy, dev_accuracy) return params if __name__ == '__main__': # YOUR CODE HERE # write code to load the train and dev sets, set up whatever you need, # and call train_classifier. from utils import TRAIN as train_data from utils import DEV as dev_data from utils import TEST as test_data from utils import L2I, I2L, F2I num_iterations = 10 learning_rate = 1e-2 dims = [len(F2I), 40, len(L2I)] params = mlpn.create_classifier(dims) trained_params = train_classifier(train_data, dev_data, num_iterations, learning_rate, params) preds = [] for features in test_data: x = feats_to_vec(features) preds.append(mlpn.predict(x, trained_params)) # with open('test.pred', 'w') as f: # for y_hat in preds: # f.write(f'{I2L[y_hat]}\n')
def accuracy_on_dataset(dataset, params): y_y_hat = [(y, pn.predict(x, params)) for x, y in dataset] if config.debug: print("yhat counter: {}".format(Counter([x[1] for x in y_y_hat]))) is_good = [a == b for a, b in y_y_hat] return sum(is_good) / len(is_good)