def aggregate_forward(self, host_forward): """ Compute e_guest.dot(e_host) Paramters --------- host_forward: DTable. key, en_e(host) """ aggregate_forward_res = self.guest_forward.join( host_forward, lambda e1, e2: (fate_operator.dot(e1[1], e2[1]), math.pow(fate_operator.dot(e1[1], e2[1]), 2))) return aggregate_forward_res
def __compute_partition_gradient(data, fit_intercept=True): """ Compute hetero regression gradient for: gradient = ∑d*x, where d is fore_gradient which differ from different algorithm Parameters ---------- data: DTable, include fore_gradient and features fit_intercept: bool, if model has interception or not. Default True Returns ---------- numpy.ndarray hetero regression model gradient """ feature = [] fore_gradient = [] for key, value in data: feature.append(value[0]) fore_gradient.append(value[1]) feature = np.array(feature) fore_gradient = np.array(fore_gradient) gradient = [] if feature.shape[0] <= 0: return 0 for j in range(feature.shape[1]): feature_col = feature[:, j] gradient_j = fate_operator.dot(feature_col, fore_gradient) gradient.append(gradient_j) if fit_intercept: bias_grad = np.sum(fore_gradient) gradient.append(bias_grad) return np.array(gradient)
def __compute_gradient(data, fit_intercept=True): feature = [] fore_gradient = [] for key, value in data: feature.append(value[0]) fore_gradient.append(value[1]) feature = np.array(feature) fore_gradient = np.array(fore_gradient) gradient = [] if feature.shape[0] <= 0: return 0 for j in range(feature.shape[1]): feature_col = feature[:, j] gradient_j = fate_operator.dot(feature_col, fore_gradient) gradient_j /= feature.shape[0] gradient.append(gradient_j) if fit_intercept: fore_gradient_size = fore_gradient.shape[0] fore_gradient = fore_gradient / fore_gradient_size bias_grad = np.sum(fore_gradient) gradient.append(bias_grad) return np.array(gradient)
def compute(self, values, coef, intercept, fit_intercept): X, Y = self.load_data(values) batch_size = len(X) if batch_size == 0: return None, None one_d_y = Y.reshape([-1, ]) d = (0.25 * np.array(fate_operator.dot(X, coef) + intercept).transpose() + 0.5 * one_d_y * -1) grad_batch = X.transpose() * d grad_batch = grad_batch.transpose() if fit_intercept: grad_batch = np.c_[grad_batch, d] # grad = sum(grad_batch) / batch_size grad = sum(grad_batch) return grad, None
def compute_gradient(values, coef, intercept, fit_intercept): LOGGER.debug("Get in compute_gradient") X, Y = load_data(values) batch_size = len(X) if batch_size == 0: return None one_d_y = Y.reshape([-1, ]) d = (0.25 * np.array(fate_operator.dot(X, coef) + intercept).transpose() + 0.5 * one_d_y * -1) grad_batch = X.transpose() * d grad_batch = grad_batch.transpose() if fit_intercept: grad_batch = np.c_[grad_batch, d] grad = sum(grad_batch) LOGGER.debug("Finish compute_gradient") return grad
def _test_compute(self, X, Y, coef, intercept, fit_intercept): batch_size = len(X) if batch_size == 0: return None, None one_d_y = Y.reshape([-1, ]) d = (0.25 * np.array(fate_operator.dot(X, coef) + intercept).transpose() + 0.5 * one_d_y * -1) grad_batch = X.transpose() * d tot_loss = np.log(1 + np.exp(np.multiply(-Y.transpose(), X.dot(coef) + intercept))).sum() avg_loss = tot_loss / Y.shape[0] # grad_batch = grad_batch.transpose() # if fit_intercept: # grad_batch = np.c_[grad_batch, d] # grad = sum(grad_batch) / batch_size return 0
def __compute_gradient(data, fit_intercept=True): """ Compute hetero-lr gradient for: gradient = ∑(1/2*ywx-1)*1/2yx, where fore_gradient = (1/2*ywx-1)*1/2y has been computed, x is features Parameters ---------- data: DTable, include fore_gradient and features fit_intercept: bool, if hetero-lr has interception or not. Default True Returns ---------- numpy.ndarray hetero-lr gradient """ feature = [] fore_gradient = [] for key, value in data: feature.append(value[0]) fore_gradient.append(value[1]) feature = np.array(feature) fore_gradient = np.array(fore_gradient) gradient = [] if feature.shape[0] <= 0: return 0 for j in range(feature.shape[1]): feature_col = feature[:, j] gradient_j = fate_operator.dot(feature_col, fore_gradient) gradient.append(gradient_j) if fit_intercept: bias_grad = np.sum(fore_gradient) gradient.append(bias_grad) gradient.append(feature.shape[0]) return np.array(gradient)
def compute_wx(self, data_instances, coef_, intercept_=0): return data_instances.mapValues( lambda v: fate_operator.dot(v.features, coef_) + intercept_)
def __compute_partition_gradient(data, fit_intercept=True, is_sparse=False): """ Compute hetero regression gradient for: gradient = ∑d*x, where d is fore_gradient which differ from different algorithm Parameters ---------- data: DTable, include fore_gradient and features fit_intercept: bool, if model has interception or not. Default True Returns ---------- numpy.ndarray hetero regression model gradient """ feature = [] fore_gradient = [] if is_sparse: row_indice = [] col_indice = [] data_value = [] row = 0 feature_shape = None for key, (sparse_features, d) in data: fore_gradient.append(d) assert isinstance(sparse_features, SparseVector) if feature_shape is None: feature_shape = sparse_features.get_shape() for idx, v in sparse_features.get_all_data(): col_indice.append(idx) row_indice.append(row) data_value.append(v) row += 1 if feature_shape is None or feature_shape == 0: return 0 sparse_matrix = sp.csr_matrix((data_value, (row_indice, col_indice)), shape=(row, feature_shape)) fore_gradient = np.array(fore_gradient) # gradient = sparse_matrix.transpose().dot(fore_gradient).tolist() gradient = fate_operator.dot(sparse_matrix.transpose(), fore_gradient).tolist() if fit_intercept: bias_grad = np.sum(fore_gradient) gradient.append(bias_grad) # LOGGER.debug("In first method, gradient: {}, bias_grad: {}".format(gradient, bias_grad)) return np.array(gradient) else: for key, value in data: feature.append(value[0]) fore_gradient.append(value[1]) feature = np.array(feature) fore_gradient = np.array(fore_gradient) if feature.shape[0] <= 0: return 0 gradient = fate_operator.dot(feature.transpose(), fore_gradient) gradient = gradient.tolist() if fit_intercept: bias_grad = np.sum(fore_gradient) gradient.append(bias_grad) return np.array(gradient)