class SVMExp:
def __init__(self, reader, helper, splitter):
self.reader = reader
self.helper = helper
self.learner = SVMLearner()
self.splitter = splitter
self.expHelper = ExperimentHelper(self.splitter, self.learner)
def experiment(self):
#self.model_complexity_exp5()
#self.model_complexity_exp6()
#self.model_complexity_exp4()
#self.model_complexity_exp44()
#self.model_complexity_exp2()
self.model_complexity_exp6()
self.model_complexity_exp5()
self.model_complexity_exp_linear1()
self.model_complexity_exp_linear2()
if (self.splitter.reader.dataset == 'Bank'):
print('bank')
self.learning_curve_iter2_bank_linear()
self.learning_curve_iter2_bank()
self.experiment_run_test_bank_linear()
self.experiment_run_test_bank()
else:
self.learning_curve_iter2_wine_linear()
self.learning_curve_iter2_wine()
self.experiment_run_test_wine()
self.experiment_run_test_wine_linear()
# Perform learning curve
#self.expHelper.learning_curve_exp()
"""self.model_complexity_exp1()
self.model_complexity_exp2()
self.model_complexity_exp3()
self.model_complexity_exp4()"""
#self.model_complexity_exp5()
#self.model_complexity_exp6()
"""self.exp_grid_search()"""
#self.learning_curve_iter2()
#self.model_complexity_exp4()
#self.model_complexity_exp44()
#self.learner.train(self.splitter.X_train, self.splitter.y_train)
#y_pred = self.learner.query(self.splitter.X_test)
"""print("Final Accuracy for " + str(self.learner.__class__)+": ",
metrics.accuracy_score(self.splitter.y_test, y_pred))"""
def model_complexity_exp_linear1(self):
#TODO should we create a new learner object??
self.learner = LinearSVMLearner(dual=True)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear-2', 'LinearKernel')
param_range = np.array([0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8])
self.expHelper.model_complexity_exp('C', param_range)
def model_complexity_exp_linear2(self):
#TODO should we create a new learner object??
self.learner = LinearSVMLearner(fit_intercept=True, C=0.01)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear-3', 'LinearKernel')
param_range = np.array([1, 2, 3, 4, 5, 6])
self.expHelper.model_complexity_exp('intercept_scaling', param_range)
def model_complexity_exp1(self):
#TODO should we create a new learner object??
self.learner = SVMLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf')
param_range = np.array([2, 4, 6, 8])
self.expHelper.model_complexity_exp('degree', param_range)
def model_complexity_exp2(self):
#TODO should we create a new learner object??
self.learner = SVMLearner(kernel='linear', C=0.2)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear4', 'Linear Kernel')
param_range = np.array([1, 2, 4, 5, 6, 7, 8])
self.expHelper.model_complexity_exp('gamma', param_range)
self.learner = SVMLearner(kernel='linear', C=0.2)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear5', 'Linear Kernel')
param_range = np.array([0.1, 0.2, 0.4, 0.5, 0.6, 0.7, 0.8])
self.expHelper.model_complexity_exp('gamma', param_range)
def model_complexity_exp3(self):
#TODO should we create a new learner object??
self.learner = SVMLearner(kernel='sigmoid')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'sigmoid', 'Sigmoid Kernel')
#param_range = np.array([0.05, 0.1, 0.2, 0.3, 0.4, 0.5])
#self.expHelper.model_complexity_exp('C', param_range)
param_range = np.array([0.01, 0.03, 0.05, 0.07, 0.09])
self.expHelper.model_complexity_exp('gamma', param_range)
def model_complexity_exp4(self):
#TODO should we create a new learner object??
self.learner = SVMLearner(kernel='linear')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear3', 'Linear Kernel')
#param_range = np.array([0.5, 1, 1.5, 2])
#param_range = np.array([2, 3, 4, 5, 6, 9, 12])
#param_range = np.array([0.01, 0.02, 0.03, 0.043, 0.05, 0.06])
param_range = np.array([0.0001, 0.0005, 0.0008, 0.001, 0.005, 0.008])
self.expHelper.model_complexity_exp('C', param_range)
def model_complexity_exp44(self):
#TODO should we create a new learner object??
self.learner = SVMLearner(kernel='linear')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'linear1', 'Linear Kernel')
#param_range = np.array([0.5, 1, 1.5, 2])
#param_range = np.array([2, 3, 4, 5, 6, 9, 12])
param_range = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.7, 0.8, 0.9, 1])
self.expHelper.model_complexity_exp('C', param_range)
"""self.learner = SVMLearner(kernel = 'linear')
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'linear3', 'Linear Kernel')
param_range = np.array([2, 3, 4, 5, 6, 9, 12])
self.expHelper.model_complexity_exp('C', param_range) """
def model_complexity_exp5(self):
#TODO should we create a new learner object??
self.learner = SVMLearner(kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf1',
'rbf Kernel')
param_range = np.array([0.05, 0.1, 0.2, 0.3, 0.4, 0.5])
self.expHelper.model_complexity_exp('C', param_range)
self.learner = SVMLearner(kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf2',
'rbf Kernel')
param_range = np.array([0.5, 1, 1.5, 2])
self.expHelper.model_complexity_exp('C', param_range)
self.learner = SVMLearner(kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf3',
'rbf Kernel')
param_range = np.array([2, 3, 4, 5, 6, 9, 12])
self.expHelper.model_complexity_exp('C', param_range)
def model_complexity_exp6(self):
#TODO should we create a new learner object??
#self.learner = SVMLearner(kernel = 'rbf', C =0.1)
self.learner = SVMLearner(kernel='rbf', C=0.5)
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf8',
'rbf Kernel')
#param_range = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7])
#param_range = np.array([0.5,2, 3, 4, 5, 6])
param_range = np.array([0.01, 0.03, 0.05, 0.07, 0.09])
self.expHelper.model_complexity_exp('gamma', param_range)
self.learner = SVMLearner(kernel='rbf', C=0.5)
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf9',
'rbf Kernel')
param_range = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7])
#param_range = np.array([0.5,2, 3, 4, 5, 6])
#param_range = np.array([0.01, 0.03, 0.05, 0.07, 0.09])
self.expHelper.model_complexity_exp('gamma', param_range)
"""self.learner = SVMLearner(kernel = 'rbf', C =0.2)
self.expHelper = ExperimentHelper(self.splitter, self.learner, 'rbf5','rbf Kernel')
#param_range = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7])
param_range = np.array([0.5,2, 3, 4, 5, 6])
#param_range = np.array([0.01, 0.03, 0.05, 0.07, 0.09])
self.expHelper.model_complexity_exp('gamma', param_range)"""
def exp_grid_search(self):
#degree_range = list(range(1, 31))
kernel_options = ['rbf']
c_range = np.array([1, 2, 3, 4, 5, 6, 9, 12])
gamma_options = np.array([0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5])
grid_param = dict(C=c_range,
kernel=kernel_options,
gamma=gamma_options)
self.expHelper.perform_grid_search(grid_param)
def learning_curve_iter2_wine(self):
self.learner = SVMLearner(gamma=0.05, C=0.5, kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_wine_linear(self):
self.learner = LinearSVMLearner(fit_intercept=True, C=0.05)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'Linear Kernel')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_bank_linear(self):
print("linear")
self.learner = LinearSVMLearner(fit_intercept=True,
C=0.01,
intercept_scaling=6)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'Linear Kernel')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_bank(self):
self.learner = SVMLearner(gamma=0.03, C=0.2, kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def experiment_run_test_wine(self):
self.learner = SVMLearner(gamma=0.05, C=0.5, kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_wine_linear(self):
self.learner = LinearSVMLearner(fit_intercept=True, C=0.05)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'Linear Kernel')
self.expHelper.experiment_run_test()
def experiment_run_test_bank_linear(self):
self.learner = LinearSVMLearner(fit_intercept=True,
C=0.01,
intercept_scaling=6)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'Linear Kernel')
self.expHelper.experiment_run_test()
def experiment_run_test_bank(self):
self.learner = SVMLearner(gamma=0.03, C=0.2, kernel='rbf')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
class KNNExp:
def __init__(self, reader, helper, splitter):
self.reader = reader
self.helper = helper
self.learner = KNNLearner()
self.splitter = splitter
self.expHelper = ExperimentHelper(self.splitter, self.learner)
def experiment(self):
self.model_complexity_exp1()
self.model_complexity_exp11()
self.model_complexity_exp2()
self.model_complexity_exp3()
if (self.splitter.reader.dataset == 'Bank'):
print('bank')
self.experiment_run_test_bank()
self.learning_curve_iter2_bank()
else:
self.experiment_run_test_wine()
self.learning_curve_iter2_wine()
# Perform learning curve
#self.expHelper.learning_curve_exp()
#self.model_complexity_exp1()
#self.model_complexity_exp2()
#self.model_complexity_exp3()
#self.model_complexity_exp4()
""""self.exp_grid_search()"""
#self.learning_curve_iter2()
#self.learner.train(self.splitter.X_train, self.splitter.y_train)
#y_pred = self.learner.query(self.splitter.X_test)
"""print("Final Accuracy for " + str(self.learner.__class__)+": ",
metrics.accuracy_score(self.splitter.y_test, y_pred))"""
def model_complexity_exp1(self):
#TODO should we create a new learner object??
self.learner = KNNLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'euclidean')
#param_range = np.array([1,2,3,4,5])
param_range = np.arange(1, 40, 2)
print(param_range)
self.expHelper.model_complexity_exp('n_neighbors', param_range)
def model_complexity_exp11(self):
#TODO should we create a new learner object??
self.learner = KNNLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'euclidean', '1')
#param_range = np.array([1,2,3,4,5])
param_range = np.arange(40, 60, 2)
print(param_range)
self.expHelper.model_complexity_exp('n_neighbors', param_range)
def model_complexity_exp2(self):
#TODO should we create a new learner object??
self.learner = KNNLearner(metric='euclidean')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'euclidean')
param_range = np.array([1, 2, 3, 4, 5])
self.expHelper.model_complexity_exp('n_neighbors', param_range)
def model_complexity_exp3(self):
#TODO should we create a new learner object??
self.learner = KNNLearner(weights='distance')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'distance weight')
param_range = np.array([1, 2, 3, 4, 5])
self.expHelper.model_complexity_exp('n_neighbors', param_range)
def model_complexity_exp4(self):
#TODO should we create a new learner object??
self.learner = KNNLearner(metric='euclidean', weights='distance')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'distance weight')
param_range = np.arange(1, 40, 2)
print(param_range)
self.expHelper.model_complexity_exp('n_neighbors', param_range)
def exp_grid_search(self):
k_range = list(range(1, 31))
weight_options = ['uniform', 'distance']
metric_options = ['euclidean', 'minkowski']
grid_param = dict(n_neighbors=k_range,
weights=weight_options,
metric=metric_options)
self.expHelper.perform_grid_search(grid_param)
"""grid_param = {
'n_estimators': [100, 300, 500, 800, 1000],
'criterion': ['gini', 'entropy'],
'bootstrap': [True, False]
}"""
def learning_curve_iter2_wine(self):
self.learner = KNNLearner(metric='euclidean',
n_neighbors=30,
weights='uniform')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_bank(self):
self.learner = KNNLearner(metric='euclidean',
n_neighbors=38,
weights='uniform')
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def experiment_run_test_wine(self):
self.learner = KNNLearner(metric='euclidean',
n_neighbors=30,
weights='uniform')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank(self):
self.learner = KNNLearner(metric='euclidean',
n_neighbors=38,
weights='uniform')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
class BoostingExp:
def __init__(self, reader, helper, splitter):
self.reader = reader
self.helper = helper
self.learner = BoostLearner()
self.splitter = splitter
self.expHelper = ExperimentHelper(self.splitter, self.learner)
def experiment(self):
# Perform learning curve
#self.expHelper.learning_curve_exp()
self.model_complexity_exp()
self.model_complexity_exp_2()
if (self.splitter.reader.dataset == 'Bank'):
print('bank')
self.learning_curve_iter2_bank()
self.experiment_run_test_bank()
else:
self.experiment_run_test_wine()
self.learning_curve_iter2_wine()
#self.learner.train(self.splitter.X_train, self.splitter.y_train)
#y_pred = self.learner.query(self.splitter.X_test)
"""print("Final Accuracy for " + str(self.learner.__class__)+": ",
metrics.accuracy_score(self.splitter.y_test, y_pred))"""
def model_complexity_exp(self):
#TODO should we create a new learner object??
self.learner = BoostLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([2, 4, 6, 8, 9, 10])
self.expHelper.model_complexity_exp('max_depth', param_range)
def model_complexity_exp_2(self):
#TODO should we create a new learner object??
self.learner = BoostLearner(max_depth=2)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([0.1, 0.2, 0.4, 0.6, 0.8, 0.9])
self.expHelper.model_complexity_exp('learning_rate', param_range)
def learning_curve_iter2_wine(self):
self.learner = BoostLearner(max_depth=9, learning_rate=0.4)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_bank(self):
self.learner = BoostLearner(max_depth=2, learning_rate=0.1)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def experiment_run_test_wine(self):
self.learner = BoostLearner(max_depth=9, learning_rate=0.4)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank(self):
self.learner = BoostLearner(max_depth=2, learning_rate=0.1)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
class ANNExp:
def __init__(self, reader, helper, splitter):
self.reader = reader
self.helper = helper
self.learner = ANNLearner()
self.splitter = splitter
self.expHelper = ExperimentHelper(self.splitter, self.learner)
def experiment(self):
self.model_complexity_exp()
self.model_complexity_exp_alpha1()
self.model_complexity_exp_epoch()
self.model_complexity_exp_epoch2()
if (self.splitter.reader.dataset == 'Bank'):
print('bank')
self.learning_curve_iter2_bank()
self.experiment_run_test_bank()
else:
self.learning_curve_iter2_wine()
self.experiment_run_test_wine()
# Perform learning curve
"""self.expHelper.learning_curve_exp()
self.model_complexity_exp()
self.model_complexity_exp_alpha1()
self.model_complexity_exp_alpha2()
#self.exp_grid_search()"""
#self.learning_curve_iter2()
#self.exp_grid_search3()
#self.learner.train(self.splitter.X_train, self.splitter.y_train)
#y_pred = self.learner.query(self.splitter.X_test)
"""print("Final Accuracy for " + str(self.learner.__class__)+": ",
metrics.accuracy_score(self.splitter.y_test, y_pred))"""
def model_complexity_exp(self):
#TODO should we create a new learner object??
self.learner = ANNLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([(50, ), (100, ), (200, ), (300, ), (400, ),
(500, )])
#param_range = np.array([100, 200,300,400, 500])
self.expHelper.model_complexity_exp('hidden_layer_sizes', param_range)
def model_complexity_exp11(self):
#TODO should we create a new learner object??
self.learner = ANNLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([(50, ), (
50,
50,
), (
50,
50,
50,
), (
50,
50,
50,
50,
), (
50,
50,
50,
50,
50,
)])
#param_range = np.array([100, 200,300,400, 500])
self.expHelper.model_complexity_exp('hidden_layer_sizes', param_range)
def model_complexity_exp_alpha21(self):
#TODO should we create a new learner object??
self.learner = ANNLearner(hidden_layer_sizes=(
50,
50,
50,
))
self.expHelper = ExperimentHelper(self.splitter, self.learner, '2')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
#param_range = np.array([0.0001, 0.001, 0.01, 0.1,1,5])
param_range = np.array([0.0001, 0.001, 0.002, 0.003, 0.005, 0.008])
self.expHelper.model_complexity_exp('alpha', param_range)
def model_complexity_exp_epoch(self):
#TODO should we create a new learner object??
self.learner = ANNLearner(activation='relu',
alpha=0.01,
hidden_layer_sizes=(
50,
50,
50,
),
learning_rate='constant',
solver='adam',
early_stopping=True)
self.expHelper = ExperimentHelper(self.splitter, self.learner, '2')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
#param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1])
param_range = np.array([1, 10, 50, 100, 200, 500])
self.expHelper.model_complexity_exp('max_iter', param_range)
def model_complexity_exp_epoch2(self):
#TODO should we create a new learner object??
self.learner = ANNLearner(hidden_layer_sizes=(300, ),
alpha=0.0001,
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner, '3')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
#param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1])
param_range = np.array([1, 10, 50, 100, 200, 500, 1000])
self.expHelper.model_complexity_exp('max_iter', param_range)
def model_complexity_exp_epoch3(self):
#TODO should we create a new learner object??
self.learner = ANNLearner(hidden_layer_sizes=(200, 100),
alpha=0.008,
early_stopping=True,
solver='sgd',
activation='tanh')
self.expHelper = ExperimentHelper(self.splitter, self.learner, '4')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
#param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1])
param_range = np.array([1, 10, 50, 100, 200, 500, 1000])
self.expHelper.model_complexity_exp('max_iter', param_range)
def model_complexity_exp_alpha1(self):
#TODO should we create a new learner object??
self.learner = ANNLearner(hidden_layer_sizes=(300, ))
self.expHelper = ExperimentHelper(self.splitter, self.learner, '1')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
#param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1])
param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1])
self.expHelper.model_complexity_exp('alpha', param_range)
self.learner = ANNLearner(hidden_layer_sizes=(390, ))
self.expHelper = ExperimentHelper(self.splitter, self.learner, '2')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
param_range = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7])
#param_range = np.array([0.0001, 0.0005, 0.001, 0.005, 0.008])
self.expHelper.model_complexity_exp('alpha', param_range)
def model_complexity_exp_alpha2(self):
#TODO should we create a new learner object??
self.learner = ANNLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner, '2')
#param_range = np.array([(100),(200,),(300,),(400,),(500,)])
param_range = np.array([0.0001, 0.001, 0.01, 0.1, 1, 5])
self.expHelper.model_complexity_exp('alpha', param_range)
def exp_grid_search2(self):
grid_param = {
'hidden_layer_sizes': [(50, 50, 50), (50, 50, 50, 50),
(50, 50, 50, 50, 50)],
'activation': ['relu'],
'solver': ['adam'],
'alpha': [0.1, 0.2, 0.3, 0.4, 0.05],
'learning_rate': ['constant'],
'momentum': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6],
'max_iter': [200, 300, 500, 700, 1000, 1500, 2000, 2500],
}
self.expHelper.perform_grid_search(grid_param)
def exp_grid_search(self):
grid_param = {
'hidden_layer_sizes': [(50, ), (20, 20, 20)],
'activation': ['relu'],
'solver': ['adam'],
'alpha': [0.0001, 0.05, 0.1, 0.2, 0.4, 0.5, 0.6],
'learning_rate': ['constant'],
'learning_rate_init': [0.001, 0.002, 0.004],
'shuffle': [True, False],
'early_stopping': [True, False],
'beta_1': [0.9, 0.5],
'beta_2': [0.999, 0.5]
}
self.expHelper.perform_grid_search(grid_param)
def exp_grid_search3(self):
grid_param = {
'hidden_layer_sizes': [(50, 50), (100, 100), (200, 200),
(300, 300), (400, 400), (500, 500)],
'activation': ['relu'],
'solver': ['sgd'],
'alpha': [0.0001, 0.05, 0.1, 0.2, 0.4, 0.5, 0.6],
'learning_rate': ['constant', 'adaptive'],
}
self.expHelper.perform_grid_search(grid_param)
def exp_grid_search4(self):
grid_param = {
'hidden_layer_sizes': [(50, 50, 50), (100, 100, 100),
(200, 200, 200), (300, 300, 100),
(400, 400, 100), (500, 500, 100)],
'activation': ['relu'],
'solver': ['sgd'],
'alpha': [0.2],
'learning_rate': ['constant']
}
self.expHelper.perform_grid_search(grid_param)
def learning_curve_iter21_wine(self):
self.learner = ANNLearner(activation='relu',
alpha=0.008,
hidden_layer_sizes=(100, ),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_wine(self):
self.learner = ANNLearner(activation='relu',
alpha=0.0001,
hidden_layer_sizes=(
50,
50,
50,
50,
),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-3')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_bank(self):
self.learner = ANNLearner(activation='relu',
alpha=0.01,
hidden_layer_sizes=(
50,
50,
50,
),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-3')
self.expHelper.learning_curve_exp()
def learning_curve_iter21_bank(self):
self.learner = ANNLearner(activation='relu',
alpha=0.01,
hidden_layer_sizes=(300, ),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def experiment_run_test_wine2(self):
self.learner = ANNLearner(activation='relu',
alpha=0.008,
hidden_layer_sizes=(100, ),
learning_rate='constant',
solver='adam',
early_stopping=True)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank2(self):
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(390, ),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank(self):
self.learner = ANNLearner(activation='relu',
alpha=0.01,
hidden_layer_sizes=(
50,
50,
50,
),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_wine(self):
self.learner = ANNLearner(activation='relu',
alpha=0.0001,
hidden_layer_sizes=(
50,
50,
50,
50,
),
learning_rate='constant',
solver='adam',
early_stopping=False)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank_iter2(self):
self.learner = ANNLearner(activation='relu',
alpha=0.06,
hidden_layer_sizes=(200, 200, 200, 200, 200,
200, 200),
learning_rate='constant',
solver='adam',
early_stopping=True,
max_iter=600,
momentum=0.4)
print('100, 100, 100, 100, 100, 100,50 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
""" self.learner = ANNLearner(
activation = 'tanh',
alpha = 0.2,
hidden_layer_sizes = (50, 50, 50, 50, 50, 50, 50, 50),
learning_rate = 'constant',
solver = 'sgd',
early_stopping = False
)
print('100, 100, 100, 100, 100, 50,50, 50 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(
activation = 'tanh',
alpha = 0.6,
hidden_layer_sizes = (100, 100, 100, 100, 100, 50, 50, 50, 50),
learning_rate = 'constant',
solver = 'sgd',
early_stopping = False
)
print('100, 100, 100, 100, 100, 50,50, 50, 50 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test() """
def experiment_run_test_bank_iter(self):
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(390, 100),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('390,100')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(200, 200, 200),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('200, 200, 200')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(400, 400, 400),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('400, 400, 400')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(500, 500, 500),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('500, 500, 500')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(200, 300, 400),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('200, 300, 400')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.7,
hidden_layer_sizes=(390, 100),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('390,100')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(200, 200, 200),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('200, 200, 200 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(400, 400, 400),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('400, 400, 400 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(500, 500, 500),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('500, 500, 500 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(200, 300, 400),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('200, 300, 400 alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(
100,
100,
100,
100,
),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('100, 100, 100, 100, alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(100, 100, 100, 100, 100),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('100, 100, 100, 100, 100, alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(100, 100, 100, 100, 100,
50),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('100, 100, 100, 100, 100, 50, alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
self.learner = ANNLearner(activation='relu',
alpha=0.3,
hidden_layer_sizes=(50, 50, 50, 50, 50, 50),
learning_rate='constant',
solver='adam',
early_stopping=False)
print('50, 50, 50, 50, 50, 50, alpha 0.3')
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
class DTExp:
def __init__(self, reader, helper, splitter):
self.reader = reader
self.helper = helper
self.learner = DTLearner()
self.splitter = splitter
self.expHelper = ExperimentHelper(self.splitter, self.learner)
def experiment(self):
self.model_complexity_exp()
if (self.splitter.reader.dataset == 'Bank'):
print('bank')
self.learning_curve_iter2_bank()
self.experiment_run_test_bank()
else:
self.learning_curve_iter2_wine()
self.experiment_run_test_wine()
# Perform learning curve
#self.expHelper.learning_curve_exp()
#self.model_complexity_exp()
#self.exp_grid_search()
#self.learning_curve_iter2()
#self.learning_curve_iter2()
#self.learner.train(self.splitter.X_train, self.splitter.y_train)
#y_pred = self.learner.query(self.splitter.X_test)
"""print("Final Accuracy for " + str(self.learner.__class__)+": ",
metrics.accuracy_score(self.splitter.y_test, y_pred))"""
def model_complexity_exp(self):
#TODO should we create a new learner object??
self.learner = DTLearner()
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([2, 4, 6, 8])
self.expHelper.model_complexity_exp('max_depth', param_range)
self.learner = DTLearner(max_depth=4)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([2, 5, 6, 8, 10])
self.expHelper.model_complexity_exp('max_leaf_nodes', param_range)
"""self.learner = DTLearner(max_depth = 4, max_leaf_nodes = 5)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
param_range = np.array([1,2,5,6,8,10])
self.expHelper.model_complexity_exp('min_samples_leaf', param_range) """
def exp_grid_search(self):
max_leaf_nodes_range = list(range(2, 20))
max_depth_range = list(range(2, 20))
min_samples_split_range = list(range(2, 5))
min_samples_leaf_range = list(range(2, 5))
grid_param = dict(max_leaf_nodes=max_leaf_nodes_range,
max_depth=max_depth_range,
min_samples_split=min_samples_split_range,
min_samples_leaf=min_samples_leaf_range)
self.expHelper.perform_grid_search(grid_param)
def learning_curve_iter2_bank(self):
self.learner = DTLearner(max_depth=4, max_leaf_nodes=5)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def learning_curve_iter2_wine(self):
self.learner = DTLearner(max_depth=4, max_leaf_nodes=5)
self.expHelper = ExperimentHelper(self.splitter, self.learner,
'-iter-2')
self.expHelper.learning_curve_exp()
def experiment_run_test_wine(self):
self.learner = DTLearner(max_depth=4, max_leaf_nodes=5)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()
def experiment_run_test_bank(self):
self.learner = DTLearner(max_depth=4, max_leaf_nodes=5)
self.expHelper = ExperimentHelper(self.splitter, self.learner)
self.expHelper.experiment_run_test()