def test_do_inference(self): # Given data_preprocessor = DataPreprocessor() device = "cpu" inferencer = Inferencer(data_preprocessor, device) data_dimensions = (BASE_GRAPH_NODE_FEATURES.size(), BASE_GRAPH.size(), BASE_GRAPH.view(-1).size()) model = ModelSelector.load_model("RNN") model = model(time_steps=1, number_of_nodes=data_dimensions[1][0], number_of_node_features=data_dimensions[0][1], fully_connected_layer_input_size=data_dimensions[1][0] * data_dimensions[0][1], fully_connected_layer_output_size=data_dimensions[2][0]) all_neighbors = to.tensor([[1, 2, -1, -1], [0, 2, -1, -1], [0, 1, 3, -1], [2, -1, -1, -1]]) dataset = GraphDataset("") dataset.enable_test_mode() tag = 'tag' dataset.dataset = [(BASE_GRAPH_NODE_FEATURES, all_neighbors, BASE_GRAPH.view(-1), tag)] inference_data, _, _ = DataPreprocessor().train_validation_test_split(dataset, 1, 0.0, 0.0) output_label_pairs_expected = [BASE_GRAPH.view(-1), BASE_GRAPH.view(-1)] # When output_label_pairs = inferencer.do_inference(model, inference_data) # Then self.assertEqual(output_label_pairs[0][0].squeeze().size(), output_label_pairs_expected[0].size()) self.assertEqual(output_label_pairs[0][1].squeeze().size(), output_label_pairs_expected[1].size())
def _prepare_dataset( self, configuration_dictionary: Dict ) -> Tuple[DataLoader, DataLoader, DataLoader, Tuple]: dataset = GraphDataset(self.data_path, test_mode=self.test_mode) dataset.enable_test_mode() self.get_logger().info("Calculating all neighbors for each node") training_data, validation_data, test_data = self.data_preprocessor \ .train_validation_test_split(dataset, configuration_dictionary['batch_size'], configuration_dictionary['validation_split'], configuration_dictionary['test_split']) data_dimensions = self.data_preprocessor.extract_data_dimensions( dataset) return training_data, validation_data, test_data, data_dimensions
def test_start(self): # Given tests_model_directory = os.path.join( "tests", "test_data", "model-checkpoints-test", "configuration&id__model&RNN__epochs&10__loss_function&MSE__optimizer" "&Adagrad__batch_size&100__validation_split&0.2__test_split" "&0.1__time_steps&1__validation_period&5", "Epoch_5_model_state_dictionary.pth") tests_results_directory = os.path.join('tests', 'results_inference') device = "cpu" data_preprocessor = DataPreprocessor() loader = Loader("RNN") inferencer = Inferencer(data_preprocessor, device) saver = Saver(tests_model_directory, tests_results_directory) self.postgres_connector = PostgresConnector() self._insert_test_data(dataset_size=1) dataset = GraphDataset(self.postgres_connector) inference = Inference(dataset, data_preprocessor, loader, inferencer, saver) # When inference.start() # Then filename_expected = datetime.now().strftime( "%d-%b-%YT%H_%M") + "_distance_maps.pickle" self.assertTrue( os.path.isfile( os.path.join(tests_results_directory, filename_expected))) # Tear down self._truncate_table()
def _build_grid_search(self, grid_search_parameters) -> GridSearch: data_preprocessor = DataPreprocessor() postgres_connector = PostgresConnector() dataset = GraphDataset(postgres_connector) model_trainer = Trainer(data_preprocessor, self.device, postgres_connector) saver = Saver(self.model_directory, self.results_directory) grid_search_configurations = self._get_all_grid_search_configurations(grid_search_parameters) return GridSearch(dataset, data_preprocessor, model_trainer, grid_search_configurations, saver)
def _build_inference(self) -> Inference: self.model = os.environ['MODEL'] data_preprocessor = DataPreprocessor() model_loader = Loader(self.model) model_inferencer = Inferencer(data_preprocessor, self.device) postgres_connector = PostgresConnector() dataset = GraphDataset(postgres_connector) saver = Saver(self.model_directory, self.results_directory) return Inference(dataset, data_preprocessor, model_loader, model_inferencer, saver)
def test_extract_data_dimensions(self): # Given dataset_length = 1 features = BASE_GRAPH_NODE_FEATURES all_neighbors = to.tensor([[1, 2, -1, -1], [0, 2, -1, -1], [0, 1, 3, -1], [2, -1, -1, -1]]) labels = BASE_GRAPH.view(-1) dataset = GraphDataset("") dataset.enable_test_mode() dataset.dataset = [(features, all_neighbors, labels, i) for i in range(dataset_length)] data_dimensions_expected = (features.size(), labels.size()) # When data_dimensions = self.data_preprocessor.extract_data_dimensions( dataset) # Then self.assertEqual(data_dimensions_expected, data_dimensions)
def test_do_evaluate(self): # Given data_dimensions = (BASE_GRAPH_NODE_FEATURES.size(), BASE_GRAPH.view(-1).size()) self.model_trainer.instantiate_attributes( data_dimensions, self.configuration_dictionary) all_neighbors = to.tensor([[1, 2, -1, -1], [0, 2, -1, -1], [0, 1, 3, -1], [2, -1, -1, -1]]) dataset = GraphDataset("") dataset.enable_test_mode() tag = 'tag' dataset.dataset = [(BASE_GRAPH_NODE_FEATURES, all_neighbors, BASE_GRAPH.view(-1), tag)] training_data, _, _ = DataPreprocessor().train_validation_test_split( dataset, 1, 0.0, 0.0) # When validation_loss = self.model_trainer.do_evaluate( evaluation_data=training_data, epoch=1) # Then self.assertTrue(validation_loss > 0.0)
def test_train_validation_test_split(self): # Given dataset_length = 10 features = BASE_GRAPH_NODE_FEATURES all_neighbors = to.tensor([[1, 2, -1, -1], [0, 2, -1, -1], [0, 1, 3, -1], [2, -1, -1, -1]]) labels = BASE_GRAPH.view(-1) dataset = GraphDataset("") dataset.enable_test_mode() dataset.dataset = [(features, all_neighbors, labels, i) for i in range(dataset_length)] train_validation_test_split_expected = [7, 2, 1] # When train_validation_test_split = self.data_preprocessor.train_validation_test_split( dataset, batch_size=1, validation_split=0.2, test_split=0.1) train_validation_test_split = [ len(dataset) for dataset in train_validation_test_split ] # Then self.assertEqual(train_validation_test_split_expected, train_validation_test_split)
def test_extract_data_dimensions(self): # Given self._insert_test_data(dataset_size=1) dataset = GraphDataset(self.postgres_connector) data_dimensions_expected = {"number_of_nodes": 4, "number_of_node_features": 4, "fully_connected_layer_input_size": 16, "fully_connected_layer_output_size": 8} # When data_dimensions = self.data_preprocessor.extract_data_dimensions(dataset) # Then self.assertEqual(data_dimensions_expected, data_dimensions) self._truncate_table()
def test_train_validation_test_split(self): # Given self._insert_test_data(dataset_size=10) dataset = GraphDataset(self.postgres_connector) train_validation_test_split_expected = [7, 2, 1] # When train_validation_test_split = self.data_preprocessor.train_validation_test_split(dataset, batch_size=1, validation_split=0.2, test_split=0.1) train_validation_test_split = [len(dataset) for dataset in train_validation_test_split] # Then self.assertEqual(train_validation_test_split_expected, train_validation_test_split) self._truncate_table()
def test_do_evaluate(self): # Given data_dimensions = {"number_of_nodes": 4, "number_of_node_features": 4, "fully_connected_layer_input_size": 16, "fully_connected_layer_output_size": 8} self.model_trainer.build(data_dimensions, self.configuration_dictionary) self._insert_test_data(1) dataset = GraphDataset(self.postgres_connector) training_data, _, _ = DataPreprocessor().train_validation_test_split(dataset, 1, 0.0, 0.0) # When validation_loss = self.model_trainer.do_evaluate_step(evaluation_data=training_data, epoch=1) # Then self.assertTrue(validation_loss > 0.0) self._truncate_table()
def test_start_for_multiple_batches_of_differing_size(self): # Given dataset_size = 5 grid_search_dictionary = { "model": ["RNN"], "epochs": [10], "batch_size": [3], "validation_split": [0.2], "test_split": [0.1], "loss_function": ["MSE"], "optimizer": ["Adagrad"], "time_steps": [1], "validation_period": [5], "scaling_factor": [0.1], "penalty_decimals": [0] } self._insert_test_data(dataset_size) dataset = GraphDataset(self.postgres_connector) grid_search_configurations = self._get_all_grid_search_configurations( grid_search_dictionary) grid_search = GridSearch(dataset, self.data_preprocessor, self.model_trainer, grid_search_configurations, self.saver) # When losses = grid_search.start() configuration_id = list(losses["training_loss"].keys())[0] # Then self.assertTrue(losses["training_loss"][configuration_id][ grid_search_dictionary["epochs"][0]] > 0.0) self.assertTrue(losses["validation_loss"][configuration_id][ grid_search_dictionary["validation_period"][0]] > 0.0) self.assertTrue( losses["test_loss"][configuration_id]["final_epoch"] > 0.0) # Tear down self._truncate_table()
def test_do_inference(self): # Given data_preprocessor = DataPreprocessor() device = "cpu" inferencer = Inferencer(data_preprocessor, device) data_dimensions = { "number_of_nodes": 4, "number_of_node_features": 4, "fully_connected_layer_input_size": 16, "fully_connected_layer_output_size": 8 } model = load_model("RNN") model = model( time_steps=1, number_of_nodes=data_dimensions["number_of_nodes"], number_of_node_features=data_dimensions["number_of_node_features"], fully_connected_layer_input_size=data_dimensions[ "fully_connected_layer_input_size"], fully_connected_layer_output_size=data_dimensions[ "fully_connected_layer_output_size"]) self.postgres_connector = PostgresConnector() self._insert_test_data(1) dataset = GraphDataset(self.postgres_connector) inference_data, _, _ = DataPreprocessor().train_validation_test_split( dataset, 1, 0.0, 0.0) output_label_pairs_expected = [ to.tensor((0, 1, 0, 2, 1, 2, 0, 0)), to.tensor((0, 1, 0, 2, 1, 2, 0, 0)) ] # When output_label_pairs = inferencer.do_inference(model, inference_data) # Then self.assertEqual(output_label_pairs[0][0].squeeze().size(), output_label_pairs_expected[0].size()) self.assertEqual(output_label_pairs[0][1].squeeze().size(), output_label_pairs_expected[1].size())
def _prepare_dataset(self) -> Tuple[DataLoader, Tuple]: dataset = GraphDataset(self.data_path, test_mode=self.test_mode) inference_dataset = self.data_preprocessor.get_dataloader(dataset) data_dimensions = self.data_preprocessor.extract_data_dimensions( dataset) return inference_dataset, data_dimensions