def main(args: argparse.Namespace) -> None:
# Fix random seeds and threads
tf.keras.utils.set_random_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", k), v)
for k, v in sorted(vars(args).items())))))
# Load data
uppercase_data = UppercaseData(args.window, args.alphabet_size)
# TODO: Implement a suitable model, optionally including regularization, select
# good hyperparameters and train the model.
#
# The inputs are _windows_ of fixed size (`args.window` characters on left,
# the character in question, and `args.window` characters on right), where
# each character is represented by a `tf.int32` index. To suitably represent
# the characters, you can:
# - Convert the character indices into _one-hot encoding_. There is no
# explicit Keras layer, but you can
# - use a Lambda layer which can encompass any function:
# tf.keras.Sequential([
# tf.keras.layers.Input(shape=[2 * args.window + 1], dtype=tf.int32),
# tf.keras.layers.Lambda(lambda x: tf.one_hot(x, len(uppercase_data.train.alphabet))),
# ...
# ])
# - or use Functional API and then any TF function can be used
# as a Keras layer:
# inputs = tf.keras.layers.Input(shape=[2 * args.window + 1], dtype=tf.int32)
# encoded = tf.one_hot(inputs, len(uppercase_data.train.alphabet))
# You can then flatten the one-hot encoded windows and follow with a dense layer.
# - Alternatively, you can use `tf.keras.layers.Embedding` (which is an efficient
# implementation of one-hot encoding followed by a Dense layer) and flatten afterwards.
model = ...
# TODO: Generate correctly capitalized test set.
# Use `uppercase_data.test.text` as input, capitalize suitable characters,
# and write the result to predictions_file (which is
# `uppercase_test.txt` in the `args.logdir` directory).
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "uppercase_test.txt"),
"w",
encoding="utf-8") as predictions_file:
...
def black_box_function(window, alphabet_size, dropout, learning_rate,
learning_rate_final, label_smoothing):
window = int(window)
alphabet_size = int(alphabet_size)
# embedding_size = int(embedding_size)
# layers_size = int(layers_size)
if learning_rate < learning_rate_final: learning_rate_final = learning_rate
learning_rate = 10**learning_rate
learning_rate_final = 10**learning_rate_final
epochs = 8
batch_size = 1024
batch_size_dev = 2048
uppercase_data = UppercaseData(window, alphabet_size)
network = Network()
network.construct(window, alphabet_size, dropout, learning_rate,
learning_rate_final, label_smoothing, epochs,
uppercase_data.train.size // batch_size)
for i in range(epochs):
for batch in uppercase_data.train.batches(batch_size):
a = network.train(batch["windows"], batch["labels"])
# print("Training {}: {:.2f}".format(i + 1, 100 * a))
accuracy = 0.0
batch_count = 0
for batch in uppercase_data.dev.batches(batch_size_dev):
a, _ = network.evaluate(batch["windows"], batch["labels"])
accuracy += a * len(batch["windows"])
batch_count += len(batch["windows"])
accuracy /= batch_count
network.close()
return accuracy
# Fix random seeds
np.random.seed(42)
tf.random.set_seed(42)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(__file__),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load data
uppercase_data = UppercaseData(args.window, args.alphabet_size)
# TODO: Implement a suitable model, optionally including regularization, select
# good hyperparameters and train the model.
#
# The inputs are _windows_ of fixed size (`args.window` characters on left,
# the character in question, and `args.window` characters on right), where
# each character is representedy by a `tf.int32` index. To suitably represent
# the characters, you can:
# - Convert the character indices into _one-hot encoding_. There is no
# explicit Keras layer, so you can
# - use a Lambda layer which can encompass any function:
# Sequential([
# tf.layers.InputLayer(input_shape=[2 * args.window + 1], dtype=tf.int32),
# tf.layers.Lambda(lambda x: tf.one_hot(x, len(uppercase_data.train.alphabet))),
# - or use Functional API and a code looking like
#!/usr/bin/env python3
import argparse
from uppercase_data import UppercaseData
parser = argparse.ArgumentParser()
parser.add_argument("system", type=str, help="Path to system output.")
parser.add_argument("dataset",
type=str,
help="Which dataset to evaluate ('dev', 'test').")
args = parser.parse_args()
with open(args.system, "r", encoding="utf-8-sig") as system_file:
system = system_file.read()
gold = getattr(UppercaseData(0), args.dataset).text
same = 0
for i in range(len(gold)):
if system[i].lower() != gold[i].lower():
raise RuntimeError(
"The system output and gold data differ on position {}: '{}' vs '{}'."
.format(i, system[i:i + 20].lower(), gold[i:i + 20].lower()))
same += gold[i] == system[i]
print("{:.2f}".format(100 * same / len(gold)))
#!/usr/bin/env python3
import argparse
import os
import numpy as np
import tensorflow as tf
from uppercase_data import UppercaseData
from uppercase_data_diakritika import UppercaseDataDiakritika
parser = argparse.ArgumentParser()
parser.add_argument("--models_path", default="./ensamble_models", type=str)
parser.add_argument("--output", default="test_out.txt", type=str)
args = parser.parse_args()
original_data = UppercaseData(0, 128)
def process_stepic(filename):
stepic_p = np.load(filename)
stepic_p[:, :, 1] = stepic_p[:, :, 1] + stepic_p[:, :, 2]
return np.mean(stepic_p[:, :, 0:2], axis=1)
stepic_p = process_stepic('test_y_aligned.npy') + process_stepic(
'v4_test_y_aligned.npy')
p = 0.5 * stepic_p[:, ::-1]
for filename in os.listdir(args.models_path):
parameters = dict([pair.split('=') for pair in filename.split(',')])
# Recreate the exact same model purely from the file
import tensorflow as tf
from uppercase_data import UppercaseData
model = tf.keras.models.load_model('path_to_my_model.h5')
alphabet_size = 500
window = 11
uppercase_data = UppercaseData(window, alphabet_size)
with open("uppercase_test.txt", "w", encoding="utf-8") as out_file:
res = model.predict(uppercase_data.dev.data["windows"][:1000])
print(list(sorted(res[:, 1], reverse=True))[:10])
# TODO: Generate correctly capitalized test set.
# Use `uppercase_data.test.text` as input, capitalize suitable characters,
# and write the result to `uppercase_test.txt` file.
pass
