class ViewData():
def __init__(self):
self.DEBUG = False
# construct DataApi instance with path prefix to data directory (relative from here)
self.data_api_impl = DataApi('../../data/')
def view_abalone_data(self):
print('\nABALONE DATA:\n')
print(self.data_api_impl.get_raw_data_frame('abalone'))
def view_car_data(self):
print('\nCAR DATA:\n')
print(self.data_api_impl.get_raw_data_frame('car'))
def view_forestfires_data(self):
print('\nFORESTFIRES DATA:\n')
print(self.data_api_impl.get_raw_data_frame('forestfires'))
def view_machine_data(self):
print('\nMACHINE DATA:\n')
print(self.data_api_impl.get_raw_data_frame('machine'))
def view_segmentation_data(self):
print('\nSEGMENTATION DATA:\n')
print(self.data_api_impl.get_raw_data_frame('segmentation'))
def view_wine_data(self):
print('\nWINE DATA:\n')
print(self.data_api_impl.get_raw_data_frame('wine'))
class DistanceFunctionsTests(unittest.TestCase):
# SETUP
@classmethod
def setUpClass(self):
self.DEBUG = False
self.METRICS = False
# construct DataApi instance with path prefix to data directory (relative from here)
self.data_api_impl = DataApi('../../../data/')
self.distance_functions_impl = DistanceFunctions()
@classmethod
def tearDownClass(self):
pass
# TESTS
# test get manhattan distance
def test_get_manhattan_distance(self):
pass
# test get euclidean distance
def test_get_euclidean_distance(self):
abalone_data = self.data_api_impl.get_raw_data_frame('abalone')
self.assertTrue(abalone_data is not None)
distance_1_2 = self.distance_functions_impl.get_euclidean_distance(abalone_data[0,:], abalone_data[1,:])
print('distance_1_2: ' + str(distance_1_2))
return edited_train_set.reset_index(drop=True)
# EXECUTE SCRIPT
if __name__ == '__main__':
print('running edited knn...')
edited_knn = EditedKNN()
data_api_impl = DataApi('../../data/')
cross_validator_impl = CrossValidator()
preprocessor_impl = Preprocessor()
wine_data = data_api_impl.get_raw_data_frame('segmentation')
prep_wine_data = preprocessor_impl.preprocess_raw_data_frame(
wine_data, 'segmentation')
wine_data_train_set = cross_validator_impl.get_training_set(
prep_wine_data, test_set_number=3)
print('wine_data_train_set.shape: ' + str(wine_data_train_set.shape))
wine_data_test_set = cross_validator_impl.get_test_set(
prep_wine_data, test_set_number, indexes_list)
edited_knn.enn(wine_data_train_set, wine_data_test_set, prep_wine_data, k)
edited_train_set = edited_knn.get_edited_training_set(wine_data_train_set,
k=25)
print('edited_train_set.shape: ' + str(edited_train_set.shape))
class CrossValidatorTests(unittest.TestCase):
# SETUP
@classmethod
def setUpClass(self):
self.DEBUG = False
self.METRICS = False
self.data_api_impl = DataApi('../../../data/')
self.cross_validator_impl = CrossValidator()
self.preprocessor_impl = Preprocessor()
@classmethod
def tearDownClass(self):
pass
# TESTS
'''
# test get indexes list for abalone data
def test_get_indexes_list_abalone_data(self):
abalone_data = self.data_api_impl.get_raw_data_frame('abalone')
self.assertTrue(abalone_data is not None)
abalone_indexes = self.cross_validator_impl.get_indexes_list(abalone_data)
self.assertTrue(len(abalone_indexes) == 4177) # 4177 rows in abalone data frame
for i in range(1, 10):
self.assertTrue(abalone_indexes.count(i) == 417) # each subset has 417 rows
self.assertTrue(abalone_indexes.count(10) == 424) # last subset has 417 + remaining...
# test get indexes list for car data
def test_get_indexes_list_car_data(self):
car_data = self.data_api_impl.get_raw_data_frame('car')
self.assertTrue(car_data is not None)
car_indexes = self.cross_validator_impl.get_indexes_list(car_data)
self.assertTrue(len(car_indexes) == 1728) # 1728 rows in car data frame
for i in range(1, 10):
self.assertTrue(car_indexes.count(i) == 172) # each subset has 172 rows
self.assertTrue(car_indexes.count(10) == 180) # last subset has 172 + remaining...
# test get indexes list for forest fires data
def test_get_indexes_list_ff_data(self):
ff_data = self.data_api_impl.get_raw_data_frame('forestfires')
self.assertTrue(ff_data is not None)
ff_indexes = self.cross_validator_impl.get_indexes_list(ff_data)
self.assertTrue(len(ff_indexes) == 518) # 518 rows in forest fires data frame
for i in range(1, 10):
self.assertTrue(ff_indexes.count(i) == 51) # each subset has 51 rows
self.assertTrue(ff_indexes.count(10) == 59) # last subset has 51 + remaining...
# test get indexes list for machine data
def test_get_indexes_list_machine_data(self):
machine_data = self.data_api_impl.get_raw_data_frame('machine')
self.assertTrue(machine_data is not None)
machine_indexes = self.cross_validator_impl.get_indexes_list(machine_data)
self.assertTrue(len(machine_indexes) == 209) # 209 rows in machine data frame
for i in range(1, 10):
self.assertTrue(machine_indexes.count(i) == 20) # each subset has 20 rows
self.assertTrue(machine_indexes.count(10) == 29) # last subset has 20 + remaining...
# test get indexes list for segmentation data
def test_get_indexes_list_segmentation_data(self):
segmentation_data = self.data_api_impl.get_raw_data_frame('segmentation')
self.assertTrue(segmentation_data is not None)
segmentation_indexes = self.cross_validator_impl.get_indexes_list(segmentation_data)
self.assertTrue(len(segmentation_indexes) == 213) # 213 rows in segmentation data frame
for i in range(1, 10):
self.assertTrue(segmentation_indexes.count(i) == 21) # each subset has 21 rows
self.assertTrue(segmentation_indexes.count(10) == 24) # last subset has 21 + remaining...
# test get indexes list for wine data
def test_get_indexes_list_wine_data(self):
wine_data = self.data_api_impl.get_raw_data_frame('wine')
self.assertTrue(wine_data is not None)
wine_indexes = self.cross_validator_impl.get_indexes_list(wine_data)
self.assertTrue(len(wine_indexes) == 6497) # 6497 rows in wine data frame
for i in range(1, 10):
self.assertTrue(wine_indexes.count(i) == 649) # each subset has 649 rows
self.assertTrue(wine_indexes.count(10) == 656) # last subset has 649 + remaining...
# TRAINING SET
# test get training set 2 with wine data
def test_get_training_set(self):
wine_data = self.data_api_impl.get_raw_data_frame('wine')
wine_data_training_set = self.cross_validator_impl.get_training_set(wine_data, 2)
self.assertTrue(wine_data_training_set.shape[0] == 5848) # 6497 - 649 rows in test set 2 means 5484 rows in training set
self.assertTrue(wine_data_training_set.shape[1] == 12) # number of columns does not change
# TEST SET
# test get test set (-2) with wine data
def test_get_test_set(self):
wine_data = self.data_api_impl.get_raw_data_frame('wine')
wine_data_test_set = self.cross_validator_impl.get_test_set(wine_data, 2)
self.assertTrue(wine_data_test_set.shape[0] == 649) # 649 rows in test set 2
self.assertTrue(wine_data_test_set.shape[1] == 12) # number of columns does not change
'''
def test_cv_partitions(self):
abalone_data = self.data_api_impl.get_raw_data_frame('abalone')
prep_abalone_data = self.preprocessor_impl.preprocess_raw_data_frame(abalone_data, 'abalone')
cv_partitions = self.cross_validator_impl.get_cv_partitions(prep_abalone_data)
self.assertTrue(cv_partitions is not None)
for partition in cv_partitions:
train_data_indexes = list(cv_partitions[partition][0].index.values)
test_data_indexes = list(cv_partitions[partition][1].index.values)
for test_index in test_data_indexes:
self.assertTrue(test_index not in train_data_indexes)
class ExperimentRunner:
'''
CONSTRUCTOR
'''
def __init__(self):
# logger instance - VERBOSE level is highest (most verbose) level for logging
self.logger = Logger('DEMO') # configure log level here
# datalayer instance - read csv data files and convert into raw data frames
self.datalayer = DataApi('../../data/')
# preprocessor instance - everything for prerocessing data frames
self.preprocessor = Preprocessor()
# cross_validator instance - setup cross validation partitions
self.cross_validator = CrossValidator()
# utils instance - random things
self.utils = Utils()
# get average result given cross validation results dictionary
def get_avg_result(self, cv_results):
result_vals = []
# for each cross validation partition, append result value to corresponding list
for test_data_key in cv_results:
test_result = cv_results[test_data_key]
result_vals.append(test_result)
# should always equal the value of the 'folds' variable in cross validator
test_data_count = len(cv_results)
# calculate average values
avg_result = sum(result_vals) / test_data_count
# return average result
return avg_result
'''
get preprocessed data ready for consumption by experiment running logic
INPUT:
- data_set_name: name of data set to fetch data for
OUTPUT:
- preprocessed data frame - fully ready for experiment consumption
'''
def get_experiment_data(self, data_set_name):
data = self.datalayer.get_raw_data_frame(data_set_name)
self.logger.log('DEMO', 'data_set_name: \t%s\n' % str(data_set_name))
self.logger.log(
'DEMO',
'raw data: \n\n%s, shape: %s\n' % (str(data), str(data.shape)))
self.logger.log('DEMO', '----------------------------------------------------' \
+ '-----------------------------------------------\n')
data = self.preprocessor.preprocess_raw_data_frame(data, data_set_name)
self.logger.log(
'DEMO', 'preprocessed data: \n\n%s, shape: %s\n' %
(str(data), str(data.shape)))
self.logger.log('DEMO', '----------------------------------------------------' \
+ '-----------------------------------------------\n')
return data
'''
run experiment
INPUT:
- data_set_name: name of data set to run experiment on
- neural_network: instance of neural network to train/test with data
- hyperparams: hyperparameters and corresponding values to use in experiment
OUTPUT:
- <void> - logs all the important stuff at DEMO level
'''
def run_experiment(self, data_set_name, neural_network, hyperparams):
# LAYER ACTIVATION FUNCTION SPECIFICATION
self.logger.log(
'DEMO', 'layer_activation_funcs: %s\n' %
str(hyperparams["layer_activation_funcs"]))
# DATA RETRIEVAL AND PREPROCESSING
data = self.get_experiment_data(data_set_name)
self.logger.log('DEMO', 'data_set_name: %s\n' % str(data_set_name))
# CROSS VALIDATION PARTITIONING
# get cross validation partitions for data
cv_partitions = self.cross_validator.get_cv_partitions(data)
# dictionary for storing accuracy results
cv_results = {}
# list of sizes of test sets used for getting average test set size
test_data_sizes = []
# NEURAL NETWORK TRAINING AND TESTING
for partition in cv_partitions:
# initialize key and corresponding nested dictionary in results dictionary
test_data_key = 'test_data_' + str(partition)
cv_results[test_data_key] = {}
# get training set and test set for given cross validation partition
train_data, test_data = cv_partitions[partition]
test_data_sizes.append(
test_data.shape[0]
) # add number of rows in test set to test_set_sizes list
# HANDLE RBF NETWORK P2 RESULTS
if neural_network.network_name == 'RBF':
# configure RBF network shape based on training data
neural_network.configure_rbf_network(train_data, data,
data_set_name,
hyperparams["k"])
# GRADIENT DESCENT
# run gradient descent for given neural network instance
test_result_vals = neural_network.train_gradient_descent(
train_data, hyperparams, partition, test_data)
self.logger.log('DEMO', ('accuracy_vals' if neural_network.CLASSIFICATION else 'error_vals') \
+ ' for partition %s: %s\n' % (str(partition+1), str(test_result_vals)), True)
# append accuracy/error result of final gradient descent iteration to results dictionary
cv_results[test_data_key] = test_result_vals[-1]
# FINAL RESULTS (THE MODEL)
self.logger.log('DEMO', '------------------------------------------------------------' \
+ ' TRAINING DONE ------------------------------------------------------------')
self.logger.log('DEMO', 'trained network: weights --> \n\n%s, shapes: %s\n' \
% (str(neural_network.weights), str(self.utils.get_shapes(neural_network.weights))), True)
self.logger.log('DEMO', 'trained network: biases --> \n\n%s, shapes: %s\n' \
% (str(neural_network.biases), str(self.utils.get_shapes(neural_network.biases))), True)
self.logger.log('DEMO', 'data_set_name: %s\n' % str(data_set_name),
True)
self.logger.log('DEMO', 'trained network: AVERAGE ' \
+ ('ACCURACY' if neural_network.CLASSIFICATION else 'ERROR') + ' --> %s\n' \
% str(self.get_avg_result(cv_results)), True)
if __name__ == '__main__':
print('k means clustering...')
k_means_clustering_impl = KMeansClustering()
data_api_impl = DataApi('../../data/')
preprocessor_impl = Preprocessor()
cross_validator_impl = CrossValidator()
'''
wine_data = data_api_impl.get_raw_data_frame('wine')
prep_wine_data = preprocessor_impl.preprocess_raw_data_frame(wine_data, 'wine')
'''
abalone_data = data_api_impl.get_raw_data_frame('abalone')
prep_abalone_data = preprocessor_impl.preprocess_raw_data_frame(abalone_data, 'abalone')
print('\npossible classes: ' + str(list(set(abalone_data.loc[:, 'CLASS'].values))) + '\n')
training_set, test_set = cross_validator_impl.get_cv_partitions(prep_abalone_data)[0]
# get training set (full data frame - rows in test_set_index bucket)
#training_set = cross_validator_impl.get_training_set(prep_abalone_data, test_set_number=3)
print('\ntraining_set.shape: ' + str(training_set.shape))
# get test set (rows in test_set_index bucket)
#test_set = cross_validator_impl.get_test_set(prep_abalone_data, test_set_number=3)
print('test_set.shape: ' + str(test_set.shape))
print('SET: ' + str(set(abalone_data.loc[:, 'CLASS'].values)))
num_poss_class_vals = len(set(abalone_data.loc[:, 'CLASS'].values))
accuracy_vals = self.filter_vals(accuracy_vals)
mean_squared_error_vals = self.filter_vals(mean_squared_error_vals)
# calculate average values
avg_accuracy = sum(accuracy_vals) / test_set_count
avg_mean_squared_error = sum(mean_squared_error_vals) / test_set_count
# return tuple with average values for zero_one_loss and mean_squared_error
return (avg_accuracy, avg_mean_squared_error)
def filter_vals(self, vals):
filtered_vals = []
for val in vals:
if val is not None:
filtered_vals.append(val)
return filtered_vals
# EXECUTE SCRIPT
if __name__ == "__main__":
print('running results...')
results_impl = Results()
data_api_impl = DataApi('../../data/')
wine_data = data_api_impl.get_raw_data_frame('wine')
class DataApiTests(unittest.TestCase):
# SETUP
@classmethod
def setUpClass(self):
self.DEBUG = False
self.METRICS = False
# construct DataApi instance with path prefix to data directory (relative from here)
self.data_api_impl = DataApi('../../../data/')
@classmethod
def tearDownClass(self):
pass
# TESTS
# test abalone data retrieval, number of rows/columns
def test_get_abalone_data(self):
abalone_data = self.data_api_impl.get_raw_data_frame('abalone')
self.assertTrue(abalone_data is not None)
self.assertTrue(
abalone_data.shape[0] == 4177) # 4177 rows in abalone data matrix
self.assertTrue(abalone_data.shape[1] ==
9) # 9 attribute columns in abalone data matrix
# test car data retrieval, number of rows/columns
def test_get_car_data(self):
car_data = self.data_api_impl.get_raw_data_frame('car')
self.assertTrue(car_data is not None)
self.assertTrue(
car_data.shape[0] == 1728) # 1728 rows in car data matrix
self.assertTrue(
car_data.shape[1] == 7) # 7 attribute columns in car data matrix
# test forestfires data retrieval, number of rows/columns
def test_get_forestfires_data(self):
forestfires_data = self.data_api_impl.get_raw_data_frame('forestfires')
self.assertTrue(forestfires_data is not None)
self.assertTrue(forestfires_data.shape[0] ==
518) # 518 rows in forestfires data matrix
self.assertTrue(forestfires_data.shape[1] ==
13) # 13 attribute columns in forestfires data matrix
# test machine data retrieval, number of rows/columns
def test_get_machine_data(self):
machine_data = self.data_api_impl.get_raw_data_frame('machine')
self.assertTrue(machine_data is not None)
self.assertTrue(
machine_data.shape[0] == 209) # 209 rows in machine data matrix
self.assertTrue(machine_data.shape[1] ==
10) # 10 attribute columns in machine data matrix
# test segmentation data retrieval, number of rows/columns
def test_get_segmentation_data(self):
segmentation_data = self.data_api_impl.get_raw_data_frame(
'segmentation')
self.assertTrue(segmentation_data is not None)
self.assertTrue(segmentation_data.shape[0] ==
213) # 213 rows in segmentation data matrix
self.assertTrue(segmentation_data.shape[1] ==
20) # 20 attribute columns in segmentation data matrix
# test wine data retrieval, number of rows/columns
def test_get_wine_data(self):
wine_data = self.data_api_impl.get_raw_data_frame('wine')
self.assertTrue(wine_data is not None)
self.assertTrue(
wine_data.shape[0] == 6497) # 6497 rows in wine data matrix
self.assertTrue(wine_data.shape[1] ==
12) # 12 attribute columns in wine data matrix
class ExperimentRunner():
def __init__(self):
self.DEBUG = False
# get instances of all the classes needed to run an experiment
self.data_api_impl = DataApi('../../data/')
self.preprocessor_impl = Preprocessor()
self.cross_validator_impl = CrossValidator()
self.parameter_tuner_impl = ParameterTuner()
# algorithm implementations
self.knn_impl = KNN()
self.enn_impl = EditedKNN()
self.cnn_impl = CondensedKNN()
self.kmeans_knn_impl = KMeansClustering()
self.k_medoids_clustering_impl = KMedoidsClustering()
self.results_processor_impl = Results()
self.CLASSIFICATION = False
self.REGRESSION = False
# run algorithm on data set with various parameters
def run_experiment(self, data_frame_name, algorithm):
self.set_experiment_type(data_frame_name)
# get raw data frame to run experiment against
raw_data_frame = self.data_api_impl.get_raw_data_frame(data_frame_name)
print(raw_data_frame)
# preprocess data
preprocessed_data_frame = self.preprocessor_impl.preprocess_raw_data_frame(raw_data_frame, data_frame_name)
print(preprocessed_data_frame)
# get indexes list for data frame cross validation - a list of row numbers used to partition the data
data_frame_indexes_list = self.cross_validator_impl.get_indexes_list(preprocessed_data_frame)
if self.DEBUG:
print('\ndata_frame_name --> ' + data_frame_name)
print('\nraw_data_frame:\n')
print(raw_data_frame)
print('\npreprocessed_data_frame:\n')
print(preprocessed_data_frame)
print('\ndata_frame_indexes_list for cross validation:\n')
print(data_frame_indexes_list)
# nested dictionary to hold algorithm performance results for each combination of training/test sets
# key pattern --> key = test_set_1 , where the number at the end of the key is the test set index
# each value is another dictionary with keys = { 'zero_one_loss', 'mean_squared_error' }
# the nested dictionary values are the corresponding loss function metrics for predictions using the test set
cross_validation_results = {}
# list of sizes of test sets used for getting average test set size
test_set_sizes = []
algorithm_parameters = self.parameter_tuner_impl.get_params(data_frame_name, algorithm)
# dictionary where key is parameter and value is tuple of average loss function results
results_by_parameter = {}
# get all cross validation partitions for given data frame
cv_partitions = self.cross_validator_impl.get_cv_partitions(preprocessed_data_frame)
# for each parameter value in the list of algorithm parameter values (see ParameterTuner)
for parameter in algorithm_parameters:
if self.DEBUG:
print('\n' + str(self.parameter_tuner_impl.get_parameter_key(algorithm)) + ': ' + str(parameter) + '\n')
# for each test set used in cross validation (number of folds)
for partition in cv_partitions:
# initialize key and corresponding nested dictionary in results dictionary
test_set_key = 'test_set_' + str(partition)
cross_validation_results[test_set_key] = {}
# get training set and test set for given cross validation partition
training_set, test_set = cv_partitions[partition]
test_set_sizes.append(test_set.shape[0]) # add number of rows in test set to test_set_sizes list
if self.DEBUG:
print('preprocessed dataframe before running algorithm:')
print(preprocessed_data_frame)
# run algorithms on training set / test set combination
# returns dictionary where key is the row index (as string) and value is the predicted class for that row
prediction_results = self.run_algorithm(data_frame_name, algorithm, training_set, test_set, \
preprocessed_data_frame, parameter)
# calculate loss function results given prediction results - measure prediction accuracy
accuracy, mean_squared_error = self.results_processor_impl.loss_function_analysis(test_set, prediction_results)
cross_validation_results[test_set_key]['accuracy'] = accuracy
cross_validation_results[test_set_key]['mean_squared_error'] = mean_squared_error
# calculate average loss function results over all cross validation folds
avg_accuracy, avg_mean_squared_error = self.results_processor_impl.get_avg_loss_vals(cross_validation_results)
avg_test_set_size = sum(test_set_sizes) / len(test_set_sizes) # get average test set size for reference
results_by_parameter[str(parameter)] = (avg_accuracy, avg_mean_squared_error)
print('\n\nRESULTS: average test set size: ' + str(avg_test_set_size) + \
((' --> accuracy: ' + str(avg_accuracy)) if self.CLASSIFICATION \
else (' --> mean_squared_error: ' + str(avg_mean_squared_error))))
print('\n---------------------------------------------------------------------------------------------------------------------')
# return dictionary of results by parameter
return results_by_parameter
def set_experiment_type(self, data_frame_name):
if data_frame_name in ['abalone', 'car', 'segmentation']:
self.CLASSIFICATION = True
self.REGRESSION = False
elif data_frame_name in ['machine', 'forestfires', 'wine']:
self.REGRESSION = True
self.CLASSIFICATION = False
else:
raise Exception('ERROR: unknown data_set_name --> ' + str(data_frame_name))
'''
run algorithm execution handler given algorithm name
INPUT:
- algorithm_name: name of algorithm to run handler for
OUTPUT:
- prediction results dictionary, maps instance index to tuple: (prediction, actual)
'''
def run_algorithm(self, data_set_name, algorithm_name, training_set, \
test_set, preprocessed_data_frame, parameter):
if algorithm == 'knn':
self.knn_impl.set_data_set(data_set_name)
self.knn_impl.set_algorithm_name(algorithm_name)
return self.knn_impl.do_knn(training_set, test_set, preprocessed_data_frame, parameter)
elif algorithm == 'enn':
self.enn_impl.set_data_set(data_set_name)
self.enn_impl.set_algorithm_name(algorithm_name)
return self.enn_impl.do_enn(training_set, test_set, preprocessed_data_frame, parameter)
elif algorithm == 'cnn':
self.cnn_impl.set_data_set(data_set_name)
self.cnn_impl.set_algorithm_name(algorithm_name)
return self.cnn_impl.do_cnn(training_set, test_set, preprocessed_data_frame, parameter)
elif algorithm == 'kmeans_knn':
self.kmeans_knn_impl.set_data_set(data_set_name)
self.kmeans_knn_impl.set_algorithm_name(algorithm_name)
return self.kmeans_knn_impl.cluster_do_knn(training_set, test_set, preprocessed_data_frame, data_set_name, parameter)
elif algorithm == 'kmedoids_knn':
self.k_medoids_clustering_impl.set_data_set(data_set_name)
self.k_medoids_clustering_impl.set_algorithm_name(algorithm_name)
return self.k_medoids_clustering_impl.cluster(training_set, test_set, preprocessed_data_frame, data_set_name, parameter)
np.random.randn(self.layer_sizes[2], self.layer_sizes[1])
]
# the first node in every list correpsonds to the the 1 output from top to bottom. Print-wise, this means each row
#,as it is printed, correpsonds to the to all weights cominging in to output node i.
#ensure that we only have layers 1 and 2 b/c RBF will always be of size 3
self.biases = [np.random.randn(self.layer_sizes[2], 1)]
# EXECUTE SCRIPT
if __name__ == '__main__':
print('\nrunning RBFNetwork...\n')
data_set_name = 'segmentation'
data_api_impl = DataApi('../../data/')
data = data_api_impl.get_raw_data_frame(data_set_name)
rbf_network_impl = RBFNetwork(data_set_name, [19, 2, 7])
#initializing neuron values
rbf_network_impl.init_RBF_Neurons(data[0:2])
#print(rbf_network_impl.rbf_neurons)
rbf_network_impl.init_weights_biases()
print('weights: %s' % str(rbf_network_impl.weights))
print('biases: %s' % str(rbf_network_impl.biases))
#test_vector = [121.0,60.0,9,0.0,0.0,2.277778,2.329629,2.888889,2.8740742,26.74074,24.666666,35.22222,20.333334,-6.2222223,25.444445,-19.222221,35.22222,0.4223002,-1.776113]
#rbf_network_impl.get_forward_output(test_vector)
#print(rbf_network_impl.rbf_neurons)
#print(data.loc[0,:])
#print(rbf_network_impl.calculate_std(data))
print('prep_segmentation_data:')
print(prep_segmentation_data)
'''
'''
raw_wine_data = data_api_impl.get_raw_data_frame('wine')
print(raw_wine_data)
normalized_wine_data = preprocessor_impl.normalize(raw_wine_data)
print(normalized_wine_data)
'''
#Check all preprocessed data sets
datasets = [
'abalone', 'car', 'segmentation', 'machine', 'forestfires', 'wine'
]
for data in datasets:
rawdata = data_api_impl.get_raw_data_frame(data)
print(str(data))
print(rawdata)
print('Preprocessed: ' + str(data))
print(preprocessor_impl.preprocess_raw_data_frame(rawdata, data))
'''
raw_car_data = data_api_impl.get_raw_data_frame('car')
print('raw_car_data:')
print(raw_car_data)
normalized_car_data = preprocessor_impl.normalize(raw_car_data)
print(normalized_car_data)
'''
#prep_wine_data = preprocessor_impl.preprocess_raw_data_frame(raw_wine_data, 'wine')
