'propValue': 'Veterans Health Administration National Drug File' }] } } }] def tearDown(self): pass def test_fetch_properties_by_rxcui(self): for test_case in self.TEST_CASES: rxcui = test_case['rxcui'] expected_properties = test_case['properties'] actual_properties = self.client.fetch_properties_by_rxcui(rxcui) self.assertEqual(expected_properties, actual_properties) def test_fetch_name_by_rxcui(self): for test_case in self.TEST_CASES: rxcui = test_case['rxcui'] expected_name = test_case['name'] actual_name = self.client.fetch_name_by_rxcui(rxcui) self.assertEqual(expected_name, actual_name) if __name__ == '__main__': suite = make_test_suite(TestRxNormClient) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
self.assertEqualFile(test_file, verify_file) def test_upload_file(self): # Define file to be uploaded. local_file_path = '/'.join([self.package, self.upload_file_name]) # Upload file. remote_file = self.client.upload_file(local_file_path, self.remote_folder_id, self.upload_file_name) # Check file content. remote_content = remote_file.content() local_content = open('/'.join([self.package, self.upload_file_name])).read() self.assertEqual(remote_content, local_content) def test_download_folder(self): # Define file to be downloaded. verify_local_dir_path = '/'.join([self.package, 'box-test-verify']) test_local_dir_path = '/'.join([self.package, 'box-test']) self.client.download_folder(self.remote_folder_id, test_local_dir_path) # Check folder content. # TODO(sbala): Write a proper validation of this check, which was only # checked ad-hoc on the test case. # filecmp.dircmp(test_local_dir_path, verify_local_dir_path).report_full_closure() if __name__ == "__main__": suite = make_test_suite(TestBoxClient) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
metric=RegressorAnalyzer.EXPLAINED_VARIANCE_SCORE) self.assertEqual(expected_explained_variance, actual_explained_variance) def test_build_report(self): # Build report. expected_report = RANDOM_REGRESSION_TEST_CASE['report'] actual_report = self._analyzer.build_report() # Assert values are correct. assert_frame_equal(expected_report, actual_report) # Build paths for expected and actual report. test_dir = os.path.dirname(os.path.abspath(__file__)) expected_report_name = 'expected-linear-predictor.report' actual_report_name = 'actual-linear-predictor.report' expected_report_path = '/'.join([test_dir, expected_report_name]) actual_report_path = '/'.join([test_dir, actual_report_name]) # Write the report. self._analyzer.write_report(actual_report_path) # Assert files equal. self.assertTrue(filecmp.cmp(expected_report_path, actual_report_path)) if __name__ == '__main__': suite = make_test_suite(TestRegressorAnalyzer) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
def test_build_report(self): # Build report. expected_report = RANDOM_100_TEST_CASE['report'] actual_report = self._ml_analyzer.build_report()[0] log.debug('expected_report: %s' % expected_report) log.debug('actual_report: %s' % actual_report) assert_frame_equal(expected_report, actual_report) # Build bootstrapped report. expected_report = RANDOM_100_TEST_CASE['ci']['report'] actual_report = self._ml_analyzer.build_report(ci=0.95)[0] assert_frame_equal(expected_report, actual_report) # Build paths for expected and actual report. test_dir = os.path.dirname(os.path.abspath(__file__)) actual_report_name = 'actual-list-classifier.report' actual_report_path = '/'.join([test_dir, actual_report_name]) # Write the report. self._ml_analyzer.write_report(actual_report_path) # Not sure how to validate this at the moment, so just validate # that it actually passes. self.assertTrue(True) if __name__ == '__main__': suite = make_test_suite(TestClassifierAnalyzer) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
# Assert values are correct. self.assertEqual(expected_accuracy, actual_accuracy) self.assertEqual(expected_lower_ci, lower_ci) self.assertEqual(expected_upper_ci, upper_ci) def test_build_report(self): # Build report. expected_report = MANUAL_PREDICTION_TEST_CASE['report'] actual_report = self._analyzer.build_report() # Assert values are correct. assert_frame_equal(expected_report, actual_report) # Build paths for expected and actual report. test_dir = os.path.dirname(os.path.abspath(__file__)) expected_report_name = 'expected-list-predictor.report' actual_report_name = 'actual-list-predictor.report' expected_report_path = '/'.join([test_dir, expected_report_name]) actual_report_path = '/'.join([test_dir, actual_report_name]) # Write the report. self._analyzer.write_report(actual_report, actual_report_path) # Assert files equal. self.assertTrue(filecmp.cmp(expected_report_path, actual_report_path)) if __name__=='__main__': suite = make_test_suite(TestPredictorAnalyzer) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
fs.set_input_matrix(X, y) # Select k best features. fs.select(k=k, percentile=percentile) feature_ranks = fs.compute_ranks() return feature_ranks def _validate_feature_ranks(self, coefs, sorted_coefs, feature_ranks, k, strict=True): # Identify the minimum true coefficient value for which we expect # feature must have been selected. min_true_coef_val = sorted_coefs[k] if strict: # Iterate through features to confirm we selected at least the k # we know we should have selected. for feature_index in range(len(feature_ranks)): if coefs[feature_index] > min_true_coef_val: # The ordering of the significant features isn't maintained # by FeatureSelector. Therefore, just confirm that the k # features with the highest true weights are selected. self.assertTrue(feature_ranks[feature_index] <= k) else: # Just confirm the top two were selected. self.assertTrue(feature_ranks[1] <= k) self.assertTrue(feature_ranks[7] <= k) if __name__=="__main__": suite = make_test_suite(TestFeatureSelector) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
actual_hyperparams = self._bsc.hyperparams() self._assert_equal_hyperparams(expected_hyperparams['model_true'], actual_hyperparams['model_true']) self._assert_equal_hyperparams(expected_hyperparams['model_false'], actual_hyperparams['model_false']) # Test params. expected_params = expected_params_by_algorithm[algorithm] actual_params = self._bsc.params() self.assertEqual(expected_params, actual_params) # Test str. expected_str = expected_str_by_algorithm[algorithm] actual_str = str(self._bsc) self.assertEqual(expected_str, actual_str) # Test description. expected_description = expected_descriptions_by_algorithm[algorithm] actual_description = self._bsc.description() self.assertEqual(expected_description, actual_description) # Test predictions. expected_y_pred = expected_y_pred_by_algorithm[algorithm] actual_y_pred = self._bsc.predict(X_test) self.assertEqualList(expected_y_pred, actual_y_pred) if __name__ == '__main__': suite = make_test_suite(TestBifurcatedSupervisedClassifier) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
# Verify feature addition. expected_matrix = MANUAL_FM_TEST_CASE['test_zero_data_imputation'] actual_matrix = self.fmt.fetch_matrix() assert_frame_equal(expected_matrix, actual_matrix) def test_median_data_imputation(self): # Impute median(f2). self.fmt.impute(feature="f2", strategy=FeatureMatrixTransform.IMPUTE_STRATEGY_MEDIAN) # Verify feature addition. expected_matrix = MANUAL_FM_TEST_CASE['test_median_data_imputation'] actual_matrix = self.fmt.fetch_matrix() assert_frame_equal(expected_matrix, actual_matrix) def _power_law_dist(self): return powerlaw.rvs(1.66, random_state=2) def test_distrbution_data_imputation(self): # Impute distribution(f2). self.fmt.impute(feature="f2", distribution=self._power_law_dist, \ strategy=FeatureMatrixTransform.IMPUTE_STRATEGY_DISTRIBUTION) # Verify feature addition. expected_matrix = MANUAL_FM_TEST_CASE['test_distribution_data_imputation'] actual_matrix = self.fmt.fetch_matrix() assert_frame_equal(expected_matrix, actual_matrix) if __name__=="__main__": suite = make_test_suite(TestFeatureMatrixTransform) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)
fm_io = FeatureMatrixIO() # Build paths for test files. app_dir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) no_header_file_name = 'test-matrix-no-header.tab' with_header_file_name = 'test-matrix-with-header.tab' no_header_file_path = os.path.join(app_dir, no_header_file_name) with_header_file_path = os.path.join(app_dir, with_header_file_name) # Read data frames from test files. matrix_no_header = MANUAL_TEST_CASE['matrix_no_header'] matrix_header = MANUAL_TEST_CASE['custom_header'] # Write data frame without header. no_header_temp_file_name = 'no-header-temp-file.tab' self._no_header_temp_file_path = os.path.join(app_dir, no_header_temp_file_name) fm_io.write_data_frame_to_file(matrix_no_header, self._no_header_temp_file_path) # Write data frame with header. with_header_temp_file_name = 'header-temp-file.tab' self._with_header_temp_file_path = os.path.join(app_dir, with_header_temp_file_name) fm_io.write_data_frame_to_file(matrix_no_header, self._with_header_temp_file_path, matrix_header) # Validate output files. self.assertTrue(filecmp.cmp(no_header_file_path, self._no_header_temp_file_path)) self.assertTrue(filecmp.cmp(with_header_file_path, self._with_header_temp_file_path)) if __name__=="__main__": suite = make_test_suite(TestFeatureMatrixIO) unittest.TextTestRunner(verbosity=TEST_RUNNER_VERBOSITY).run(suite)