Update config names

docs/notebooks/WSI_brain.ipynb

@@ -78,7 +78,7 @@
    },
    "outputs": [],
    "source": [
-    "basic = BaSiC(get_darkfield=True, lambda_flatfield_coef=10)\n",
+    "basic = BaSiC(get_darkfield=True, smoothness_flatfield=10)\n",
     "basic.fit(images)"
    ]
   },

docs/notebooks/timelapse_brightfield.ipynb

@@ -78,7 +78,7 @@
    },
    "outputs": [],
    "source": [
-    "basic = BaSiC(get_darkfield=True, lambda_flatfield_coef=10)\n",
+    "basic = BaSiC(get_darkfield=True, smoothness_flatfield=10)\n",
     "basic.fit(images)"
    ]
   },

docs/notebooks/timelapse_nanog.ipynb

@@ -78,7 +78,7 @@
    },
    "outputs": [],
    "source": [
-    "basic = BaSiC(get_darkfield=True, lambda_flatfield_coef=10)\n",
+    "basic = BaSiC(get_darkfield=True, smoothness_flatfield=10)\n",
     "basic.fit(images)"
    ]
   },
@@ -129,8 +129,8 @@
    "outputs": [],
    "source": [
     "basic = BaSiC(\n",
-    "    get_darkfield=True, lambda_flatfield_coef=100\n",
-    ")  # increase lambda_flatfield_coef for smoother flatfield\n",
+    "    get_darkfield=True, smoothness_flatfield=100\n",
+    ")  # increase smoothness_flatfield for smoother flatfield\n",
     "basic.fit(images)"
    ]
   },

misc_notebooks/compare_lagrangian.ipynb

@@ -63,9 +63,9 @@
     "        fitting_mode=\"ladmap\",\n",
     "        working_size=None,\n",
     "        get_darkfield=d,\n",
-    "        lambda_flatfield_coef=100 / 80000,\n",
-    "        lambda_darkfield_coef=0.2,\n",
-    "        lambda_darkfield_sparse_coef=0.2,\n",
+    "        smoothness_flatfield=100 / 80000,\n",
+    "        smoothness_darkfield=0.2,\n",
+    "        sparse_cost_darkfield=0.2,\n",
     "        max_reweight_iterations=1,\n",
     "    )\n",
     "    for d in [False, True]\n",
@@ -84,16 +84,16 @@
     "        assert np.allclose(res, b._residual, atol=100000, rtol=1e-2)\n",
     "        print(\n",
     "            [\n",
-    "                b._lambda_flatfield,\n",
-    "                b._lambda_darkfield,\n",
-    "                b._lambda_darkfield_sparse,\n",
+    "                b._smoothness_flatfield,\n",
+    "                b._smoothness_darkfield,\n",
+    "                b._sparse_cost_darkfield,\n",
     "            ]\n",
     "        )\n",
     "        lagrangians = [\n",
     "            np.sum(np.abs(res)),\n",
-    "            b._lambda_flatfield * np.sum(np.abs(JaxDCT.dct2d(b._S))),\n",
-    "            b._lambda_darkfield * np.sum(np.abs(JaxDCT.dct2d(b._D_R))),\n",
-    "            b._lambda_darkfield_sparse * np.sum(np.abs(b._D_R)),\n",
+    "            b._smoothness_flatfield * np.sum(np.abs(JaxDCT.dct2d(b._S))),\n",
+    "            b._smoothness_darkfield * np.sum(np.abs(JaxDCT.dct2d(b._D_R))),\n",
+    "            b._sparse_cost_darkfield * np.sum(np.abs(b._D_R)),\n",
     "        ]\n",
     "        print(lagrangians)\n",
     "        print(sum(lagrangians) / 1e9)\n",
@@ -103,9 +103,9 @@
     "                \"lagrangian_value\": np.sum(lagrangians),\n",
     "                \"fitting_mode\": b.fitting_mode,\n",
     "                \"get_darkfield\": b.get_darkfield,\n",
-    "                \"lambda_flatfield\": b._lambda_flatfield,\n",
-    "                \"lambda_darkfield\": b._lambda_darkfield,\n",
-    "                \"lambda_darkfield_sparse\": b._lambda_darkfield_sparse,\n",
+    "                \"smoothness_flatfield\": b._smoothness_flatfield,\n",
+    "                \"smoothness_darkfield\": b._smoothness_darkfield,\n",
+    "                \"sparse_cost_darkfield\": b._sparse_cost_darkfield,\n",
     "            }\n",
     "        )\n",
     "result_df = pd.DataFrame.from_records(result_df)"

misc_notebooks/organize_test_data.ipynb

@@ -44,7 +44,7 @@
    "source": [
     "basic = BaSiC(\n",
     "    get_darkfield=False,\n",
-    "    lambda_flatfield_coef=1,\n",
+    "    smoothness_flatfield=1,\n",
     "    max_reweight_iterations=1,\n",
     "    max_iterations=2000,\n",
     ")\n",
@@ -146,9 +146,9 @@
     "        print(j)\n",
     "        b = BaSiC(\n",
     "            fitting_mode=fitting_mode,\n",
-    "            lambda_flatfield_coef=1.0,\n",
-    "            lambda_darkfield_coef=1.0,\n",
-    "            lambda_darkfield_sparse_coef=0.01,\n",
+    "            smoothness_flatfield=1.0,\n",
+    "            smoothness_darkfield=1.0,\n",
+    "            sparse_cost_darkfield=0.01,\n",
     "            get_darkfield=get_darkfield,\n",
     "            sort_intensity=sort_intensity,\n",
     "            max_reweight_iterations=4,\n",

misc_notebooks/test_3d_fit.ipynb

@@ -243,7 +243,7 @@
      "text": [
       "INFO:basicpy.basicpy:Initializing BaSiC 5326684736 with parameters: \n",
       "get_darkfield: False\n",
-      "lambda_flatfield_coef: 10\n",
+      "smoothness_flatfield: 10\n",
       "\n",
       "INFO:basicpy.basicpy:=== BaSiC fit started ===\n",
       "INFO:basicpy.basicpy:reweighting iteration 0\n",
@@ -262,7 +262,7 @@
     }
    ],
    "source": [
-    "basic = BaSiC(get_darkfield=False, lambda_flatfield_coef=10)\n",
+    "basic = BaSiC(get_darkfield=False, smoothness_flatfield=10)\n",
     "basic.fit(images)"
    ]
   },

src/basicpy/_jax_routines.py

@@ -36,15 +36,15 @@ class BaseFit(BaseModel):
         1e-6,
         description="Optimization tolerance for update diff.",
     )
-    lambda_darkfield: float = Field(
+    smoothness_darkfield: float = Field(
         0.0,
         description="Darkfield smoothness weight for sparse reguralization.",
     )
-    lambda_darkfield_sparse: float = Field(
+    sparse_cost_darkfield: float = Field(
         0.0,
         description="Darkfield sparseness weight for sparse reguralization.",
     )
-    lambda_flatfield: float = Field(
+    smoothness_flatfield: float = Field(
         0.0,
         description="Flatfield smoothness weight for sparse reguralization.",
     )
@@ -228,7 +228,9 @@ def _step(
             + jnp.sum(B[:, newax, newax, newax] * (Im - I_B - I_R + Y / mu), axis=0)
             / eta_S
         )
-        S_new = idct3d(_jshrinkage(dct3d(S_new), self.lambda_flatfield / (eta_S * mu)))
+        S_new = idct3d(
+            _jshrinkage(dct3d(S_new), self.smoothness_flatfield / (eta_S * mu))
+        )
         S_new = jnp.where(S_new.min() < 0, S_new - S_new.min(), S_new)
         dS = S_new - S
         S = S_new
@@ -263,10 +265,10 @@ def _step(
                 Im - BS - D_R[newax, ...] - D_Z - I_R + Y / mu, axis=0
             )
             D_R_new = idct3d(
-                _jshrinkage(dct3d(D_R_new), self.lambda_darkfield / eta_D / mu)
+                _jshrinkage(dct3d(D_R_new), self.smoothness_darkfield / eta_D / mu)
             )
             D_R_new = _jshrinkage(
-                D_R_new, self.lambda_darkfield_sparse * dark_weight / eta_D / mu
+                D_R_new, self.sparse_cost_darkfield * dark_weight / eta_D / mu
             )
             dD_R = D_R_new - D_R
             D_R = D_R_new
@@ -385,7 +387,7 @@ def _step(
         #    print(type(temp_W))
         temp_W = jnp.mean(temp_W, axis=0)
         S_hat = S_hat + dct2d(temp_W)
-        S_hat = _jshrinkage(S_hat, self.lambda_flatfield / (self._ent1 * mu))
+        S_hat = _jshrinkage(S_hat, self.smoothness_flatfield / (self._ent1 * mu))
         S = idct2d(S_hat)
         I_B = S[newax, ...] * B[:, newax, newax] + D_R[newax, ...] + D_Z
         I_R = (Im - I_B + Y / mu) / self._ent1
@@ -430,9 +432,9 @@ def _step(
 
             # smooth A_offset
             D_R = dct2d(D_R)
-            D_R = _jshrinkage(D_R, self.lambda_darkfield / (self._ent2 * mu))
+            D_R = _jshrinkage(D_R, self.smoothness_darkfield / (self._ent2 * mu))
             D_R = idct2d(D_R)
-            D_R = _jshrinkage(D_R, self.lambda_darkfield_sparse / (self._ent2 * mu))
+            D_R = _jshrinkage(D_R, self.sparse_cost_darkfield / (self._ent2 * mu))
             D_R = D_R + Z
         fit_residual = R - I_B
         Y = Y + mu * fit_residual

src/basicpy/basicpy.py

@@ -115,13 +115,13 @@ class BaSiC(BaseModel):
         False,
         description="When True, will estimate the darkfield shading component.",
     )
-    lambda_flatfield_coef: float = Field(
+    smoothness_flatfield: float = Field(
         1.0, description="Weight of the flatfield term in the Lagrangian."
     )
-    lambda_darkfield_coef: float = Field(
+    smoothness_darkfield: float = Field(
         1.0, description="Weight of the darkfield term in the Lagrangian."
     )
-    lambda_darkfield_sparse_coef: float = Field(
+    sparse_cost_darkfield: float = Field(
         0.01, description="Weight of the darkfield sparse term in the Lagrangian."
     )
     max_iterations: int = Field(
@@ -186,9 +186,9 @@ class BaSiC(BaseModel):
     _B: float = PrivateAttr(None)
     _D_R: float = PrivateAttr(None)
     _D_Z: float = PrivateAttr(None)
-    _lambda_flatfield: float = PrivateAttr(None)
-    _lambda_darkfield: float = PrivateAttr(None)
-    _lambda_darkfield_sparse: float = PrivateAttr(None)
+    _smoothness_flatfield: float = PrivateAttr(None)
+    _smoothness_darkfield: float = PrivateAttr(None)
+    _sparse_cost_darkfield: float = PrivateAttr(None)
 
     _settings_fname = "settings.json"
     _profiles_fname = "profiles.npy"
@@ -338,23 +338,23 @@ def fit(
             mean_image = jnp.mean(Im2, axis=0)
             mean_image = mean_image / jnp.mean(Im2)
             mean_image_dct = JaxDCT.dct3d(mean_image.T)
-            self._lambda_flatfield = (
-                jnp.sum(jnp.abs(mean_image_dct)) / 800 * self.lambda_flatfield_coef
+            self._smoothness_flatfield = (
+                jnp.sum(jnp.abs(mean_image_dct)) / 800 * self.smoothness_flatfield
             )
-            self._lambda_darkfield = (
-                self._lambda_flatfield * self.lambda_darkfield_coef / 2.5
+            self._smoothness_darkfield = (
+                self._smoothness_flatfield * self.smoothness_darkfield / 2.5
             )
-            self._lambda_darkfield_sparse = (
-                self._lambda_flatfield * self.lambda_darkfield_sparse_coef / 2.5 * 100
+            self._sparse_cost_darkfield = (
+                self._smoothness_darkfield * self.sparse_cost_darkfield * 100
             )
         else:
-            self._lambda_flatfield = self.lambda_flatfield_coef
-            self._lambda_darkfield = self.lambda_darkfield_coef
-            self._lambda_darkfield_sparse = self.lambda_darkfield_sparse_coef
+            self._smoothness_flatfield = self.smoothness_flatfield
+            self._smoothness_darkfield = self.smoothness_darkfield
+            self._sparse_cost_darkfield = self.sparse_cost_darkfield
 
-        logger.info(f"lamba_flatfield set to {self._lambda_flatfield}")
-        logger.info(f"lamba_darkfield set to {self._lambda_darkfield}")
-        logger.info(f"lamba_darkfield_sparse set to {self._lambda_darkfield_sparse}")
+        logger.info(f"_smoothness_flatfield set to {self._smoothness_flatfield}")
+        logger.info(f"_smoothness_darkfield set to {self._smoothness_darkfield}")
+        logger.info(f"_sparse_cost_darkfield set to {self._sparse_cost_darkfield}")
 
         # spectral_norm = jnp.linalg.norm(Im.reshape((Im.shape[0], -1)), ord=2)
         _temp = jnp.linalg.svd(Im2.reshape((Im2.shape[0], -1)), full_matrices=False)
@@ -367,9 +367,9 @@ def fit(
         fit_params = self.dict()
         fit_params.update(
             dict(
-                lambda_flatfield=self._lambda_flatfield,
-                lambda_darkfield=self._lambda_darkfield,
-                lambda_darkfield_sparse=self._lambda_darkfield_sparse,
+                smoothness_flatfield=self._smoothness_flatfield,
+                smoothness_darkfield=self._smoothness_darkfield,
+                sparse_cost_darkfield=self._sparse_cost_darkfield,
                 # matrix 2-norm (largest sing. value)
                 init_mu=init_mu,
                 max_mu=init_mu * self.max_mu_coef,
@@ -421,9 +421,9 @@ def fit(
             if not converged:
                 logger.warning("single-step optimization did not converge.")
             if S.max() == 0:
-                logger.error("S is zero. Please try to increase lambda_darkfield_coef.")
+                logger.error("S is zero. Please try to increase smoothness_darkfield.")
                 raise RuntimeError(
-                    "S is zero. Please try to increase lambda_darkfield_coef."
+                    "S is zero. Please try to increase smoothness_darkfield."
                 )
             self._S = S
             self._D_R = D_R

tests/test_basic.py

@@ -78,7 +78,7 @@ def test_basic_resize(synthesized_test_data, resize_mode):
 # Test BaSiC fitting function (with synthetic data)
 def test_basic_fit_synthetic(synthesized_test_data):
 
-    basic = BaSiC(get_darkfield=False, lambda_flatfield_coef=1)
+    basic = BaSiC(get_darkfield=False, smoothness_flatfield=1)
 
     gradient, images, truth = synthesized_test_data
 
@@ -238,7 +238,7 @@ def profiles():
 def model_path(tmp_path, profiles):
     settings_json = """\
     {"epsilon": 0.2, "get_darkfield": false,
-    "lambda_darkfield_coef": 0.0, "lambda_flatfield_coef": 0.0, "max_iterations": 500,
+    "smoothness_darkfield": 0.0, "smoothness_flatfield": 0.0, "max_iterations": 500,
     "max_reweight_iterations": 10, "optimization_tol": 1e-06, "reweighting_tol": 0.001,
     "working_size": 128}
     """