import other modules

Author: yixuan

rehline/__init__.py

@@ -1,3 +1,6 @@
 # Import from internal C++ module
 from ._internal import rehline_internal, rehline_result
 
+from .rehloss import ReHLoss, PQLoss
+from .main import ReHLine, ReHLine_solver
+

rehline/_rehline.py rehline/main.pyrehline/_rehline.py renamed to rehline/main.py

@@ -1,23 +1,23 @@
-""" ReHLine: Regularized Composite ReHU/ReLU Loss Minimization """
+""" ReHLine: Regularized Composite ReLU-ReHU Loss Minimization with Linear Computation and Linear Convergence """
 
 # Authors: Ben Dai <[email protected]>
-#          C++ support by Yixuan Qiu <[email protected]>
+#          C++ support by Yixuan Qiu <[email protected]>
 
 # License: MIT License
 
 import numpy as np
 from sklearn.base import BaseEstimator
-import rehline
 from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
-import base
+from .base import relu, rehu
+from ._internal import rehline_internal, rehline_result
 
 def ReHLine_solver(X, U, V,
         Tau=np.empty(shape=(0, 0)),
         S=np.empty(shape=(0, 0)), T=np.empty(shape=(0, 0)),
         A=np.empty(shape=(0, 0)), b=np.empty(shape=(0)),
         max_iter=1000, tol=1e-4, shrink=True, verbose=True):
-    result = rehline.rehline_result()
-    rehline.rehline_internal(result, X, A, b, U, V, S, T, Tau, max_iter, tol, shrink, verbose)
+    result = rehline_result()
+    rehline_internal(result, X, A, b, U, V, S, T, Tau, max_iter, tol, shrink, verbose)
     return result
 
 class ReHLine(BaseEstimator):
@@ -193,7 +193,7 @@ def call_ReLHLoss(self, input):
             relu_input = (self.U.T * input[:,np.newaxis]).T + self.V
         if self.H > 0:
             rehu_input = (self.S.T * input[:,np.newaxis]).T + self.T
-        return np.sum(base.relu(relu_input), 0) + np.sum(base.rehu(rehu_input), 0)
+        return np.sum(relu(relu_input), 0) + np.sum(rehu(rehu_input), 0)
 
 
     def fit(self, X, sample_weight=None):

rehline/rehloss.py

@@ -1,13 +1,13 @@
 """ ReHLoss: Convert a piecewise quadratic loss function to a ReHLoss. """
 
 # Authors: Ben Dai <[email protected]>
-#          Yixuan Qiu <[email protected]>
+#          Yixuan Qiu <[email protected]>
 
 # License: MIT License
 
 
 import numpy as np
-import base
+from .base import relu, rehu, _check_relu
 
 class ReHLoss(object):
     """
@@ -68,14 +68,14 @@ def __call__(self, x):
         if (self.L > 0) and (self.H > 0):
             assert self.relu_coef.shape[1] == self.rehu_coef.shape[1], "n_samples for `relu_coef` and `rehu_coef` should be the same shape!"
 
-        base._check_relu(self.relu_coef, self.relu_intercept)
-        base._check_rehu(self.rehu_coef, self.rehu_intercept, self.rehu_cut)
+        _check_relu(self.relu_coef, self.relu_intercept)
+        _check_rehu(self.rehu_coef, self.rehu_intercept, self.rehu_cut)
 
         self.L, self.H, self.n = self.relu_coef.shape[0], self.rehu_coef.shape[0], self.relu_coef.shape[1]
         relu_input = (self.relu_coef.T * x[:,np.newaxis]).T + self.relu_intercept
         rehu_input = (self.rehu_coef.T * x[:,np.newaxis]).T + self.rehu_intercept
 
-        return np.sum(base.relu(relu_input), 0) + np.sum(base.rehu(rehu_input), 0)
+        return np.sum(relu(relu_input), 0) + np.sum(rehu(rehu_input), 0)
 
 
 class PQLoss(object):