Thining results

.github/workflows/code_formatting.yml

@@ -35,7 +35,7 @@ jobs:
       - name: Run isort and black when required and commit back
         if: ${{ failure() || steps.checks.outcome == 'failure'}}
         env:
-          GITHUB_ACCESS_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           isort .
           black .

.github/workflows/manual_release.yml

@@ -27,7 +27,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
       - name: Get version
         env:
-          GITHUB_ACCESS_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         id: version
         run: |
           version=$(python .github/get_version.py)
@@ -36,4 +36,4 @@ jobs:
       - name: Create Release
         run: gh release create ${{ env.BUMPED_VERSION }} --generate-notes
         env:
-          GITHUB_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/release_tagging.yml

@@ -27,7 +27,7 @@ jobs:
           python-version: ${{ matrix.python-version }}
       - name: Get version
         env:
-          GITHUB_ACCESS_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         id: version
         run: |
           version=$(python .github/get_version.py)
@@ -36,4 +36,4 @@ jobs:
       - name: Create Release
         run: gh release create ${{ env.BUMPED_VERSION }} --generate-notes
         env:
-          GITHUB_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/sonarcloud_analysis.yml

@@ -31,7 +31,7 @@ jobs:
       - name: SonarCloud Scan
         uses: SonarSource/sonarcloud-github-action@master
         env:
-          GITHUB_TOKEN: ${{ secrets.OPENMCMC_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
       - name: Upload SonarCloud Scan Report
         uses: actions/upload-artifact@master

src/openmcmc/mcmc.py

@@ -32,7 +32,8 @@ class MCMC:
                      specified will be sampler from prior distributions
         samplers (list): list of the samplers to be used for each parameter to be estimated.
         n_burn (int): number of initial burn in these iterations are not stored.
-        n_iter (int): number of iterations which are stored in store.
+        n_thin (int): number of iterations to thin by.
+        n_iter (int): number of iterations which are stored in store. For every iteration, n_thin iterations are run.
         store (dict): dictionary storing MCMC output as np.array for each inference parameter.
 
     """
@@ -42,6 +43,7 @@ class MCMC:
     model: Model
     n_burn: int = 5000
     n_iter: int = 5000
+    n_thin: int = 1
     store: dict = field(default_factory=dict, init=False)
 
     def __post_init__(self):
@@ -91,8 +93,9 @@ def run_mcmc(self):
 
         """
         for i_it in tqdm(range(-self.n_burn, self.n_iter)):
-            for sampler in self.samplers:
-                self.state = sampler.sample(self.state)
+            for _ in range(self.n_thin):
+                for sampler in self.samplers:
+                    self.state = sampler.sample(self.state)
 
             if i_it < 0:
                 continue

tests/test_mcmc.py

@@ -63,26 +63,31 @@ def fix_state(request):
 
 
 @pytest.fixture(
-    params=[(0, 4000), (2000, 4000), (0, 6000), (2000, 6000)],
-    ids=["n_burn=0,n_iter=4000", "n_burn=non-zero,n_iter=4000", "n_burn=0,n_iter=6000", "n_burn=non-zero,n_iter=6000"],
-    name="nburn_niter",
+    params=[(0, 4000, 1), (2000, 4000, 5), (0, 6000, 10), (2000, 6000, 1)],
+    ids=[
+        "n_burn=0,n_iter=4000, n_thin=1",
+        "n_burn=non-zero,n_iter=4000,n_thin=5",
+        "n_burn=0,n_iter=6000, n_thin=10",
+        "n_burn=non-zero,n_iter=6000,n_thin=1",
+    ],
+    name="mcmc_settings",
 )
-def fix_nburn_niter(request):
+def fix_mcmc_settings(request):
     """Define the initial state for the MCMC."""
-    [n_burn, n_iter] = request.param
-    nburn_niter = {"nburn": n_burn, "niter": n_iter}
+    [n_burn, n_iter, n_thin] = request.param
+    fix_mcmc_settings = {"nburn": n_burn, "niter": n_iter, "nthin": n_thin}
 
-    return nburn_niter
+    return fix_mcmc_settings
 
 
-def test_run_mcmc(state: dict, sampler: list, model: Model, nburn_niter: dict, monkeypatch):
+def test_run_mcmc(state: dict, sampler: list, model: Model, mcmc_settings: dict, monkeypatch):
     """Test run_mcmc function Checks size is correct for the output parameters of the function (state and store) based
     on the number of iterations (n_iter) and number of burn (n_burn), i.e.,
 
     Args:
         state: dictionary
         model: Model input
-        nburn_niter: dictionary of mcmc settings
+        mcmc_settings: dictionary of mcmc settings
         monkeypatch object for avoiding computationally expensive mcmc sampler.
 
     """
@@ -105,32 +110,39 @@ def mock_log_p(self, current_state):
     monkeypatch.setattr(NormalGamma, "store", mock_store)
     monkeypatch.setattr(Model, "log_p", mock_log_p)
 
-    M = MCMC(state, sampler, model, n_burn=nburn_niter["nburn"], n_iter=nburn_niter["niter"])
+    M = MCMC(
+        state,
+        sampler,
+        model,
+        n_burn=mcmc_settings["nburn"],
+        n_iter=mcmc_settings["niter"],
+        n_thin=mcmc_settings["nthin"],
+    )
     M.store["count"] = 0
     M.run_mcmc()
-    assert M.state["count"] == (M.n_iter + M.n_burn) * len(sampler)
+    assert M.state["count"] == (M.n_iter + M.n_burn) * len(sampler) * M.n_thin
     assert M.store["count"] == M.n_iter * len(sampler)
 
 
-def test_post_init(state: dict, sampler: list, model: Model, nburn_niter: dict):
+def test_post_init(state: dict, sampler: list, model: Model, mcmc_settings: dict):
     """This function test __pos__init function to check returned store and state parameters are np.array of the
     dimension n * 1
 
     Args:
         state: dictionary
-        nburn_niter: integer
+        mcmc_settings: integer
         model:
 
     """
-    M = MCMC(state, sampler, model, n_iter=nburn_niter["niter"])
+    M = MCMC(state, sampler, model, n_iter=mcmc_settings["niter"])
 
     assert isinstance(M.state["count"], np.ndarray)
     assert M.state["count"].ndim == 2
 
     assert isinstance(M.state["beta"], np.ndarray)
     assert M.state["beta"].ndim == 2
-    assert (len(M.store) - 1) * (M.store["beta"]).shape[1] == len(sampler) * nburn_niter["niter"]
-    assert M.store["log_post"].size == nburn_niter["niter"]
+    assert (len(M.store) - 1) * (M.store["beta"]).shape[1] == len(sampler) * mcmc_settings["niter"]
+    assert M.store["log_post"].size == mcmc_settings["niter"]
 
     if len(sampler) > 1:
         assert isinstance(M.state["tau"], np.ndarray)