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