def test_predict_not_enough_instances(self):
        global cnn
        cnn = ConvolutionalNeuralNetwork(24)

        X_train_set, y_train_set, X_test, _, stats = MainTransformer.get_training_and_test_set(dataset,
                                                                                               'Pollutant',
                                                                                               'Uncertainty',
                                                                                               size=0.95,
                                                                                               normalize=True)

        cnn.train(X_train_set, y_train_set, stats=stats)

        predictions = cnn.predict(X_test=X_test, uncertainty=True)

        n_none_predictions = len(list(filter(lambda x: x[0] is None and x[1] is None, predictions)))

        assert X_test.shape[0] == n_none_predictions
    def test_train(self):
        seq_length = 24
        cnn = ConvolutionalNeuralNetwork(seq_length)

        X_train_set, y_train_set, _, _, stats = MainTransformer.get_training_and_test_set(dataset,
                                                                                          'Pollutant',
                                                                                          'Uncertainty',
                                                                                          size=0.85,
                                                                                          normalize=True)

        assert not cnn.is_built
        assert cnn.n_features is None
        assert cnn.seq_length == seq_length
        assert cnn.stats['dataset_stats'] != stats

        cnn.train(X_train_set, y_train_set, stats)

        assert cnn.is_built
        assert cnn.n_features == X_train_set.shape[1]
        assert cnn.seq_length == seq_length
        assert cnn.stats['dataset_stats'] == stats
    def test_update_stats(self):
        seq_length = 24
        updated_cnn = ConvolutionalNeuralNetwork(seq_length)

        X_train_set, y_train_set, _, _, stats = MainTransformer.get_training_and_test_set(dataset,
                                                                                          'Pollutant',
                                                                                          'Uncertainty',
                                                                                          size=0.85,
                                                                                          normalize=True)

        updated_cnn.train(X_train_set, y_train_set, stats)

        instances = updated_cnn.stats['n_instances_trained']
        dataset_stats = updated_cnn.stats['dataset_stats']

        assert X_train_set.shape[0] == instances
        assert stats == dataset_stats

        X_train_set, y_train_set, _, _, stats = MainTransformer.get_training_and_test_set(dataset,
                                                                                          'Pollutant',
                                                                                          'Uncertainty',
                                                                                          size=0.5,
                                                                                          normalize=True)

        updated_cnn.train(X_train_set, y_train_set, stats)

        assert X_train_set.shape[0] + instances == updated_cnn.stats['n_instances_trained']
        assert len(cnn.stats['dataset_stats'].keys()) == len(stats.keys()) == len(dataset_stats.keys())

        missing_data = X_train_set.drop(axis=1, columns='Temperature', inplace=False, errors='ignore')

        with pytest.raises(WrongNumberOfFeatures):
            updated_cnn.train(missing_data, y_train_set, stats)
    def test_eval_not_enough(self):
        cnn = ConvolutionalNeuralNetwork(24)

        dataset, err = DB.DBManager.get_dataset(datetime_from=datetime.strptime("01-01-2018 01:00", '%d-%m-%Y %H:%M'),
                                                datetime_to=datetime.strptime("03-01-2018 06:00", '%d-%m-%Y %H:%M'),
                                                # longitude=-1.395778,
                                                # latitude=50.908140,
                                                config=ConfigReader.CONFIG)

        # just testing, don't care about overfitting
        X_train_set, y_train_set, X_test, y_test, stats = MainTransformer.get_training_and_test_set(dataset,
                                                                                                    'Pollutant',
                                                                                                    'Uncertainty',
                                                                                                    size=0.8,
                                                                                                    normalize=True)

        cnn.train(X_train_set, y_train_set, stats=stats)
        result, predictions, y_test_set = cnn.eval(X_test, y_test)

        predictions_size = len(predictions)

        assert predictions_size == len(X_test)