def test_simple_train(self): trainer_params = uw3_trainer_params() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d train.main(trainer_params) keras.backend.clear_session() resume_training.main([os.path.join(d, "checkpoint", "checkpoint_0001")])
def test_train_without_center_normalizer(self): trainer_params = uw3_trainer_params(with_validation=False) trainer_params.scenario.data.pre_proc.replace_all( CenterNormalizerProcessorParams, ScaleToHeightProcessorParams()) trainer_params.scenario.data.__post_init__() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pure_lstm_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ BiLSTMLayerParams(hidden_nodes=10), BiLSTMLayerParams(hidden_nodes=20), ] with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_dilated_block_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(), DilatedBlockLayerParams(filters=10), DilatedBlockLayerParams(filters=10), Conv2DLayerParams(filters=10), ] with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pure_cnn_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(), Conv2DLayerParams(filters=20, strides=IntVec2D(2, 2), kernel_size=IntVec2D(4, 4)), Conv2DLayerParams(filters=30), ] with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_concat_cnn_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(), DilatedBlockLayerParams(filters=10), TransposedConv2DLayerParams(filters=10), ConcatLayerParams( concat_indices=[1, 4] ), # corresponds to output of first and fourth layer Conv2DLayerParams(filters=10), BiLSTMLayerParams(hidden_nodes=10), ] post_init(trainer_params) cmd_line_trainer_params = parse_args([ "--network", "conv=10,pool=2x2,db=10:2,tconv=10,concat=1:4,conv=10,lstm=10" ]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) cmd_line_trainer_params = parse_args([ "--model.layers", "Conv", "Pool", "DilatedBlock", "TConv", "Concat", "Conv", "BiLSTM", "--model.layers.0.filters", "10", "--model.layers.2.filters", "10", "--model.layers.3.filters", "10", "--model.layers.4.concat_indices", "1", "4", "--model.layers.5.filters", "10", "--model.layers.6.hidden_nodes", "10", ]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_concat_cnn_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(), DilatedBlockLayerParams(filters=10), TransposedConv2DLayerParams(filters=10), ConcatLayerParams( concat_indices=[1, 4] ), # corresponds to output of first and fourth layer Conv2DLayerParams(filters=10), BiLSTMLayerParams(hidden_nodes=10), ] with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pretraining_same_codec(self): # Trained on uw3, applied on uw3 trainer_params = default_uw3_trainer_params() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d logs = main(trainer_params) self.assertLess(logs["val_CER"], 0.002)
def test_pure_cnn_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(), Conv2DLayerParams(filters=20, strides=IntVec2D(2, 2), kernel_size=IntVec2D(4, 4)), Conv2DLayerParams(filters=30), ] post_init(trainer_params) cmd_line_trainer_params = parse_args( ["--network", "conv=10,pool=2x2,conv=20:4x4:2x2,conv=30"]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) cmd_line_trainer_params = parse_args([ "--model.layers", "Conv", "Pool", "Conv", "Conv", "--model.layers.0.filters", "10", "--model.layers.2.filters", "20", "--model.layers.2.kernel_size.x", "4", "--model.layers.2.kernel_size.y", "4", "--model.layers.2.strides.x", "2", "--model.layers.2.strides.y", "2", "--model.layers.3.filters", "30", ]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_dilated_block_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ Conv2DLayerParams(filters=10), MaxPool2DLayerParams(strides=IntVec2D(2, 2)), DilatedBlockLayerParams(filters=10), DilatedBlockLayerParams(filters=10), Conv2DLayerParams(filters=10), ] post_init(trainer_params) cmd_line_trainer_params = parse_args( ["--network", "conv=10,pool=2x2:2x2,db=10:2,db=10:2,conv=10"]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) cmd_line_trainer_params = parse_args([ "--model.layers", "Conv", "Pool", "DilatedBlock", "DilatedBlock", "Conv", "--model.layers.0.filters", "10", "--model.layers.1.strides", "2", "2", "--model.layers.2.filters", "10", "--model.layers.3.filters", "10", "--model.layers.4.filters", "10", ]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pure_lstm_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = [ BiLSTMLayerParams(hidden_nodes=10), BiLSTMLayerParams(hidden_nodes=20), ] post_init(trainer_params) cmd_line_trainer_params = parse_args(["--network", "lstm=10,lstm=20"]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) cmd_line_trainer_params = parse_args([ "--model.layers", "BiLSTM", "BiLSTM", "--model.layers.0.hidden_nodes", "10", "--model.layers.1.hidden_nodes", "20", ]) self.assertDictEqual(trainer_params.scenario.model.to_dict(), cmd_line_trainer_params.scenario.model.to_dict()) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_train_abbyy_test_page(self): trainer_params = default_trainer_params() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pretraining_with_codec_adaption_no_preload(self): trainer_params = default_pagexml_trainer_params(preload=False) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_default_architecture(self): trainer_params = uw3_trainer_params() trainer_params.scenario.model.layers = default_layers() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_simple_train_no_preload(self): trainer_params = setup_trainer_params(preload=False) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def run_for_single_line(args): # lines/network/pretraining as base dir args.base_dir = os.path.join(args.base_dir, "all" if args.n_lines < 0 else str(args.n_lines)) pretrain_prefix = "scratch" if args.weights and len(args.weights) > 0: pretrain_prefix = ",".join([split_all_ext(os.path.basename(path))[0] for path in args.weights]) args.base_dir = os.path.join(args.base_dir, args.network, pretrain_prefix) if not os.path.exists(args.base_dir): os.makedirs(args.base_dir) tmp_dir = os.path.join(args.base_dir, "tmp") if not os.path.exists(tmp_dir): os.makedirs(tmp_dir) best_models_dir = os.path.join(args.base_dir, "models") if not os.path.exists(best_models_dir): os.makedirs(best_models_dir) prediction_dir = os.path.join(args.base_dir, "predictions") if not os.path.exists(prediction_dir): os.makedirs(prediction_dir) # select number of files files = args.files if args.n_lines > 0: all_files = glob_all(args.files) files = random.sample(all_files, args.n_lines) # run the cross-fold-training setattr(args, "early_stopping_best_model_output_dir", best_models_dir) setattr(args, "output_dir", tmp_dir) setattr(args, "keep_temporary_files", False) setattr(args, "files", files) setattr(args, "text_files", None) setattr(args, "gt_extension", None) setattr(args, "dataset", DataSetType.FILE) setattr(args, "best_model_label", "{id}") if not args.skip_train: train_script.main(args) dump_file = os.path.join(tmp_dir, "prediction.pkl") # run the prediction if not args.skip_eval: # locate the eval script (must be in the same dir as "this") predict_script_path = os.path.join(this_absdir, "predict_and_eval.py") model = os.path.join(best_models_dir, "best.ckpt.json") if not os.path.exists(model): raise Exception(f"Expected model at '{model}', but file does not exist") for line in run(prefix_run_command([ "python3", "-u", predict_script_path, "-j", str(args.num_threads), "--batch_size", str(args.batch_size), "--dump", dump_file, "--files"] + args.eval_files + [ ] + (["--verbose"] if args.verbose else []) + [ "--checkpoint"] + [model] + [ ], args.run, {"threads": args.num_threads}), verbose=args.verbose): # Print the output of the thread if args.verbose: print(line) import pickle with open(dump_file, 'rb') as f: prediction = pickle.load(f) return prediction
def test_simple_train(self): trainer_params = default_trainer_params(with_validation=False) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_train_with_val(self): trainer_params = default_trainer_params(with_validation=True, preload=False) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pretraining_with_codec_adaption(self): trainer_params = default_trainer_params() with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_pretraining_without_codec_adaption(self): trainer_params = default_trainer_params() trainer_params.codec.keep_loaded = True with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_train_from_files_file(self): trainer_params = uw3_trainer_params(with_validation=True, from_files_file=True) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_train_split(self): trainer_params = uw3_trainer_params(with_split=True, preload=False) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_augmentation_train_val(self): trainer_params = default_trainer_params(with_validation=True) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_augmentation_train_val_split(self): trainer_params = default_trainer_params(preload=False, with_split=True) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)
def test_train_split(self): trainer_params = default_trainer_params(with_split=True) with tempfile.TemporaryDirectory() as d: trainer_params.output_dir = d main(trainer_params)