class AdaBoostClassifierImpl():
def __init__(self,
base_estimator=None,
n_estimators=50,
learning_rate=1.0,
algorithm='SAMME.R',
random_state=None):
self._hyperparams = {
'base_estimator': base_estimator,
'n_estimators': n_estimators,
'learning_rate': learning_rate,
'algorithm': algorithm,
'random_state': random_state
}
self._wrapped_model = SKLModel(**self._hyperparams)
def fit(self, X, y=None):
if (y is not None):
self._wrapped_model.fit(X, y)
else:
self._wrapped_model.fit(X)
return self
def predict(self, X):
return self._wrapped_model.predict(X)
def predict_proba(self, X):
return self._wrapped_model.predict_proba(X)
def decision_function(self, X):
return self._wrapped_model.decision_function(X)
class AdaBoostClassifierImpl():
def __init__(self, base_estimator=None, n_estimators=50, learning_rate=1.0, algorithm='SAMME.R', random_state=None):
if isinstance(base_estimator, lale.operators.Operator):
if isinstance(base_estimator, lale.operators.IndividualOp):
base_estimator = base_estimator._impl_instance()._wrapped_model
else:
raise ValueError("If base_estimator is a Lale operator, it needs to be an individual operator. ")
self._hyperparams = {
'base_estimator': base_estimator,
'n_estimators': n_estimators,
'learning_rate': learning_rate,
'algorithm': algorithm,
'random_state': random_state}
self._wrapped_model = SKLModel(**self._hyperparams)
def fit(self, X, y=None):
if (y is not None):
self._wrapped_model.fit(X, y)
else:
self._wrapped_model.fit(X)
return self
def predict(self, X):
return self._wrapped_model.predict(X)
def predict_proba(self, X):
return self._wrapped_model.predict_proba(X)
def decision_function(self, X):
return self._wrapped_model.decision_function(X)
#:# model
params = {'learning_rate': 0.5, 'n_estimators': 300}
classifier = AdaBoostClassifier(**params)
classifier.fit(X_train, y_train)
#:# hash
#:# e595f5d5683f3e3692608020cd5bde18
md5 = hashlib.md5(str(classifier).encode('utf-8')).hexdigest()
print(f'md5: {md5}')
#:# audit
y_pred = classifier.predict(transform_pipeline.transform(X_test))
y_pred_proba = classifier.predict_proba(
transform_pipeline.transform(X_test))[:, 1]
tn, fp, fn, tp = confusion_matrix(y_test, y_pred).ravel()
print(f'acc: {accuracy_score(y_test, y_pred)}')
print(f'auc: {roc_auc_score(y_test, y_pred_proba)}')
print(f'precision: {precision_score(y_test, y_pred)}')
print(f'recall: {recall_score(y_test, y_pred)}')
print(f'specificity: {tn/(tn+fp)}')
print(f'f1: {f1_score(y_test, y_pred)}')
#:# session info
# Dodaj wersję pythona w session info
sessionInfo = {
# Train and test random forests.
# load_path = "../homesite_data/resources/oversampled_normalized_data_ratio_2.5.bin"
load_path = "../homesite_data/resources/oversampled_normalized_data_ratio_2.bin"
homesite = Data()
homesite.load_sliptted_data(load_path)
del homesite.test_x # Deleted to save memory.
clf_ann = NeuralNetwork(path = "../homesite_data/ann_weights.bin", lr = 0.00005, \
lamb = 0)
train_output_ann = clf_ann.get_hidden_output(homesite.train_x)
validation_output_ann = clf_ann.get_hidden_output(homesite.validation_x)
# train_output_ann = np.hstack((train_output_ann, homesite.train_x))
# validation_output_ann = np.hstack((validation_output_ann, homesite.validation_x))
for c in range(1, 10):
# Train classifier.
print "Training classifier."
clf = AdaBoostClassifier(n_estimators=1 + 100 * c)
clf.fit(train_output_ann, homesite.train_y)
# Test classifier.
print 'Testing classifier.'
predicted_labels = clf.predict_proba(validation_output_ann)[:, 1]
# Show final results.
results = confusion_matrix(homesite.validation_y,
np.round(predicted_labels))
accuracy, precision, recall = compute_performance_metrics(results)
auc = compute_auc(homesite.validation_y, predicted_labels)
