def _d_predict_d_params(self, X, predicts):
X_affine = data_helper.affine_X(X)
dp0 = X_affine * (predicts[:, 0] *
(1.0 - predicts[:, 0]))[:, np.newaxis]
out = np.zeros((X_affine.shape[0], 2) + self._get_params()[0].shape,
dtype=np.float64)
out[:, 0, :] = dp0
out[:, 1, :] = -dp0
return [out]
def grad_f(params_dict, k, X):
k_eq_0_out = f(params_dict, 0, X)
X_affine = data_helper.affine_X(X)
grad_k_eq_0_out = (k_eq_0_out *
(1 - k_eq_0_out))[:, np.newaxis] * X_affine
return {
"theta": grad_k_eq_0_out
} if k == 0 else {
"theta": -grad_k_eq_0_out
}
def predict(self, X):
#clean the single input vs. multi input vs. not-affined input handling up a lot
if len(X.shape) == 1:
X = np.array([X])
assert (X.shape[1] == self.__theta.shape[0]
or X.shape[1] == self.__theta.shape[0] - 1)
if X.shape[1] != self.__theta.shape[0]:
X = data_helper.affine_X(X)
out = self.__s(np.dot(X, self.__theta), 0)
return out[0] if X.shape[0] == 1 else out
def _d_predict_d_theta(self, X, predicts):
X_affine = data_helper.affine_X(X)
d_kernel_d_theta = self._d_kernel_d_v2(X_affine, self._theta,
self.__bias, self.__degree)
dp0 = d_kernel_d_theta * (predicts[:, 0] *
(1.0 - predicts[:, 0]))[:, np.newaxis]
out = np.zeros((X.shape[0], 2) + (self._theta.shape), dtype=np.float64)
out[:, 0, :] = dp0
out[:, 1, :] = -dp0
return out
def train(self, X, y, steps, step_size):
X = data_helper.affine_X(X)
self.__rand_init_theta(X.shape[1])
unique_labels = np.unique(y)
for iter in range(steps):
grad = self.__gradient(X, y, unique_labels)
self.__theta -= step_size * grad
if iter % 1000 == 0:
print("iter: ", iter)
print("expected gini: ", self.expected_gini(X, y))
print("actual gini: ", self.gini(X, y))
print("------------------------------------------")
def grad_f_A(params_dict, k, X, t_X, d_f_0_out):
X_affine = data_helper.affine_X(X)
d_t_X = act_func.derivative_wrt_activation(t_X)
X_affine_times_d_f_0_out = X_affine * d_f_0_out[:, np.newaxis]
k_0_out = np.zeros((X.shape[0], ) + params_dict["A"].shape)
#want to speed this up, but can't think of any way to
for k1 in range(k_0_out.shape[1]):
k_0_out[:,k1,:] = params_dict["theta"][k1] * \
X_affine_times_d_f_0_out *\
d_t_X[:,k1][:,np.newaxis]
k_0_out[:, :, k_0_out.shape[2] - 1] *= TRANSFORM_BIAS_DAMPEN
k_0_out *= TRANSFORM_DAMPEN
return k_0_out if k == 0 else -k_0_out
def grad_f_A(params_dict, k, X, t_X, f_0_out):
X_affine = data_helper.affine_X(X)
d_t_X = act_func.derivative_wrt_activation(
t_X) #d_t_X[i,j] is the derivative of act_func w.r.t. t_X[i,j]
k_0_out = np.zeros((X.shape[0], ) + params_dict["A"].shape)
for k in range(k_0_out.shape[1]):
for r in range(k_0_out.shape[2]):
k_0_out[:,k,r] = params_dict["theta"][k] * \
X_affine[:,r] * \
(f_0_out*(1-f_0_out)) * \
d_t_X[:,k]
k_0_out[:, :, k_0_out.shape[2] - 1] *= TRANSFORM_BIAS_DAMPEN_FACTOR
k_0_out *= A_GRAD_DAMPEN_FACTOR
return k_0_out if k == 0 else -k_0_out
def f(params_dict, k, X):
X_affine = data_helper.affine_X(X)
k_eq_0_out = stable_func.sigmoid(
np.dot(X_affine, params_dict["theta"]))
return k_eq_0_out if k == 0 else 1 - k_eq_0_out
def t(params_dict, X):
X_affine = data_helper.affine_X(X)
A_Xs = np.dot(params_dict["A"], X_affine.T).T
assert (A_Xs.shape[0] == X_affine.shape[0])
return data_helper.affine_X(act_func.act(A_Xs))
def predict(self, X):
X_affine = data_helper.affine_X(X)
p0 = stable_func.sigmoid(
self._kernel(X_affine, self._theta, self.__bias, self.__degree))
return np.column_stack([p0, 1 - p0])
def predict(self, X):
X_affine = data_helper.affine_X(X)
p0 = stable_func.sigmoid(np.dot(X_affine, self._get_params()[0]))
return np.column_stack([p0, 1 - p0])
def __dot_prepare_transform(self, transformed_X):
return data_helper.affine_X(transformed_X)#transformed_X
def __transform_prepare_X(self, X):
return data_helper.affine_X(X)
import model.impurity.global_impurity3.node_model3_maker as node_model3_maker from model.impurity.global_impurity3.global_impurity_node3 import GlobalImpurityNode3 import sklearn.datasets as datasets import toolbox.data_helper as data_helper import timeit import numpy as np from model.impurity.global_impurity3.global_impurity_model_tree3 import GlobalImpurityModelTree3 np.random.seed(seed = 42) X,y = datasets.load_digits(return_X_y = True)#datasets.load_iris(return_X_y = True)# FEATURES = range(X.shape[1])#[0,1] X = X[:, FEATURES] X = X.astype(np.float64) X/=16.0 NUM_POINTS = X.shape[0] X = X[0:NUM_POINTS,:] y = y[:NUM_POINTS] X = data_helper.affine_X(X) unique_labels = np.unique(y) tree = GlobalImpurityModelTree3(node_model3_maker.logistic_model_at_depth(X.shape[1])) tree.train(X, y, 10.0, 100000, 1, 10, 0, 0, 5, iters_per_prune = 5, print_progress_iters = 5)