def create_multi_model_systems( folder: str, model_type: str, power_system_type: PowerType) -> List[RuntimeSystem]: model_type = model_type.upper() assert model_type in ( 'SKIP_RNN', 'PHASED_RNN'), 'Unknown model type: {0}'.format(model_type) runtime_systems: List[RuntimeSystem] = [] valid_results: List[ModelResults] = [] test_results: List[ModelResults] = [] model_paths: List[str] = [] for model_path in iterate_files( folder, pattern=r'model-{0}-.*model_best\.pkl\.gz'.format(model_type)): model, dataset = restore_neural_network(model_path, dataset_folder=dataset_folder) if model_type == 'SKIP_RNN': valid_result = execute_skip_rnn_model(model, dataset, series=DataSeries.VALID) test_result = execute_skip_rnn_model(model, dataset, series=DataSeries.TEST) else: valid_result = execute_phased_rnn_model(model, dataset, series=DataSeries.VALID) test_result = execute_phased_rnn_model(model, dataset, series=DataSeries.TEST) valid_results.append(valid_result) test_results.append(test_result) model_paths.append(model_path) # Concatenate the results from each model test_results_concat = concat_model_results(test_results) valid_results_concat = concat_model_results(valid_results) power_system = make_power_system(num_levels=seq_length, seq_length=seq_length, model_type=model.model_type, power_type=power_system_type) under_budget = RuntimeSystem(test_results=test_results_concat, valid_results=valid_results_concat, system_type=SystemType.FIXED_UNDER_BUDGET, model_path=model_paths[0], dataset_folder=dataset_folder, seq_length=seq_length, num_levels=len(model_paths), num_classes=num_classes, power_system=power_system) runtime_systems.append(under_budget) return runtime_systems
num_classes = model.metadata[NUM_CLASSES] num_levels = model.num_outputs # Get the validation and test results valid_results = execute_adaptive_model(model=model, dataset=dataset, series=DataSeries.VALID) test_results = execute_adaptive_model(model=model, dataset=dataset, series=DataSeries.TEST) max_time = test_results.stop_probs.shape[0] power_system = make_power_system(num_levels=num_levels, seq_length=seq_length, model_type=model.model_type, power_type=power_type) # Make the run-time system system = RuntimeSystem(test_results=test_results, valid_results=valid_results, system_type=SystemType.ADAPTIVE, model_path=model_path, dataset_folder=args.dataset_folder, power_system=power_system, seq_length=seq_length, num_levels=num_levels, num_classes=num_classes) key = 'BUDGET_RNN({0}) ADAPTIVE'.format(model.stride_length) adaptive_result_dict[key] = test_results
model, dataset = restore_neural_network(adaptive_model_path, dataset_folder=dataset_folder) num_levels = model.num_outputs seq_length = model.metadata[SEQ_LENGTH] num_classes = model.metadata[NUM_CLASSES] valid_results = execute_adaptive_model(model, dataset, series=DataSeries.VALID) test_results = execute_adaptive_model(model, dataset, series=DataSeries.TEST) adaptive_power_system = make_power_system(num_levels=num_levels, seq_length=seq_length, power_type=power_system_type, model_type=model.model_type) adaptive_system = RuntimeSystem(valid_results=valid_results, test_results=test_results, system_type=SystemType.ADAPTIVE, model_path=adaptive_model_path, dataset_folder=dataset_folder, seq_length=seq_length, num_levels=num_levels, num_classes=num_classes, power_system=adaptive_power_system) runtime_systems.append(adaptive_system) adaptive_fixed_under_budget = RuntimeSystem( valid_results=valid_results,
def convert_network(model_path: str, model_parameters: Dict[str, np.ndarray], precision: int, sensor_type: str, is_msp: bool): # Extract the model meta-data and hyper-parameters hypers = get_hyperparameters(model_path) metadata = get_metadata(model_path) model_type = SequenceModelType[hypers.model_params['model_type'].upper()] # Holds a list of C variable declarations for each trainable parameter weight_variables: List[str] = [] # Estimate LEA RAM consumption for model weights lea_ram_estimation = 0 # Create C declarations for all trainable variables for var_name, var_value in model_parameters.items(): layer_name, weight_type = parse_variable_name(var_name) c_declaration = None if layer_name in (EMBEDDING_NAME, STOP_PREDICTION, OUTPUT_LAYER_NAME, RNN_CELL_NAME, AGGREGATION_NAME): c_declaration = weight_matrix_conversion(layer_name, weight_type, var_value, precision=precision, is_msp=is_msp) else: raise ValueError('Unknown layer name: {0}'.format(layer_name)) if isinstance(var_value, np.ndarray) and should_use_lea_ram(var_value): lea_ram_estimation += 2 * var_value.shape[0] * var_value.shape[1] weight_variables.append(c_declaration) # Extract meta-data and hyper-parameters to create the computational graph state_size = hypers.model_params['state_size'] num_outputs = hypers.model_params.get('num_outputs', 1) stride_length = hypers.model_params.get('stride_length', 1) rnn_cell_type = hypers.model_params['rnn_cell_type'] seq_length = metadata[SEQ_LENGTH] num_input_features = metadata[INPUT_SHAPE][0] if hypers.model_params['output_type'] == 'multi_classification': num_output_features = metadata[NUM_CLASSES] else: num_output_features = metadata[NUM_OUTPUT_FEATURES] # Get thresholds for Sample RNNs thresholds = np.zeros(shape=(1, num_outputs)) budgets = np.array([0]) label_counts = np.zeros(shape=(1, 1, num_outputs)) avg_energy = np.zeros(shape=(1, )) if model_type == SequenceModelType.SAMPLE_RNN: save_folder, model_file_name = os.path.split(model_path) model_name = extract_model_name(model_file_name) controller_path = os.path.join( save_folder, CONTROLLER_PATH.format(sensor_type, model_name)) if os.path.exists(controller_path): controller_info = read_by_file_suffix(controller_path) thresholds = controller_info['thresholds'] budgets = controller_info['budgets'] # Estimate the energy level for each threshold set avg_level_counts = controller_info['avg_level_counts'] power_system = make_power_system( mode=PowerType[sensor_type.upper()], num_levels=num_outputs, seq_length=seq_length) power_estimates = power_system.get_power_estimates() avg_energy = np.sum(avg_level_counts * np.expand_dims(power_estimates, axis=0), axis=-1) print(avg_energy) avg_energy = tensor_to_fixed_point(avg_energy, precision=precision) distribution = controller_info['label_distribution'] label_counts_lst: List[np.ndarray] = [] for budget in budgets: budget_counts: List[np.ndarray] = [] for _, counts in sorted(distribution[budget].items()): budget_counts.append(np.expand_dims(counts, axis=0)) label_counts_lst.append( np.expand_dims(np.vstack(budget_counts), axis=0)) label_counts = np.vstack(label_counts_lst).astype(int) # Get the power estimates num_levels = num_outputs if model_type == SequenceModelType.SAMPLE_RNN else seq_length power_system = make_power_system(mode=PowerType[sensor_type.upper()], num_levels=num_levels, seq_length=seq_length) power_estimates = power_system.get_power_estimates() # [L] power_estimates = tensor_to_fixed_point(power_estimates, precision=precision) with open('neural_network_parameters.h', 'w') as out_file: # Include necessary header files out_file.write('#include <stdint.h>\n') out_file.write('#include "math/matrix.h"\n\n') # Create header guard out_file.write('#ifndef NEURAL_NETWORK_PARAMS_GUARD\n') out_file.write('#define NEURAL_NETWORK_PARAMS_GUARD\n\n') # Create constants used during graph construction out_file.write(create_constant('FIXED_POINT_PRECISION', precision)) out_file.write(create_constant('STATE_SIZE', state_size)) out_file.write( create_constant('NUM_INPUT_FEATURES', num_input_features)) out_file.write( create_constant('NUM_OUTPUT_FEATURES', num_output_features)) out_file.write(create_constant('SEQ_LENGTH', seq_length)) out_file.write(create_constant('NUM_OUTPUTS', num_outputs)) out_file.write(create_constant('STRIDE_LENGTH', stride_length)) out_file.write( create_constant('SAMPLES_PER_SEQ', int(seq_length / num_outputs))) out_file.write(create_constant('NUM_BUDGETS', len(budgets))) out_file.write( create_constant('{0}_TRANSFORM'.format(rnn_cell_type.upper()), value=None)) out_file.write( create_constant('IS_{0}'.format(model_type.name.upper()), value=None)) if 'on_fraction' in hypers.model_params: on_fraction = float_to_fixed_point( hypers.model_params['on_fraction'], precision) out_file.write(create_constant('ON_FRACTION', value=on_fraction)) if is_msp: out_file.write(create_constant('IS_MSP', value=None)) out_file.write(create_constant('VECTOR_COLS', value=2)) else: out_file.write(create_constant('VECTOR_COLS', value=1)) out_file.write('\n') thresholds = tensor_to_fixed_point(thresholds, precision=precision) thresholds_variable = create_array(thresholds, name='THRESHOLDS', dtype='int16_t') out_file.write(thresholds_variable + '\n') budgets = tensor_to_fixed_point(budgets, precision=precision) budgets_variable = create_array(budgets, name='BUDGETS', dtype='int32_t') out_file.write(budgets_variable + '\n') avg_energy_variable = create_array(avg_energy, name='AVG_ENERGY', dtype='int16_t') out_file.write(avg_energy_variable + '\n') power_estimates_variable = create_array(power_estimates, name='ENERGY_ESTIMATES', dtype='int32_t') out_file.write(power_estimates_variable + '\n') label_counts_variable = create_array(label_counts, name='LABEL_COUNTS', dtype='int16_t') if (is_msp): out_file.write("#pragma PERSISTENT(LABEL_COUNTS)\n") out_file.write(label_counts_variable + '\n') out_file.write('\n\n'.join(weight_variables)) out_file.write('\n#endif\n')