pyANOVAapprox 2.0.5__tar.gz → 2.0.7__tar.gz

{pyanovaapprox-2.0.5 → pyanovaapprox-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyANOVAapprox
-Version: 2.0.5
+Version: 2.0.7
 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.5 → pyanovaapprox-2.0.7}/pyproject.toml

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

{pyanovaapprox-2.0.5 → pyanovaapprox-2.0.7}/src/pyANOVAapprox/approx.py

@@ -1,4 +1,5 @@
 import copy
+import warnings
 
 import pyANOVAapprox.analysis as ANOVAanalysis
 import pyANOVAapprox.bandwidth as ANOVAbandwidth
@@ -186,6 +187,11 @@ class approx:
         lam={0.0},
     ):
 
+        if type(lam) is np.ndarray:
+            lam = {float(i) for i in lam}
+        if type(lam) is list:
+            lam = set(lam)
+
         self.X = X
 
         if X.shape[0] != y.shape[0]:
@@ -222,6 +228,9 @@ class approx:
         self.trafo = [None]
         self.fc = [{}]
         self.aktsetting = 0
+        self.lam = {}
+        for i in lam:
+            self.lam[i] = [0]
 
         if setting.N is not None:
             self.addTrafo()
@@ -233,17 +242,24 @@ class approx:
         self.trafo.append(None)
         self.fc.append({})
 
-    def getSettingNr(self, settingnr=None):
-        return self.aktsetting if settingnr is None else settingnr
+    def getSettingNr(self, settingnr=None, lam=None, warn=True):
+        if lam is None:
+            return self.aktsetting if settingnr is None else settingnr
+        else:
+            if lam in self.lam.keys():
+                return self.lam[lam][-1] if settingnr is None else settingnr
+            else:
+                warnings.warn("Not yet approximated for this lambda")
+                return self.aktsetting if settingnr is None else settingnr
 
-    def getSetting(self, settingnr=None):
-        return self.setting[self.getSettingNr(settingnr)]
+    def getSetting(self, settingnr=None, lam=None):
+        return self.setting[self.getSettingNr(settingnr, lam)]
 
-    def getTrafo(self, settingnr=None):
-        return self.trafo[self.getSettingNr(settingnr)]
+    def getTrafo(self, settingnr=None, lam=None):
+        return self.trafo[self.getSettingNr(settingnr, lam)]
 
-    def getFc(self, settingnr=None):
-        return self.fc[self.getSettingNr(settingnr)]
+    def getFc(self, settingnr=None, lam=None):
+        return self.fc[self.getSettingNr(settingnr, lam)]
 
     def addTrafo(self, settingnr=None):
         setting = self.getSetting(settingnr)
@@ -356,6 +372,7 @@ class approx:
         If lam is a np.ndarray of dtype float, this function computes the approximation for the regularization parameters contained in lam.
         If lam is a float, this function computes the approximation for the regularization parameter lam.
         """
+
         setting = self.getSetting(settingnr)
 
         if lam is None:
@@ -393,6 +410,7 @@ class approx:
         solver_verbose,
         solver_tol,
     ):
+        settingnrs = []
         setting = self.getSetting(settingnr)
 
         n = len(self.y)
@@ -401,20 +419,24 @@ 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])
+        fix = dict([(u, tuple([False] * len(u))) for u in setting.U])
+        bw =  [tuple([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)
-
+        if verbosity > 2:
+            print("B =", B)
         for idx in range(maxiter):
             if verbosity > 0:
                 print("===== Iteration ", str(idx + 1), " =====")
-            bw = compute_bandwidth(B, D, t)
+            bw, fix = compute_bandwidth(B, D, t, fix, bw)
             if setting.N is not None:
                 self.addSetting(setting)
                 settingnr = self.aktsetting
+                settingnrs = settingnrs + [settingnr]
                 setting = self.getSetting(settingnr)
 
             setting.N = [bw[i] for i in setting.U]
@@ -469,9 +491,12 @@ class approx:
                     wr.writerow(
                         ["t in it" + str(idx + 1)] + [str(t[i]) for i in setting.U]
                     )
-            if t == dict([(u, [math.nan] * len(u)) for u in setting.U]) or D == dict([(u, [math.nan] * len(u)) for u in setting.U]):
-                return D, t
-        return D, t
+
+            if all([math.isnan(j) for j in sum([D[i] for i in D], [])]) and all(
+                [math.isnan(j) for j in sum([t[i] for i in D], [])]
+            ):
+                break
+        return settingnrs
 
     def autoapproximate(
         self,
@@ -486,18 +511,21 @@ class approx:
         solver_verbose=False,
         solver_tol=1e-8,
     ):
+        settingnr = self.getSettingNr(settingnr)
         setting = self.getSetting(settingnr)
 
         if lam is None:
             lam = setting.lam
         else:
+            if isinstance(lam, np.ndarray):
+                lam = {float(l) for l in lam}
             if not isinstance(lam, set):
                 lam = {lam}
             setting.lam = lam
 
-        if len(lam) == 1:
-            return self._autoapproximate(
-                lam.pop(),
+        for l in lam:
+            settingnrs = self._autoapproximate(
+                l,
                 settingnr=settingnr,
                 B=B,
                 maxiter=maxiter,
@@ -508,22 +536,7 @@ class approx:
                 solver_verbose=solver_verbose,
                 solver_tol=solver_tol,
             )
-        else:
-            return {
-                l: self._autoapproximate(
-                    l,
-                    settingnr=settingnr,
-                    B=B,
-                    maxiter=maxiter,
-                    solver=solver,
-                    verbosity=verbosity,
-                    solver_max_iter=solver_max_iter,
-                    solver_weights=solver_weights,
-                    solver_verbose=solver_verbose,
-                    solver_tol=solver_tol,
-                )
-                for l in lam
-            }
+            self.lam[l] = self.lam[l] + settingnrs
 
     def evaluate(self, settingnr=None, lam=None, X=None):
         """
@@ -534,7 +547,7 @@ class approx:
         - If only lam is given: evaluate at self.X for specific lam.
         - If neither are given: evaluate at self.X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
 
         if X is not None:
             if setting.basis == "per" and (np.min(X) < -0.5 or np.max(X) >= 0.5):
@@ -552,14 +565,14 @@ class approx:
                 basis_vect=setting.basis_vect,
             )
         else:
-            trafo = self.getTrafo(settingnr)
+            trafo = self.getTrafo(settingnr, lam)
 
         if (
             lam is not None
         ):  # evaluate( a::approx; X::Matrix{Float64}, λ::Float64 )::Union{Vector{ComplexF64},Vector{Float64}}
-            return trafo @ self.getFc(settingnr)[lam]
+            return trafo @ self.getFc(settingnr, lam)[lam]
         else:  # evaluate( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Vector{ComplexF64},Vector{Float64}}}
-            return {λ: trafo @ self.getFc(settingnr)[λ] for λ in setting.lam}
+            return {λ: trafo @ self.getFc(settingnr, lam)[λ] for λ in self.lam.keys()}
 
     def evaluateANOVAterms(self, settingnr=None, X=None, lam=None):
         """
@@ -568,7 +581,7 @@ class approx:
         - If lam is given: evaluate at X for specific lam.
         - If lam is not given: evaluate at X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
         if X is None:
             X = self.X
 
@@ -600,14 +613,14 @@ class approx:
             lam is not None
         ):  # evaluateANOVAterms( a::approx; X::Matrix{Float64}, λ::Float64 )::Union{Matrix{ComplexF64},Matrix{Float64}}
             for j, u in enumerate(setting.U):
-                values[:, j] = trafo[u] @ self.getFc(settingnr)[lam][u]
+                values[:, j] = trafo[u] @ self.getFc(settingnr, lam)[lam][u]
             return values
         else:  # evaluateANOVAterms( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Matrix{ComplexF64},Matrix{Float64}}}
             results = {}
-            for λ in setting.lam:
+            for λ in self.lam.keys():
                 vals = np.zeros_like(values)
                 for j, u in enumerate(setting.U):
-                    vals[:, j] = trafo[u] @ self.getFc(settingnr)[λ][u]
+                    vals[:, j] = trafo[u] @ self.getFc(settingnr, lam)[λ][u]
                 results[λ] = vals
             return results
 
@@ -618,7 +631,7 @@ class approx:
         - If lam is given: evaluate at X for specific lam.
         - If lam is not given: evaluate at X for all lam.
         """
-        setting = self.getSetting(settingnr)
+        setting = self.getSetting(settingnr, lam)
 
         if X is None:
             X = self.X
@@ -648,7 +661,7 @@ class approx:
 
         else:  # evaluateSHAPterms( a::approx; X::Matrix{Float64} )::Dict{Float64,Union{Matrix{ComplexF64},Matrix{Float64}}}
             results = {}
-            for l in setting.lam:
+            for l in self.lam.keys():
                 terms = self.evaluateANOVAterms(X, l)
 
                 Dtype = np.complex128 if setting.basis == "per" else np.float64

{pyanovaapprox-2.0.5 → pyanovaapprox-2.0.7}/src/pyANOVAapprox/bandwidth.py

@@ -9,6 +9,8 @@ def getfcu(ghat, u):
     # fcu = np.permute_dims(fcu, range(len(bws))[::-1])
     fcu = ghat[u].reshape(bws - 1)
     fcu = np.permute_dims(fcu, range(len(bws)))
+    #if(u == (3,7)):
+    #    print(fcu)
 
     return fcu
 
@@ -30,48 +32,90 @@ def getaxissum(ghat, u, j, system):
     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
+    #if(u == (3,7)):
+    #    print(j,fcuj)
 
+    return fcuj
 
-def compute_bandwidth(B, D, t):
+def compute_bandwidth(B, D, t, fix, oldbw):
     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)
+    # fix erweitern: NaN-Einträge in t werden automatisch fixiert
+    fix = {u: list(fix[u]) for u in us}  # deep copy
+    for u in us:
+        for j in range(len(u)):
+            if math.isnan(t[u][j]):
+                fix[u][j] = True
+
+    # Für fixierte Einträge: Bandbreite aus oldbw übernehmen
+    for u in us:
+        for j in range(len(u)):
+            if fix[u][j]:
+                bw[u][j] = oldbw[u][j]
+
+    minfreqs = sum(
+        math.prod(
+            (oldbw[u][j] - 1) if fix[u][j] else (6 - 1)
+            for j in range(len(u))
+        )
+        for u in us
+    )
     if B < minfreqs:
         raise ValueError(f"Budget too small: {B} < {minfreqs}")
 
-    def fun_lmbda_u(lmbda, u):
-        p1 = math.prod((bw[u][j] - 1) for j in range(len(u)) if math.isnan(t[u][j]))
-        p2 = math.prod(
-            ((2 * t[u][j] * D[u][j]) / lmbda) ** (0.5 / t[u][j])
+    def A_u(u):
+        return sum(
+            0.5 / t[u][j]
             for j in range(len(u))
-            if not math.isnan(t[u][j])
-        )
-        denom_exp = 1 + sum(
-            0.5 / t[u][j] for j in range(len(u)) if not math.isnan(t[u][j])
+            if not fix[u][j]
         )
-        return (p1 * p2) ** (1 / denom_exp)
-
-    def fun_lmbda(lmbda, B):
-        total = 0.0
-        for u in us:
-            total += fun_lmbda_u(math.exp(lmbda), u)
-        return total - B
 
-    lmbda = math.exp(bisect(lambda t: fun_lmbda(t, B), -100, 100))
+    def B_u(u):
+        prod_C = math.prod(
+            D[u][j] ** (0.5 / t[u][j])
+            for j in range(len(u))
+            if not fix[u][j]
+        )
+        prod_fix = math.prod(
+            (bw[u][j] - 1)
+            for j in range(len(u))
+            if fix[u][j]
+        )
+        return prod_C * prod_fix
 
+    def fun_lmbda_u(lmbda, u):
+        Au = A_u(u)
+        Bu = B_u(u)
+        if Au == 0:
+            # Alle Einträge in u sind fixiert: kein Beitrag zur Optimierung
+            return 0.0
+        exp = 1.0 / (1.0 + Au)
+        return Bu ** exp * (lmbda * Au) ** (-Au * exp)
+
+    def fun_lmbda(log_lmbda):
+        lmbda = math.exp(log_lmbda)
+        return sum(fun_lmbda_u(lmbda, u) for u in us) - (B - 1)
+
+    log_lmbda = bisect(fun_lmbda, -100, 100)
+    lmbda = math.exp(log_lmbda)
+
+    # Optimale Bandbreiten berechnen
     for u in us:
+        Au = A_u(u)
+        Bu = B_u(u)
+        if Au == 0:
+            continue  # alle fixiert, bw[u] bereits gesetzt
         sizeIu = fun_lmbda_u(lmbda, u)
         for j in range(len(u)):
-            if not math.isnan(t[u][j]):
-                bwuj = ((2 * t[u][j] * D[u][j]) / (lmbda * sizeIu)) ** (
+            if not fix[u][j]:
+                bwuj = (D[u][j] / (lmbda * Bu * Au) ** (1.0 / (1.0 + Au))) ** (
                     0.5 / t[u][j]
                 ) + 1
-                bw[u][j] = 2 * round(0.5 * bwuj)
+                bw[u][j] = max(6, 2 * round(0.5 * bwuj))
 
-    return bw
+    return bw, fix
 
 
 def fitrate_log(y):
@@ -155,8 +199,8 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
             )
 
             if verbosity > 5:
-                
-                y = np.cumsum(axissum)[::-1]
+
+                y = np.cumsum(axissum[::-1])[::-1]
                 ax.plot(
                     range(1, len(y) + 1),
                     y,
@@ -164,15 +208,14 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
                     marker="o",
                     #                    color=j
                 )
-
             if (idx is None) or idx >= len(axissum):
                 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)[::-1])[0:idx])
-                
-                if tuj < 0.004:
+                Duj, tuj = fitrate_log((np.cumsum(axissum[::-1])[::-1])[0:idx])
+                #print(u,j,tuj)
+                if abs(tuj) < 0.004:
                     D[u][j] = math.nan
                     t[u][j] = math.nan
                 else:
@@ -191,11 +234,16 @@ def estimate_rates(self, lam, settingnr=None, verbosity=0):
             # plt.figure(figsize=(12, 9))
             # for ax in ps:
             #    plt.sca(ax)
+            time = ""
+            if verbosity > 8:
+                from datetime import datetime
+
+                time = str(round(datetime.timestamp(datetime.now())))
             fig.savefig(
                 os.path.join(
                     "log",
                     "figures",
-                    str(num).strip() + "_rates_" + str(u).strip() + ".png",
+                    time + "_" + str(num).strip() + "_rates_" + str(u).strip() + ".png",
                 )
             )
             num = num + 1