pyANOVAapprox 2.0.0__tar.gz → 2.0.2__tar.gz

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 2.0.0
+Version: 2.0.2
 Summary: Approximation Package for High-Dimensional Functions
 Project-URL: Homepage, https://github.com/NFFT/pyGroupedTransforms
 Author-email: Felix Wirth <fwi012001@gmail.com>

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyANOVAapprox"
-version = "2.0.0"
+version = "2.0.2"
 authors = [
   { name="Felix Wirth", email="fwi012001@gmail.com" },
 ]

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/exampleAutoapproximate.py

@@ -56,7 +56,7 @@ ads.autoapproximate()
 ## get approximation accuracy ##
 ################################
 
-# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
+# mse = ads.get_mse() # get mse error at the given training points
 mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/exampleCheb.py

@@ -86,8 +86,8 @@ ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
 ## get approximation accuracy ##
 ################################
 
-# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
-mse = ANOVAapprox.get_mse(ads, X_test, y_test)  # get mse error at the test points
+# mse = ads.get_mse() # get mse error at the given training points
+mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error
@@ -100,7 +100,7 @@ print("mse = " + str(mse_min))
 ###############################################
 
 
-ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
+ar = ads.get_AttributeRanking(lam=λ_min)  # get the attrbute ranking
 
 plt.figure()
 markers, stemlines, baseline = plt.stem(
@@ -121,7 +121,7 @@ plt.grid(True, which="both", ls="--", linewidth=0.5)
 plt.show()  # plot the arrtibute ranking in an logplot
 print("active dimensions: " + str(ar[ar > 1e-2]))
 
-gsis = ANOVAapprox.get_GSI(ads, λ_min)
+gsis = ads.get_GSI(lam=λ_min)
 label = list(ads.U[1:])
 l = len(label)
 plt.figure()
@@ -166,7 +166,7 @@ a.approximate(
     lam=lambdas, max_iter=max_iter, solver="lsqr"
 )  # do the approximation for all specified regularisation parameters
 
-mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
+mse = a.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/exampleClassification.py

@@ -97,7 +97,7 @@ print("accuracity = " + str(acc))
 ## Analyze the model to improve the accuracy ##
 ###############################################
 
-ar = ANOVAapprox.get_AttributeRanking(ads, 0.0)  # get the attrbute ranking
+ar = ads.get_AttributeRanking(lam=0.0)  # get the attrbute ranking
 
 plt.figure()
 markers, stemlines, baseline = plt.stem(
@@ -118,7 +118,7 @@ plt.grid(True, which="both", ls="--", linewidth=0.5)
 plt.show()  # plot the arrtibute ranking in an logplot
 print("active dimensions: " + str(ar[ar > 1e-2]))
 
-gsis = ANOVAapprox.get_GSI(ads, 0.0)
+gsis = ads.get_GSI(lam=0.0)
 label = list(ads.U[1:])
 l = len(label)
 plt.figure()

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/exampleNonPeriodic.py

@@ -84,8 +84,8 @@ ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
 ## get approximation accuracy ##
 ################################
 
-# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
-mse = ANOVAapprox.get_mse(ads, X_test, y_test)  # get mse error at the test points
+# mse = ads.get_mse() # get mse error at the given training points
+mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error
@@ -98,7 +98,7 @@ print("mse = " + str(mse_min))
 ###############################################
 
 
-ar = ANOVAapprox.get_AttributeRanking(ads, λ_min)  # get the attrbute ranking
+ar = ads.get_AttributeRanking(lam=λ_min)  # get the attrbute ranking
 
 plt.figure()
 markers, stemlines, baseline = plt.stem(
@@ -119,8 +119,8 @@ plt.grid(True, which="both", ls="--", linewidth=0.5)
 plt.show()  # plot the arrtibute ranking in an logplot
 print("active dimensions: " + str(ar[ar > 1e-2]))
 
-gsis = ANOVAapprox.get_GSI(ads, λ_min)
-label = list(ads.U[1:])
+gsis = ads.get_GSI(lam=λ_min)
+label = list(ads.getSetting().U[1:])
 l = len(label)
 plt.figure()
 x_values = np.arange(1, l + 1)
@@ -150,7 +150,7 @@ print(
 ################################################
 
 Umask = np.append(np.array([True]), gsis > 1e-2)
-U = [ads.U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
+U = [ads.getSetting().U[i] for i in np.arange(0, len(Umask))[Umask]]  # get important subsets
 bws = M / (math.log10(M) * (len(U) - 1))  # calculate frequencies per subset
 N = [
     math.floor(bws ** (1 / max(1, len(u))) / 2) * 2 for u in U
@@ -164,7 +164,7 @@ a.approximate(
     lam=lambdas, max_iter=max_iter, solver="lsqr"
 )  # do the approximation for all specified regularisation parameters
 
-mse = ANOVAapprox.get_mse(a, X_test, y_test)  # get mse error at the test points
+mse = a.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get
 )  # get the regularisation parameter which leads to the minimal error
@@ -183,7 +183,7 @@ print("mse = " + str(mse_min))
 y_eval_anova = a.evaluateANOVAterms(
     X=X_test, lam=λ_min
 )  # evaluate all of the ANOVA terms
-pos = a.U.index((3,))  # find the index for the subset u=[3]
+pos = a.getSetting().U.index((3,))  # find the index for the subset u=[3]
 y_eval_anova_3 = y_eval_anova.T[pos]
 
 perm = np.argsort(X_test.T[3])

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/examplePeriodic.py

@@ -89,7 +89,7 @@ ads.approximate(lam=lambdas, max_iter=max_iter, solver="lsqr")
 ## get approximation accuracy ##
 ################################
 
-# mse = ANOVAapprox.get_mse(ads) # get mse error at the given training points
+# mse = ads.get_mse() # get mse error at the given training points
 mse = ads.get_mse(X=X_test, y=y_test)  # get mse error at the test points
 λ_min = min(
     mse, key=mse.get

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/simpleTest/exampleWavelet.py

@@ -81,10 +81,10 @@ print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].
 #######################
 
 ### Do sensitivity analysis ####
-gsis = ANOVAapprox.get_GSI(
-    anova_model, 0.0
+anova_model.get_GSI(
+  lam=0.0
 )  # calculates indices for importance of terms (gsis is vector, with indices belonging to terms in anova_model.U)
-gsis_as_dict = ANOVAapprox.get_GSI(anova_model, 0.0, dict=true)
+anova_model.get_GSI(lam=0.0, Dict=true)
 
 y_min_calc = 10 ** (np.min(np.log10(gsis)) - 0.5)
 label = list(anova_model.U[1:])
@@ -113,8 +113,8 @@ plt.show()
 ################################
 
 ### error analysis ###
-mse_train = ANOVAapprox.get_mse(anova_model, lam=0.0)
-mse_test = ANOVAapprox.get_mse(anova_model, X_test, y_test, lam=0.0)
+mse_train = anova_model.get_mse(lam=0.0)
+mse_test = anova_model.get_mse(X=X_test, y=y_test, lam=0.0)
 
 print("MSE on test points: " + str(mse_test))
 
@@ -122,13 +122,13 @@ print("MSE on test points: " + str(mse_test))
 ## Approximation with better suited index set ##
 ################################################
 
-U = ANOVAapprox.get_ActiveSet(anova_model, [0.01, 0.01], lam=0.0)
+U = anova_model.get_ActiveSet(eps=[0.01, 0.01], lam=0.0)
 print("Found index-set U: " + str(U))
-anova_model = ANOVAapprox.approx(
-    X, y, U=U, N=[i + 2 for i in N], basis=basis
+anova_model = anova_model.approx(
+    X=X, y=y, U=U, N=[i + 2 for i in N], basis=basis
 )  # increase number of paramers in N for the important terms
 anova_model.approximate(lam=lambdas)
 print("Total number of used parameters = " + str(len(anova_model.fc[lambdas[0]].vec())))
-mse_train = ANOVAapprox.get_mse(anova_model, lam=0.0)
-mse_test = ANOVAapprox.get_mse(anova_model, X_test, y_test, lam=0.0)
+mse_train = anova_model.get_mse(lam=0.0)
+mse_test = anova_model.get_mse(X=X_test, y=y_test, lam=0.0)
 print("MSE on test points after ANOVA truncation: " + str(mse_test))

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/src/pyANOVAapprox/__init__.py

@@ -8,6 +8,8 @@ from pyGroupedTransforms import *
 from scipy.optimize import bisect
 from scipy.sparse.linalg import lsqr
 from scipy.special import erf
+import csv
+import os
 
 # from sklearn.metrics import roc_auc_score
 

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/src/pyANOVAapprox/approx.py

@@ -187,6 +187,9 @@ class approx:
     ):
 
         self.X = X
+        
+        if X.shape[0] != y.shape[0]:
+            raise ValueError("X and y have different lengths.")
 
         setting = approx_setting(
             parent=self,
@@ -246,8 +249,6 @@ class approx:
         setting = self.getSetting(settingnr)
         if settingnr is None:
             settingnr = self.aktsetting
-        # print(setting.U)
-        # print(setting.N)
         self.trafo[settingnr] = GroupedTransform(
             system=gt_systems[setting.basis],
             U=setting.U,
@@ -386,7 +387,7 @@ class approx:
         B,
         maxiter,
         solver,
-        verbose,
+        verbosity,
         solver_max_iter,
         solver_weights,
         solver_verbose,
@@ -400,8 +401,16 @@ class approx:
 
         D = dict([(u, tuple([1.0] * len(u))) for u in setting.U])
         t = dict([(u, tuple([1.0] * len(u))) for u in setting.U])
+        
+        if verbosity>3:
+            if not os.path.exists("log"):
+                os.mkdir("log")
+            with open('log/log.csv', 'w', newline='') as csvfile:
+                csv.writer(csvfile, delimiter=',').writerow(["it"] + setting.U)
 
         for idx in range(maxiter):
+            if verbosity > 0:
+                print("===== Iteration ", str(idx + 1), " =====")
             bw = compute_bandwidth(B, D, t)
             if setting.N is not None:
                 self.addSetting(setting)
@@ -411,9 +420,14 @@ class approx:
             setting.N = [bw[i] for i in setting.U]
             self.addTrafo()
 
-            if verbose:
-                print("bw in iteration", str(idx + 1), "are", str(bw))
-
+            if verbosity > 0:
+                for i in setting.U:
+                    print("bw in", str(i), ":", bw[i])
+                #print("bw in iteration", str(idx + 1), "are", str(bw))
+                print()
+            if verbosity > 3:
+                with open('log/log.csv', 'a', newline='') as csvfile:
+                    csv.writer(csvfile, delimiter=',').writerow(["bw in it"+str(idx+1)] + [str(bw[i]) for i in setting.U])
             self.approximate(
                 lam=lam,
                 solver=solver,
@@ -423,16 +437,25 @@ class approx:
                 tol=solver_tol,
             )
 
-            D, t = self.estimate_rates(lam=lam, verbose=verbose)
-            if verbose:
-                print(
-                    "estimated rates in iteration",
-                    str(idx + 1),
-                    "are D =",
-                    str(D),
-                    "and t =",
-                    str(t),
-                )
+            D, t = self.estimate_rates(lam=lam, verbosity=verbosity)
+            if verbosity > 1:
+                for i in setting.U:
+                    print("estimated rates for", str(i), ": D = ", str(D[i]), "and t = ", str(t[i]) )
+                print()
+                
+                #print(
+                #    "estimated rates in iteration",
+                #    str(idx + 1),
+                #    "are D =",
+                #    str(D),
+                #    "and t =",
+                #    str(t),
+                #)
+            if verbosity > 3:
+                with open('log/log.csv', 'a', newline='') as csvfile:
+                    wr = csv.writer(csvfile, delimiter=',')
+                    wr.writerow(["D in it"+str(idx+1)] + [str(D[i]) for i in setting.U])
+                    wr.writerow(["t in it"+str(idx+1)] + [str(t[i]) for i in setting.U])
         return D, t
 
     def autoapproximate(
@@ -442,7 +465,7 @@ class approx:
         B=None,
         maxiter=2,
         solver="lsqr",
-        verbose=False,
+        verbosity=0,
         solver_max_iter=50,
         solver_weights=None,
         solver_verbose=False,
@@ -464,7 +487,7 @@ class approx:
                 B=B,
                 maxiter=maxiter,
                 solver=solver,
-                verbose=verbose,
+                verbosity=verbosity,
                 solver_max_iter=solver_max_iter,
                 solver_weights=solver_weights,
                 solver_verbose=solver_verbose,
@@ -478,7 +501,7 @@ class approx:
                     B=B,
                     maxiter=maxiter,
                     solver=solver,
-                    verbose=verbose,
+                    verbosity=verbosity,
                     solver_max_iter=solver_max_iter,
                     solver_weights=solver_weights,
                     solver_verbose=solver_verbose,
@@ -543,7 +566,7 @@ class approx:
 
         Xt = transformX(X, setting.basis)
 
-        if self.setting[settingnr].basis == "per":
+        if self.getSetting(settingnr).basis == "per":
             values = np.zeros((Xt.shape[0], len(self.setting[settingnr].U)), "complex")
         else:
             values = np.zeros((Xt.shape[0], len(self.setting[settingnr].U)), "float")

{pyanovaapprox-2.0.0 → pyanovaapprox-2.0.2}/src/pyANOVAapprox/bandwidth.py

@@ -5,23 +5,30 @@ def getfcu(ghat, u):
     idx = [s.u for s in ghat.settings].index(u)
     bws = ghat.settings[idx].bandwidths
 
-    fcu = ghat[u].reshape(bws[::-1] - 1)
-    fcu = np.permute_dims(fcu, range(len(bws))[::-1])
-
+    #fcu = ghat[u].reshape(bws[::-1] - 1)
+    #fcu = np.permute_dims(fcu, range(len(bws))[::-1])
+    fcu = ghat[u].reshape(bws - 1)
+    fcu = np.permute_dims(fcu, range(len(bws)))
+    
     return fcu
 
 
-def getaxissum(ghat, u, j):
+def getaxissum(ghat, u, j, system):
     fcu = getfcu(ghat, u)
     idx = [s.u for s in ghat.settings].index(u)
     bws = ghat.settings[idx].bandwidths
 
     fcuj = np.sum(abs(fcu) ** 2, axis=tuple([i for i in range(len(u)) if i != j]))
 
-    fcuj = (
-        fcuj[np.mod(range(int(bws[j] / 2), bws[j]), bws[j] - 1)]
-        + fcuj[range(int(bws[j] / 2) - 1, -1, -1)]
-    )
+    if system == "exp":
+        fcuj = (
+            fcuj[np.mod(range(int(bws[j] / 2), bws[j]), bws[j] - 1)]
+            + fcuj[range(int(bws[j] / 2) - 1, -1, -1)]
+        )
+    elif system == "cos":
+        pass
+    else:
+        raise ValueError("For this basis is estimate rates not implemented")
     # fcuj = np.concatenate(fcuj[math.ceil(bws[j]/2):] + [fcuj[0]]) + fcuj[math.ceil(bws[j]/2)-1::-1]
     return fcuj
 
@@ -30,7 +37,7 @@ def compute_bandwidth(B, D, t):
     us = set(D.keys()) - {()}
     bw = {u: [6] * len(u) for u in us}
     bw[()] = []
-
+    
     minfreqs = sum(math.prod((bw[u][j] - 1) for j in range(len(u))) for u in us)
     if B < minfreqs:
         raise ValueError(f"Budget too small: {B} < {minfreqs}")
@@ -104,7 +111,7 @@ def most_common_value(data):
     return t[max_index]
 
 
-def estimate_rates(self, lam, settingnr=None, verbose=False):
+def estimate_rates(self, lam, settingnr=None, verbosity=0):
     us = [s.u for s in self.getTrafo(settingnr).settings]
     nhat = GroupedCoefficients(
         self.getTrafo(settingnr).settings,
@@ -116,25 +123,28 @@ def estimate_rates(self, lam, settingnr=None, verbose=False):
 
     mcl = np.exp(most_common_value(np.log(abs(self.getFc(settingnr)[lam].data))))
     threshold = 100 * mcl**2
-
-    if verbose:
-        ps = []
+    
+    if verbosity>5:
+        if not os.path.exists(os.path.join("log","figures")):
+            os.mkdir(os.path.join("log","figures"))
+        num = 0
+        
+    system = self.getTrafo(settingnr).system
 
     for u in us:
         if len(u) == 0:
             continue
 
-        if verbose:
+        if verbosity>5:
             fig, ax = plt.subplots()
             ax.set_xscale("log")
             ax.set_yscale("log")
             ax.set_title(str(u))
-            ps.append(ax)
 
         for j in range(len(u)):
-            axissum = getaxissum(self.getFc(settingnr)[lam], u, j)
+            axissum = getaxissum(self.getFc(settingnr)[lam], u, j, system)
 
-            axissumnum = getaxissum(nhat, u, j)
+            axissumnum = getaxissum(nhat, u, j, system)
             idx = next(
                 (
                     i
@@ -144,7 +154,7 @@ def estimate_rates(self, lam, settingnr=None, verbose=False):
                 None,
             )
 
-            if verbose:
+            if verbosity>5:
 
                 y = np.cumsum(axissum[::-1])[::-1]
                 ax.plot(
@@ -156,26 +166,28 @@ def estimate_rates(self, lam, settingnr=None, verbose=False):
                 )
 
             if (idx is None) or idx >= len(axissum):
-                D[u][len(u) - j - 1] = math.nan
-                t[u][len(u) - j - 1] = math.nan
+                D[u][j] = math.nan
+                t[u][j] = math.nan
             else:
                 idx = min(len(axissum), len(axissum) - idx + 2)
                 Duj, tuj = fitrate_log(np.cumsum((axissum[0:idx])[::-1])[::-1])
-                D[u][len(u) - j - 1] = Duj
-                t[u][len(u) - j - 1] = -tuj / 2
+                D[u][j] = Duj
+                t[u][j] = -tuj / 2
 
-                if verbose:
+                if verbosity>5:
                     x = np.arange(1, idx + 1)
                     ax.plot(
                         x,
-                        D[u][len(u) - j - 1] * x ** (-2 * t[u][len(u) - j - 1]),
+                        D[u][j] * x ** (-2 * t[u][j]),
                         linewidth=2,
                         #                        color=j
                     )
-    if verbose:
-        plt.figure(figsize=(12, 9))
-        for ax in ps:
-            plt.sca(ax)
-        plt.show()
+        if verbosity>5:
+            #plt.figure(figsize=(12, 9))
+            #for ax in ps:
+            #    plt.sca(ax)
+            fig.savefig(os.path.join("log","figures", str(num).strip()+ "_rates_" + str(u).strip() + ".png"))
+            num = num + 1
+            plt.close(fig) 
 
     return D, t