def tune_neural_network():
kfold = StratifiedKFold(n_splits=4,
shuffle=True) # 4-fold cross-validation
# neural net parameters
units = [200, 200] # neurons in each hidden layer
dropout = 0.2 # dropout rate
epochs = 5 # epochs
batch_size = 150 # size in batch
learn_rate = 0.001
#momentum = 0.8 # to work with SGD
kernel_initializer = 'normal' # weight init
bias_initializer = 'normal' # bias initi
activation_function = 'relu'
scores = []
for train, test in kfold.split(
data, labels): # train on 3 pieces evaluate on 1 (4 total runs)
model = NN.generate_neural_network(total_features, units, dropout,
learn_rate, kernel_initializer,
bias_initializer,
activation_function)
NN.train_neural_network(model, epochs, batch_size, data[train],
labels[train]) # train neural network
score = NN.evaluate_neural_network(model, data[test],
labels[test]) # evaluate neural net
scores.append(score)
print("Average accuracy: ", np.mean(scores), "Standard Deviation:",
np.std(scores))
def train_neural_network():
print("Training neural network")
(data, labels) = neural_network.load_training_data(OUTPUT_FOLDER)
(training_dataset, validation_dataset, training_lab,
validation_lab) = neural_network.configure_training_data(data, labels)
network = neural_network.create_neural_network()
neural_network.train_neural_network(network, training_dataset,
validation_dataset, training_lab,
validation_lab)
neural_network.save_neural_network(network)
def train_models():
data, labels, test_data, test_labels = create_sets()
model = NB.train_multi_naive_bayes_classifier(data, labels, save=False)
NB.test_multi_naive_bayes_classifier(model, test_data, test_labels)
model = DT.train_decision_tree_classifier(data, labels, save=False)
DT.test_decision_tree_classifier(model, test_data, test_labels)
model = RF.train_random_forest_classifier(data, labels, save=False)
RF.test_random_forest_classifier(model, test_data, test_labels)
model = KNN.train_knn_classifier(data, labels, save=False)
KNN.test_knn_classifier(model, test_data, test_labels)
model = LR.train_logistic_regression_classifier(data, labels, save=False)
LR.test_logistic_regression_classifier(model, test_data, test_labels)
model = SVM.train_svm_classifier(data, labels, save=False)
SVM.test_svm_classifier(model, test_data, test_labels)
# init the neural net
model = NN.generate_neural_network(total_features, units, dropout,
learn_rate, kernel_initializer,
bias_initializer, activation_function)
"""
train the neural network with the given model, epochs, batch size, train data-labels.
Specify verbosity level, validation data, callbacks and plots if needed.
Default parameters:
verbose=0, validation=False, val_data=None, val_labels=None, callbacks=False, plot_history=False
example:
NN.train_neural_network(model, epochs, batch_size, data, labels, verbose=0,
validation=True, val_data=test_data, val_labels=test_labels,
callbacks=True, plot_history=True)
This is the main training stage and thus we want to save the best models at the right times. This is done
setting the callback to True. Keras will seek for the minimum validation loss and it saves the model with
the highest validation accuracy.
"""
NN.train_neural_network(model,
epochs,
batch_size,
data,
labels,
verbose=2,
validation=True,
val_data=test_data,
val_labels=test_labels,
callbacks=True)
NN.test_neural_network(model, test_data, test_labels)
def adversarial_training():
NN.train_neural_network(trained_model, 4, 15, val_data, val_labels, verbose=2)
trained_model.save('Adam_adversarial_training_adv_1500_0.3.h5')
predictions = trained_model.predict(val_data)
confusion = confusion_matrix(val_labels, np.argmax(predictions, axis=1))
print(confusion)
TP = confusion[1, 1]
TN = confusion[0, 0]
FP = confusion[0, 1]
FN = confusion[1, 0]
FNR = FN / float(FN + TP) * 100
FPR = FP / float(FP + TN) * 100
accuracy = ((TP + TN) / float(TP + TN + FP + FN)) * 100
print("Adversarial FP:", FP, "- FN:", FN, "- TP:", TP, "- TN", TN)
print("Adversarial Accuracy:", accuracy, "- FPR:", FPR, "- FNR:", FNR)
def par_tune(train_features, train_labels):
# for i in range(avg_run):
# alpha= 0.01 * 10**(-1*i)
# print("alpha= %f" % alpha)
best_accuracy = -1.0
if test_layers_combination:
test_layers = (
(50, ),
(300, ),
(500, ),
(700, ),
#(400), (600), (700), (800), (1200), (1600),
#(400, 100), (800, 200), (1200, 300), (1600, 400),
#(400, 100, 40), (800, 400, 200), (1600, 800, 200),
#(400, 300, 200, 100), (400, 400, 400, 400), (800, 800, 800, 800)
)
else:
test_layers = ((700, ), )
for tlayer in test_layers:
print("********** Layers:", tlayer, "**********")
n_test_tot = 0
n_test_cor = 0
for i in range(avg_run):
train_f_shuff, train_l_shuff, test_f_shuff, test_l_shuff = make_train_test(
train_features, train_labels, test_split)
trained_nn = nn.train_neural_network(train_f_shuff,
train_l_shuff,
rescale_base,
hidden_layer_sizes=tlayer,
tol=2e-5)
n_cor_i, n_tot_i, wrong_f, wrong_l, wrong_p = nn.test_neural_network(
trained_nn, test_f_shuff, test_l_shuff, rescale_base)
n_test_cor += n_cor_i
n_test_tot += n_tot_i
# print("***** PCA *****")
# trained_nn = nn.train_neural_network(reduced_features[:n_train], train_labels[:n_train], rescale_base)
# wrong_f, wrong_l, wrong_p = nn.test_neural_network(trained_nn, reduced_features[n_train:n_train_data], train_labels[n_train:n_train_data], rescale_base)
if best_accuracy < n_test_cor / n_test_tot:
best_accuracy = n_test_cor / n_test_tot
best_trained_nn = trained_nn
best_trained_nn.name = tlayer
print('--- Average accuracy: ', n_test_cor / n_test_tot, ' ---')
print()
# for i in range(10):
# input_tol= 10**(-1*i)
# print("Tol:", input_tol)
# trained_nn = nn.train_neural_network(train_features[0:n_data-test_split], train_labels[0:n_data-test_split], rescale_base, hidden_layer_sizes = (700), tol= input_tol)
# wrong_f, wrong_l, wrong_p = nn.test_neural_network(trained_nn, train_features[n_train:n_train_data], train_labels[n_train:n_train_data], rescale_base)
# print()
print('Best neural network is', best_trained_nn.name)
return best_trained_nn
def test_can_learn_left_vs_right(self):
data = np.array([
[2.0, 0.0, 0],
[0.0, -1.0, 1],
[0.0, 6.0, 1],
[-1.0, 0.0, 0],
])
# Training uses random initialization, so seed the generator to ensure we get the same value
# every time.
np.random.seed(0)
model = nn.train_neural_network(data, [2, 2, 2], epochs=500)
X = np.array([
[10.0, 0.0],
[0.0, 5.0],
])
prediction = model.predict(X)
expected_prediction = np.array([0, 1])
numpy.testing.assert_almost_equal(prediction,
expected_prediction,
decimal=3)
def random_sub_sampling(runs):
score_gnb = [] # score for gaussian naive bayes
score_mnb = [] # scores for multinomial naive bayes
score_cnb = [] # scores for complement naive bayes
score_bnb = [] # scores for bernoulli naive bayes
score_dt = [] # scores for decision trees
score_rf = [] # scores for random forest
score_knn = [] # scores for k nearest neighbors
score_lr = [] # scores for logistic regression
score_svm = [] # scores for support vector machines
score_nn = [] # scores for neural network
for i in range(runs):
data, labels, test_data, test_labels = create_random_sets(
) # choose random training and testing sets
#model = GNB.train_gaussian_naive_bayes_classifier(data, labels) # train Gaussian Naive Bayes
#score_gnb = GNB.evaluate_gaussian_naive_bayes_classifier(model, test_data, test_labels) # evaluate performance
#model = MNB.train_multi_naive_bayes_classifier(data, labels) # train Multinomial Naive Bayes
#score_mnb = MNB.evaluate_multi_naive_bayes_classifier(model, test_data, test_labels)
#model = CNB.train_complement_naive_bayes_classifier(data, labels) # train Complement Naive Bayes
#score_cnb = CNB.evaluate_complement_naive_bayes_classifier(model, test_data, test_labels)
#model = BNB.train_bernoulli_naive_bayes_classifier(data, labels) # train Bernoulli Naive Bayes
#score_bnb = BNB.evaluate_bernoulli_naive_bayes_classifier(model, test_data, test_labels)
#model = DT.train_decision_tree_classifier(data, labels) # train Decision Tree Classifier
#score_dt = DT.evaluate_decision_tree_classifier(model, test_data, test_labels)
#model = RF.train_random_forest_classifier(data, labels) # train Random Forest
#score_rf = RF.evaluate_random_forest_classifier(model, test_data, test_labels)
#model = KNN.train_knn_classifier(data, labels) # train k-Nearest Neighbors Classifier
#score_knn = KNN.evaluate_knn_classifier(model, test_data, test_labels)
#model = LR.train_logistic_regression_classifier(data, labels) # train logistic Regression
#score_lr = LR.evaluate_logistic_regression_classifier(model, test_data, test_labels)
#model = SVM.train_svm_classifier(data, labels) # train Support Vector Machines
#score_svm = SVM.evaluate_svm_classifier(model, test_data, test_labels)
# init neural net
model = NN.generate_neural_network(total_features, units, dropout,
learn_rate, kernel_initializer,
bias_initializer,
activation_function)
"""
this is not the actual training procedure and we don't want to save the models. To save models and implement
the early stopping technique refer to train_models.py
The goal of this operation is only to determine the behavior of models to random training sets and random
testing sets!
So, only train and evaluate models.
"""
NN.train_neural_network(model,
epochs,
batch_size,
data,
labels,
verbose=2)
score = NN.evaluate_neural_network(model, test_data, test_labels)
score_nn.append(score)
# get average accuracy and standard deviation for each model for each model
#print("NB Average accuracy: ", np.mean(score_gnb), "Standard Deviation:", np.std(score_gnb))
#print("MNB Average accuracy: ", np.mean(score_mnb), "Standard Deviation:", np.std(score_mnb))
#print("CNB Average accuracy: ", np.mean(score_cnb), "Standard Deviation:", np.std(score_cnb))
#print("BNB Average accuracy: ", np.mean(score_bnb), "Standard Deviation:", np.std(score_bnb))
#print("DT Average accuracy: ", np.mean(score_dt), "Standard Deviation:", np.std(score_dt))
#print("RF Average accuracy: ", np.mean(score_rf), "Standard Deviation:", np.std(score_rf))
#print("kNN Average accuracy: ", np.mean(score_knn), "Standard Deviation:", np.std(score_knn))
#print("LR Average accuracy: ", np.mean(score_lr), "Standard Deviation:", np.std(score_lr))
#print("SVM Average accuracy: ", np.mean(score_svm), "Standard Deviation:", np.std(score_svm))
print("NN Average accuracy: ", np.mean(score_nn), "Standard Deviation:",
np.std(score_nn))
def main():
random.seed(142)
np.random.seed(142)
tf.random.set_seed(142)
parser = ArgumentParser()
parser.add_argument('-t', '--track', dest='track_name', type=str, required=True, choices=['nouns', 'verbs'],
help='A competition track name (nouns or verbs).')
parser.add_argument('-f', '--fasttext', dest='fasttext_name', type=str, required=True,
help='A binary file with a Facebook-like FastText model (*.bin).')
parser.add_argument('-w', '--wordnet', dest='wordnet_dir', type=str, required=True,
help='A directory with unarchived RuWordNet.')
parser.add_argument('-i', '--input', dest='input_data_dir', type=str, required=True,
help='A directory with input data, i.e. lists of unseen hyponyms for public and private '
'submission.')
parser.add_argument('-o', '--output', dest='output_data_dir', type=str, required=True,
help='A directory with output data, i.e. lists of unseen hyponyms and their hypernyms, found '
'as a result of this program execution, for public and private submission.')
parser.add_argument('-c', '--cache_dir', dest='cache_dir', type=str, required=True,
help='A directory with cached data for training.')
parser.add_argument('-n', '--number', dest='number_of_hypernyms', type=int, required=False, default=10,
help='A number of hypernyms generated for each unseen hyponym.')
parser.add_argument('--conv', dest='conv_size', type=int, required=False, default=512,
help='A number of feature maps in a 1D convolution layer for each convolution window.')
parser.add_argument('--n_hidden', dest='hidden_layers_number', type=int, required=False, default=1,
help='A number of hidden dense layers after the convolution layer.')
parser.add_argument('--hidden_size', dest='hidden_layer_size', type=int, required=False, default=4096,
help='Size of each hidden dense layer.')
parser.add_argument('--dropout', dest='dropout_rate', type=float, required=False, default=0.5,
help='A fraction of the input units to drop for the dropout technique.')
parser.add_argument('--lr_max', dest='max_learning_rate', type=float, required=False, default=1e-3,
help='A maximal learning rate for the cyclical learning rate schedule.')
parser.add_argument('--lr_min', dest='min_learning_rate', type=float, required=False, default=1e-5,
help='A minimal learning rate for the cyclical learning rate schedule.')
parser.add_argument('--cycle_length', dest='training_cycle_length', type=int, required=False, default=11,
help='A period or cycle length for the cyclical learning rate schedule.')
parser.add_argument('--epochs', dest='max_epochs', type=int, required=False, default=1000,
help='A maximal number of epochs to train the neural network.')
parser.add_argument('--batch', dest='batch_size', type=int, required=False, default=128, help='A mini-batch size.')
parser.add_argument('--bayesian', dest='bayesian_nn', action='store_true',
help='Must a Bayesian neural network be used?')
parser.add_argument('--monte_carlo', dest='num_monte_carlo', type=int, required=False, default=20,
help='A sample number for the Monte Carlo inference in a bayesian neural network.')
parser.add_argument('--kl_weight', dest='kl_weight', type=float, required=False, default=0.5,
help='Weight of the KL loss for Bayesian deep learning.')
args = parser.parse_args()
assert args.number_of_hypernyms >= 10, \
'{0} is too small value for the hypernyms number!'.format(args.number_of_hypernyms)
is_bayesian = args.bayesian_nn
if is_bayesian:
num_monte_carlo = args.num_monte_carlo
assert num_monte_carlo > 1
else:
num_monte_carlo = 0
cached_data_dir = os.path.normpath(args.cache_dir)
assert os.path.isdir(cached_data_dir)
nltk.download('punkt')
wordnet_dir = os.path.normpath(args.wordnet_dir)
assert os.path.isdir(wordnet_dir)
wordnet_senses_name = os.path.join(wordnet_dir, 'senses.N.xml' if args.track_name == 'nouns' else 'senses.V.xml')
wordnet_synsets_name = os.path.join(wordnet_dir, 'synsets.N.xml' if args.track_name == 'nouns' else 'synsets.V.xml')
wordnet_relations_name = os.path.join(
wordnet_dir,
'synset_relations.N.xml' if args.track_name == 'nouns' else 'synset_relations.V.xml'
)
assert os.path.isfile(wordnet_senses_name)
assert os.path.isfile(wordnet_synsets_name)
assert os.path.isfile(wordnet_relations_name)
fasttext_model_path = os.path.normpath(args.fasttext_name)
assert os.path.isfile(fasttext_model_path)
input_data_dir = os.path.normpath(args.input_data_dir)
os.path.isdir(input_data_dir), 'Directory `{0}` does not exist!'.format(input_data_dir)
output_data_dir = os.path.normpath(args.output_data_dir)
os.path.isdir(output_data_dir), 'Directory `{0}` does not exist!'.format(output_data_dir)
public_data_name = os.path.join(input_data_dir,
'{0}_public.tsv'.format('nouns' if args.track_name == 'nouns' else 'verbs'))
assert os.path.isfile(public_data_name), 'File `{0}` does not exist!'.format(public_data_name)
public_submission_name = os.path.join(output_data_dir,
'submitted_{0}_public.tsv'.format(('nouns' if args.track_name == 'nouns'
else 'verbs')))
private_data_name = os.path.join(input_data_dir,
'{0}_private.tsv'.format('nouns' if args.track_name == 'nouns' else 'verbs'))
assert os.path.isfile(private_data_name), 'File `{0}` does not exist!'.format(private_data_name)
private_submission_name = os.path.join(output_data_dir,
'submitted_{0}_private.tsv'.format(('nouns' if args.track_name == 'nouns'
else 'verbs')))
synsets = ruwordnet_parsing.load_synsets(senses_file_name=wordnet_senses_name,
synsets_file_name=wordnet_synsets_name)
data_for_public_submission = hyponyms_loading.load_terms_for_submission(public_data_name)
print('Number of hyponyms for public submission is {0}.'.format(len(data_for_public_submission)))
data_for_private_submission = hyponyms_loading.load_terms_for_submission(private_data_name)
print('Number of hyponyms for private submission is {0}.'.format(len(data_for_private_submission)))
print('')
solver_name = os.path.join(cached_data_dir, 'fasttext_and_{0}_cnn.h5'.format(
'bayesian' if is_bayesian else 'simple'))
solver_params_name = os.path.join(cached_data_dir, 'fasttext_and_{0}_cnn_params.pkl'.format(
'bayesian' if is_bayesian else 'simple'))
if does_neural_network_exist(solver_name) and os.path.isfile(solver_params_name):
with open(solver_params_name, 'rb') as fp:
(max_hyponym_length, max_hypernym_length, all_tokens, embeddings_matrix, conv_size, hidden_layer_size,
hidden_layers_number) = pickle.load(fp)
assert isinstance(embeddings_matrix, np.ndarray)
assert len(embeddings_matrix.shape) == 2
assert embeddings_matrix.shape[0] == (len(all_tokens) + 1)
if is_bayesian:
solver = neural_network.build_bayesian_cnn(
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length,
word_embeddings=embeddings_matrix, n_feature_maps=args.conv_size,
hidden_layer_size=args.hidden_layer_size, n_hidden_layers=args.hidden_layers_number,
n_train_samples=100, kl_weight=args.kl_weight
)
else:
solver = neural_network.build_cnn(
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length,
word_embeddings=embeddings_matrix, n_feature_maps=args.conv_size,
hidden_layer_size=args.hidden_layer_size,
n_hidden_layers=args.hidden_layers_number, dropout_rate=args.dropout_rate
)
solver.load_weights(solver_name)
print('The neural network has been loaded from the `{0}`...'.format(solver_name))
else:
data_for_training, data_for_validation, data_for_testing = ruwordnet_parsing.prepare_data_for_training(
senses_file_name=wordnet_senses_name, synsets_file_name=wordnet_synsets_name,
relations_file_name=wordnet_relations_name
)
all_tokens = ruwordnet_parsing.tokens_from_synsets(synsets, additional_sources=[data_for_public_submission,
data_for_private_submission])
print('Vocabulary size is {0}.'.format(len(all_tokens)))
embeddings_matrix = trainset_preparing.calculate_word_embeddings(all_tokens, fasttext_model_path)
print('All word embeddings are calculated...')
max_hyponym_length, max_hypernym_length = trainset_preparing.get_maximal_lengths_of_texts(synsets)
print('Maximal length of a single hyponym is {0}.'.format(max_hyponym_length))
print('Maximal length of a single hypernym is {0}.'.format(max_hypernym_length))
print('')
X_train, y_train = trainset_preparing.build_dataset_for_training(
data=data_for_training, synsets=synsets, tokens_dict=all_tokens,
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length
)
X_val, y_val = trainset_preparing.build_dataset_for_training(
data=data_for_validation, synsets=synsets, tokens_dict=all_tokens,
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length
)
if is_bayesian:
solver = neural_network.build_bayesian_cnn(
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length,
word_embeddings=embeddings_matrix, n_feature_maps=args.conv_size,
hidden_layer_size=args.hidden_layer_size, n_hidden_layers=args.hidden_layers_number,
n_train_samples=y_train.shape[0], kl_weight=args.kl_weight
)
else:
solver = neural_network.build_cnn(
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length,
word_embeddings=embeddings_matrix, n_feature_maps=args.conv_size,
hidden_layer_size=args.hidden_layer_size,
n_hidden_layers=args.hidden_layers_number, dropout_rate=args.dropout_rate
)
solver = neural_network.train_neural_network(
X_train=X_train, y_train=y_train, X_val=X_val, y_val=y_val,
neural_network=solver, max_epochs=args.max_epochs, training_cycle_length=args.training_cycle_length,
max_learning_rate=args.max_learning_rate, min_learning_rate=args.min_learning_rate,
is_bayesian=is_bayesian, num_monte_carlo=num_monte_carlo, batch_size=args.batch_size
)
del X_train, y_train, X_val, y_val
X_test, y_test = trainset_preparing.build_dataset_for_training(
data=data_for_testing, synsets=synsets, tokens_dict=all_tokens,
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length
)
neural_network.evaluate_neural_network(
X=X_test, y_true=y_test,
neural_network=solver, batch_size=args.batch_size,
num_monte_carlo=num_monte_carlo
)
del X_test, y_test
with open(solver_params_name, 'wb') as fp:
pickle.dump((max_hyponym_length, max_hypernym_length, all_tokens, embeddings_matrix, args.conv_size,
args.hidden_layer_size, args.hidden_layers_number), fp, protocol=pickle.HIGHEST_PROTOCOL)
solver.save_weights(solver_name, overwrite=True)
n_data_parts = 20
print('Public submission is started...')
if os.path.isfile(public_submission_name):
predicted_hyponyms = load_existing_predictions(public_submission_name)
else:
predicted_hyponyms = set()
with codecs.open(public_submission_name, mode='a', encoding='utf-8', errors='ignore') as fp:
data_part_size = int(np.ceil(len(data_for_public_submission) / n_data_parts))
data_part_counter = 0
for idx, hyponym in enumerate(data_for_public_submission):
if hyponym not in predicted_hyponyms:
dataset, synset_IDs = trainset_preparing.build_dataset_for_submission(
unseen_hyponym=hyponym, synsets=synsets, tokens_dict=all_tokens,
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length
)
probabilities = neural_network.apply_neural_network(
X=dataset, neural_network=solver,
batch_size=args.batch_size, num_monte_carlo=num_monte_carlo
)
del dataset
best_synsets = list(map(lambda idx: (synset_IDs[idx], probabilities[idx]), range(len(synset_IDs))))
best_synsets.sort(key=lambda it: (-it[1], it[0]))
if len(best_synsets) > args.number_of_hypernyms:
n = args.number_of_hypernyms
else:
n = len(best_synsets)
for synset_id in map(lambda it: it[0], best_synsets[0:n]):
fp.write('{0}\t{1}\t{2}\n'.format(' '.join(hyponym).upper(), synset_id, synsets[synset_id][2]))
del synset_IDs, best_synsets
if (idx + 1) % data_part_size == 0:
data_part_counter += 1
print(' {0} % of public data have been processed...'.format(data_part_counter * 5))
if data_part_counter < n_data_parts:
print(' 100 % of public data have been processed...')
print('Public submission is finished...')
print('')
print('Private submission is started...')
if os.path.isfile(private_submission_name):
predicted_hyponyms = load_existing_predictions(private_submission_name)
else:
predicted_hyponyms = set()
with codecs.open(private_submission_name, mode='a', encoding='utf-8', errors='ignore') as fp:
data_part_size = int(np.ceil(len(data_for_private_submission) / n_data_parts))
data_part_counter = 0
for idx, hyponym in enumerate(data_for_private_submission):
if hyponym not in predicted_hyponyms:
dataset, synset_IDs = trainset_preparing.build_dataset_for_submission(
unseen_hyponym=hyponym, synsets=synsets, tokens_dict=all_tokens,
max_hyponym_length=max_hyponym_length, max_hypernym_length=max_hypernym_length
)
probabilities = neural_network.apply_neural_network(
X=dataset, neural_network=solver,
batch_size=args.batch_size, num_monte_carlo=num_monte_carlo
)
del dataset
best_synsets = list(map(lambda idx: (synset_IDs[idx], probabilities[idx]), range(len(synset_IDs))))
best_synsets.sort(key=lambda it: (-it[1], it[0]))
if len(best_synsets) > args.number_of_hypernyms:
n = args.number_of_hypernyms
else:
n = len(best_synsets)
for synset_id in map(lambda it: it[0], best_synsets[0:n]):
fp.write('{0}\t{1}\t{2}\n'.format(' '.join(hyponym).upper(), synset_id, synsets[synset_id][2]))
del synset_IDs, best_synsets
if (idx + 1) % data_part_size == 0:
data_part_counter += 1
print(' {0} % of private data have been processed...'.format(data_part_counter * 5))
if data_part_counter < n_data_parts:
print(' 100 % of private data have been processed...')
print('Private submission is finished...')
print('')
print(test_features.shape)
#pd.display(train_features[1], length_x, length_y)
###### Perform PCA reduction ######
if use_PCA:
train_features, pca_model, n_rf = pr.pca_reduction(train_features)
print(train_features.shape)
###### Tune pars of NN ######
if tune_parameters:
trained_nn = par_tune(train_features, train_labels)
else:
## Training NN and get results ######
trained_nn = nn.train_neural_network(train_features,
train_labels,
rescale_base,
hidden_layer_sizes=(700),
tol=1e-10)
###### Print out wrong cases ######
if print_wrong_cases and not tune_parameters and not use_PCA:
print('Wrong cases:')
for i in range(min(10, len(wrong_l))):
print("(i, label, predict)", i, ",", wrong_l[i], ",", wrong_p[i])
pd.display(wrong_f[i], length_x, length_y)
###### Output predicts for test data ######
if output_predict:
print('--- Output predicts for test data ---')
if use_PCA:
test_features = pr.pca_transform(test_features, pca_model, n_rf)
