def test_abs_weight_restrictions_multiplier_model(data): base_model = MultiplierModelBase(data, 0, MultiplierInputOrientedModel()) bounds = {'I2': (0.01, 0.5)} model = MultiplierModelWithAbsoluteWeightRestrictions(base_model, bounds) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_if_category_is_within_abs_limits( model_solution, bounds) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_abs_weights_multi_output.xls') bounds = {'I2': (None, 0.05)} model = MultiplierModelWithAbsoluteWeightRestrictions(base_model, bounds) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_if_category_is_within_abs_limits( model_solution, bounds) work_book2 = Workbook() writer = XLSWriter(Parameters(), work_book2, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book2.save('tests/test_abs_weights_upper_bound_multi_output.xls')
def test_create_params_str(): params = Parameters() params.update_parameter('ORIENTATION', 'input') params.update_parameter('RETURN_TO_SCALE', 'VRS') assert dea_utils.create_params_str(params) == 'input orientation, VRS' params.update_parameter('RETURN_TO_SCALE', 'CRS') assert dea_utils.create_params_str(params) == 'input orientation, CRS'
def test_super_efficiency_medium(DEA_example2_data): data = DEA_example2_data data.add_input_category('I1') data.add_input_category('I2') data.add_input_category('I3') data.add_output_category('O1') data.add_output_category('O2') model = EnvelopmentModelBase( data, EnvelopmentModelInputOriented(generate_supper_efficiency_upper_bound), DefaultConstraintCreator()) super_efficiency_model = SupperEfficiencyModel(model) start_time = datetime.datetime.now() solution = super_efficiency_model.run() end_time = datetime.datetime.now() utils_for_tests.check_optimal_solution_status_and_sizes(solution, data) dmus = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'] utils_for_tests.check_efficiency_scores(dmus, [ 1.652173892, 0.6485875732, 0.909247759, 1.116838534, 0.5490716156, 2.485294106, 1.244945494, 0.824120607, 2.299898658, 0.6267333816, 1.088235274 ], solution, data, 1e-6) work_book = xlwt.Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(solution) work_book.save('tests/test_super_efficiency_output.xls')
def test_all_constraints_multiplier_model(data): model = MultiplierModelBase(data, 0, MultiplierInputOrientedModel()) bounds = {'I1': (None, 0.4)} model = MultiplierModelWithVirtualWeightRestrictions(model, bounds) abs_bounds = {'I2': (None, 0.2)} model = MultiplierModelWithAbsoluteWeightRestrictions(model, abs_bounds) ratio_bounds = {('I1', 'I2'): (None, 0.4), ('O1', 'O2'): (0.01, None)} model = MultiplierModelWithPriceRatioConstraints(model, ratio_bounds) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_if_category_is_within_abs_limits( model_solution, abs_bounds) utils_for_tests.check_if_category_is_within_virtual_limits( model_solution, bounds) utils_for_tests.check_if_category_is_within_price_ratio_constraints( model_solution, ratio_bounds) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_all_constraints_multi_output.xls')
def test_maximize_slacks_usual_weakly_disposable_vars(): categories, xls_data, dmu_name, sheet_name = read_data( 'tests/DEA_example2_data.xls') coefficients, has_same_dmus = convert_to_dictionary(xls_data) assert has_same_dmus is False assert validate_data(categories, coefficients) is True data = construct_input_data_instance(categories, coefficients) data.add_input_category('I1') data.add_input_category('I2') data.add_input_category('I3') data.add_output_category('O1') data.add_output_category('O2') model = EnvelopmentModelVRSDecorator( EnvelopmentModelBase( data, EnvelopmentModelInputOriented( generate_upper_bound_for_efficiency_score), DisposableVarsConstraintCreator(set(['I2', 'O1'])))) model = MaximizeSlacksModel(model) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_optimal_solution_status_and_sizes( model_solution, data) dmus = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'] utils_for_tests.check_efficiency_scores( dmus, [1, 0.86998617, 1, 1, 1, 1, 1, 1, 1, 0.6386574, 1], model_solution, data) work_book = xlwt.Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_max_slacks_weakly_disp_vars_output.xls') clean_up_pickled_files()
def text_frame_price_ratio(request): categories = ['I1', 'I2', 'O1', 'O2'] text_frame = TextForWeights(None, 'price ratio', 'Input <= 0.5', categories, Parameters(), 'PRICE_RATIO_RESTRICTIONS', True) request.addfinalizer(text_frame.destroy) return text_frame
def test_run_with_categorical_dmus(categorical_from_book): data = categorical_from_book model = MultiplierModelBase(data, 0, MultiplierInputOrientedModel()) categorical_model = ModelWithCategoricalDMUs(model, 'Category') start_time = datetime.datetime.now() solution = categorical_model.run() end_time = datetime.datetime.now() dmus = ['L1', 'L2', 'L3', 'L4', 'L5', 'L6', 'L7', 'L8', 'L9', 'L10', 'L11', 'L12', 'L13', 'L14', 'L15', 'L16', 'L17', 'L18', 'L19', 'L20', 'L21', 'L22', 'L23'] utils_for_tests.check_efficiency_scores(dmus, [0.377, 0.879, 0.936, 1, 1, 1, 0.743, 0.648, 1, 0.815, 0.646, 0.835, 0.794, 0.835, 1, 0.687, 1, 0.787, 1, 0.849, 0.787, 0.681, 1], solution, data, 1e-3) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds(), categorical='Category') writer.write_data(solution) work_book.save('tests/test_categorical_output.xls')
def build_models(params, model_input): ''' Creates several models and parameters in the case when RETURN_TO_SCALE or ORIENTATION is set to both. If neither RETURN_TO_SCALE nor ORIENTATION is set to both, then no new models will be created, a copy of the given model and parameters will be returned. Args: params (Parameters): parameters. model_input (InputData): data instance. Returns: tuple of list of ModelBase, list of Parameters: tuple with two lists. The first list contains all created models, the second list contains corresponding parameters. ''' model_factory.add_input_and_output_categories(params, model_input) rts_type = params.get_parameter_value('RETURN_TO_SCALE') list_of_param_objects = [] original_params = Parameters() original_params.copy_all_params(params) list_of_param_objects.append(original_params) if rts_type == 'both': original_params.update_parameter('RETURN_TO_SCALE', 'VRS') params_with_crs = Parameters() params_with_crs.copy_all_params(original_params) params_with_crs.update_parameter('RETURN_TO_SCALE', 'CRS') list_of_param_objects.append(params_with_crs) orientation_type = original_params.get_parameter_value('ORIENTATION') nb_param_objs = len(list_of_param_objects) if orientation_type == 'both': possible_orientation = ['input', 'output'] for count in range(nb_param_objs): assert(count < 2) param_obj = list_of_param_objects[count] param_obj.update_parameter('ORIENTATION', possible_orientation[count]) new_param_obj = Parameters() new_param_obj.copy_all_params(param_obj) new_param_obj.update_parameter('ORIENTATION', possible_orientation[1 - count]) list_of_param_objects.append(new_param_obj) models = [] for param_object in list_of_param_objects: models.append(model_factory.create_model(param_object, model_input)) return models, list_of_param_objects
def test_add_empty_input_and_output_categories(DEA_example_data): allParams = Parameters() allParams.update_parameter('INPUT_CATEGORIES', '') allParams.update_parameter('OUTPUT_CATEGORIES', 'O1; O2') with pytest.raises(ValueError) as excinfo: factory.add_input_and_output_categories(allParams, DEA_example_data) assert str( excinfo.value) == 'Both input and output categories must be specified'
def __init__(self, parent): super().__init__(parent) self.options_frame = OptionsFrameMock(parent) self.input_categories_frame = CategoryFrameMock() self.output_categories_frame = CategoryFrameMock() self.clear_all_called = False self.weight_frame_name = '' self.params = Parameters()
def weight_frame(request): parent = Tk() current_categories = ['I1', 'I2', 'I3'] params = ParamsFrameMock(parent) weight_frame = WeightFrame(params, current_categories, Parameters(), StringVar(master=parent)) request.addfinalizer(parent.destroy) return weight_frame
def box(request): parent = Tk() box = CategoriesCheckBox(parent, 'text', True, Parameters(), 'INPUT_CATEGORIES') global categories for category in categories: box.add_category(category) request.addfinalizer(parent.destroy) return box
def options_frame(request): parent = Tk() params = Parameters() current_categories = [] options_frame = OptionsFrameMock(parent, params, current_categories, CategoryFrameMock(), CategoryFrameMock()) request.addfinalizer(parent.destroy) return options_frame
def test_add_input_and_output_categories(DEA_example_data): allParams = Parameters() allParams.update_parameter('INPUT_CATEGORIES', 'I1; I2') allParams.update_parameter('OUTPUT_CATEGORIES', 'O1; O2') factory.add_input_and_output_categories(allParams, DEA_example_data) assert 'I1' in DEA_example_data.input_categories assert 'I2' in DEA_example_data.input_categories assert 'O1' in DEA_example_data.output_categories assert 'O2' in DEA_example_data.output_categories
def test_write_data_xls(model): start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() work_book = xlwt.Workbook() params = Parameters() writer = XLSWriter(params, work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_output.xls')
def test_show_solution(sol_frame, model): model_solution, ranks, state = peel_the_onion_method(model) sol_frame.show_solution([model_solution], Parameters(), ['params to print'], datetime.datetime.today(), 5, ranks=[ranks]) assert sol_frame.nb_tabs == 8 assert len(sol_frame.all_tabs) == 8 assert sol_frame.nb_filled_tabs == 8 for count, tab in enumerate(sol_frame.all_tabs): assert sol_frame.tab(count, 'text') == tab.name model_solution = model.run() solutions = [model_solution] sol_frame.show_solution(solutions, Parameters(), ['params to print'], datetime.datetime.today(), 5) assert sol_frame.nb_tabs == 7 assert len(sol_frame.all_tabs) == 7 assert sol_frame.nb_filled_tabs == 7 for count, tab in enumerate(sol_frame.all_tabs): assert sol_frame.tab(count, 'text') == tab.name
def test_auto_name_if_needed(): params = Parameters() file_name = 'out.txt' params.update_parameter('OUTPUT_FILE', file_name) assert dea_utils.auto_name_if_needed(params, 'txt') == file_name params.update_parameter('OUTPUT_FILE', '') data_file_name = 'dataFileForAutoName.xls' params.update_parameter('DATA_FILE', data_file_name) assert dea_utils.auto_name_if_needed( params, 'csv') == 'dataFileForAutoName_result.csv' params.update_parameter('OUTPUT_FILE', 'auto') assert dea_utils.auto_name_if_needed( params, 'xls') == 'dataFileForAutoName_result.xls' with pytest.raises(ValueError) as excinfo: dea_utils.auto_name_if_needed(params, 'haha') assert str(excinfo.value) == 'haha is not supported output format'
def __init__(self, parent, current_categories, data_from_params_file, str_var_for_input_output_boxes, weights_status_str, *args, **kw): Notebook.__init__(self, parent, *args, **kw) self.parent = parent self.params = Parameters() self.current_categories = current_categories self.input_categories_frame = None self.output_categories_frame = None self.params_from_file_lbl = None self.data_from_params_file = data_from_params_file self.str_var_for_input_output_boxes = str_var_for_input_output_boxes self.weight_tab = None self.load_without_data = IntVar() self.options_frame = None self.create_widgets(weights_status_str)
def test_on_save_solution_ok(solution_tab, model): model_solution = model.run() solutions = [model_solution] params = Parameters() param_strs = ['param_strs'] run_date = datetime.datetime.today() solution_tab.show_solution(solutions, params, param_strs, run_date, 5) assert solution_tab.model_solutions == solutions assert solution_tab.params == params assert solution_tab.param_strs == param_strs assert solution_tab.run_date == run_date assert solution_tab.total_seconds == 5 solution_tab.on_save_solution() assert os.path.isfile(solution_tab.ask_file_name_to_save(1)) os.remove(solution_tab.ask_file_name_to_save(1))
def params(request): params = Parameters() params.update_parameter('INPUT_CATEGORIES', 'I1; I2') params.update_parameter('OUTPUT_CATEGORIES', 'O1; O2') params.update_parameter('DEA_FORM', 'env') params.update_parameter('RETURN_TO_SCALE', 'CRS') params.update_parameter('ORIENTATION', 'input') params.update_parameter('NON_DISCRETIONARY_CATEGORIES', '') params.update_parameter('WEAKLY_DISPOSAL_CATEGORIES', '') params.update_parameter('USE_SUPER_EFFICIENCY', '') params.update_parameter('ABS_WEIGHT_RESTRICTIONS', '') params.update_parameter('VIRTUAL_WEIGHT_RESTRICTIONS', '') params.update_parameter('PRICE_RATIO_RESTRICTIONS', '') params.update_parameter('MAXIMIZE_SLACKS', '') params.update_parameter('MULTIPLIER_MODEL_TOLERANCE', '0') params.update_parameter('CATEGORICAL_CATEGORY', '') params.update_parameter('PEEL_THE_ONION', '') return params
def test_price_ratio_restrictions_env_model(data): model = EnvelopmentModelBase( data, EnvelopmentModelInputOriented( generate_upper_bound_for_efficiency_score), DefaultConstraintCreator()) bounds = {('I1', 'I2'): (None, 0.4), ('O1', 'O2'): (0.01, None)} model = EnvelopmentModelWithPriceRatioConstraints(model, bounds) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_if_category_is_within_price_ratio_constraints( model_solution, bounds) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_price_ratio_env_output.xls')
def test_virual_restrictions_env_model(data): model = EnvelopmentModelBase( data, EnvelopmentModelInputOriented( generate_upper_bound_for_efficiency_score), DefaultConstraintCreator()) bounds = {'I2': (0.01, 0.5)} model = EnvelopmentModelWithVirtualWeightRestrictions(model, bounds) start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() utils_for_tests.check_if_category_is_within_virtual_limits( model_solution, bounds) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_virtual_constraints_env_output.xls')
def test_super_efficiency_with_VRS(DEA_example2_data): data = DEA_example2_data data.add_input_category('I1') data.add_input_category('I2') data.add_input_category('I3') data.add_output_category('O1') data.add_output_category('O2') model = EnvelopmentModelBase( data, EnvelopmentModelInputOriented(generate_supper_efficiency_upper_bound), DefaultConstraintCreator()) model = EnvelopmentModelVRSDecorator(model) super_efficiency_model = SupperEfficiencyModel(model) start_time = datetime.datetime.now() solution = super_efficiency_model.run() end_time = datetime.datetime.now() work_book = xlwt.Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(solution) work_book.save('tests/test_super_efficiency_with_VRS.xls')
def test_peel_the_onion_CRS_multi_output_oriented(DEA_example2_data): model = _create_large_model_CRS_multi_output_oriented_with_non_discretionary( DEA_example2_data) start_time = datetime.datetime.now() solution, ranks, state = peel_the_onion_method(model) end_time = datetime.datetime.now() _check_large_model_CRS_multi_output_oriented_with_non_discretionary( solution, model.input_data) dmus = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K'] expected_ranks = [1, 3, 2, 1, 3, 1, 1, 2, 1, 2, 1] utils_for_tests.check_onion_ranks( model.input_data, dmus, expected_ranks, ranks) work_book = Workbook() ranks_as_list = [] ranks_as_list.append(ranks) writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds(), ranks=ranks_as_list) writer.write_data(solution) work_book.save('tests/test_peel_the_onion.xls')
def test_abs_restrictions_env_model_output(data): filename = 'tests/DEA_Harish_parameters.txt' params = parse_parameters_from_file(filename) categories, data, dmu_name, sheet_name = read_data( params.get_parameter_value('DATA_FILE')) coefficients, has_same_dmus = convert_to_dictionary(data) model_input = construct_input_data_instance(categories, coefficients) models, all_params = build_models(params, model_input) assert len(models) == 1 and len(all_params) == 1 model = models[0] start_time = datetime.datetime.now() model_solution = model.run() end_time = datetime.datetime.now() bounds = {'Urban Roads (%)': (None, 0.003)} utils_for_tests.check_if_category_is_within_abs_limits( model_solution, bounds) work_book = Workbook() writer = XLSWriter(Parameters(), work_book, datetime.datetime.today(), (end_time - start_time).total_seconds()) writer.write_data(model_solution) work_book.save('tests/test_abs_constraints_env_outoriented_output.xls')
def text_frame(request): categories = ['I1', 'I2', 'O1', 'O2'] text_frame = TextForWeights(None, 'Absolute', 'Input <= 0.5', categories, Parameters(), 'ABS_WEIGHT_RESTRICTIONS') request.addfinalizer(text_frame.destroy) return text_frame